Skip to main content Link Search Menu Expand Document (external link)

Layer overview

A Layer<ROut, E, RIn> describes how to build one or more services in your application. Services can be injected into effects via Effect.provideService. Effects can require services via Effect.service.

Layer can be thought of as recipes for producing bundles of services, given their dependencies (other services).

Construction of services can be effectful and utilize resources that must be acquired and safely released when the services are done being utilized.

By default layers are shared, meaning that if the same layer is used twice the layer will only be allocated a single time.

Because of their excellent composition properties, layers are the idiomatic way in Effect-TS to create services that depend on other services.

Added in v2.0.0


Table of contents


clock

setClock

Signature

export declare const setClock: <A extends Clock.Clock>(clock: A) => Layer<never>

Added in v2.0.0

config

setConfigProvider

Sets the current ConfigProvider.

Signature

export declare const setConfigProvider: (configProvider: ConfigProvider) => Layer<never>

Added in v2.0.0

constructors

context

Constructs a Layer that passes along the specified context as an output.

Signature

export declare const context: <R>() => Layer<R, never, R>

Added in v2.0.0

die

Constructs a layer that dies with the specified defect.

Signature

export declare const die: (defect: unknown) => Layer<unknown>

Added in v2.0.0

dieSync

Constructs a layer that dies with the specified defect.

Signature

export declare const dieSync: (evaluate: LazyArg<unknown>) => Layer<unknown>

Added in v2.0.0

effect

Constructs a layer from the specified effect.

Signature

export declare const effect: {
  <T extends Context.Tag<any, any>>(
    tag: T
  ): <E, R>(effect: Effect.Effect<Context.Tag.Service<T>, E, R>) => Layer<Context.Tag.Identifier<T>, E, R>
  <T extends Context.Tag<any, any>, E, R>(
    tag: T,
    effect: Effect.Effect<Context.Tag.Service<T>, E, R>
  ): Layer<Context.Tag.Identifier<T>, E, R>
}

Added in v2.0.0

effectContext

Constructs a layer from the specified effect, which must return one or more services.

Signature

export declare const effectContext: <A, E, R>(effect: Effect.Effect<Context.Context<A>, E, R>) => Layer<A, E, R>

Added in v2.0.0

effectDiscard

Constructs a layer from the specified effect discarding it’s output.

Signature

export declare const effectDiscard: <X, E, R>(effect: Effect.Effect<X, E, R>) => Layer<never, E, R>

Added in v2.0.0

empty

A Layer that constructs an empty Context.

Signature

export declare const empty: Layer<never, never, never>

Added in v2.0.0

fail

Constructs a layer that fails with the specified error.

Signature

export declare const fail: <E>(error: E) => Layer<unknown, E, never>

Added in v2.0.0

failCause

Constructs a layer that fails with the specified cause.

Signature

export declare const failCause: <E>(cause: Cause.Cause<E>) => Layer<unknown, E, never>

Added in v2.0.0

failCauseSync

Constructs a layer that fails with the specified cause.

Signature

export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Layer<unknown, E, never>

Added in v2.0.0

failSync

Constructs a layer that fails with the specified error.

Signature

export declare const failSync: <E>(evaluate: LazyArg<E>) => Layer<unknown, E, never>

Added in v2.0.0

function

Constructs a layer from the context using the specified function.

Signature

export declare const function: <A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(tagA: A, tagB: B, f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>) => Layer<Context.Tag.Identifier<B>, never, Context.Tag.Identifier<A>>

Added in v2.0.0

scope

A layer that constructs a scope and closes it when the workflow the layer is provided to completes execution, whether by success, failure, or interruption. This can be used to close a scope when providing a layer to a workflow.

Signature

export declare const scope: Layer<Scope.CloseableScope, never, never>

Added in v2.0.0

scoped

Constructs a layer from the specified scoped effect.

Signature

export declare const scoped: {
  <T extends Context.Tag<any, any>>(
    tag: T
  ): <E, R>(
    effect: Effect.Effect<Context.Tag.Service<T>, E, R>
  ) => Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>
  <T extends Context.Tag<any, any>, E, R>(
    tag: T,
    effect: Effect.Effect<Context.Tag.Service<T>, E, R>
  ): Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>
}

Added in v2.0.0

scopedContext

Constructs a layer from the specified scoped effect, which must return one or more services.

Signature

export declare const scopedContext: <A, E, R>(
  effect: Effect.Effect<Context.Context<A>, E, R>
) => Layer<A, E, Exclude<R, Scope.Scope>>

Added in v2.0.0

scopedDiscard

Constructs a layer from the specified scoped effect.

Signature

export declare const scopedDiscard: <X, E, R>(
  effect: Effect.Effect<X, E, R>
) => Layer<never, E, Exclude<R, Scope.Scope>>

Added in v2.0.0

service

Constructs a layer that accesses and returns the specified service from the context.

Signature

export declare const service: <T extends Context.Tag<any, any>>(
  tag: T
) => Layer<Context.Tag.Identifier<T>, never, Context.Tag.Identifier<T>>

Added in v2.0.0

succeed

Constructs a layer from the specified value.

Signature

export declare const succeed: {
  <T extends Context.Tag<any, any>>(
    tag: T
  ): (resource: Context.Tag.Service<T>) => Layer<Context.Tag.Identifier<T>, never, never>
  <T extends Context.Tag<any, any>>(
    tag: T,
    resource: Context.Tag.Service<T>
  ): Layer<Context.Tag.Identifier<T>, never, never>
}

Added in v2.0.0

succeedContext

Constructs a layer from the specified value, which must return one or more services.

Signature

export declare const succeedContext: <A>(context: Context.Context<A>) => Layer<A, never, never>

Added in v2.0.0

suspend

Lazily constructs a layer. This is useful to avoid infinite recursion when creating layers that refer to themselves.

Signature

export declare const suspend: <RIn, E, ROut>(evaluate: LazyArg<Layer<ROut, E, RIn>>) => Layer<ROut, E, RIn>

Added in v2.0.0

sync

Lazily constructs a layer from the specified value.

Signature

export declare const sync: {
  <T extends Context.Tag<any, any>>(
    tag: T
  ): (evaluate: LazyArg<Context.Tag.Service<T>>) => Layer<Context.Tag.Identifier<T>, never, never>
  <T extends Context.Tag<any, any>>(
    tag: T,
    evaluate: LazyArg<Context.Tag.Service<T>>
  ): Layer<Context.Tag.Identifier<T>, never, never>
}

Added in v2.0.0

syncContext

Lazily constructs a layer from the specified value, which must return one or more services.

Signature

export declare const syncContext: <A>(evaluate: LazyArg<Context.Context<A>>) => Layer<A, never, never>

Added in v2.0.0

conversions

launch

Builds this layer and uses it until it is interrupted. This is useful when your entire application is a layer, such as an HTTP server.

Signature

export declare const launch: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<never, E, RIn>

Added in v2.0.0

toRuntime

Converts a layer that requires no services into a scoped runtime, which can be used to execute effects.

Signature

export declare const toRuntime: <RIn, E, ROut>(
  self: Layer<ROut, E, RIn>
) => Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>

Added in v2.0.0

toRuntimeWithMemoMap

Converts a layer that requires no services into a scoped runtime, which can be used to execute effects.

Signature

export declare const toRuntimeWithMemoMap: {
  (
    memoMap: MemoMap
  ): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>
  <RIn, E, ROut>(
    self: Layer<ROut, E, RIn>,
    memoMap: MemoMap
  ): Effect.Effect<Runtime.Runtime<ROut>, E, Scope.Scope | RIn>
}

Added in v2.0.0

destructors

build

Builds a layer into a scoped value.

Signature

export declare const build: <RIn, E, ROut>(
  self: Layer<ROut, E, RIn>
) => Effect.Effect<Context.Context<ROut>, E, Scope.Scope | RIn>

Added in v2.0.0

buildWithScope

Builds a layer into an Effect value. Any resources associated with this layer will be released when the specified scope is closed unless their scope has been extended. This allows building layers where the lifetime of some of the services output by the layer exceed the lifetime of the effect the layer is provided to.

Signature

export declare const buildWithScope: {
  (scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>
  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, scope: Scope.Scope): Effect.Effect<Context.Context<ROut>, E, RIn>
}

Added in v2.0.0

error handling

catchAll

Recovers from all errors.

Signature

export declare const catchAll: {
  <E, RIn2, E2, ROut2>(
    onError: (error: E) => Layer<ROut2, E2, RIn2>
  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>
  <RIn, E, ROut, RIn2, E2, ROut2>(
    self: Layer<ROut, E, RIn>,
    onError: (error: E) => Layer<ROut2, E2, RIn2>
  ): Layer<ROut & ROut2, E2, RIn | RIn2>
}

Added in v2.0.0

catchAllCause

Recovers from all errors.

Signature

export declare const catchAllCause: {
  <E, RIn2, E2, ROut2>(
    onError: (cause: Cause.Cause<E>) => Layer<ROut2, E2, RIn2>
  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut & ROut2, E2, RIn2 | RIn>
  <RIn, E, ROut, RIn2, E2, ROut22>(
    self: Layer<ROut, E, RIn>,
    onError: (cause: Cause.Cause<E>) => Layer<ROut22, E2, RIn2>
  ): Layer<ROut & ROut22, E2, RIn | RIn2>
}

Added in v2.0.0

orDie

Translates effect failure into death of the fiber, making all failures unchecked and not a part of the type of the layer.

Signature

export declare const orDie: <A, E, R>(self: Layer<A, E, R>) => Layer<A, never, R>

Added in v2.0.0

orElse

Executes this layer and returns its output, if it succeeds, but otherwise executes the specified layer.

Signature

export declare const orElse: {
  <A2, E2, R2>(that: LazyArg<Layer<A2, E2, R2>>): <A, E, R>(self: Layer<A, E, R>) => Layer<A & A2, E2 | E, R2 | R>
  <A, E, R, A2, E2, R2>(self: Layer<A, E, R>, that: LazyArg<Layer<A2, E2, R2>>): Layer<A & A2, E | E2, R | R2>
}

Added in v2.0.0

folding

match

Feeds the error or output services of this layer into the input of either the specified failure or success layers, resulting in a new layer with the inputs of this layer, and the error or outputs of the specified layer.

Signature

export declare const match: {
  <E, A2, E2, R2, A, A3, E3, R3>(options: {
    readonly onFailure: (error: E) => Layer<A2, E2, R2>
    readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
  }): <R>(self: Layer<A, E, R>) => Layer<A2 & A3, E2 | E3, R2 | R3 | R>
  <A, E, R, A2, E2, R2, A3, E3, R3>(
    self: Layer<A, E, R>,
    options: {
      readonly onFailure: (error: E) => Layer<A2, E2, R2>
      readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
    }
  ): Layer<A2 & A3, E2 | E3, R | R2 | R3>
}

Added in v2.0.0

matchCause

Feeds the error or output services of this layer into the input of either the specified failure or success layers, resulting in a new layer with the inputs of this layer, and the error or outputs of the specified layer.

Signature

export declare const matchCause: {
  <E, A2, E2, R2, A, A3, E3, R3>(options: {
    readonly onFailure: (cause: Cause.Cause<E>) => Layer<A2, E2, R2>
    readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
  }): <R>(self: Layer<A, E, R>) => Layer<A2 & A3, E2 | E3, R2 | R3 | R>
  <A, E, R, A2, E2, R2, A3, E3, R3>(
    self: Layer<A, E, R>,
    options: {
      readonly onFailure: (cause: Cause.Cause<E>) => Layer<A2, E2, R2>
      readonly onSuccess: (context: Context.Context<A>) => Layer<A3, E3, R3>
    }
  ): Layer<A2 & A3, E2 | E3, R | R2 | R3>
}

Added in v2.0.0

getters

isFresh

Returns true if the specified Layer is a fresh version that will not be shared, false otherwise.

Signature

export declare const isFresh: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => boolean

Added in v2.0.0

isLayer

Returns true if the specified value is a Layer, false otherwise.

Signature

export declare const isLayer: (u: unknown) => u is Layer<unknown, unknown, unknown>

Added in v2.0.0

logging

setUnhandledErrorLogLevel

Signature

export declare const setUnhandledErrorLogLevel: (level: Option.Option<LogLevel>) => Layer<never>

Added in v2.0.0

mapping

discard

Replaces the layer’s output with void and includes the layer only for its side-effects.

Signature

export declare const discard: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<never, E, RIn>

Added in v2.0.0

map

Returns a new layer whose output is mapped by the specified function.

Signature

export declare const map: {
  <A, B>(f: (context: Context.Context<A>) => Context.Context<B>): <E, R>(self: Layer<A, E, R>) => Layer<B, E, R>
  <A, E, R, B>(self: Layer<A, E, R>, f: (context: Context.Context<A>) => Context.Context<B>): Layer<B, E, R>
}

Added in v2.0.0

mapError

Returns a layer with its error channel mapped using the specified function.

Signature

export declare const mapError: {
  <E, E2>(f: (error: E) => E2): <A, R>(self: Layer<A, E, R>) => Layer<A, E2, R>
  <A, E, R, E2>(self: Layer<A, E, R>, f: (error: E) => E2): Layer<A, E2, R>
}

Added in v2.0.0

memo map

buildWithMemoMap

Builds a layer into an Effect value, using the specified MemoMap to memoize the layer construction.

Signature

export declare const buildWithMemoMap: {
  (
    memoMap: MemoMap,
    scope: Scope.Scope
  ): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect.Effect<Context.Context<ROut>, E, RIn>
  <RIn, E, ROut>(
    self: Layer<ROut, E, RIn>,
    memoMap: MemoMap,
    scope: Scope.Scope
  ): Effect.Effect<Context.Context<ROut>, E, RIn>
}

Added in v2.0.0

makeMemoMap

Constructs a MemoMap that can be used to build additional layers.

Signature

export declare const makeMemoMap: Effect.Effect<MemoMap, never, never>

Added in v2.0.0

models

Layer (interface)

Signature

export interface Layer<in ROut, out E = never, out RIn = never> extends Layer.Variance<ROut, E, RIn>, Pipeable {}

Added in v2.0.0

MemoMap (interface)

Signature

export interface MemoMap {
  readonly [MemoMapTypeId]: MemoMapTypeId

  /** @internal */
  readonly getOrElseMemoize: <RIn, E, ROut>(
    layer: Layer<ROut, E, RIn>,
    scope: Scope.Scope
  ) => Effect.Effect<Context.Context<ROut>, E, RIn>
}

Added in v2.0.0

requests & batching

setRequestBatching

Signature

export declare const setRequestBatching: (requestBatching: boolean) => Layer<never>

Added in v2.0.0

setRequestCache

Signature

export declare const setRequestCache: {
  <E, R>(cache: Effect.Effect<Request.Cache, E, R>): Layer<never, E, Exclude<R, Scope.Scope>>
  (cache: Request.Cache): Layer<never>
}

Added in v2.0.0

setRequestCaching

Signature

export declare const setRequestCaching: (requestCaching: boolean) => Layer<never>

Added in v2.0.0

retrying

retry

Retries constructing this layer according to the specified schedule.

Signature

export declare const retry: {
  <X, E, RIn2>(
    schedule: Schedule.Schedule<X, E, RIn2>
  ): <ROut, RIn>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
  <ROut, E, RIn, X, RIn2>(
    self: Layer<ROut, E, RIn>,
    schedule: Schedule.Schedule<X, E, RIn2>
  ): Layer<ROut, E, RIn | RIn2>
}

Added in v2.0.0

scheduler

setScheduler

Signature

export declare const setScheduler: (scheduler: Scheduler.Scheduler) => Layer<never>

Added in v2.0.0

sequencing

flatMap

Constructs a layer dynamically based on the output of this layer.

Signature

export declare const flatMap: {
  <A, A2, E2, R2>(
    f: (context: Context.Context<A>) => Layer<A2, E2, R2>
  ): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
  <A, E, R, A2, E2, R2>(
    self: Layer<A, E, R>,
    f: (context: Context.Context<A>) => Layer<A2, E2, R2>
  ): Layer<A2, E | E2, R | R2>
}

Added in v2.0.0

flatten

Flattens layers nested in the context of an effect.

Signature

export declare const flatten: {
  <I, A, E2, R2>(tag: Context.Tag<I, Layer<A, E2, R2>>): <E, R>(self: Layer<I, E, R>) => Layer<A, E2 | E, R2 | R>
  <I, E, R, A, E2, R2>(self: Layer<I, E, R>, tag: Context.Tag<I, Layer<A, E2, R2>>): Layer<A, E | E2, R | R2>
}

Added in v2.0.0

tap

Performs the specified effect if this layer succeeds.

Signature

export declare const tap: {
  <ROut, XR extends ROut, RIn2, E2, X>(
    f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>
  ): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E2 | E, RIn2 | RIn>
  <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
    self: Layer<ROut, E, RIn>,
    f: (context: Context.Context<XR>) => Effect.Effect<X, E2, RIn2>
  ): Layer<ROut, E | E2, RIn | RIn2>
}

Added in v2.0.0

tapError

Performs the specified effect if this layer fails.

Signature

export declare const tapError: {
  <E, XE extends E, RIn2, E2, X>(
    f: (e: XE) => Effect.Effect<X, E2, RIn2>
  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>
  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
    self: Layer<ROut, E, RIn>,
    f: (e: XE) => Effect.Effect<X, E2, RIn2>
  ): Layer<ROut, E | E2, RIn | RIn2>
}

Added in v2.0.0

tapErrorCause

Performs the specified effect if this layer fails.

Signature

export declare const tapErrorCause: {
  <E, XE extends E, RIn2, E2, X>(
    f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>
  ): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn2 | RIn>
  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
    self: Layer<ROut, E, RIn>,
    f: (cause: Cause.Cause<XE>) => Effect.Effect<X, E2, RIn2>
  ): Layer<ROut, E | E2, RIn | RIn2>
}

Added in v2.0.0

symbols

LayerTypeId

Signature

export declare const LayerTypeId: typeof LayerTypeId

Added in v2.0.0

LayerTypeId (type alias)

Signature

export type LayerTypeId = typeof LayerTypeId

Added in v2.0.0

MemoMapTypeId

Signature

export declare const MemoMapTypeId: typeof MemoMapTypeId

Added in v2.0.0

MemoMapTypeId (type alias)

Signature

export type MemoMapTypeId = typeof MemoMapTypeId

Added in v2.0.0

tracing

parentSpan

Adds the provided span to the span stack.

Signature

export declare const parentSpan: (span: Tracer.ParentSpan) => Layer<Tracer.ParentSpan>

Added in v2.0.0

setTracer

Create a Layer that sets the current Tracer

Signature

export declare const setTracer: (tracer: Tracer.Tracer) => Layer<never>

Added in v2.0.0

setTracerEnabled

Signature

export declare const setTracerEnabled: (enabled: boolean) => Layer<never>

Added in v2.0.0

setTracerTiming

Signature

export declare const setTracerTiming: (enabled: boolean) => Layer<never>

Added in v2.0.0

span

Create and add a span to the current span stack.

The span is ended when the Layer is released.

Signature

export declare const span: (
  name: string,
  options?:
    | {
        readonly attributes?: Record<string, unknown> | undefined
        readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
        readonly parent?: Tracer.ParentSpan | undefined
        readonly root?: boolean | undefined
        readonly context?: Context.Context<never> | undefined
        readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined
      }
    | undefined
) => Layer<Tracer.ParentSpan>

Added in v2.0.0

withParentSpan

Signature

export declare const withParentSpan: {
  (span: Tracer.ParentSpan): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
  <A, E, R>(self: Layer<A, E, R>, span: Tracer.ParentSpan): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
}

Added in v2.0.0

withSpan

Signature

export declare const withSpan: {
  (
    name: string,
    options?:
      | {
          readonly attributes?: Record<string, unknown> | undefined
          readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
          readonly parent?: Tracer.ParentSpan | undefined
          readonly root?: boolean | undefined
          readonly context?: Context.Context<never> | undefined
          readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined
        }
      | undefined
  ): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, Exclude<R, Tracer.ParentSpan>>
  <A, E, R>(
    self: Layer<A, E, R>,
    name: string,
    options?:
      | {
          readonly attributes?: Record<string, unknown> | undefined
          readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
          readonly parent?: Tracer.ParentSpan | undefined
          readonly root?: boolean | undefined
          readonly context?: Context.Context<never> | undefined
          readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined
        }
      | undefined
  ): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
}

Added in v2.0.0

utils

Layer (namespace)

Added in v2.0.0

Variance (interface)

Signature

export interface Variance<in ROut, out E, out RIn> {
  readonly [LayerTypeId]: {
    readonly _ROut: Types.Contravariant<ROut>
    readonly _E: Types.Covariant<E>
    readonly _RIn: Types.Covariant<RIn>
  }
}

Added in v2.0.0

Context (type alias)

Signature

export type Context<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>]
  ? _RIn
  : never

Added in v2.0.0

Error (type alias)

Signature

export type Error<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>]
  ? _E
  : never

Added in v2.0.0

Success (type alias)

Signature

export type Success<T extends Layer<never, any, any>> = [T] extends [Layer<infer _ROut, infer _E, infer _RIn>]
  ? _ROut
  : never

Added in v2.0.0

extendScope

Extends the scope of this layer, returning a new layer that when provided to an effect will not immediately release its associated resources when that effect completes execution but instead when the scope the resulting effect depends on is closed.

Signature

export declare const extendScope: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, Scope.Scope | RIn>

Added in v2.0.0

fiberRefLocallyScopedWith

Signature

export declare const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) => A) => Layer<never>

Added in v2.0.0

fresh

Creates a fresh version of this layer that will not be shared.

Signature

export declare const fresh: <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>

Added in v2.0.0

locally

Signature

export declare const locally: {
  <X>(ref: FiberRef<X>, value: X): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
  <A, E, R, X>(self: Layer<A, E, R>, ref: FiberRef<X>, value: X): Layer<A, E, R>
}

Added in v2.0.0

locallyEffect

Signature

export declare const locallyEffect: {
  <RIn, E, ROut, RIn2, E2, ROut2>(
    f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>
  ): (self: Layer<ROut, E, RIn>) => Layer<ROut2, E2, RIn2>
  <RIn, E, ROut, RIn2, E2, ROut2>(
    self: Layer<ROut, E, RIn>,
    f: (_: Effect.Effect<RIn, E, Context.Context<ROut>>) => Effect.Effect<RIn2, E2, Context.Context<ROut2>>
  ): Layer<ROut2, E2, RIn2>
}

Added in v2.0.0

locallyScoped

Signature

export declare const locallyScoped: <A>(self: FiberRef<A>, value: A) => Layer<never>

Added in v2.0.0

locallyWith

Signature

export declare const locallyWith: {
  <X>(ref: FiberRef<X>, value: (_: X) => X): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
  <A, E, R, X>(self: Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X): Layer<A, E, R>
}

Added in v2.0.0

memoize

Returns a scoped effect that, if evaluated, will return the lazily computed result of this layer.

Signature

export declare const memoize: <RIn, E, ROut>(
  self: Layer<ROut, E, RIn>
) => Effect.Effect<Layer<ROut, E, RIn>, never, Scope.Scope>

Added in v2.0.0

passthrough

Returns a new layer that produces the outputs of this layer but also passes through the inputs.

Signature

export declare const passthrough: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Layer<RIn | ROut, E, RIn>

Added in v2.0.0

project

Projects out part of one of the services output by this layer using the specified function.

Signature

export declare const project: {
  <A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(
    tagA: A,
    tagB: B,
    f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>
  ): <RIn, E>(self: Layer<Context.Tag.Identifier<A>, E, RIn>) => Layer<Context.Tag.Identifier<B>, E, RIn>
  <RIn, E, A extends Context.Tag<any, any>, B extends Context.Tag<any, any>>(
    self: Layer<Context.Tag.Identifier<A>, E, RIn>,
    tagA: A,
    tagB: B,
    f: (a: Context.Tag.Service<A>) => Context.Tag.Service<B>
  ): Layer<Context.Tag.Identifier<B>, E, RIn>
}

Added in v2.0.0

provide

Feeds the output services of this builder into the input of the specified builder, resulting in a new builder with the inputs of this builder as well as any leftover inputs, and the outputs of the specified builder.

Signature

export declare const provide: {
  <RIn, E, ROut>(
    self: Layer<ROut, E, RIn>
  ): <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>) => Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
  <RIn2, E2, ROut2, RIn, E, ROut>(
    that: Layer<ROut2, E2, RIn2>,
    self: Layer<ROut, E, RIn>
  ): Layer<ROut2, E2 | E, RIn | Exclude<RIn2, ROut>>
}

Added in v2.0.0

provideMerge

Feeds the output services of this layer into the input of the specified layer, resulting in a new layer with the inputs of this layer, and the outputs of both layers.

Signature

export declare const provideMerge: {
  <RIn, E, ROut>(
    self: Layer<ROut, E, RIn>
  ): <RIn2, E2, ROut2>(that: Layer<ROut2, E2, RIn2>) => Layer<ROut | ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
  <RIn2, E2, ROut2, RIn, E, ROut>(
    that: Layer<ROut2, E2, RIn2>,
    self: Layer<ROut, E, RIn>
  ): Layer<ROut2 | ROut, E2 | E, RIn | Exclude<RIn2, ROut>>
}

Added in v2.0.0

unwrapEffect

Signature

export declare const unwrapEffect: <A, E1, R1, E, R>(
  self: Effect.Effect<Layer<A, E1, R1>, E, R>
) => Layer<A, E1 | E, R1 | R>

Added in v2.0.0

unwrapScoped

Signature

export declare const unwrapScoped: <A, E1, R1, E, R>(
  self: Effect.Effect<Layer<A, E1, R1>, E, R>
) => Layer<A, E1 | E, R1 | Exclude<R, Scope.Scope>>

Added in v2.0.0

zipping

merge

Merges this layer with the specified layer concurrently, producing a new layer with combined input and output types.

Signature

export declare const merge: {
  <RIn2, E2, ROut2>(
    that: Layer<ROut2, E2, RIn2>
  ): <RIn, E1, ROut>(self: Layer<ROut, E1, RIn>) => Layer<ROut2 | ROut, E2 | E1, RIn2 | RIn>
  <RIn, E1, ROut, RIn2, E2, ROut2>(
    self: Layer<ROut, E1, RIn>,
    that: Layer<ROut2, E2, RIn2>
  ): Layer<ROut | ROut2, E1 | E2, RIn | RIn2>
}

Added in v2.0.0

mergeAll

Combines all the provided layers concurrently, creating a new layer with merged input, error, and output types.

Signature

export declare const mergeAll: <Layers extends [Layer<never, any, any>, ...Layer<never, any, any>[]]>(
  ...layers: Layers
) => Layer<
  { [k in keyof Layers]: Layer.Success<Layers[k]> }[number],
  { [k in keyof Layers]: Layer.Error<Layers[k]> }[number],
  { [k in keyof Layers]: Layer.Context<Layers[k]> }[number]
>

Added in v2.0.0

zipWith

Combines this layer with the specified layer concurrently, creating a new layer with merged input types and combined output types using the provided function.

Signature

export declare const zipWith: {
  <B, E2, R2, A, C>(
    that: Layer<B, E2, R2>,
    f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
  ): <E, R>(self: Layer<A, E, R>) => Layer<C, E2 | E, R2 | R>
  <A, E, R, B, E2, R2, C>(
    self: Layer<A, E, R>,
    that: Layer<B, E2, R2>,
    f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
  ): Layer<C, E | E2, R | R2>
}

Added in v2.0.0