I assume we want to use one resource to create another, cleaning up along the way.

The trickiness seems to be converting from B to Resource[B] to return from the flatMap method. This needs to be done by the caller, where the type of B is known, and where the desired implicit conversion functions are in scope. There, map() can be used with a f:A=>B, which is converted to f:A=>Resource[B].

sealed trait Resource[+T] {
  val value: T

  def close: Unit

  def use[X](f: T => X) = try {f(value)} finally {close}

  def map[B](f: T => Resource[B]): Resource[B] = use(f)

  def flatMap[B](f: T => B): Resource[B] = error("Compiler can't use the generic type 'B' to find an implicit function B => Resource[B]")

  def flatMapSpecific(f: T => java.io.InputStream): Resource[java.io.InputStream] = {
    import Resource._
    val b = use(f)
    b
  }
}

import java.io.InputStream

object Resource {
  def resource[T](t: T, c: => Unit) = new Resource[T] {
    val value = t

    def close = c
  }

  implicit def InputStreamResource(t: InputStream) = resource(t, t.close)
}

object Example {
  import Resource._

  def main(args: Array[String]) {
    val in = new java.io.FileInputStream("/etc/passwd")
    println(in.map(copyStream).map(copyStream) use (_.read.toChar))
  }

  def copyStream(i: InputStream): InputStream = {
    new ByteArrayInputStream(Array(i.read.toByte))
  }
}

Peace
-stpehan

Well, that’s not true, I just have no idea HOW it is doing it