A function that receives its arguments from DI object graph, including named instances via izumi.distage.model.definition.Id annotation.

The following syntaxes are supported by extractor macro:

Inline lambda:

make[Unit].from {
  i: Int @Id("special") => ()
}

Method reference:

def constructor(@Id("special") i: Int): Unit = ()

make[Unit].from(constructor _)

make[Unit].from(constructor(_))

Function value with an annotated signature:

val constructor: (Int @Id("special"), String @Id("special")) => Unit = (_, _) => ()

make[Unit].from(constructor)

Using intermediate vals will lose annotations when converting a method into a function value, Prefer passing inline lambdas such as { x => y } or method references such as (method _) or (method(_)).:

def constructorMethod(@Id("special") i: Int): Unit = ()

val constructor = constructorMethod _

make[Unit].from(constructor) // SURPRISE: Will summon regular Int, not a "special" Int from DI object graph
make[Unit].from(constructorMethod _) // Will work correctly: summon "special" Int

Prefer annotating parameter types, not parameters: class X(i: Int @Id("special")) { ... }

case class X(i: Int @Id("special"))

make[X].from(X.apply _) // summons special Int

Functoid forms an applicative functor via its izumi.distage.model.providers.Functoid.pure & izumi.distage.model.providers.Functoid#map2 methods

Bind to a result of executing a purely-functional effect

Example:

import cats.effect.concurrent.Ref
import cats.effect.IO

make[Ref[IO, Int]].named("globalMutableCounter").fromEffect(Ref[IO](0))

Bind to result of acquiring a resource

The resource will be released when the izumi.distage.model.Locator holding it is released. Typically, after .use is called on the result of izumi.distage.model.Injector#produce

You can create resources with Lifecycle.make, by inheriting from Lifecycle or by converting an existing cats.effect.Resource

You can bind a cats.effect.Resource directly:

import cats.effect._

val myResource: Resource[IO, Unit] = Resource.make(IO(println("Acquiring!")))(IO(println("Releasing!")))

make[Unit].fromResource(myResource)

Bind to result of executing an effect bound to a key at F[I]

This will execute the effect again for every refEffect binding

Example:

import cats.effect.concurrent.Ref
import cats.effect.IO

make[IO[Ref[IO, Int]]].named("counterFactory").from(Ref[IO](0))

// execute the effect bound above to key `DIKey.get[IO[Ref[IO, Int]]].named("counterFactory")` to create and bind a new Ref
make[Ref[IO, Int]].named("globalCounter1")
  .refEffect[IO, Ref[IO, Int]]("counterFactory")

make[Ref[IO, Int]].named("globalCounter2")
  .refEffect[IO, Ref[IO, Int]]("counterFactory")

// globalCounter1 and globalCounter2 are two independent mutable references

Bind to a result of acquiring a resource bound to a key at R

This will acquire a NEW resource again for every refResource binding

Create a dummy binding that throws an exception with an error message when it's created.

Useful for prototyping.

Bind by reference to another bound key

Example:

trait T
class T1 extends T

make[T1]
make[T].using[T1]

Here, only T1 will be created. A class that depends on T will receive an instance of T1