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

Layer.ts 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.

Since v2.0.0

Exports Grouped by Category

Random

setRandom

Signature

declare const setRandom: <A extends Random.Random>(random: A) => Layer<never>

Source

Since v3.15.0

clock

setClock

Signature

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

Source

Since v2.0.0

config

setConfigProvider

Sets the current ConfigProvider.

Signature

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

Source

Since v2.0.0

constructors

context

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

Signature

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

Source

Since v2.0.0

die

Constructs a layer that dies with the specified defect.

Signature

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

Source

Since v2.0.0

dieSync

Constructs a layer that dies with the specified defect.

Signature

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

Source

Since v2.0.0

effect

Constructs a layer from the specified effect.

Signature

declare const effect: {
  <I, S>(tag: Context.Tag<I, S>): <E, R>(effect: Effect.Effect<Types.NoInfer<S>, E, R>) => Layer<I, E, R>
  <I, S, E, R>(tag: Context.Tag<I, S>, effect: Effect.Effect<Types.NoInfer<S>, E, R>): Layer<I, E, R>
}

Source

Since v2.0.0

effectContext

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

Signature

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

Source

Since v2.0.0

effectDiscard

Constructs a layer from the specified effect, discarding its output.

Signature

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

Source

Since v2.0.0

empty

A Layer that constructs an empty Context.

Signature

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

Source

Since v2.0.0

fail

Constructs a layer that fails with the specified error.

Signature

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

Source

Since v2.0.0

failCause

Constructs a layer that fails with the specified cause.

Signature

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

Source

Since v2.0.0

failCauseSync

Constructs a layer that fails with the specified cause.

Signature

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

Source

Since v2.0.0

failSync

Constructs a layer that fails with the specified error.

Signature

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

Source

Since v2.0.0

function

Constructs a layer from the context using the specified function.

Signature

declare const function: <I1, S1, I2, S2>(tagA: Context.Tag<I1, S1>, tagB: Context.Tag<I2, S2>, f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>) => Layer<I2, never, I1>

Source

Since 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

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

Source

Since v2.0.0

scoped

Constructs a layer from the specified scoped effect.

Signature

declare const scoped: {
  <I, S>(
    tag: Context.Tag<I, S>
  ): <E, R>(effect: Effect.Effect<Types.NoInfer<S>, E, R>) => Layer<I, E, Exclude<R, Scope.Scope>>
  <I, S, E, R>(
    tag: Context.Tag<I, S>,
    effect: Effect.Effect<Types.NoInfer<S>, E, R>
  ): Layer<I, E, Exclude<R, Scope.Scope>>
}

Source

Since v2.0.0

scopedContext

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

Signature

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

Source

Since v2.0.0

scopedDiscard

Constructs a layer from the specified scoped effect.

Signature

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

Source

Since v2.0.0

service

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

Signature

declare const service: <I, S>(tag: Context.Tag<I, S>) => Layer<I, never, I>

Source

Since v2.0.0

succeed

Constructs a layer from the specified value.

Signature

declare const succeed: {
  <I, S>(tag: Context.Tag<I, S>): (resource: Types.NoInfer<S>) => Layer<I>
  <I, S>(tag: Context.Tag<I, S>, resource: Types.NoInfer<S>): Layer<I>
}

Source

Since v2.0.0

succeedContext

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

Signature

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

Source

Since v2.0.0

suspend

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

Signature

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

Source

Since v2.0.0

sync

Lazily constructs a layer from the specified value.

Signature

declare const sync: {
  <I, S>(tag: Context.Tag<I, S>): (evaluate: LazyArg<Types.NoInfer<S>>) => Layer<I>
  <I, S>(tag: Context.Tag<I, S>, evaluate: LazyArg<Types.NoInfer<S>>): Layer<I>
}

Source

Since v2.0.0

syncContext

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

Signature

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

Source

Since 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

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

Source

Since v2.0.0

toRuntime

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

Signature

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

Source

Since v2.0.0

toRuntimeWithMemoMap

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

Signature

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>
}

Source

Since v2.0.0

destructors

build

Builds a layer into a scoped value.

Signature

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

Source

Since 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

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>
}

Source

Since v2.0.0

error handling

catchAll

Recovers from all errors.

Signature

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>
}

Source

Since v2.0.0

catchAllCause

Recovers from all errors.

Signature

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>
}

Source

Since 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

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

Source

Since v2.0.0

orElse

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

Signature

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>
}

Source

Since 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

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>
}

Source

Since 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

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>
}

Source

Since v2.0.0

getters

isFresh

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

Signature

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

Source

Since v2.0.0

isLayer

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

Signature

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

Source

Since v2.0.0

logging

setUnhandledErrorLogLevel

Signature

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

Source

Since v2.0.0

mapping

discard

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

Signature

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

Source

Since v2.0.0

map

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

Signature

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>
}

Source

Since v2.0.0

mapError

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

Signature

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>
}

Source

Since v2.0.0

memo map

buildWithMemoMap

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

Signature

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>
}

Source

Since v2.0.0

makeMemoMap

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

Signature

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

Source

Since v2.0.0

models

CurrentMemoMap

Signature

declare const CurrentMemoMap: Context.Reference<CurrentMemoMap, MemoMap>

Source

Since v3.13.0

CurrentMemoMap (interface)

Signature

export interface CurrentMemoMap {
  readonly _: unique symbol
}

Source

Since v3.13.0

Layer (interface)

Signature

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

Source

Since 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>
}

Source

Since v2.0.0

requests & batching

setRequestBatching

Signature

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

Source

Since v2.0.0

setRequestCache

Signature

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

Source

Since v2.0.0

setRequestCaching

Signature

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

Source

Since v2.0.0

retrying

retry

Retries constructing this layer according to the specified schedule.

Signature

declare const retry: {
  <X, E, RIn2>(
    schedule: Schedule.Schedule<X, NoInfer<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>
}

Source

Since v2.0.0

scheduler

setScheduler

Signature

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

Source

Since v2.0.0

sequencing

flatMap

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

Signature

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>
}

Source

Since v2.0.0

flatten

Flattens layers nested in the context of an effect.

Signature

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>
}

Source

Since v2.0.0

tap

Performs the specified effect if this layer succeeds.

Signature

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>
}

Source

Since v2.0.0

tapError

Performs the specified effect if this layer fails.

Signature

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>
}

Source

Since v2.0.0

tapErrorCause

Performs the specified effect if this layer fails.

Signature

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>
}

Source

Since v2.0.0

symbols

LayerTypeId

Signature

declare const LayerTypeId: unique symbol

Source

Since v2.0.0

LayerTypeId (type alias)

Signature

type LayerTypeId = typeof LayerTypeId

Source

Since v2.0.0

MemoMapTypeId

Signature

declare const MemoMapTypeId: unique symbol

Source

Since v2.0.0

MemoMapTypeId (type alias)

Signature

type MemoMapTypeId = typeof MemoMapTypeId

Source

Since v2.0.0

tracing

annotateLogs

Signature

declare const annotateLogs: {
  (key: string, value: unknown): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
  (values: Record<string, unknown>): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
  <A, E, R>(self: Layer<A, E, R>, key: string, value: unknown): Layer<A, E, R>
  <A, E, R>(self: Layer<A, E, R>, values: Record<string, unknown>): Layer<A, E, R>
}

Source

Since v3.3.0

annotateSpans

Signature

declare const annotateSpans: {
  (key: string, value: unknown): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
  (values: Record<string, unknown>): <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>
  <A, E, R>(self: Layer<A, E, R>, key: string, value: unknown): Layer<A, E, R>
  <A, E, R>(self: Layer<A, E, R>, values: Record<string, unknown>): Layer<A, E, R>
}

Source

Since v3.3.0

parentSpan

Adds the provided span to the span stack.

Signature

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

Source

Since v2.0.0

setTracer

Create a Layer that sets the current Tracer

Signature

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

Source

Since v2.0.0

setTracerEnabled

Signature

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

Source

Since v2.0.0

setTracerTiming

Signature

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

Source

Since v2.0.0

span

Create and add a span to the current span stack.

The span is ended when the Layer is released.

Signature

declare const span: (
  name: string,
  options?: Tracer.SpanOptions & {
    readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined
  }
) => Layer<Tracer.ParentSpan>

Source

Since v2.0.0

withParentSpan

Signature

declare const withParentSpan: {
  (span: Tracer.AnySpan): <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.AnySpan): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
}

Source

Since v2.0.0

withSpan

Signature

declare const withSpan: {
  (
    name: string,
    options?: Tracer.SpanOptions & {
      readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | 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?: Tracer.SpanOptions & {
      readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined
    }
  ): Layer<A, E, Exclude<R, Tracer.ParentSpan>>
}

Source

Since v2.0.0

utils

Layer (namespace)

Source

Since 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>
  }
}

Source

Since v2.0.0

Any (interface)

Signature

export interface Any {
  readonly [LayerTypeId]: {
    readonly _ROut: Types.Contravariant<never>
    readonly _E: Types.Covariant<any>
    readonly _RIn: Types.Covariant<any>
  }
}

Source

Since v3.9.0

Context (type alias)

Signature

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

Source

Since v2.0.0

Error (type alias)

Signature

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

Source

Since v2.0.0

Success (type alias)

Signature

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

Source

Since 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

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

Source

Since v2.0.0

fiberRefLocallyScopedWith

Signature

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

Source

Since v2.0.0

fresh

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

Signature

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

Source

Since v2.0.0

locally

Signature

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>
}

Source

Since v2.0.0

locallyEffect

Signature

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>
}

Source

Since v2.0.0

locallyScoped

Signature

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

Source

Since v2.0.0

locallyWith

Signature

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>
}

Source

Since v2.0.0

memoize

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

Signature

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

Source

Since v2.0.0

passthrough

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

Signature

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

Source

Since v2.0.0

project

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

Signature

declare const project: {
  <I1, S1, I2, S2>(
    tagA: Context.Tag<I1, S1>,
    tagB: Context.Tag<I2, S2>,
    f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
  ): <RIn, E>(self: Layer<I1, E, RIn>) => Layer<I2, E, RIn>
  <RIn, E, I1, S1, I2, S2>(
    self: Layer<I1, E, RIn>,
    tagA: Context.Tag<I1, S1>,
    tagB: Context.Tag<I2, S2>,
    f: (a: Types.NoInfer<S1>) => Types.NoInfer<S2>
  ): Layer<I2, E, RIn>
}

Source

Since 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

declare const provide: {
  <RIn, E, ROut>(
    that: Layer<ROut, E, RIn>
  ): <RIn2, E2, ROut2>(self: Layer<ROut2, E2, RIn2>) => Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
  <const Layers extends [Layer.Any, ...Array<Layer.Any>]>(
    that: Layers
  ): <A, E, R>(
    self: Layer<A, E, R>
  ) => Layer<
    A,
    E | { [k in keyof Layers]: Layer.Error<Layers[k]> }[number],
    | { [k in keyof Layers]: Layer.Context<Layers[k]> }[number]
    | Exclude<R, { [k in keyof Layers]: Layer.Success<Layers[k]> }[number]>
  >
  <RIn2, E2, ROut2, RIn, E, ROut>(
    self: Layer<ROut2, E2, RIn2>,
    that: Layer<ROut, E, RIn>
  ): Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
  <A, E, R, const Layers extends [Layer.Any, ...Array<Layer.Any>]>(
    self: Layer<A, E, R>,
    that: Layers
  ): Layer<
    A,
    E | { [k in keyof Layers]: Layer.Error<Layers[k]> }[number],
    | { [k in keyof Layers]: Layer.Context<Layers[k]> }[number]
    | Exclude<R, { [k in keyof Layers]: Layer.Success<Layers[k]> }[number]>
  >
}

Source

Since 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

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>>
}

Source

Since v2.0.0

unwrapEffect

Signature

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

Source

Since v2.0.0

unwrapScoped

Signature

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

Source

Since v2.0.0

updateService

Updates a service in the context with a new implementation.

Details

This function modifies the existing implementation of a service in the context. It retrieves the current service, applies the provided transformation function f, and replaces the old service with the transformed one.

When to Use

This is useful for adapting or extending a service’s behavior during the creation of a layer.

Signature

declare const updateService: (<I, A>(
  tag: Context.Tag<I, A>,
  f: (a: A) => A
) => <A1, E1, R1>(layer: Layer<A1, E1, R1>) => Layer<A1, E1, I | R1>) &
  (<A1, E1, R1, I, A>(layer: Layer<A1, E1, R1>, tag: Context.Tag<I, A>, f: (a: A) => A) => Layer<A1, E1, I | R1>)

Source

Since v3.13.0

zipping

merge

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

Signature

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>
}

Source

Since v2.0.0

mergeAll

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

Signature

declare const mergeAll: <Layers extends [Layer<never, any, any>, ...Array<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]
>

Source

Since 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

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>
}

Source

Since v2.0.0