<const Name extends string>(
config: RunnerConfig & { readonly name: Name }
): Context.Service<
internal.GateRunner & { readonly _tag: Name },
internal.GateRunner
> & {
layer: Layer.Layer<
internal.GateRunner & { readonly _tag: Name },
never,
never
>
}Generic runner tag + layer — no observation, no handle shape, no RPC.
constructors
Source src/Gate.ts:116111 lines
export const const makeRunner: <Name extends string>(
config: RunnerConfig & { readonly name: Name }
) => Context.Service<
internal.GateRunner & { readonly _tag: Name },
internal.GateRunner
> & {
layer: Layer.Layer<
internal.GateRunner & { readonly _tag: Name },
never,
never
>
}
Generic runner tag + layer — no observation, no handle shape, no RPC.
makeRunner = <const function (type parameter) Name in <const Name extends string>(config: RunnerConfig & {
readonly name: Name;
}): Context.Service<internal.GateRunner & {
readonly _tag: Name;
}, internal.GateRunner> & {
...;
}
config: RunnerConfig & { readonly name: Name }config: RunnerConfig & { readonly name: const Name extends stringname: function (type parameter) Name in <const Name extends string>(config: RunnerConfig & {
readonly name: Name;
}): Context.Service<internal.GateRunner & {
readonly _tag: Name;
}, internal.GateRunner> & {
...;
}
const tag: Context.Service<
internal.GateRunner & { readonly _tag: Name },
internal.GateRunner
>
const tag: {
of: (this: void, self: internal.GateRunner) => internal.GateRunner;
context: (self: internal.GateRunner) => Context.Context<internal.GateRunner & { readonly _tag: Name }>;
use: (f: (service: internal.GateRunner) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, (internal.GateRunner & { readonly _tag: Name }) | R>;
useSync: (f: (service: internal.GateRunner) => A) => Effect.Effect<A, never, internal.GateRunner & { readonly _tag: Name }>;
Identifier: Identifier;
Service: Shape;
key: string;
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;
}
import ContextContext.const Service: {
<Identifier, Shape = Identifier>(
key: string
): Service<Identifier, Shape>
<Self, Shape>(): <
Identifier extends string,
E,
R = Types.unassigned,
Args extends ReadonlyArray<any> = never
>(
id: Identifier,
options?:
| {
readonly make:
| ((
...args: Args
) => Effect<Shape, E, R>)
| Effect<Shape, E, R>
| undefined
}
| undefined
) => ServiceClass<Self, Identifier, Shape> &
([Types.unassigned] extends [R]
? unknown
: {
readonly make: [Args] extends [never]
? Effect<Shape, E, R>
: (
...args: Args
) => Effect<Shape, E, R>
})
<Self>(): <
Identifier extends string,
Make extends
| Effect<any, any, any>
| ((...args: any) => Effect<any, any, any>)
>(
id: Identifier,
options: { readonly make: Make }
) => ServiceClass<
Self,
Identifier,
Make extends
| Effect<infer _A, infer _E, infer _R>
| ((
...args: infer _Args
) => Effect<infer _A, infer _E, infer _R>)
? _A
: never
> & { readonly make: Make }
}
Creates a Context service key.
When to use
Use when you need to define a context service key for a dependency that must
be provided by the surrounding context.
Details
Call Context.Service("Key") for a function-style key, or use the two-stage
form Context.Service<Self, Shape>()("Key") for class-style service
declarations. The returned key can be yielded as an Effect and passed to
Context.make, Context.add, and the Context getter functions.
Gotchas
The string key is the runtime identity of the service. Reusing the same key
string for unrelated services makes them occupy the same slot in a
Context.
Example (Creating service keys)
import { Context } from "effect"
// Create a simple service
const Database = Context.Service<{
query: (sql: string) => string
}>("Database")
// Create a service class
class Config extends Context.Service<Config, {
port: number
}>()("Config") {}
// Use the services to create contexts
const db = Context.make(Database, {
query: (sql) => `Result: ${sql}`
})
const config = Context.make(Config, { port: 8080 })
Service<
type Runner = internal.GateRunnerA generic runner that wraps any effect with concurrency gating.
Runner & { readonly _tag: const Name extends string_tag: function (type parameter) Name in <const Name extends string>(config: RunnerConfig & {
readonly name: Name;
}): Context.Service<internal.GateRunner & {
readonly _tag: Name;
}, internal.GateRunner> & {
...;
}
type Runner = internal.GateRunnerA generic runner that wraps any effect with concurrency gating.
Runner
>(config: RunnerConfig & { readonly name: Name }config.name: const Name extends stringname);
const const runnerLayer: Layer.Layer<
internal.GateRunner & { readonly _tag: Name },
never,
never
>
const runnerLayer: {
build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<GateRunner & { readonly _tag: Name }>, never, never>;
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 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>>
}
Constructs a layer from an effect that produces a single service.
When to use
Use when you need to construct a Layer-provided service with an Effect,
dependencies, or scoped resource acquisition.
Details
This allows you to create a Layer from an Effect that produces a service.
The Effect is executed in the scope of the layer, allowing for proper
resource management.
Example (Creating a layer from an effect)
import { Context, Effect, Layer } from "effect"
class Database extends Context.Service<Database, {
readonly query: (sql: string) => Effect.Effect<string>
}>()("Database") {}
const layer = Layer.effect(Database,
Effect.sync(() => ({
query: (sql: string) => Effect.succeed(`Query: ${sql}`)
}))
)
effect(const tag: Context.Service<
internal.GateRunner & { readonly _tag: Name },
internal.GateRunner
>
const tag: {
of: (this: void, self: internal.GateRunner) => internal.GateRunner;
context: (self: internal.GateRunner) => Context.Context<internal.GateRunner & { readonly _tag: Name }>;
use: (f: (service: internal.GateRunner) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, (internal.GateRunner & { readonly _tag: Name }) | R>;
useSync: (f: (service: internal.GateRunner) => A) => Effect.Effect<A, never, internal.GateRunner & { readonly _tag: Name }>;
Identifier: Identifier;
Service: Shape;
key: string;
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;
}
import internalinternal.const makeRunnerEffect: (
config: internal.GateRunnerConfig
) => Effect.Effect<internal.GateRunner>
config: RunnerConfig & { readonly name: Name }config));
return var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.assign<Context.Service<internal.GateRunner & {
readonly _tag: Name;
}, internal.GateRunner>, {
layer: Layer.Layer<internal.GateRunner & {
readonly _tag: Name;
}, never, never>;
}>(target: Context.Service<internal.GateRunner & {
readonly _tag: Name;
}, internal.GateRunner>, source: {
layer: Layer.Layer<internal.GateRunner & {
readonly _tag: Name;
}, never, never>;
}): Context.Service<internal.GateRunner & {
readonly _tag: Name;
}, internal.GateRunner> & {
layer: Layer.Layer<internal.GateRunner & {
readonly _tag: Name;
}, never, never>;
} (+3 overloads)
Copy the values of all of the enumerable own properties from one or more source objects to a
target object. Returns the target object.
assign(const tag: Context.Service<
internal.GateRunner & { readonly _tag: Name },
internal.GateRunner
>
const tag: {
of: (this: void, self: internal.GateRunner) => internal.GateRunner;
context: (self: internal.GateRunner) => Context.Context<internal.GateRunner & { readonly _tag: Name }>;
use: (f: (service: internal.GateRunner) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, (internal.GateRunner & { readonly _tag: Name }) | R>;
useSync: (f: (service: internal.GateRunner) => A) => Effect.Effect<A, never, internal.GateRunner & { readonly _tag: Name }>;
Identifier: Identifier;
Service: Shape;
key: string;
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;
}
layer: Layer.Layer<
internal.GateRunner & { readonly _tag: Name },
never,
never
>
(property) layer: {
build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<GateRunner & { readonly _tag: Name }>, never, never>;
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 runnerLayer: Layer.Layer<
internal.GateRunner & { readonly _tag: Name },
never,
never
>
const runnerLayer: {
build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<GateRunner & { readonly _tag: Name }>, never, never>;
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; <…;
}