<const Name extends string>(
config: RunHyperlinkRunnerConfig & { readonly name: Name }
): Context.Service<
internal.RunHyperlinkRunner & { readonly _tag: Name },
internal.RunHyperlinkRunner
> & {
layer: Layer.Layer<
internal.RunHyperlinkRunner & { readonly _tag: Name },
never,
never
>
}Generic runner tag + layer — no observation, no handle shape, no RPC.
constructors
Source src/RunHyperlink.ts:102810 lines
export const const makeRunner: <Name extends string>(
config: RunHyperlinkRunnerConfig & {
readonly name: Name
}
) => Context.Service<
any,
internal.RunHyperlinkRunner
> & { layer: Layer.Layer<any, unknown, unknown> }
Generic runner tag + layer — no observation, no handle shape, no RPC.
makeRunner = <const function (type parameter) Name in <const Name extends string>(config: RunHyperlinkRunnerConfig & {
readonly name: Name;
}): Context.Service<any, internal.RunHyperlinkRunner> & {
layer: Layer.Layer<any, unknown, unknown>;
}
config: RunHyperlinkRunnerConfig & {
readonly name: Name
}
name: const Name extends stringname: function (type parameter) Name in <const Name extends string>(config: RunHyperlinkRunnerConfig & {
readonly name: Name;
}): Context.Service<any, internal.RunHyperlinkRunner> & {
layer: Layer.Layer<any, unknown, unknown>;
}
const tag: Context.Service<
any,
internal.RunHyperlinkRunner
>
const tag: {
of: (this: void, self: internal.RunHyperlinkRunner) => internal.RunHyperlinkRunner;
context: (self: internal.RunHyperlinkRunner) => Context.Context<any>;
use: (f: (service: internal.RunHyperlinkRunner) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, any>;
useSync: (f: (service: internal.RunHyperlinkRunner) => A) => Effect.Effect<A, never, any>;
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: <any, internal.RunHyperlinkRunner>(key: string) => Context.Service<any, internal.RunHyperlinkRunner> (+2 overloads)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 RunHyperlinkRunner =
internal.RunHyperlinkRunner
A generic runner that wraps any effect with concurrency gating.
RunHyperlinkRunner & { readonly _tag: const Name extends string_tag: function (type parameter) Name in <const Name extends string>(config: RunHyperlinkRunnerConfig & {
readonly name: Name;
}): Context.Service<any, internal.RunHyperlinkRunner> & {
layer: Layer.Layer<any, unknown, unknown>;
}
type RunHyperlinkRunner =
internal.RunHyperlinkRunner
A generic runner that wraps any effect with concurrency gating.
RunHyperlinkRunner
>(config: RunHyperlinkRunnerConfig & {
readonly name: Name
}
name: const Name extends stringname);
const const runnerLayer: Layer.Layer<
any,
unknown,
unknown
>
const runnerLayer: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<any>, unknown, unknown>;
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: <any, internal.RunHyperlinkRunner>(service: Context.Key<any, internal.RunHyperlinkRunner>) => <E, R>(effect: Effect.Effect<internal.RunHyperlinkRunner, E, R>) => Layer.Layer<any, E, Exclude<R, Scope.Scope>> (+1 overload)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<
any,
internal.RunHyperlinkRunner
>
const tag: {
of: (this: void, self: internal.RunHyperlinkRunner) => internal.RunHyperlinkRunner;
context: (self: internal.RunHyperlinkRunner) => Context.Context<any>;
use: (f: (service: internal.RunHyperlinkRunner) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, any>;
useSync: (f: (service: internal.RunHyperlinkRunner) => A) => Effect.Effect<A, never, any>;
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.makeRunnerEffect(config: RunHyperlinkRunnerConfig & {
readonly name: Name
}
var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.assign<Context.Service<any, internal.RunHyperlinkRunner>, {
layer: Layer.Layer<any, unknown, unknown>;
}>(target: Context.Service<any, internal.RunHyperlinkRunner>, source: {
layer: Layer.Layer<any, unknown, unknown>;
}): Context.Service<any, internal.RunHyperlinkRunner> & {
layer: Layer.Layer<any, unknown, unknown>;
} (+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<
any,
internal.RunHyperlinkRunner
>
const tag: {
of: (this: void, self: internal.RunHyperlinkRunner) => internal.RunHyperlinkRunner;
context: (self: internal.RunHyperlinkRunner) => Context.Context<any>;
use: (f: (service: internal.RunHyperlinkRunner) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, any>;
useSync: (f: (service: internal.RunHyperlinkRunner) => A) => Effect.Effect<A, never, any>;
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<any, unknown, unknown>(property) layer: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<any>, unknown, unknown>;
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<
any,
unknown,
unknown
>
const runnerLayer: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<any>, unknown, unknown>;
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; <…;
}