Scala 2.13

If your are on Scala 2.13 then you should use the Using object:

import scala.util.Using val a: Try[Int] = Using(new FileInputStream("/tmp/someFile")) { fileInputStream => // Do what you need in fith you fileInputStream here. } 

It takes two functions. The first one is a function that can create or provide the closable resource, and the second function is the one that takes the closable resource as a parameter, and can use it for something. Using will then in simple terms do the following for you:

1. Call the first function to create the closable resource.
2. Call the second function, and provide the resource as a parameter.
3. Hold on to the returned value of the second function.
4. Call close on the resource.
5. Return the value (or exception) it got from the second function wrapped in a Try.

Using can be used on many other things than classes that implements AutoCloseable; you just have to provide an implicit value, telling Using how to close your specific resource.

Pre-Scala 2.13

In older versions of Scala, there is no directly support for javas try-with-resources construct, but your can pretty easily build your own support by applying the loan pattern. The following is a simple but not optimal example, that is easy to understand. A more correct solution is given later in this answer:

import java.lang.AutoCloseable def autoClose[A <: AutoCloseable,B]( closeable: A)(fun: (A) ⇒ B): B = { try { fun(closeable) } finally { closeable.close() } } 

This defines a reusable method that works pretty much like a try-with-resource construct in Java. It takes two parameters. First is an instance of AutoClosable, and second is a function that takes the same AutoClosable type as a paremeter and returns the same type as the method. The method then executes the function inside a try, and close the AutoClosable in its finally block.

You can use it like the following (here used to get the result of findAny() on the Stream).

val result: Optional[String] = autoClose(Files.lines(Paths.get("somefile.txt"))) { stream ⇒ stream.findAny() } 

In case you want to catch exceptions, you have 2 choices:

1. Add a try/catch block around the stream.findAny() call.
2. Add a catch block to the try block in the autoClose method. Note that this should only be done if the logic inside the catch block is usable from all places where autoClose is called.

Note that as Vitalii Vitrenko points out in a comment, this method will swallow the exception from the close method if both the function supplied by the client, and the close method on the AutoCloseable throw an exception. Java's try-with-resources handles this, and we can make autoClose do so too, by making it a bit more complex:

 def autoClose[A <: AutoCloseable,B]( closeable: A)(fun: (A) ⇒ B): B = { var t: Throwable = null try { fun(closeable) } catch { case funT: Throwable ⇒ t = funT throw t } finally { if (t != null) { try { closeable.close() } catch { case closeT: Throwable ⇒ t.addSuppressed(closeT) throw t } } else { closeable.close() } } } 

This works by storing the potential exception the client function throws, and adding the potential exception of the close method to it as a supressed exception. This is pretty close to how Oracle explains the actual workings of try-with-resources: Better Resource Management with Java SE 7: Beyond Syntactic Sugar

However, this is Scala, and a lot of people will prefer to program in a more functional way. In a more functional way, the method should return a Try, instead of throwing an exception. This avoids a side effect of throwing an exception, and makes it clear to the client that the response may be a failure that should be handled (as pointed out in the answer by Stas). In a functional implementation, we would also like to avoid having a var, so a naive attempt could be:

 // Warning this implementation is not 100% safe, see below def autoCloseTry[A <: AutoCloseable,B]( closeable: A)(fun: (A) ⇒ B): Try[B] = { Try(fun(closeable)).transform( result ⇒ { closeable.close() Success(result) }, funT ⇒ { Try(closeable.close()).transform( _ ⇒ Failure(funT), closeT ⇒ { funT.addSuppressed(closeT) Failure(funT) } ) } ) } 

This could then be called like this:

 val myTry = autoCloseTry(closeable) { resource ⇒ //doSomethingWithTheResource 33 } myTry match { case Success(result) ⇒ doSomethingWithTheResult(result) case Failure(t) ⇒ handleMyExceptions(t) } 

Or you could just call .get on myTry to make it return the result, or throw the exception.

However as Kolmar points out in a comment, this implementation is flawed, due to how the return statement works in scala. Consider the following:

 class MyClass extends AutoCloseable { override def close(): Unit = println("Closing!") } def foo: Try[Int] = { autoCloseTry(new MyClass) { _ => return Success(0) } } println(foo) 

We would expect this to print "Closing!", but it will not. The problem here is the explicit return statement inside the function body. It makes the method skip the logic in the autoCloseTry method, and thereby just returns Success(0), without closing the resource.

To fix that problem, we can create a mix of the 2 solutions, one that has the functional API of returning a Try, but uses the classic implementation based on try/finally blocks:

 def autoCloseTry[A <: AutoCloseable,B]( closeable: A)(fun: (A) ⇒ B): Try[B] = { var t: Throwable = null try { Success(fun(closeable)) } catch { case funT: Throwable ⇒ t = funT Failure(t) } finally { if (t != null) { try { closeable.close() } catch { case closeT: Throwable ⇒ t.addSuppressed(closeT) Failure(t) } } else { closeable.close() } } } 

This should fix the problem, and can be used just like the first attempt. However it shows that this a bit error prone, and the faulty implementation has been in this answer as the recommended version for quite some time. So unless you trying to avoid having to many libraries, you should properly consider using this functionality from a library. I think that there is already one other answer pointing to one, but my guess is that there is multiply libraries, that solves this problem in different ways.