DIResource is a class that captures the effectful allocation of a resource, along with its finalizer. This can be used to wrap expensive resources.

Resources can be created using DIResource.make:

def open(file: File): DIResource[IO, BufferedReader] =
  DIResource.make(IO { new BufferedReader(new FileReader(file)) })(in => IO { in.close() })

Using inheritance from DIResource:

final class BufferedReaderResource(file: File)
  extends DIResource[IO, BufferedReader] {
    val acquire = IO { new BufferedReader(new FileReader(file)) }
    def release(in: BufferedReader) = IO { in.close() }
  }

Using constructor-based inheritance from DIResource.Make, DIResource.LiftF, etc:

final class BufferedReaderResource(file: File)
  extends DIResource.Make[IO, BufferedReader](
    acquire = IO { new BufferedReader(new FileReader(file)) },
    release = in => IO { in.close() },
  }

Or by converting an existing cats.effect.Resource or a zio.ZManaged. Use DIResource.fromCats, DIResource.DIResourceCatsSyntax#toCats and DIResource.fromZIO, DIResource.DIResourceZIOSyntax#toZIO to convert back and forth.

Usage is done via use:

open(file1).use { in1 =>
  open(file2).use { in2 =>
    readFiles(in1, in2)
  }
}

DIResources can be combined into a larger resource via DIResourceBase.flatMap:

val res: DIResource[IO, (BufferedReader, BufferedReader)] =
  open(file1).flatMap { in1 =>
   open(file2).flatMap { in2 =>
     IO.pure(in1 -> in2)
   }
 }

Nested resources are released in reverse order of acquisition. Outer resources are released even if an inner use or release fails.

DIResource can be used in non-FP context with DIResource.Simple it can also mimic Java's initialization-after-construction with DIResource.Mutable

Use DIResource's to specify lifecycles of objects injected into the object graph.

import distage.{DIResource, ModuleDef, Injector}
import cats.effect.IO

class DBConnection
class MessageQueueConnection

val dbResource = DIResource.make(IO { println("Connecting to DB!"); new DBConnection })(_ => IO(println("Disconnecting DB")))
val mqResource = DIResource.make(IO { println("Connecting to Message Queue!"); new MessageQueueConnection })(_ => IO(println("Disconnecting Message Queue")))

class MyApp(db: DBConnection, mq: MessageQueueConnection) {
  val run = IO(println("Hello World!"))
}

val module = new ModuleDef {
  make[DBConnection].fromResource(dbResource)
  make[MessageQueueConnection].fromResource(mqResource)
  make[MyApp]
}

Injector().produceFGet[IO, MyApp](module)
  .use(_.run())
  .unsafeRunSync()

Will produce the following output:

Connecting to DB!
Connecting to Message Queue!
Hello World!
Disconnecting Message Queue
Disconnecting DB

The lifecycle of the entire object graph is itself expressed with DIResource, you can control it by controlling the scope of .use or by manually invoking DIResourceBase.acquire and DIResourceBase.release.