Queue
A Queue
is a lightweight in-memory queue with built-in back-pressure, enabling asynchronous, purely-functional, and type-safe handling of data.
A Queue<A>
stores values of type A
and provides two fundamental operations:
API | Description |
---|---|
Queue.offer | Adds a value of type A to the queue. |
Queue.take | Removes and returns the oldest value from the queue. |
Example (Adding and Retrieving an Item)
1import { import Effect
Effect, import Queue
Queue } from "effect"2
3const const program: Effect.Effect<number, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<number>, never, never>> | YieldWrap<Effect.Effect<number, never, never>> | YieldWrap<Effect.Effect<...>>, number>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 // Creates a bounded queue with capacity 1005 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(100)6 // Adds 1 to the queue7 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 1)8 // Retrieves and removes the oldest value9 const const value: number
value = yield* import Queue
Queue.const take: <number>(self: Queue.Dequeue<number>) => Effect.Effect<number, never, never>
Takes the oldest value in the queue. If the queue is empty, this will return
a computation that resumes when an item has been added to the queue.
take(const queue: Queue.Queue<number>
queue)10 return const value: number
value11})12
13import Effect
Effect.const runPromise: <number, never>(effect: Effect.Effect<number, never, never>, options?: {
readonly signal?: AbortSignal;
} | undefined) => Promise<number>
Executes an effect and returns a `Promise` that resolves with the result.
Use `runPromise` when working with asynchronous effects and you need to integrate with code that uses Promises.
If the effect fails, the returned Promise will be rejected with the error.
runPromise(const program: Effect.Effect<number, never, never>
program).(method) Promise<number>.then<void, never>(onfulfilled?: ((value: number) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
then(namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log)14// Output: 1
Queues can be bounded (with a specified capacity) or unbounded (without a limit). Different types of queues handle new values differently when they reach capacity.
A bounded queue applies back-pressure when full, meaning any Queue.offer
operation will suspend until there is space.
Example (Creating a Bounded Queue)
1import { import Queue
Queue } from "effect"2
3// Creating a bounded queue with a capacity of 1004const const boundedQueue: Effect<Queue.Queue<number>, never, never>
boundedQueue = import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(100)
A dropping queue discards new values if the queue is full.
Example (Creating a Dropping Queue)
1import { import Queue
Queue } from "effect"2
3// Creating a dropping queue with a capacity of 1004const const droppingQueue: Effect<Queue.Queue<number>, never, never>
droppingQueue = import Queue
Queue.const dropping: <number>(requestedCapacity: number) => Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue` with the dropping strategy.
When the capacity of the queue is reached, new elements will be dropped and the
old elements will remain.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
dropping<number>(100)
A sliding queue removes old values to make space for new ones when it reaches capacity.
Example (Creating a Sliding Queue)
1import { import Queue
Queue } from "effect"2
3// Creating a sliding queue with a capacity of 1004const const slidingQueue: Effect<Queue.Queue<number>, never, never>
slidingQueue = import Queue
Queue.const sliding: <number>(requestedCapacity: number) => Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue` with the sliding strategy.
When the capacity of the queue is reached, new elements will be added and the
old elements will be dropped.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
sliding<number>(100)
An unbounded queue has no capacity limit, allowing unrestricted additions.
Example (Creating an Unbounded Queue)
1import { import Queue
Queue } from "effect"2
3// Creates an unbounded queue without a capacity limit4const const unboundedQueue: Effect<Queue.Queue<number>, never, never>
unboundedQueue = import Queue
Queue.const unbounded: <number>() => Effect<Queue.Queue<number>, never, never>
Creates a new unbounded `Queue`.
unbounded<number>()
Use Queue.offer
to add values to the queue.
Example (Adding a Single Item)
1import { import Effect
Effect, import Queue
Queue } from "effect"2
3const const program: Effect.Effect<void, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<number>, never, never>> | YieldWrap<Effect.Effect<boolean, never, never>>, void>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(100)5 // Adds 1 to the queue6 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 1)7})
When using a back-pressured queue, Queue.offer
suspends if the queue is full. To avoid blocking the main fiber, you can fork the Queue.offer
operation.
Example (Handling a Full Queue with Effect.fork
)
1import { import Effect
Effect, import Queue
Queue, import Fiber
Fiber } from "effect"2
3const const program: Effect.Effect<number, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<number>, never, never>> | YieldWrap<Effect.Effect<number, never, never>> | YieldWrap<Effect.Effect<...>> | YieldWrap<...>, number>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(1)5 // Fill the queue with one item6 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 1)7 // Attempting to add a second item will suspend as the queue is full8 const const fiber: Fiber.RuntimeFiber<boolean, never>
fiber = yield* import Effect
Effect.const fork: <boolean, never, never>(self: Effect.Effect<boolean, never, never>) => Effect.Effect<Fiber.RuntimeFiber<boolean, never>, never, never>
Returns an effect that forks this effect into its own separate fiber,
returning the fiber immediately, without waiting for it to begin executing
the effect.
You can use the `fork` method whenever you want to execute an effect in a
new fiber, concurrently and without "blocking" the fiber executing other
effects. Using fibers can be tricky, so instead of using this method
directly, consider other higher-level methods, such as `raceWith`,
`zipPar`, and so forth.
The fiber returned by this method has methods to interrupt the fiber and to
wait for it to finish executing the effect. See `Fiber` for more
information.
Whenever you use this method to launch a new fiber, the new fiber is
attached to the parent fiber's scope. This means when the parent fiber
terminates, the child fiber will be terminated as well, ensuring that no
fibers leak. This behavior is called "auto supervision", and if this
behavior is not desired, you may use the `forkDaemon` or `forkIn` methods.
fork(import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 2))9 // Empties the queue to make space10 yield* import Queue
Queue.const take: <number>(self: Queue.Dequeue<number>) => Effect.Effect<number, never, never>
Takes the oldest value in the queue. If the queue is empty, this will return
a computation that resumes when an item has been added to the queue.
take(const queue: Queue.Queue<number>
queue)11 // Joins the fiber, completing the suspended offer12 yield* import Fiber
Fiber.const join: <boolean, never>(self: Fiber.Fiber<boolean, never>) => Effect.Effect<boolean, never, never>
Joins the fiber, which suspends the joining fiber until the result of the
fiber has been determined. Attempting to join a fiber that has erred will
result in a catchable error. Joining an interrupted fiber will result in an
"inner interruption" of this fiber, unlike interruption triggered by
another fiber, "inner interruption" can be caught and recovered.
join(const fiber: Fiber.RuntimeFiber<boolean, never>
fiber)13 // Returns the size of the queue after additions14 return yield* import Queue
Queue.const size: <number>(self: Queue.Enqueue<number> | Queue.Dequeue<number>) => Effect.Effect<number>
Retrieves the size of the queue, which is equal to the number of elements
in the queue. This may be negative if fibers are suspended waiting for
elements to be added to the queue.
size(const queue: Queue.Queue<number>
queue)15})16
17import Effect
Effect.const runPromise: <number, never>(effect: Effect.Effect<number, never, never>, options?: {
readonly signal?: AbortSignal;
} | undefined) => Promise<number>
Executes an effect and returns a `Promise` that resolves with the result.
Use `runPromise` when working with asynchronous effects and you need to integrate with code that uses Promises.
If the effect fails, the returned Promise will be rejected with the error.
runPromise(const program: Effect.Effect<number, never, never>
program).(method) Promise<number>.then<void, never>(onfulfilled?: ((value: number) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
then(namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log)18// Output: 1
You can also add multiple items at once using Queue.offerAll
.
Example (Adding Multiple Items)
1import { import Effect
Effect, import Queue
Queue, import Array
Array } from "effect"2
3const const program: Effect.Effect<number, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<number>, never, never>> | YieldWrap<Effect.Effect<number, never, never>> | YieldWrap<Effect.Effect<...>>, number>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(100)5 const const items: [number, ...number[]]
items = import Array
Array.const range: (start: number, end: number) => Array.NonEmptyArray<number>
Return a `NonEmptyArray` containing a range of integers, including both endpoints.
range(1, 10)6 // Adds all items to the queue at once7 yield* import Queue
Queue.const offerAll: <number>(self: Queue.Enqueue<number>, iterable: Iterable<number>) => Effect.Effect<boolean> (+1 overload)
For Bounded Queue: uses the `BackPressure` Strategy, places the values in
the queue and always returns true. If the queue has reached capacity, then
the fiber performing the `offerAll` will be suspended until there is room
in the queue.
For Unbounded Queue: Places all values in the queue and returns true.
For Sliding Queue: uses `Sliding` Strategy If there is room in the queue,
it places the values otherwise it removes the old elements and enqueues the
new ones. Always returns true.
For Dropping Queue: uses `Dropping` Strategy, It places the values in the
queue but if there is no room it will not enqueue them and return false.
offerAll(const queue: Queue.Queue<number>
queue, const items: [number, ...number[]]
items)8 // Returns the size of the queue after additions9 return yield* import Queue
Queue.const size: <number>(self: Queue.Enqueue<number> | Queue.Dequeue<number>) => Effect.Effect<number>
Retrieves the size of the queue, which is equal to the number of elements
in the queue. This may be negative if fibers are suspended waiting for
elements to be added to the queue.
size(const queue: Queue.Queue<number>
queue)10})11
12import Effect
Effect.const runPromise: <number, never>(effect: Effect.Effect<number, never, never>, options?: {
readonly signal?: AbortSignal;
} | undefined) => Promise<number>
Executes an effect and returns a `Promise` that resolves with the result.
Use `runPromise` when working with asynchronous effects and you need to integrate with code that uses Promises.
If the effect fails, the returned Promise will be rejected with the error.
runPromise(const program: Effect.Effect<number, never, never>
program).(method) Promise<number>.then<void, never>(onfulfilled?: ((value: number) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
then(namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log)13// Output: 10
The Queue.take
operation removes and returns the oldest item from the queue. If the queue is empty, Queue.take
will suspend and only resume when an item is added. To prevent blocking, you can fork the Queue.take
operation into a new fiber.
Example (Waiting for an Item in a Fiber)
1import { import Effect
Effect, import Queue
Queue, import Fiber
Fiber } from "effect"2
3const const program: Effect.Effect<string, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<string>, never, never>> | YieldWrap<Effect.Effect<Fiber.RuntimeFiber<string, never>, never, never>> | YieldWrap<...> | YieldWrap<...>, string>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<string>
queue = yield* import Queue
Queue.const bounded: <string>(requestedCapacity: number) => Effect.Effect<Queue.Queue<string>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<string>(100)5 // This take operation will suspend because the queue is empty6 const const fiber: Fiber.RuntimeFiber<string, never>
fiber = yield* import Effect
Effect.const fork: <string, never, never>(self: Effect.Effect<string, never, never>) => Effect.Effect<Fiber.RuntimeFiber<string, never>, never, never>
Returns an effect that forks this effect into its own separate fiber,
returning the fiber immediately, without waiting for it to begin executing
the effect.
You can use the `fork` method whenever you want to execute an effect in a
new fiber, concurrently and without "blocking" the fiber executing other
effects. Using fibers can be tricky, so instead of using this method
directly, consider other higher-level methods, such as `raceWith`,
`zipPar`, and so forth.
The fiber returned by this method has methods to interrupt the fiber and to
wait for it to finish executing the effect. See `Fiber` for more
information.
Whenever you use this method to launch a new fiber, the new fiber is
attached to the parent fiber's scope. This means when the parent fiber
terminates, the child fiber will be terminated as well, ensuring that no
fibers leak. This behavior is called "auto supervision", and if this
behavior is not desired, you may use the `forkDaemon` or `forkIn` methods.
fork(import Queue
Queue.const take: <string>(self: Queue.Dequeue<string>) => Effect.Effect<string, never, never>
Takes the oldest value in the queue. If the queue is empty, this will return
a computation that resumes when an item has been added to the queue.
take(const queue: Queue.Queue<string>
queue))7 // Adds an item to the queue8 yield* import Queue
Queue.const offer: <string>(self: Queue.Enqueue<string>, value: string) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<string>
queue, "something")9 // Joins the fiber to get the result of the take operation10 const const value: string
value = yield* import Fiber
Fiber.const join: <string, never>(self: Fiber.Fiber<string, never>) => Effect.Effect<string, never, never>
Joins the fiber, which suspends the joining fiber until the result of the
fiber has been determined. Attempting to join a fiber that has erred will
result in a catchable error. Joining an interrupted fiber will result in an
"inner interruption" of this fiber, unlike interruption triggered by
another fiber, "inner interruption" can be caught and recovered.
join(const fiber: Fiber.RuntimeFiber<string, never>
fiber)11 return const value: string
value12})13
14import Effect
Effect.const runPromise: <string, never>(effect: Effect.Effect<string, never, never>, options?: {
readonly signal?: AbortSignal;
} | undefined) => Promise<string>
Executes an effect and returns a `Promise` that resolves with the result.
Use `runPromise` when working with asynchronous effects and you need to integrate with code that uses Promises.
If the effect fails, the returned Promise will be rejected with the error.
runPromise(const program: Effect.Effect<string, never, never>
program).(method) Promise<string>.then<void, never>(onfulfilled?: ((value: string) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
then(namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log)15// Output: something
To retrieve the queue’s first item without suspending, use Queue.poll
. If the queue is empty, Queue.poll
returns None
; if it has an item, it wraps it in Some
.
Example (Polling an Item)
1import { import Effect
Effect, import Queue
Queue } from "effect"2
3const const program: Effect.Effect<Option<number>, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<number>, never, never>> | YieldWrap<Effect.Effect<Option<number>, never, never>> | YieldWrap<...>, Option<...>>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(100)5 // Adds items to the queue6 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 10)7 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 20)8 // Retrieves the first item if available9 const const head: Option<number>
head = yield* import Queue
Queue.const poll: <number>(self: Queue.Dequeue<number>) => Effect.Effect<Option<number>, never, never>
Returns the first value in the `Queue` as a `Some<A>`, or `None` if the queue
is empty.
poll(const queue: Queue.Queue<number>
queue)10 return const head: Option<number>
head11})12
13import Effect
Effect.const runPromise: <Option<number>, never>(effect: Effect.Effect<Option<number>, never, never>, options?: {
readonly signal?: AbortSignal;
} | undefined) => Promise<Option<...>>
Executes an effect and returns a `Promise` that resolves with the result.
Use `runPromise` when working with asynchronous effects and you need to integrate with code that uses Promises.
If the effect fails, the returned Promise will be rejected with the error.
runPromise(const program: Effect.Effect<Option<number>, never, never>
program).(method) Promise<Option<number>>.then<void, never>(onfulfilled?: ((value: Option<number>) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
then(namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log)14/*15Output:16{17 _id: "Option",18 _tag: "Some",19 value: 1020}21*/
To retrieve multiple items, use Queue.takeUpTo
, which returns up to the specified number of items. If there aren’t enough items, it returns all available items without waiting for more.
Example (Taking Multiple Items)
1import { import Effect
Effect, import Queue
Queue } from "effect"2
3const const program: Effect.Effect<Chunk<number>, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<number>, never, never>> | YieldWrap<Effect.Effect<Chunk<number>, never, never>> | YieldWrap<...>, Chunk<...>>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(100)5 // Adds items to the queue6 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 10)7 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 20)8 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 30)9 // Retrieves up to 2 items10 const const chunk: Chunk<number>
chunk = yield* import Queue
Queue.const takeUpTo: <number>(self: Queue.Dequeue<number>, max: number) => Effect.Effect<Chunk<number>, never, never> (+1 overload)
Takes up to max number of values from the queue.
takeUpTo(const queue: Queue.Queue<number>
queue, 2)11 return const chunk: Chunk<number>
chunk12})13
14import Effect
Effect.const runPromise: <Chunk<number>, never>(effect: Effect.Effect<Chunk<number>, never, never>, options?: {
readonly signal?: AbortSignal;
} | undefined) => Promise<Chunk<number>>
Executes an effect and returns a `Promise` that resolves with the result.
Use `runPromise` when working with asynchronous effects and you need to integrate with code that uses Promises.
If the effect fails, the returned Promise will be rejected with the error.
runPromise(const program: Effect.Effect<Chunk<number>, never, never>
program).(method) Promise<Chunk<number>>.then<void, never>(onfulfilled?: ((value: Chunk<number>) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
then(namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log)15/*16Output:17{18 _id: "Chunk",19 values: [ 10, 20 ]20}21*/
To retrieve all items from the queue at once, use Queue.takeAll
. This operation completes immediately, returning an empty collection if the queue is empty.
Example (Taking All Items)
1import { import Effect
Effect, import Queue
Queue } from "effect"2
3const const program: Effect.Effect<Chunk<number>, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<number>, never, never>> | YieldWrap<Effect.Effect<Chunk<number>, never, never>> | YieldWrap<...>, Chunk<...>>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(100)5 // Adds items to the queue6 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 10)7 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 20)8 yield* import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer(const queue: Queue.Queue<number>
queue, 30)9 // Retrieves all items from the queue10 const const chunk: Chunk<number>
chunk = yield* import Queue
Queue.const takeAll: <number>(self: Queue.Dequeue<number>) => Effect.Effect<Chunk<number>, never, never>
Takes all the values in the queue and returns the values. If the queue is
empty returns an empty collection.
takeAll(const queue: Queue.Queue<number>
queue)11 return const chunk: Chunk<number>
chunk12})13
14import Effect
Effect.const runPromise: <Chunk<number>, never>(effect: Effect.Effect<Chunk<number>, never, never>, options?: {
readonly signal?: AbortSignal;
} | undefined) => Promise<Chunk<number>>
Executes an effect and returns a `Promise` that resolves with the result.
Use `runPromise` when working with asynchronous effects and you need to integrate with code that uses Promises.
If the effect fails, the returned Promise will be rejected with the error.
runPromise(const program: Effect.Effect<Chunk<number>, never, never>
program).(method) Promise<Chunk<number>>.then<void, never>(onfulfilled?: ((value: Chunk<number>) => void | PromiseLike<void>) | null | undefined, onrejected?: ((reason: any) => PromiseLike<never>) | null | undefined): Promise<...>
Attaches callbacks for the resolution and/or rejection of the Promise.
then(namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log)15/*16Output:17{18 _id: "Chunk",19 values: [ 10, 20, 30 ]20}21*/
The Queue.shutdown
operation allows you to interrupt all fibers that are currently suspended on offer*
or take*
operations. This action also empties the queue and makes any future offer*
and take*
calls terminate immediately.
Example (Interrupting Fibers on Queue Shutdown)
1import { import Effect
Effect, import Queue
Queue, import Fiber
Fiber } from "effect"2
3const const program: Effect.Effect<void, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<void, never, never>>, void>(f: (resume: Effect.Adapter) => Generator<YieldWrap<Effect.Effect<void, never, never>>, void, never>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(3)5 // Forks a fiber that waits to take an item from the queue6 const const fiber: Fiber.RuntimeFiber<number, never>
fiber = yield* import Effect
Effect.const fork: <number, never, never>(self: Effect.Effect<number, never, never>) => Effect.Effect<Fiber.RuntimeFiber<number, never>, never, never>
Returns an effect that forks this effect into its own separate fiber,
returning the fiber immediately, without waiting for it to begin executing
the effect.
You can use the `fork` method whenever you want to execute an effect in a
new fiber, concurrently and without "blocking" the fiber executing other
effects. Using fibers can be tricky, so instead of using this method
directly, consider other higher-level methods, such as `raceWith`,
`zipPar`, and so forth.
The fiber returned by this method has methods to interrupt the fiber and to
wait for it to finish executing the effect. See `Fiber` for more
information.
Whenever you use this method to launch a new fiber, the new fiber is
attached to the parent fiber's scope. This means when the parent fiber
terminates, the child fiber will be terminated as well, ensuring that no
fibers leak. This behavior is called "auto supervision", and if this
behavior is not desired, you may use the `forkDaemon` or `forkIn` methods.
fork(import Queue
Queue.const take: <number>(self: Queue.Dequeue<number>) => Effect.Effect<number, never, never>
Takes the oldest value in the queue. If the queue is empty, this will return
a computation that resumes when an item has been added to the queue.
take(const queue: Queue.Queue<number>
queue))7 // Shuts down the queue, interrupting the fiber8 yield* import Queue
Queue.const shutdown: <number>(self: Queue.Enqueue<number> | Queue.Dequeue<number>) => Effect.Effect<void>
Interrupts any fibers that are suspended on `offer` or `take`. Future calls
to `offer*` and `take*` will be interrupted immediately.
shutdown(const queue: Queue.Queue<number>
queue)9 // Joins the interrupted fiber10 yield* import Fiber
Fiber.const join: <number, never>(self: Fiber.Fiber<number, never>) => Effect.Effect<number, never, never>
Joins the fiber, which suspends the joining fiber until the result of the
fiber has been determined. Attempting to join a fiber that has erred will
result in a catchable error. Joining an interrupted fiber will result in an
"inner interruption" of this fiber, unlike interruption triggered by
another fiber, "inner interruption" can be caught and recovered.
join(const fiber: Fiber.RuntimeFiber<number, never>
fiber)11})
The Queue.awaitShutdown
operation can be used to run an effect when the queue shuts down. It waits until the queue is closed and resumes immediately if the queue is already shut down.
Example (Waiting for Queue Shutdown)
1import { import Effect
Effect, import Queue
Queue, import Fiber
Fiber, import Console
Console } from "effect"2
3const const program: Effect.Effect<void, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<void, never, never>>, void>(f: (resume: Effect.Adapter) => Generator<YieldWrap<Effect.Effect<void, never, never>>, void, never>) => Effect.Effect<...> (+1 overload)
gen(function* () {4 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const bounded: <number>(requestedCapacity: number) => Effect.Effect<Queue.Queue<number>, never, never>
Makes a new bounded `Queue`. When the capacity of the queue is reached, any
additional calls to `offer` will be suspended until there is more room in
the queue.
**Note**: When possible use only power of 2 capacities; this will provide
better performance by utilising an optimised version of the underlying
`RingBuffer`.
bounded<number>(3)5 // Forks a fiber to await queue shutdown and log a message6 const const fiber: Fiber.RuntimeFiber<void, never>
fiber = yield* import Effect
Effect.const fork: <void, never, never>(self: Effect.Effect<void, never, never>) => Effect.Effect<Fiber.RuntimeFiber<void, never>, never, never>
Returns an effect that forks this effect into its own separate fiber,
returning the fiber immediately, without waiting for it to begin executing
the effect.
You can use the `fork` method whenever you want to execute an effect in a
new fiber, concurrently and without "blocking" the fiber executing other
effects. Using fibers can be tricky, so instead of using this method
directly, consider other higher-level methods, such as `raceWith`,
`zipPar`, and so forth.
The fiber returned by this method has methods to interrupt the fiber and to
wait for it to finish executing the effect. See `Fiber` for more
information.
Whenever you use this method to launch a new fiber, the new fiber is
attached to the parent fiber's scope. This means when the parent fiber
terminates, the child fiber will be terminated as well, ensuring that no
fibers leak. This behavior is called "auto supervision", and if this
behavior is not desired, you may use the `forkDaemon` or `forkIn` methods.
fork(7 import Queue
Queue.const awaitShutdown: <number>(self: Queue.Enqueue<number> | Queue.Dequeue<number>) => Effect.Effect<void>
Waits until the queue is shutdown. The `Effect` returned by this method will
not resume until the queue has been shutdown. If the queue is already
shutdown, the `Effect` will resume right away.
awaitShutdown(const queue: Queue.Queue<number>
queue).(method) Pipeable.pipe<Effect.Effect<void, never, never>, Effect.Effect<void, never, never>>(this: Effect.Effect<...>, ab: (_: Effect.Effect<void, never, never>) => Effect.Effect<void, never, never>): Effect.Effect<...> (+21 overloads)
pipe(8 import Effect
Effect.const andThen: <Effect.Effect<void, never, never>>(f: Effect.Effect<void, never, never>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R> (+3 overloads)
Executes a sequence of two actions, typically two `Effect`s, where the second action can depend on the result of the first action.
The `that` action can take various forms:
- a value
- a function returning a value
- a promise
- a function returning a promise
- an effect
- a function returning an effect
andThen(import Console
Console.const log: (...args: ReadonlyArray<any>) => Effect.Effect<void>
log("shutting down"))9 )10 )11 // Shuts down the queue, triggering the await in the fiber12 yield* import Queue
Queue.const shutdown: <number>(self: Queue.Enqueue<number> | Queue.Dequeue<number>) => Effect.Effect<void>
Interrupts any fibers that are suspended on `offer` or `take`. Future calls
to `offer*` and `take*` will be interrupted immediately.
shutdown(const queue: Queue.Queue<number>
queue)13 yield* import Fiber
Fiber.const join: <void, never>(self: Fiber.Fiber<void, never>) => Effect.Effect<void, never, never>
Joins the fiber, which suspends the joining fiber until the result of the
fiber has been determined. Attempting to join a fiber that has erred will
result in a catchable error. Joining an interrupted fiber will result in an
"inner interruption" of this fiber, unlike interruption triggered by
another fiber, "inner interruption" can be caught and recovered.
join(const fiber: Fiber.RuntimeFiber<void, never>
fiber)14})15
16import Effect
Effect.const runPromise: <void, never>(effect: Effect.Effect<void, never, never>, options?: {
readonly signal?: AbortSignal;
} | undefined) => Promise<void>
Executes an effect and returns a `Promise` that resolves with the result.
Use `runPromise` when working with asynchronous effects and you need to integrate with code that uses Promises.
If the effect fails, the returned Promise will be rejected with the error.
runPromise(const program: Effect.Effect<void, never, never>
program)17// Output: shutting down
Sometimes, you might want certain parts of your code to only add values to a queue (Enqueue
) or only retrieve values from a queue (Dequeue
). Effect provides interfaces to enforce these specific capabilities.
All methods for adding values to a queue are defined by the Enqueue
interface. This restricts the queue to only offer operations.
Example (Restricting Queue to Offer-only Operations)
1import { import Queue
Queue } from "effect"2
3const const send: (offerOnlyQueue: Queue.Enqueue<number>, value: number) => Effect<boolean, never, never>
send = ((parameter) offerOnlyQueue: Queue.Enqueue<number>
offerOnlyQueue: import Queue
Queue.interface Enqueue<in A>
Enqueue<number>, (parameter) value: number
value: number) => {4 // This queue is restricted to offer operations only5
6 // Error: cannot use take on an offer-only queue7 // @ts-expect-error8 import Queue
Queue.const take: <unknown>(self: Queue.Dequeue<unknown>) => Effect<unknown, never, never>
Takes the oldest value in the queue. If the queue is empty, this will return
a computation that resumes when an item has been added to the queue.
take((parameter) offerOnlyQueue: Queue.Enqueue<number>
offerOnlyQueue)9
10 // Valid offer operation11 return import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect<boolean> (+1 overload)
Places one value in the queue.
offer((parameter) offerOnlyQueue: Queue.Enqueue<number>
offerOnlyQueue, (parameter) value: number
value)12}
Similarly, all methods for retrieving values from a queue are defined by the Dequeue
interface, which restricts the queue to only take operations.
Example (Restricting Queue to Take-only Operations)
1import { import Queue
Queue } from "effect"2
3const const receive: (takeOnlyQueue: Queue.Dequeue<number>) => Effect<number, never, never>
receive = ((parameter) takeOnlyQueue: Queue.Dequeue<number>
takeOnlyQueue: import Queue
Queue.interface Dequeue<out A>
Dequeue<number>) => {4 // This queue is restricted to take operations only5
6 // Error: cannot use offer on a take-only queue7 // @ts-expect-error8 import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect<boolean> (+1 overload)
Places one value in the queue.
offer((parameter) takeOnlyQueue: Queue.Dequeue<number>
takeOnlyQueue, 1)9
10 // Valid take operation11 return import Queue
Queue.const take: <number>(self: Queue.Dequeue<number>) => Effect<number, never, never>
Takes the oldest value in the queue. If the queue is empty, this will return
a computation that resumes when an item has been added to the queue.
take((parameter) takeOnlyQueue: Queue.Dequeue<number>
takeOnlyQueue)12}
The Queue
type combines both Enqueue
and Dequeue
, so you can easily pass it to different parts of your code, enforcing only Enqueue
or Dequeue
behaviors as needed.
Example (Using Offer-only and Take-only Queues Together)
1import { import Effect
Effect, import Queue
Queue } from "effect"2
3const const send: (offerOnlyQueue: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean, never, never>
send = ((parameter) offerOnlyQueue: Queue.Enqueue<number>
offerOnlyQueue: import Queue
Queue.interface Enqueue<in A>
Enqueue<number>, (parameter) value: number
value: number) => {4 return import Queue
Queue.const offer: <number>(self: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean> (+1 overload)
Places one value in the queue.
offer((parameter) offerOnlyQueue: Queue.Enqueue<number>
offerOnlyQueue, (parameter) value: number
value)5}6
7const const receive: (takeOnlyQueue: Queue.Dequeue<number>) => Effect.Effect<number, never, never>
receive = ((parameter) takeOnlyQueue: Queue.Dequeue<number>
takeOnlyQueue: import Queue
Queue.interface Dequeue<out A>
Dequeue<number>) => {8 return import Queue
Queue.const take: <number>(self: Queue.Dequeue<number>) => Effect.Effect<number, never, never>
Takes the oldest value in the queue. If the queue is empty, this will return
a computation that resumes when an item has been added to the queue.
take((parameter) takeOnlyQueue: Queue.Dequeue<number>
takeOnlyQueue)9}10
11const const program: Effect.Effect<void, never, never>
program = import Effect
Effect.const gen: <YieldWrap<Effect.Effect<Queue.Queue<number>, never, never>> | YieldWrap<Effect.Effect<boolean, never, never>> | YieldWrap<Effect.Effect<...>>, void>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {12 const const queue: Queue.Queue<number>
queue = yield* import Queue
Queue.const unbounded: <number>() => Effect.Effect<Queue.Queue<number>, never, never>
Creates a new unbounded `Queue`.
unbounded<number>()13
14 // Add values to the queue15 yield* const send: (offerOnlyQueue: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean, never, never>
send(const queue: Queue.Queue<number>
queue, 1)16 yield* const send: (offerOnlyQueue: Queue.Enqueue<number>, value: number) => Effect.Effect<boolean, never, never>
send(const queue: Queue.Queue<number>
queue, 2)17
18 // Retrieve values from the queue19 namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log(yield* const receive: (takeOnlyQueue: Queue.Dequeue<number>) => Effect.Effect<number, never, never>
receive(const queue: Queue.Queue<number>
queue))20 namespace console
var console: Console
The `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:
* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.
_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.
Example using the global `console`:
```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
// Error: Whoops, something bad happened
// at [eval]:5:15
// at Script.runInThisContext (node:vm:132:18)
// at Object.runInThisContext (node:vm:309:38)
// at node:internal/process/execution:77:19
// at [eval]-wrapper:6:22
// at evalScript (node:internal/process/execution:76:60)
// at node:internal/main/eval_string:23:3
const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```
Example using the `Console` class:
```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);
myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err
const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): void
Prints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).
```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```
See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log(yield* const receive: (takeOnlyQueue: Queue.Dequeue<number>) => Effect.Effect<number, never, never>
receive(const queue: Queue.Queue<number>
queue))21})22
23import Effect
Effect.const runFork: <void, never>(effect: Effect.Effect<void, never, never>, options?: RunForkOptions) => RuntimeFiber<void, never>
Executes an effect and returns a `RuntimeFiber` that represents the running computation.
Use `runFork` when you want to start an effect without blocking the current execution flow.
It returns a fiber that you can observe, interrupt, or join as needed.
runFork(const program: Effect.Effect<void, never, never>
program)24/*25Output:26127228*/