Type Members

1.  final case class Activation(activeChoices: Map[Axis, AxisChoice]) extends AnyVal with Product with Serializable

   Selection of active choices among those available in an Activation Axis

   Selection of active choices among those available in an Activation Axis

   import distage.{Activation, Repo, Mode}
   
   Activation(
     Repo -> Repo.Prod,
     Mode -> Mode.Test,
   )

   See also

   Activation Axis

2.  trait Axis extends AnyRef
3.  sealed trait Binding extends AnyRef
4.  trait BindingTag extends AnyRef

   An attachment that can be added to a binding using its .tagged method

5.  trait BootstrapContextModule extends BootstrapModule
6.  trait BootstrapContextModuleDef extends BootstrapContextModule with ModuleDefDSL
7.  trait BootstrapModule extends ModuleBase
8.  trait BootstrapModuleDef extends BootstrapModule with ModuleDefDSL
9.  trait DIStageAnnotation extends Annotation with StaticAnnotation with TypeConstraint
10.  final class Id extends Annotation with DIStageAnnotation

    Annotation for summoning named instances.

    Annotation for summoning named instances.

    Example:

    val module = new ModuleDef {
      make[Int].named("three").from(3)
      make[Int].named("five").from(5)
    }
    
    Injector().produce(module).run {
      (five: Int @Id("five"), three: Int @Id("three")) =>
        assert(5 == five)
        assert(3 == three)
    }

    Note

    javax.inject.Named annotation is also supported

11.  abstract class Identifier extends AnyRef

    Type of a name for a named instance, which can be any type that implements izumi.distage.model.reflection.IdContract typeclass, e.g.

    Type of a name for a named instance, which can be any type that implements izumi.distage.model.reflection.IdContract typeclass, e.g. String

    Example:

    implicit val idInt: IdContract[Int] = new IdContract.IdContractImpl[Int]
    
    val module = new ModuleDef {
      make[Int].named(3).from(3)
      make[Int].named(5).from(5)
    }

12.  sealed abstract class ImplDef extends Product with CachedProductHashcode
13.  type Lifecycle[+F[_], +OuterResource] = functional.lifecycle.Lifecycle[F, OuterResource]
14.  type Lifecycle2[+F[+_, +_], +E, +A] = functional.lifecycle.Lifecycle[[β$0$]F[E, β$0$], A]
15.  type Lifecycle3[+F[-_, +_, +_], -R, +E, +A] = functional.lifecycle.Lifecycle[[γ$1$]F[R, E, γ$1$], A]
16.  trait LocatorDef extends AbstractLocator with AbstractBindingDefDSL[BindDSL, BindDSLUnnamedAfterFrom, SetDSL]
17.  trait Module extends ModuleBase
18.  trait ModuleBase extends CachedHashcode
19.  trait ModuleDef extends Module with ModuleDefDSL

    DSL for defining module Bindings.

    DSL for defining module Bindings.

    Example:

    class Program[F[_]: TagK: Monad] extends ModuleDef {
      make[TaglessProgram[F]]
    }
    
    object TryInterpreters extends ModuleDef {
      make[Validation.Handler[Try]].from(tryValidationHandler)
      make[Interaction.Handler[Try]].from(tryInteractionHandler)
    }
    
    // Combine modules into a full program
    val TryProgram = new Program[Try] ++ TryInterpreters

    Singleton bindings:

    • make[X] = create X using its constructor
    • makeTrait[X] = create an abstract class or a trait X using izumi.distage.constructors.TraitConstructor (Auto-Traits feature)
    • makeFactory[X] = create a "factory-like" abstract class or a trait X using izumi.distage.constructors.FactoryConstructor (Auto-Factories feature)
    • make[X].from[XImpl] = bind X to its subtype XImpl using XImpl's constructor
    • make[X].fromTrait[XImpl] = bind X to its abstract class or a trait subtype XImpl, deriving constructor using izumi.distage.constructors.TraitConstructor (Auto-Traits feature)
    • make[X].fromFactory[XImpl] = bind X to its "factory-like" abstract class or a trait subtype XImpl, deriving constructor using izumi.distage.constructors.FactoryConstructor (Auto-Factories feature)
    • make[X].from(myX) = bind X to an already existing instance myX
    • make[X].from { y: Y => new X(y) } = bind X to an instance of X constructed by a given Functoid requesting an Y parameter
    • make[X].from { y: Y @Id("special") => new X(y) } = bind X to an instance of X constructed by a given Functoid, requesting a named "special" Y parameter
    • make[X].from { y: Y => new X(y) }.annotateParameter[Y]("special") = bind X to an instance of X constructed by a given Functoid, requesting a named "special" Y parameter
    • make[X].named("special") = bind a named instance of X. It can then be summoned using Id annotation.
    • make[X].using[X]("special") = bind X to refer to another already bound named instance at key [X].named("special")
    • make[X].fromEffect(X.create[F]: F[X]) = create X using a purely-functional effect X.create in F monad
    • make[X].fromResource(X.resource[F]: Lifecycle[F, X]) = create X using a Lifecycle value specifying its creation and destruction lifecycle
    • make[X].from[XImpl].modify(fun(_)) = Create X using XImpl's constructor and apply fun to the result
    • make[X].from[XImpl].modifyBy(_.flatAp { (c: C, d: D) => (x: X) => c.method(x, d) }) = Create X using XImpl's constructor and modify its Functoid using the provided lambda - in this case by summoning additional C & D dependencies and applying C.method to X

    Set bindings:

    • many[X].add[X1].add[X2] = bind a Set of X, and add subtypes X1 and X2 created via their constructors to it. Sets can be bound in multiple different modules. All the elements of the same set in different modules will be joined together.
    • many[X].add(x1).add(x2) = add *instances* x1 and x2 to a Set[X]
    • many[X].add { y: Y => new X1(y).add { y: Y => X2(y) } = add instances of X1 and X2 constructed by a given Provider function
    • many[X].named("special").add[X1] = create a named set of X, all the elements of it are added to this named set.
    • many[X].ref[XImpl] = add a reference to an already **existing** binding of XImpl to a set of X's
    • many[X].ref[X]("special") = add a reference to an **existing** named binding of X to a set of X's

    Mutators:

    • modify[X](fun(_)) = add a modifier applying fun to the value bound at X (mutator application order is unspecified)
    • modify[X].by(_.flatAp { (c: C, d: D) => (x: X) => c.method(x, d) }) = add a modifier, applying the provided lambda to a Functoid retrieving X - in this case by summoning additional C & D dependencies and applying C.method to X

    Tags:

    • make[X].tagged("t1", "t2) = attach tags to X's binding.
    • many[X].add[X1].tagged("x1tag") = Tag a specific element of X. The tags of sets and their elements are separate.
    • many[X].tagged("xsettag") = Tag the binding of empty Set of X with a tag. The tags of sets and their elements are separate.

    Includes:

    • include(that: ModuleDef) = add all bindings in that module into this module

    See also

    TagK

    Id

    ModuleDefDSL

20.  trait ModuleMake[+T <: ModuleBase] extends Aux[T, T]
21.  final class With[T] extends Annotation with DIStageAnnotation

    This annotation lets you choose a more specific implementation for a result of factory method other than its return type.

    This annotation lets you choose a more specific implementation for a result of factory method other than its return type.

    Example:

    trait Actor {
      def id: UUID
    }
    
    trait ActorFactory {
      @With[ActorImpl]
      def newActor(id: UUID): Actor
    }
    
    class ActorImpl(val id: UUID, someDependency: SomeDependency) extends Actor
    class SomeDependency
    
    val module = new ModuleDef {
      make[ActorFactory]
      // generated factory implementation:
      //
      // make[ActorFactory].from {
      //  (someDependency: SomeDependency) =>
      //    new ActorFactory {
      //      override def newActor(id: UUID): Actor = {
      //        new ActorImpl(id, someDependency)
      //      }
      //    }
      // }
    }

    See also

    Auto-Factories

22.  final class impl extends Annotation with DIStageAnnotation

    An optional, documentation-only annotation conveying that an abstract class or a trait is the 'actual' implementation of its supertypes and will be bound later in DI with izumi.distage.constructors.TraitConstructor or izumi.distage.constructors.FactoryConstructor

    An optional, documentation-only annotation conveying that an abstract class or a trait is the 'actual' implementation of its supertypes and will be bound later in DI with izumi.distage.constructors.TraitConstructor or izumi.distage.constructors.FactoryConstructor

    Abstract classes or traits without obvious concrete subclasses may hinder the readability of a codebase, if you still want to use them to avoid writing the full constructor, you may use this annotation to aid the reader in understanding your intentions.

    @impl abstract class Impl(
      pluser: Pluser
    ) extends PlusedInt

    See also

    Auto-Traits

    Auto-Factories