<E = never, R = never>(
self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>
): Layer.Layer<never, E, Exclude<R, Scope>>Provides a layer that installs a ConfigProvider as the active provider for
all downstream effects, replacing any previously installed provider.
When to use
Use to set the config source for an entire application or test suite.
Details
Accepts either a plain ConfigProvider or an Effect that produces one.
When given an Effect, it is evaluated once when the layer is built.
Example (Reading config from a JSON object)
import { Config, ConfigProvider, Effect, Layer } from "effect"
const TestLayer = ConfigProvider.layer(
ConfigProvider.fromUnknown({ port: 8080 })
)
const program = Effect.gen(function*() {
const port = yield* Config.number("port")
return port
})
// Effect.runSync(Effect.provide(program, TestLayer)) // 8080export const const layer: <E = never, R = never>(
self:
| ConfigProvider
| Effect.Effect<ConfigProvider, E, R>
) => Layer.Layer<never, E, Exclude<R, Scope>>
Provides a layer that installs a ConfigProvider as the active provider for
all downstream effects, replacing any previously installed provider.
When to use
Use to set the config source for an entire application or test suite.
Details
Accepts either a plain ConfigProvider or an Effect that produces one.
When given an Effect, it is evaluated once when the layer is built.
Example (Reading config from a JSON object)
import { Config, ConfigProvider, Effect, Layer } from "effect"
const TestLayer = ConfigProvider.layer(
ConfigProvider.fromUnknown({ port: 8080 })
)
const program = Effect.gen(function*() {
const port = yield* Config.number("port")
return port
})
// Effect.runSync(Effect.provide(program, TestLayer)) // 8080
layer = <function (type parameter) E in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>): Layer.Layer<never, E, Exclude<R, Scope>>E = never, function (type parameter) R in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>): Layer.Layer<never, E, Exclude<R, Scope>>R = never>(
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>): Layer.Layer<never, E, Exclude<R, Scope>>E, function (type parameter) R in <E = never, R = never>(self: ConfigProvider | Effect.Effect<ConfigProvider, E, R>): Layer.Layer<never, E, Exclude<R, Scope>>R>
): 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>): Layer.Layer<never, E, Exclude<R, Scope>>E, 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>): Layer.Layer<never, E, Exclude<R, Scope>>R, Scope>> =>
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>
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)(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;
}
import LayerLayer.const succeed: {
<I, S>(service: Context.Key<I, S>): (
resource: S
) => Layer<I>
<I, S>(
service: Context.Key<I, S>,
resource: Types.NoInfer<S>
): Layer<I>
}
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)(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; <…;
}