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
- config
- constructors
- conversions
- destructors
- error handling
- folding
- getters
- logging
- mapping
- memo map
- models
- requests & batching
- retrying
- scheduler
- sequencing
- symbols
- tracing
- utils
- zipping
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: {
<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>
}
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 its 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>
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>
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>
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>
Added in v2.0.0
function
Constructs a layer from the context using the specified function.
Signature
export 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>
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.Scope, never, never>
Added in v2.0.0
scoped
Constructs a layer from the specified scoped effect.
Signature
export 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>>
}
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: <I, S>(tag: Context.Tag<I, S>) => Layer<I, never, I>
Added in v2.0.0
succeed
Constructs a layer from the specified value.
Signature
export 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>
}
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>
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: {
<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>
}
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>
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, 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>
}
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
annotateLogs
Signature
export 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>
}
Added in v3.3.0
annotateSpans
Signature
export 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>
}
Added in v3.3.0
parentSpan
Adds the provided span to the span stack.
Signature
export declare const parentSpan: (span: Tracer.AnySpan) => 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?: Tracer.SpanOptions & {
readonly onEnd?: ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined
}
) => Layer<Tracer.ParentSpan>
Added in v2.0.0
withParentSpan
Signature
export 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>>
}
Added in v2.0.0
withSpan
Signature
export 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>>
}
Added in v2.0.0
utils
Layer (namespace)
Added in 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>
}
}
Added in v3.9.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 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 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 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: {
<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>
}
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>(
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]>
>
}
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, E | E1, R | R1>
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, E | E1, R1 | Exclude<R, Scope.Scope>>
Added in 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
export 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>)
Added in v3.13.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>, ...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]
>
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