MakeDSLBase

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))

Adds a dependency on Local3[F]

Warning: removes the precise subtype of Lifecycle because of Lifecycle.map: Integration checks mixed-in as a trait onto a Lifecycle value result here will be lost

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

Adds a dependency on Local3[F]

Warning: removes the precise subtype of Lifecycle because of Lifecycle.map: Integration checks mixed-in as a trait onto a Lifecycle value result here will be lost

Adds a dependency on Local3[F]

Warning: removes the precise subtype of Lifecycle because of Lifecycle.map: Integration checks mixed-in as a trait onto a Lifecycle value result here will be lost

Adds a dependency on Local3[F]

Adds a dependency on Local3[F]