Skip to content
Effect Documentation

Introduction

Introduction to Sinks

In the world of streams, a Sink<A, In, L, E, R> plays a crucial role. It’s like a specialized function designed to consume elements generated by a Stream. Here’s a breakdown of what a Sink does:

  • It can consume a varying number of In elements, which might be zero, one, or more.
  • It has the potential to encounter errors of type E.
  • Ultimately, it produces a value of type A.
  • Additionally, it can return a remainder of type L, which represents any leftover elements.

To use a Sink for processing a stream, you simply pass it to the Stream.run function:

1
import { 
import Stream
Stream, 
import Sink
Sink, 
import Effect
Effect } from "effect"
2


3
// Define a stream with numbers 1, 2, and 3
4
const 
const stream: Stream.Stream<number, never, never>
stream = 
import Stream
Stream.
const make: <[number, number, number]>(as_0: number, as_1: number, as_2: number) => Stream.Stream<number, never, never>
Creates a stream from an sequence of values.
make(1, 2, 3)
5


6
// Create a sink that sums numbers
7
const 
const sink: Sink.Sink<number, number, never, never, never>
sink = 
import Sink
Sink.
const sum: Sink.Sink<number, number, never, never, never>
A sink that sums incoming numeric values.
sum
8


9
// Run the stream through the sink to obtain the result
10
const 
const sum: Effect.Effect<number, never, never>
sum = 
import Stream
Stream.
const run: <number, never, never, number, never, never>(self: Stream.Stream<number, never, never>, sink: Sink.Sink<number, number, unknown, never, never>) => Effect.Effect<number, never, never> (+1 overload)
Runs the sink on the stream to produce either the sink's result or an error.
run(
const stream: Stream.Stream<number, never, never>
stream, 
const sink: Sink.Sink<number, number, never, never, never>
sink)
11


12
import 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 sum: Effect.Effect<number, never, never>
sum).
(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
/*
14
Output:
15
6
16
*/