Attributes
- Companion:
- object
- Graph
- Supertypes
- class Objecttrait Matchableclass Any
- Known subtypes
- class MakeDSL[T]class MakeNamedDSL[T]
Members list
Value members
Concrete methods
A function that receives its arguments from DI object graph, including named instances via izumi.distage.model.definition.Id annotation.
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
Attributes
- See also:
izumi.distage.model.reflection.macros.FunctoidMacro]
Functoid is based on the Magnet Pattern: http://spray.io/blog/2012-12-13-the-magnet-pattern/
Essentially Functoid is a function-like entity with additional properties, so it's funny name is reasonable enough: https://en.wiktionary.org/wiki/-oid#English
Bind to a result of executing a purely-functional effect
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))
Attributes
Attributes
- See also:
Bind to result of acquiring a resource
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)
Attributes
- See also:
- cats.effect.Resource: https://typelevel.org/cats-effect/datatypes/resource.html
Attributes
- See also:
Bind to a Lifecycle class which has a ZIO effect type that specifies dependencies via zio environment, e.g.
Bind to a Lifecycle class which has a ZIO effect type that specifies dependencies via zio environment, e.g.
class IntLifecycle extends Lifecycle.OfZIO[Double, Nothing, Int](
for {
double <- ZIO.service[Double]
_ <- ZIO.acquireRelease(ZIO.unit)(_ => ZIO.succeed(println("Closed")))
} yield double.toInt
)
val module = new ModuleDef {
make[Int].fromZEnvLifecycle[IntLifecycle]
make[Double].from(5.0)
}
Injector[Task]().produceRun(module) {
(i: Int) => ZIO.succeed(println(i))
}
// 5
// Closed
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
Attributes
Bind to a Lifecycle value which has a ZIO effect type that specifies dependencies via zio environment
Bind to a Lifecycle value which has a ZIO effect type that specifies dependencies via zio environment
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
Attributes
Bind to a Lifecycle value which has a ZIO effect type that specifies dependencies via zio environment
Bind to a Lifecycle value which has a ZIO effect type that specifies dependencies via zio environment
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
Attributes
Bind to result of executing an effect bound to a key at F[I]
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
Attributes
Bind to a result of acquiring a resource bound to a key at R
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
Attributes
Create a dummy binding that throws an exception with an error message when it's created.
Create a dummy binding that throws an exception with an error message when it's created.
Useful for prototyping.
Attributes
Bind by reference to another bound key
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