ZLayer

Companion class ZLayer

object ZLayer extends ZLayerCompanionVersionSpecific

Linear Supertypes

ZLayerCompanionVersionSpecific, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

ZLayer
ZLayerCompanionVersionSpecific
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

sealed trait Debug extends AnyRef
implicit final class ZLayerPassthroughOps[RIn, E, ROut] extends AnyVal
implicit final class ZLayerProjectOps[R, E, A] extends AnyVal
implicit final class ZLayerProvideSomeOps[RIn, E, ROut] extends AnyVal

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def apply[RIn, E, ROut](zio: ZIO[RIn, E, ROut])(implicit arg0: Tag[ROut], trace: ZTraceElement): ZLayer[RIn, E, ROut]
Constructs a layer from an effectual resource.
def apply[RIn, E, ROut](managed: ZManaged[RIn, E, ROut])(implicit arg0: Tag[ROut], trace: ZTraceElement): ZLayer[RIn, E, ROut]
Constructs a layer from a managed resource.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
def collectAll[R, E, A, Collection[+Element] <: Iterable[Element]](in: Collection[ZLayer[R, E, A]])(implicit arg0: Tag[A], tag: Tag[Collection[A]], bf: zio.BuildFrom[Collection[ZLayer[R, E, A]], A, Collection[A]], trace: ZTraceElement): ZLayer[R, E, Collection[A]]
Gathers up the ZLayer inside of the given collection, and combines them into a single ZLayer containing an equivalent collection of results.
final def die(t: Throwable)(implicit trace: ZTraceElement): ZLayer[Any, Nothing, Nothing]
Constructs a layer that dies with the specified throwable.
def environment[A](implicit trace: ZTraceElement): ZLayer[A, Nothing, A]
Constructs a layer that passes along the specified environment as an output.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fail[E](e: E)(implicit trace: ZTraceElement): Layer[E, Nothing]
Constructs a layer that fails with the specified error.
def failCause[E](cause: Cause[E])(implicit trace: ZTraceElement): Layer[E, Nothing]
Constructs a layer that fails with the specified cause.
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def foreach[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ ZLayer[R, E, B])(implicit arg0: Tag[B], tag: Tag[Collection[B]], bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZLayer[R, E, Collection[B]]
Applies the function f to each element of the Collection[A] and returns the results in a new Collection[B].
def fromAcquireRelease[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ URIO[R, Any])(implicit arg0: Tag[A], trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from acquire and release actions.
Constructs a layer from acquire and release actions. The acquire and release actions will be performed uninterruptibly.
def fromAcquireReleaseEnvironment[R, E, A](acquire: ZIO[R, E, ZEnvironment[A]])(release: (ZEnvironment[A]) ⇒ URIO[R, Any])(implicit trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from acquire and release actions, which must return one or more services.
Constructs a layer from acquire and release actions, which must return one or more services. The acquire and release actions will be performed uninterruptibly.
def fromFunction[A, B](f: (ZEnvironment[A]) ⇒ B)(implicit arg0: Tag[B], trace: ZTraceElement): ZLayer[A, Nothing, B]
Constructs a layer from the environment using the specified function.
def fromFunctionEnvironment[A, B](f: (ZEnvironment[A]) ⇒ ZEnvironment[B])(implicit trace: ZTraceElement): ZLayer[A, Nothing, B]
Constructs a layer from the environment using the specified function, which must return one or more services.
def fromFunctionEnvironmentManaged[A, E, B](f: (ZEnvironment[A]) ⇒ ZManaged[Any, E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]
Constructs a layer from the environment using the specified effectful resourceful function, which must return one or more services.
def fromFunctionEnvironmentZIO[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]
Constructs a layer from the environment using the specified effectful function, which must return one or more services.
def fromFunctionManaged[A, E, B](f: (ZEnvironment[A]) ⇒ ZManaged[Any, E, B])(implicit arg0: Tag[B], trace: ZTraceElement): ZLayer[A, E, B]
Constructs a layer from the environment using the specified effectful resourceful function.
def fromFunctionZIO[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, B])(implicit arg0: Tag[B], trace: ZTraceElement): ZLayer[A, E, B]
Constructs a layer from the environment using the specified effectful function.
def fromManaged[R, E, A](m: ZManaged[R, E, A])(implicit arg0: Tag[A], trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from a managed resource.
def fromManagedEnvironment[R, E, A](m: ZManaged[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from a managed resource, which must return one or more services.
def fromZIO[R, E, A](zio: ZIO[R, E, A])(implicit arg0: Tag[A], trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from the specified effect.
def fromZIOEnvironment[R, E, A](zio: ZIO[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from the specified effect, which must return one or more services.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def make[R]: WirePartiallyApplied[R]
Automatically assembles a layer for the provided type.
Automatically assembles a layer for the provided type.
```
ZLayer.make[Car](carLayer, wheelsLayer, engineLayer)
```
Definition Classes
ZLayerCompanionVersionSpecific
def makeCustom[R]: WireSomePartiallyApplied[ZEnv, R]
Automatically constructs a layer for the provided type R, leaving a remainder ZEnv.
Automatically constructs a layer for the provided type R, leaving a remainder ZEnv. This will satisfy all transitive ZEnv requirements with ZEnv.any, allowing them to be provided later.
```
val oldLadyLayer: ZLayer[Fly, Nothing, OldLady] = ???
val flyLayer: ZLayer[Blocking, Nothing, Fly] = ???

// The ZEnv you use later will provide both Blocking to flyLayer and Console to zio
val layer : ZLayer[ZEnv, Nothing, OldLady] = ZLayer.makeCustom[OldLady](oldLadyLayer, flyLayer)
```
Definition Classes
ZLayerCompanionVersionSpecific
def makeSome[R0, R]: WireSomePartiallyApplied[R0, R]
Automatically constructs a layer for the provided type R, leaving a remainder R0.
Automatically constructs a layer for the provided type R, leaving a remainder R0.
```
val carLayer: ZLayer[Engine with Wheels, Nothing, Car] = ???
val wheelsLayer: ZLayer[Any, Nothing, Wheels] = ???

val layer = ZLayer.makeSome[Engine, Car](carLayer, wheelsLayer)
```
Definition Classes
ZLayerCompanionVersionSpecific
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
def service[A](implicit arg0: Tag[A], trace: ZTraceElement): ZLayer[A, Nothing, A]
Constructs a layer that accesses and returns the specified service from the environment.
def succeed[A](a: A)(implicit arg0: Tag[A], trace: ZTraceElement): ULayer[A]
Constructs a layer from the specified value.
def succeedEnvironment[A](a: ZEnvironment[A])(implicit trace: ZTraceElement): ULayer[A]
Constructs a layer from the specified value, which must return one or more services.
def suspend[RIn, E, ROut](layer: ⇒ ZLayer[RIn, E, ROut]): ZLayer[RIn, E, ROut]
Lazily constructs a layer.
Lazily constructs a layer. This is useful to avoid infinite recursion when creating layers that refer to themselves.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
object Debug

Deprecated Value Members

def fromAcquireReleaseMany[R, E, A](acquire: ZIO[R, E, ZEnvironment[A]])(release: (ZEnvironment[A]) ⇒ URIO[R, Any])(implicit trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from acquire and release actions, which must return one or more services.
Constructs a layer from acquire and release actions, which must return one or more services. The acquire and release actions will be performed uninterruptibly.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromAcquireReleaseEnvironment
def fromEffect[R, E, A](zio: ZIO[R, E, A])(implicit arg0: Tag[A], trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from the specified effect.
Constructs a layer from the specified effect.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromZIO
def fromEffectMany[R, E, A](zio: ZIO[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from the specified effect, which must return one or more services.
Constructs a layer from the specified effect, which must return one or more services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromZIOMany
def fromFunctionM[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, B])(implicit arg0: Tag[B], trace: ZTraceElement): ZLayer[A, E, B]
Constructs a layer from the environment using the specified effectful function.
Constructs a layer from the environment using the specified effectful function.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromFunctionZIO
def fromFunctionMany[A, B](f: (ZEnvironment[A]) ⇒ ZEnvironment[B])(implicit trace: ZTraceElement): ZLayer[A, Nothing, B]
Constructs a layer from the environment using the specified function, which must return one or more services.
Constructs a layer from the environment using the specified function, which must return one or more services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromFunctionEnvironment
def fromFunctionManyM[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]
Constructs a layer from the environment using the specified effectful function, which must return one or more services.
Constructs a layer from the environment using the specified effectful function, which must return one or more services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromFunctionManyZIO
def fromFunctionManyManaged[A, E, B](f: (ZEnvironment[A]) ⇒ ZManaged[Any, E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]
Constructs a layer from the environment using the specified effectful resourceful function, which must return one or more services.
Constructs a layer from the environment using the specified effectful resourceful function, which must return one or more services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromFunctionEnvironmentManaged
def fromFunctionManyZIO[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]
Constructs a layer from the environment using the specified effectful function, which must return one or more services.
Constructs a layer from the environment using the specified effectful function, which must return one or more services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromFunctionEnvironmentZIO
def fromManagedMany[R, E, A](m: ZManaged[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from a managed resource, which must return one or more services.
Constructs a layer from a managed resource, which must return one or more services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromManagedEnvironment
def fromService[A, B](f: (A) ⇒ B)(implicit arg0: Tag[A], arg1: Tag[B], trace: ZTraceElement): ZLayer[A, Nothing, B]
Constructs a layer that purely depends on the specified service.
Constructs a layer that purely depends on the specified service.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServiceM[A, R, E, B](f: (A) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A], arg1: Tag[B], trace: ZTraceElement): ZLayer[R with A, E, B]
Constructs a layer that effectfully depends on the specified service.
Constructs a layer that effectfully depends on the specified service.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServiceManaged[A, R, E, B](f: (A) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A], arg1: Tag[B], trace: ZTraceElement): ZLayer[R with A, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified service.
Constructs a set of services that resourcefully and effectfully depends on the specified service.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServiceMany[A, B](f: (A) ⇒ ZEnvironment[B])(implicit arg0: Tag[A], trace: ZTraceElement): ZLayer[A, Nothing, B]
Constructs a layer that purely depends on the specified service, which must return one or more services.
Constructs a layer that purely depends on the specified service, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServiceManyM[A, R, E, B](f: (A) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A], trace: ZTraceElement): ZLayer[R with A, E, B]
Constructs a layer that effectfully depends on the specified service, which must return one or more services.
Constructs a layer that effectfully depends on the specified service, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServiceManyManaged[A, R, E, B](f: (A) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A], trace: ZTraceElement): ZLayer[R with A, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified service, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified service, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[A21], arg22: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20 with A21, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, B](f: (A0, A1, A2, A3, A4, A5, A6, A7) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, A6, B](f: (A0, A1, A2, A3, A4, A5, A6) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, A5, B](f: (A0, A1, A2, A3, A4, A5) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, A4, B](f: (A0, A1, A2, A3, A4) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, A3, B](f: (A0, A1, A2, A3) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, A2, B](f: (A0, A1, A2) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServices[A0, A1, B](f: (A0, A1) ⇒ B)(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[B], trace: ZTraceElement): ZLayer[A0 with A1, Nothing, B]
Constructs a layer that purely depends on the specified services.
Constructs a layer that purely depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[A21], arg22: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20 with A21, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, A6, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, A5, R, E, B](f: (A0, A1, A2, A3, A4, A5) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, A4, R, E, B](f: (A0, A1, A2, A3, A4) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, A3, R, E, B](f: (A0, A1, A2, A3) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, A2, R, E, B](f: (A0, A1, A2) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesM[A0, A1, R, E, B](f: (A0, A1) ⇒ ZIO[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1, E, B]
Constructs a layer that effectfully depends on the specified services.
Constructs a layer that effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[A21], arg22: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20 with A21, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified service.
Constructs a set of services that resourcefully and effectfully depends on the specified service.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified service.
Constructs a set of services that resourcefully and effectfully depends on the specified service.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified service.
Constructs a set of services that resourcefully and effectfully depends on the specified service.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, A7, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, A6, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, A5, R, E, B](f: (A0, A1, A2, A3, A4, A5) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, A4, R, E, B](f: (A0, A1, A2, A3, A4) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, A3, R, E, B](f: (A0, A1, A2, A3) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, A2, R, E, B](f: (A0, A1, A2) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManaged[A0, A1, R, E, B](f: (A0, A1) ⇒ ZManaged[R, E, B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[B], trace: ZTraceElement): ZLayer[R with A0 with A1, E, B]
Constructs a set of services that resourcefully and effectfully depends on the specified services.
Constructs a set of services that resourcefully and effectfully depends on the specified services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[A21], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20 with A21, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, A8, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, A7, B](f: (A0, A1, A2, A3, A4, A5, A6, A7) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, A6, B](f: (A0, A1, A2, A3, A4, A5, A6) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, A5, B](f: (A0, A1, A2, A3, A4, A5) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, A4, B](f: (A0, A1, A2, A3, A4) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, A3, B](f: (A0, A1, A2, A3) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, A2, B](f: (A0, A1, A2) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], trace: ZTraceElement): ZLayer[A0 with A1 with A2, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesMany[A0, A1, B](f: (A0, A1) ⇒ ZEnvironment[B])(implicit arg0: Tag[A0], arg1: Tag[A1], trace: ZTraceElement): ZLayer[A0 with A1, Nothing, B]
Constructs a layer that purely depends on the specified services, which must return one or more services.
Constructs a layer that purely depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromService.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[A21], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20 with A21, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, A8, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, A7, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, A6, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, A5, R, E, B](f: (A0, A1, A2, A3, A4, A5) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, A4, R, E, B](f: (A0, A1, A2, A3, A4) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, A3, R, E, B](f: (A0, A1, A2, A3) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, A2, R, E, B](f: (A0, A1, A2) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyM[A0, A1, R, E, B](f: (A0, A1) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], trace: ZTraceElement): ZLayer[R with A0 with A1, E, B]
Constructs a layer that effectfully depends on the specified services, which must return one or more services.
Constructs a layer that effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceM.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], arg21: Tag[A21], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20 with A21, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], arg20: Tag[A20], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], arg19: Tag[A19], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], arg18: Tag[A18], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], arg17: Tag[A17], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], arg16: Tag[A16], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], arg15: Tag[A15], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], arg14: Tag[A14], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], arg13: Tag[A13], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], arg12: Tag[A12], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], arg11: Tag[A11], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], arg10: Tag[A10], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], arg9: Tag[A9], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, A8, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], arg8: Tag[A8], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, A7, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], arg7: Tag[A7], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, A6, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], arg6: Tag[A6], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, A5, R, E, B](f: (A0, A1, A2, A3, A4, A5) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], arg5: Tag[A5], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, A4, R, E, B](f: (A0, A1, A2, A3, A4) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], arg4: Tag[A4], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, A3, R, E, B](f: (A0, A1, A2, A3) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], arg3: Tag[A3], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, A2, R, E, B](f: (A0, A1, A2) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], arg2: Tag[A2], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromServicesManyManaged[A0, A1, R, E, B](f: (A0, A1) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: Tag[A0], arg1: Tag[A1], trace: ZTraceElement): ZLayer[R with A0 with A1, E, B]
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services.
Constructs a layer that resourcefully and effectfully depends on the specified services, which must return one or more services. For the more common variant that returns a single service see fromServiceManaged.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use toLayer
def fromZIOMany[R, E, A](zio: ZIO[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]
Constructs a layer from the specified effect, which must return one or more services.
Constructs a layer from the specified effect, which must return one or more services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromZIOEnvironment
def identity[A](implicit arg0: zio.EnvironmentTag[A], trace: ZTraceElement): ZLayer[A, Nothing, A]
An identity layer that passes along its inputs.
An identity layer that passes along its inputs. Note that this represents an identity with respect to the >>> operator. It represents an identity with respect to the ++ operator when the environment type is Any.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use environment
def requires[A](implicit arg0: zio.EnvironmentTag[A], trace: ZTraceElement): ZLayer[A, Nothing, A]
Constructs a layer that passes along the specified environment as an output.
Constructs a layer that passes along the specified environment as an output.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use environment
def succeedMany[A](a: ZEnvironment[A])(implicit trace: ZTraceElement): ULayer[A]
Constructs a layer from the specified value, which must return one or more services.
Constructs a layer from the specified value, which must return one or more services.

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use succeedEnvironment

Packages

ZLayer

Companion class ZLayer

object ZLayer extends ZLayerCompanionVersionSpecific

Type Members

Value Members

Deprecated Value Members

Inherited from ZLayerCompanionVersionSpecific

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

ZLayer 

Companion class ZLayer

object ZLayer extends ZLayerCompanionVersionSpecific

Type Members

Value Members

Deprecated Value Members

Inherited from ZLayerCompanionVersionSpecific

Inherited from AnyRef

Inherited from Any

Ungrouped

ZLayer