<const Id extends string, E, RUser>(
id: Id,
effect: Effect.Effect<void, E, RUser>
): Process<RUser>
<const Id extends string, E, RUser>(
id: Id,
effect: Effect.Effect<void, E, RUser>,
polling: AnyPollingLayer
): Process<RUser>
<const Id extends string, E, RUser>(
id: Id,
effect: Effect.Effect<void, E, RUser>,
schedule: AnyScheduleLayer
): Process<RUser>
<const Id extends string, E, RUser, RSchedule>(
id: Id,
effect: Effect.Effect<void, E, RUser>,
schedule: ProcessScheduleInitializer<RSchedule>
): Process<RUser | RSchedule>
<const Id extends string, E, RUser>(
id: Id,
effect: Effect.Effect<void, E, RUser>,
polling: AnyPollingLayer,
schedule: AnyScheduleLayer
): Process<RUser>
<const Id extends string, E, RUser, RSchedule>(
id: Id,
effect: Effect.Effect<void, E, RUser>,
polling: AnyPollingLayer,
schedule: ProcessScheduleInitializer<RSchedule>
): Process<RUser | RSchedule>
<const Id extends string, E, RUser>(
id: Id,
effect: Effect.Effect<void, E, RUser>,
schedule: AnyScheduleLayer,
polling: AnyPollingLayer
): Process<RUser>
<const Id extends string, E, RUser, RSchedule>(
id: Id,
effect: Effect.Effect<void, E, RUser>,
schedule: ProcessScheduleInitializer<RSchedule>,
polling: AnyPollingLayer
): Process<RUser | RSchedule>
<const Id extends string, E, RUser>(
id: Id,
config: ProcessMakeOptions<E, RUser>
): Process<RUser>Create a managed Process.
function function make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser>RUser>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser>Id,
effect: Effect.Effect<void, E, RUser>(parameter) effect: {
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 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<void, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser>RUser>,
): interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser>RUser>;
function function make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer): Process<RUser> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer): Process<RUser>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer): Process<RUser>RUser>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer): Process<RUser>Id,
effect: Effect.Effect<void, E, RUser>(parameter) effect: {
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 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<void, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer): Process<RUser>RUser>,
polling: ProcessPollingInput(parameter) polling: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<PollingTag>, 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; <…;
}
type AnyPollingLayer = Layer.Layer<
PollingTag,
never,
never
>
interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer): Process<RUser>RUser>;
function function make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer): Process<RUser> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer): Process<RUser>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer): Process<RUser>RUser>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer): Process<RUser>Id,
effect: Effect.Effect<void, E, RUser>(parameter) effect: {
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 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<void, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer): Process<RUser>RUser>,
schedule: ProcessScheduleLayerInput(parameter) schedule: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<ProcessScheduleTag>, 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; <…;
}
type AnyScheduleLayer = Layer.Layer<
ProcessScheduleTag,
never,
never
>
interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer): Process<RUser>RUser>;
function function make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>E, function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RUser, function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RSchedule>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>Id,
effect: Effect.Effect<void, E, RUser>(parameter) effect: {
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 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<void, function (type parameter) E in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>E, function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RUser>,
schedule: ProcessScheduleInitializer<RSchedule>schedule: type ProcessScheduleInitializer<
R = never
> = (
controls: ProcessScheduleControls
) => Effect.Effect<void, never, R>
A function that seeds a process's schedule via its
ProcessScheduleControls
.
ProcessScheduleInitializer<function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RSchedule>,
): interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RUser | function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RSchedule>;
function function make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: AnyScheduleLayer): Process<RUser> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: AnyScheduleLayer): Process<RUser>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: AnyScheduleLayer): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: AnyScheduleLayer): Process<RUser>RUser>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: AnyScheduleLayer): Process<RUser>Id,
effect: Effect.Effect<void, E, RUser>(parameter) effect: {
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 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<void, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: AnyScheduleLayer): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: AnyScheduleLayer): Process<RUser>RUser>,
polling: ProcessPollingInput(parameter) polling: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<PollingTag>, 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; <…;
}
type AnyPollingLayer = Layer.Layer<
PollingTag,
never,
never
>
schedule: ProcessScheduleLayerInput(parameter) schedule: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<ProcessScheduleTag>, 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; <…;
}
type AnyScheduleLayer = Layer.Layer<
ProcessScheduleTag,
never,
never
>
interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: AnyScheduleLayer): Process<RUser>RUser>;
function function make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>E, function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RUser, function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RSchedule>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>Id,
effect: Effect.Effect<void, E, RUser>(parameter) effect: {
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 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<void, function (type parameter) E in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>E, function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RUser>,
polling: ProcessPollingInput(parameter) polling: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<PollingTag>, 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; <…;
}
type AnyPollingLayer = Layer.Layer<
PollingTag,
never,
never
>
schedule: ProcessScheduleInitializer<RSchedule>schedule: type ProcessScheduleInitializer<
R = never
> = (
controls: ProcessScheduleControls
) => Effect.Effect<void, never, R>
A function that seeds a process's schedule via its
ProcessScheduleControls
.
ProcessScheduleInitializer<function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RSchedule>,
): interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RUser | function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, polling: AnyPollingLayer, schedule: ProcessScheduleInitializer<RSchedule>): Process<RUser | RSchedule>RSchedule>;
function function make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer, polling: AnyPollingLayer): Process<RUser> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer, polling: AnyPollingLayer): Process<RUser>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer, polling: AnyPollingLayer): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer, polling: AnyPollingLayer): Process<RUser>RUser>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer, polling: AnyPollingLayer): Process<RUser>Id,
effect: Effect.Effect<void, E, RUser>(parameter) effect: {
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 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<void, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer, polling: AnyPollingLayer): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer, polling: AnyPollingLayer): Process<RUser>RUser>,
schedule: ProcessScheduleLayerInput(parameter) schedule: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<ProcessScheduleTag>, 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; <…;
}
type AnyScheduleLayer = Layer.Layer<
ProcessScheduleTag,
never,
never
>
polling: ProcessPollingInput(parameter) polling: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<PollingTag>, 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; <…;
}
type AnyPollingLayer = Layer.Layer<
PollingTag,
never,
never
>
interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: AnyScheduleLayer, polling: AnyPollingLayer): Process<RUser>RUser>;
function function make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>E, function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>RUser, function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>RSchedule>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>Id,
effect: Effect.Effect<void, E, RUser>(parameter) effect: {
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 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<void, function (type parameter) E in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>E, function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>RUser>,
schedule: ProcessScheduleInitializer<RSchedule>schedule: type ProcessScheduleInitializer<
R = never
> = (
controls: ProcessScheduleControls
) => Effect.Effect<void, never, R>
A function that seeds a process's schedule via its
ProcessScheduleControls
.
ProcessScheduleInitializer<function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>RSchedule>,
polling: ProcessPollingInput(parameter) polling: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<PollingTag>, 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; <…;
}
type AnyPollingLayer = Layer.Layer<
PollingTag,
never,
never
>
interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>RUser | function (type parameter) RSchedule in make<const Id extends string, E, RUser, RSchedule>(id: Id, effect: Effect.Effect<void, E, RUser>, schedule: ProcessScheduleInitializer<RSchedule>, polling: AnyPollingLayer): Process<RUser | RSchedule>RSchedule>;
function function make<const Id extends string, E, RUser>(id: Id, config: ProcessMakeOptions<E, RUser>): Process<RUser> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, config: ProcessMakeOptions<E, RUser>): Process<RUser>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, config: ProcessMakeOptions<E, RUser>): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, config: ProcessMakeOptions<E, RUser>): Process<RUser>RUser>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, config: ProcessMakeOptions<E, RUser>): Process<RUser>Id,
config: ProcessMakeOptions<E, RUser>(parameter) config: {
effect: Effect.Effect<void, E, RUser>;
_store: ProcessStoreWriter;
_storeScopeTag: StoreScopeTag;
_resultRef: SubscriptionRef.SubscriptionRef<Option.Option<unknown>>;
polling: AnyPollingLayer;
schedule: ProcessScheduleInitializer<RUser> | AnyScheduleLayer;
scheduleLayer: AnyScheduleLayer;
}
interface ProcessMakeOptions<E, RUser>Configuration for
Process.make
when using the config-object form (id is separate).
ProcessMakeOptions<function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, config: ProcessMakeOptions<E, RUser>): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, config: ProcessMakeOptions<E, RUser>): Process<RUser>RUser>,
): interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, config: ProcessMakeOptions<E, RUser>): Process<RUser>RUser>;
function function make<const Id extends string, E, RUser>(id: Id, effect: Effect.Effect<void, E, RUser>): Process<RUser> (+8 overloads)Create a managed
Process
.
make<const function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>Id extends string, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>RUser>(
id: const Id extends stringid: function (type parameter) Id in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>Id,
effectOrConfig: | Effect.Effect<void, E, RUser>
| ProcessMakeOptions<E, RUser>
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<void, function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>RUser> | interface ProcessMakeOptions<E, RUser>Configuration for
Process.make
when using the config-object form (id is separate).
ProcessMakeOptions<function (type parameter) E in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>E, function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>RUser>,
third: ProcessMakeLayerArg<RUser> | undefinedthird?: type ProcessMakeLayerArg<RUser> =
| ProcessPollingInput
| ProcessScheduleLayerInput
| ProcessScheduleInitializer<RUser>
function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>RUser>,
fourth: ProcessMakeLayerArg<RUser> | undefinedfourth?: type ProcessMakeLayerArg<RUser> =
| ProcessPollingInput
| ProcessScheduleLayerInput
| ProcessScheduleInitializer<RUser>
function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>RUser>,
): interface Process<out R>Managed process handle for the process manager.
Process<function (type parameter) RUser in make<const Id extends string, E, RUser>(id: Id, effectOrConfig: Effect.Effect<void, E, RUser> | ProcessMakeOptions<E, RUser>, third?: ProcessMakeLayerArg<RUser>, fourth?: ProcessMakeLayerArg<RUser>): Process<RUser>RUser> {
return const buildProcess: <E, RUser>(
name: string,
config: ProcessMakeOptions<E, RUser>
) => Process<RUser>
id: const Id extends stringid, const resolveProcessMakeConfig: <
E,
RUser
>(
effectOrConfig:
| Effect.Effect<void, E, RUser>
| ProcessMakeOptions<E, RUser>,
third?: ProcessMakeLayerArg<RUser>,
fourth?: ProcessMakeLayerArg<RUser>
) => ProcessMakeOptions<E, RUser>
effectOrConfig: | Effect.Effect<void, E, RUser>
| ProcessMakeOptions<E, RUser>
third: ProcessMakeLayerArg<RUser> | undefinedthird, fourth: ProcessMakeLayerArg<RUser> | undefinedfourth));
}