Subcontext

izumi.distage.Subcontext
trait Subcontext[F[_], +A]

Attributes

See also
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class SubcontextImpl[F, A]

Members list

Value members

Abstract methods

def plan: Plan
def produce()(implicit F: QuasiIO[F], tagK: Tag[F]): Lifecycle[F, A]
def produceRun[B](f: A => F[B])(implicit F: QuasiIO[F], tagK: Tag[F]): F[B]

Same as .produce[F]().use(f)

Same as .produce[F]().use(f)

Attributes

Note

Resources allocated by the subcontext will be closed after f exits. Use produce if you need to extend the lifetime of the Subcontext's resources.

def provide[T](value: T)(implicit evidence$1: Tag[T], pos: CodePositionMaterializer): Subcontext[F, A]
def provide[T](name: Identifier)(value: T)(implicit evidence$1: Tag[T], pos: CodePositionMaterializer): Subcontext[F, A]
def unsafeModify[B](f: Functoid[A] => Functoid[B]): Subcontext[F, B]

Unsafely substitute the Functoid that extracts the root component.

Unsafely substitute the Functoid that extracts the root component.

Note, because the plan has been calculated ahead of time with A as the root, it's not possible to request additional components via Functoid that weren't already in the graph as dependencies of A – everything that A doesn't depend on is not in the plan.

Example:

val submodule = new ModuleDef {
 make[Int].fromValue(3)
 make[Int].named("five").from((_: Int) + 2)
 make[String].fromValue("x")
}

makeSubcontext[Int].named("five").withSubmodule(submodule)

...

(subcontext: Subcontext[Int])
 .unsafeModify(_ => Functoid.identity[String])
 .produceRun(println(_))
 // error: `String` is not available

A binding for String is defined in the submodule, but is not referenced by Int @Id("five") binding. Therefore, it was removed by garbage collection and cannot be extracted with this Subcontext. You'd have to create another Subcontext[String] with the same submodule to create String:

makeSubcontext[String](submodule)

...

(subcontext: Subcontext[String])
 .produceRun(println(_))
 // x

If you DO need dynamic replanning, you'll need to use nested injection directly.

Attributes

Concrete methods

final def map[B : Tag](f: A => B): Subcontext[F, B]
final def widen[B >: A]: Subcontext[F, B]
final def widen[B](implicit ev: A <:< B): Subcontext[F, B]
final def widenF[G[x]]: Subcontext[G, A]
final def widenF[G[_]](implicit ev: F[Unit] <:< G[Unit]): Subcontext[G, A]

Deprecated methods

final def produceRunSimple[B](f: A => B)(implicit ev: F[Unit] <:< Identity[Unit]): B

Attributes

Deprecated
[Since version 1.3.0] use regular produceRun with Subcontext[F = Identity]