<E = never, R = never>(
self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>,
options?: { readonly asPrimary?: boolean | undefined } | undefined
): Layer.Layer<never, E, Exclude<R, Scope>>Creates a Layer that composes a new ConfigProvider with the currently
active one, rather than replacing it.
When to use
Use to add defaults that should only apply when the primary provider has no
value for a path, or override specific keys while keeping the rest from the
existing provider by setting asPrimary: true.
Details
By default, the new provider acts as a fallback and is consulted only when
the current provider returns undefined. Set asPrimary: true to make the
new provider the primary source, with the existing one as fallback.
Example (Adding default values)
import { ConfigProvider } from "effect"
const defaults = ConfigProvider.fromUnknown({
HOST: "localhost",
PORT: "3000"
})
// The current env provider is tried first; `defaults` is the fallback
const DefaultsLayer = ConfigProvider.layerAdd(defaults)export const const layerAdd: <E = never, R = never>(
self:
| ConfigProvider
| Effect.Effect<ConfigProvider, E, R>,
options?:
| { readonly asPrimary?: boolean | undefined }
| undefined
) => Layer.Layer<never, E, Exclude<R, Scope>>
Creates a Layer that composes a new ConfigProvider with the currently
active one, rather than replacing it.
When to use
Use to add defaults that should only apply when the primary provider has no
value for a path, or override specific keys while keeping the rest from the
existing provider by setting asPrimary: true.
Details
By default, the new provider acts as a fallback and is consulted only when
the current provider returns undefined. Set asPrimary: true to make the
new provider the primary source, with the existing one as fallback.
Example (Adding default values)
import { ConfigProvider } from "effect"
const defaults = ConfigProvider.fromUnknown({
HOST: "localhost",
PORT: "3000"
})
// The current env provider is tried first; `defaults` is the fallback
const DefaultsLayer = ConfigProvider.layerAdd(defaults)
layerAdd = <function (type parameter) E in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>, options?: {
readonly asPrimary?: boolean | undefined;
} | undefined): Layer.Layer<never, E, Exclude<R, Scope>>
function (type parameter) R in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>, options?: {
readonly asPrimary?: boolean | undefined;
} | undefined): Layer.Layer<never, E, Exclude<R, Scope>>
self: | ConfigProvider
| Effect.Effect<ConfigProvider, E, R>
import EffectEffect.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<ConfigProvider, function (type parameter) E in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>, options?: {
readonly asPrimary?: boolean | undefined;
} | undefined): Layer.Layer<never, E, Exclude<R, Scope>>
function (type parameter) R in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>, options?: {
readonly asPrimary?: boolean | undefined;
} | undefined): Layer.Layer<never, E, Exclude<R, Scope>>
options: | {
readonly asPrimary?: boolean | undefined
}
| undefined
asPrimary?: boolean | undefinedasPrimary?: boolean | undefined
} | undefined
): import LayerLayer.interface Layer<in ROut, out E = never, out RIn = never>A Layer describes how to build one or more services for dependency injection.
When to use
Use to model construction of application services for dependency injection,
especially when services have dependencies, can fail during construction, or
need scoped setup and release.
Details
A Layer<ROut, E, RIn> represents ROut as the services this layer
provides, E as the possible errors during layer construction, and RIn as
the services this layer requires as dependencies.
Layer<never, function (type parameter) E in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>, options?: {
readonly asPrimary?: boolean | undefined;
} | undefined): Layer.Layer<never, E, Exclude<R, Scope>>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) R in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>, options?: {
readonly asPrimary?: boolean | undefined;
} | undefined): Layer.Layer<never, E, Exclude<R, Scope>>
import LayerLayer.const effect: {
<I, S>(service: Context.Key<I, S>): <E, R>(
effect: Effect<S, E, R>
) => Layer<I, E, Exclude<R, Scope.Scope>>
<I, S, E, R>(
service: Context.Key<I, S>,
effect: Effect<Types.NoInfer<S>, E, R>
): Layer<I, E, Exclude<R, Scope.Scope>>
}
const ConfigProvider: Context.Reference<ConfigProvider>const ConfigProvider: {
key: string;
Service: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
};
defaultValue: () => Shape;
of: (this: void, self: ConfigProvider) => ConfigProvider;
context: (self: ConfigProvider) => Context.Context<never>;
use: (f: (service: ConfigProvider) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
useSync: (f: (service: ConfigProvider) => A) => Effect.Effect<A, never, never>;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
The core interface for loading raw configuration data.
When to use
Use to type-annotate variables that hold a provider or to implement a
custom provider via
make
.
Details
load(path) is the semantic lookup operation used by the Config module.
It applies provider transformations and composition before consulting the
underlying source. undefined means "not found" and SourceError means the
source itself failed.
Context reference for the active raw configuration provider, registered in the context with a
default value of fromEnv(). Because it is a Context.Reference, it is
available without explicit provision; Config schemas automatically resolve
it.
When to use
Use to override the active raw configuration provider for an entire program,
or retrieve the current provider inside an Effect.
Example (Providing a custom provider)
import { ConfigProvider, Effect } from "effect"
const provider = ConfigProvider.fromUnknown({ port: 8080 })
const program = Effect.gen(function*() {
const current = yield* ConfigProvider.ConfigProvider
return current
}).pipe(
Effect.provideService(ConfigProvider.ConfigProvider, provider)
)
ConfigProvider)(
import EffectEffect.const gen: {
<Eff extends Effect<any, any, any>, AEff>(
f: () => Generator<Eff, AEff, never>
): Effect<
AEff,
[Eff] extends [never]
? never
: [Eff] extends [
Effect<infer _A, infer E, infer _R>
]
? E
: never,
[Eff] extends [never]
? never
: [Eff] extends [
Effect<infer _A, infer _E, infer R>
]
? R
: never
>
<Self, Eff extends Effect<any, any, any>, AEff>(
options: { readonly self: Self },
f: (this: Self) => Generator<Eff, AEff, never>
): Effect<
AEff,
[Eff] extends [never]
? never
: [Eff] extends [
Effect<infer _A, infer E, infer _R>
]
? E
: never,
[Eff] extends [never]
? never
: [Eff] extends [
Effect<infer _A, infer _E, infer R>
]
? R
: never
>
}
const current: ConfigProviderconst current: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
const ConfigProvider: Context.Reference<ConfigProvider>const ConfigProvider: {
key: string;
Service: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
};
defaultValue: () => Shape;
of: (this: void, self: ConfigProvider) => ConfigProvider;
context: (self: ConfigProvider) => Context.Context<never>;
use: (f: (service: ConfigProvider) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
useSync: (f: (service: ConfigProvider) => A) => Effect.Effect<A, never, never>;
Identifier: Identifier;
stack: string | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
The core interface for loading raw configuration data.
When to use
Use to type-annotate variables that hold a provider or to implement a
custom provider via
make
.
Details
load(path) is the semantic lookup operation used by the Config module.
It applies provider transformations and composition before consulting the
underlying source. undefined means "not found" and SourceError means the
source itself failed.
Context reference for the active raw configuration provider, registered in the context with a
default value of fromEnv(). Because it is a Context.Reference, it is
available without explicit provision; Config schemas automatically resolve
it.
When to use
Use to override the active raw configuration provider for an entire program,
or retrieve the current provider inside an Effect.
Example (Providing a custom provider)
import { ConfigProvider, Effect } from "effect"
const provider = ConfigProvider.fromUnknown({ port: 8080 })
const program = Effect.gen(function*() {
const current = yield* ConfigProvider.ConfigProvider
return current
}).pipe(
Effect.provideService(ConfigProvider.ConfigProvider, provider)
)
ConfigProvider
const const configProvider: ConfigProviderconst configProvider: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import EffectEffect.const isEffect: (
u: unknown
) => u is Effect<any, any, any>
Checks whether a value is an Effect.
Example (Checking whether a value is an Effect)
import { Effect } from "effect"
console.log(Effect.isEffect(Effect.succeed(1))) // true
console.log(Effect.isEffect("hello")) // false
isEffect(self: | ConfigProvider
| Effect.Effect<ConfigProvider, E, R>
self: | ConfigProvider
| Effect.Effect<ConfigProvider, E, R>
(parameter) self: {
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
self: | ConfigProvider
| Effect.Effect<ConfigProvider, E, R>
(parameter) self: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
options: | {
readonly asPrimary?: boolean | undefined
}
| undefined
asPrimary?: boolean | undefinedasPrimary ? const orElse: {
(that: ConfigProvider): (
self: ConfigProvider
) => ConfigProvider
(
self: ConfigProvider,
that: ConfigProvider
): ConfigProvider
}
const configProvider: ConfigProviderconst configProvider: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
const current: ConfigProviderconst current: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
const orElse: {
(that: ConfigProvider): (
self: ConfigProvider
) => ConfigProvider
(
self: ConfigProvider,
that: ConfigProvider
): ConfigProvider
}
const current: ConfigProviderconst current: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
const configProvider: ConfigProviderconst configProvider: {
load: (path: Path) => Effect.Effect<Node | undefined, SourceError>;
state: ProviderState;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}