Packages

final class MakeDSL[T] extends MakeDSLBase[T, MakeDSLUnnamedAfterFrom[T]] with MakeDSLMutBase[T]

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. MakeDSL
  2. MakeDSLMutBase
  3. MakeDSLBase
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new MakeDSL(mutableState: SingletonRef, key: TypeKey)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def addOp[R](op: SingletonInstruction)(newState: (SingletonRef) => R): R
    Attributes
    protected[this]
    Definition Classes
    MakeDSLMutBase
  5. def aliased[T1 >: T](name: String)(implicit arg0: Tag[T1], pos: CodePositionMaterializer): MakeDSLAfterAlias[T]
    Definition Classes
    MakeDSLMutBase
  6. def aliased[T1 >: T](implicit arg0: Tag[T1], pos: CodePositionMaterializer): MakeDSLAfterAlias[T]
    Definition Classes
    MakeDSLMutBase
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. def bind(impl: ImplDef): MakeDSLUnnamedAfterFrom[T]
    Attributes
    protected[this]
    Definition Classes
    MakeDSLMakeDSLBase
  9. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  10. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  11. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  12. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  13. final def from[I <: T](function: ProviderMagnet[I]): MakeDSLUnnamedAfterFrom[T]

    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)

    Annotation processing is done by a macro and macros are rarely perfect, Prefer passing an inline lambda such as { x => y } or a method reference such as (method _) or (method(_)) Annotation info may be lost ONLY in a few cases detailed below, though:

    • If an annotated method has been hidden by an intermediate val
    • If an .apply method of a case class is passed when case class _parameters_ are annotated, not their types

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

    When binding a case class to constructor, prefer passing new X(_) instead of X.apply _ because apply will not preserve parameter annotations from case class definitions:

    case class X(@Id("special") i: Int)
    
    make[X].from(X.apply _) // summons regular Int
    make[X].from(new X(_)) // summons special Int

    HOWEVER, if you annotate the types of parameters instead of their names, apply WILL work:

    case class X(i: Int @Id("special"))
    
    make[X].from(X.apply _) // summons special Int

    Using intermediate vals will lose annotations when converting a method into a function value, prefer using annotated method directly as method reference (method _):

    def constructorMethod(@Id("special") i: Int): Unit = ()
    
    val constructor = constructorMethod _
    
    make[Unit].from(constructor) // Will summon regular Int, not a "special" Int from DI object graph
    Definition Classes
    MakeDSLBase
    See also

    izumi.distage.model.reflection.macros.ProviderMagnetMacro

    'Magnet' in the name refers to the Magnet Pattern: http://spray.io/blog/2012-12-13-the-magnet-pattern/

  14. final def from[I <: T](function: => I)(implicit arg0: Tag[I]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  15. final def from[I <: T](implicit arg0: AnyConstructor[I]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  16. final def fromEffect[F[_], I <: T](function: ProviderMagnet[F[I]])(implicit arg0: TagK[F], arg1: Tag[I]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  17. final def fromEffect[F[_], I <: T](instance: F[I])(implicit arg0: TagK[F], arg1: Tag[I]): MakeDSLUnnamedAfterFrom[T]

    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))
    Definition Classes
    MakeDSLBase
  18. final def fromResource[R0, R <: DIResourceBase[Any, T]](function: ProviderMagnet[R0])(implicit adapt: Aux[R0, R], tag: ResourceTag[R]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  19. final def fromResource[R](function: ProviderMagnet[R with DIResourceBase[Any, T]])(implicit tag: ResourceTag[R]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  20. final def fromResource[R](instance: R with DIResourceBase[Any, T])(implicit tag: ResourceTag[R]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  21. final def fromResource[R <: DIResourceBase[Any, T]](implicit arg0: AnyConstructor[R], tag: ResourceTag[R]): MakeDSLUnnamedAfterFrom[T]

    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.Producer.produceF

    You can create resources with DIResource.make, by inheriting from DIResource 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)
    Definition Classes
    MakeDSLBase
    See also

    - cats.effect.Resource: https://typelevel.org/cats-effect/datatypes/resource.html

  22. final def fromValue[I <: T](instance: I)(implicit arg0: Tag[I]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  23. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  24. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  25. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  26. val key: TypeKey
    Attributes
    protected
    Definition Classes
    MakeDSLMakeDSLMutBaseMakeDSLBase
  27. val mutableState: SingletonRef
    Attributes
    protected
    Definition Classes
    MakeDSLMakeDSLMutBase
  28. def named[I](name: I)(implicit idContract: IdContract[I]): MakeNamedDSL[T]
  29. def namedByImpl: MakeNamedDSL[T]
  30. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  31. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  32. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  33. final def refEffect[F[_], I <: T, EFF <: F[I]](name: String)(implicit arg0: TagK[F], arg1: Tag[I], arg2: Tag[EFF]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  34. final def refEffect[F[_], I <: T, EFF <: F[I]](implicit arg0: TagK[F], arg1: Tag[I], arg2: Tag[EFF]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  35. final def refEffect[F[_], I <: T](name: String)(implicit arg0: TagK[F], arg1: Tag[I]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  36. final def refEffect[F[_], I <: T](implicit arg0: TagK[F], arg1: Tag[I]): MakeDSLUnnamedAfterFrom[T]

    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
    Definition Classes
    MakeDSLBase
  37. final def refResource[R <: DIResourceBase[Any, T]](name: String)(implicit tag: ResourceTag[R]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  38. final def refResource[R <: DIResourceBase[Any, T]](implicit tag: ResourceTag[R]): MakeDSLUnnamedAfterFrom[T]

    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

    Definition Classes
    MakeDSLBase
  39. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  40. def tagged(tags: BindingTag*): MakeDSL[T]
  41. def toString(): String
    Definition Classes
    AnyRef → Any
  42. def todo(implicit pos: CodePositionMaterializer): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  43. final def using[I <: T](name: String)(implicit arg0: Tag[I]): MakeDSLUnnamedAfterFrom[T]
    Definition Classes
    MakeDSLBase
  44. final def using[I <: T](implicit arg0: Tag[I]): MakeDSLUnnamedAfterFrom[T]

    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

    Definition Classes
    MakeDSLBase
  45. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  46. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  47. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from MakeDSLMutBase[T]

Inherited from MakeDSLBase[T, MakeDSLUnnamedAfterFrom[T]]

Inherited from AnyRef

Inherited from Any

Ungrouped