Effect Data Types

Interop With Data

The Data module in the Effect ecosystem simplifies value comparison by automatically implementing the Equal and Hash traits. This eliminates the need for manual implementations, making equality checks straightforward.

Example (Comparing Structs with Data)

1
import { 
import Data
Data, 
import Equal
Equal } from "effect"
2

3
const 
const person1: {
    readonly name: string;
    readonly age: number;
}
person1 = 
import Data
Data.
const struct: <{
    name: string;
    age: number;
}>(a: {
    name: string;
    age: number;
}) => {
    readonly name: string;
    readonly age: number;
}@example 
import { Data, Equal } from "effect"

const alice = Data.struct({ name: "Alice", age: 30 })

const bob = Data.struct({ name: "Bob", age: 40 })

assert.deepStrictEqual(Equal.equals(alice, alice), true)
assert.deepStrictEqual(Equal.equals(alice, Data.struct({ name: "Alice", age: 30 })), true)

assert.deepStrictEqual(Equal.equals(alice, { name: "Alice", age: 30 }), false)
assert.deepStrictEqual(Equal.equals(alice, bob), false)
@since ― 2.0.0
struct({ 
name: string
name: "Alice", 
age: number
age: 30 })
4
const 
const person2: {
    readonly name: string;
    readonly age: number;
}
person2 = 
import Data
Data.
const struct: <{
    name: string;
    age: number;
}>(a: {
    name: string;
    age: number;
}) => {
    readonly name: string;
    readonly age: number;
}@example 
import { Data, Equal } from "effect"

const alice = Data.struct({ name: "Alice", age: 30 })

const bob = Data.struct({ name: "Bob", age: 40 })

assert.deepStrictEqual(Equal.equals(alice, alice), true)
assert.deepStrictEqual(Equal.equals(alice, Data.struct({ name: "Alice", age: 30 })), true)

assert.deepStrictEqual(Equal.equals(alice, { name: "Alice", age: 30 }), false)
assert.deepStrictEqual(Equal.equals(alice, bob), false)
@since ― 2.0.0
struct({ 
name: string
name: "Alice", 
age: number
age: 30 })
5

6
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
import Equal
Equal.
function equals<{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}>(self: {
    readonly name: string;
    readonly age: number;
}, that: {
    readonly name: string;
    readonly age: number;
}): boolean (+1 overload)@since ― 2.0.0
equals(
const person1: {
    readonly name: string;
    readonly age: number;
}
person1, 
const person2: {
    readonly name: string;
    readonly age: number;
}
person2))
7
// Output: true

By default, schemas like Schema.Struct do not implement the Equal and Hash traits. This means that two decoded objects with identical values will not be considered equal.

Example (Default Behavior Without Equal and Hash)

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Equal
Equal } from "effect"
3

4
const 
const schema: Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>
schema = 
import Schema
Schema.
function Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>(fields: {
    name: typeof Schema.String;
    age: typeof Schema.Number;
}): Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}> (+1 overload)@since ― 3.10.0
Struct({
5
  
name: typeof Schema.String
name: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
6
  
age: typeof Schema.Number
age: 
import Schema
Schema.
class Number
export Number@since ― 3.10.0
Number
7
})
8

9
const 
const decode: (i: {
    readonly name: string;
    readonly age: number;
}, overrideOptions?: ParseOptions) => Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
decode = 
import Schema
Schema.
const decode: <{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}, never>(schema: Schema.Schema<{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}, never>, options?: ParseOptions) => (i: {
    readonly name: string;
    readonly age: number;
}, overrideOptions?: ParseOptions) => Effect<...>@since ― 3.10.0
decode(
const schema: Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>
schema)
10

11
const 
const person1: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
person1 = 
const decode: (i: {
    readonly name: string;
    readonly age: number;
}, overrideOptions?: ParseOptions) => Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
decode({ 
name: string
name: "Alice", 
age: number
age: 30 })
12
const 
const person2: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
person2 = 
const decode: (i: {
    readonly name: string;
    readonly age: number;
}, overrideOptions?: ParseOptions) => Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
decode({ 
name: string
name: "Alice", 
age: number
age: 30 })
13

14
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
import Equal
Equal.
function equals<Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>, Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>>(self: Effect<...>, that: Effect<...>): boolean (+1 overload)@since ― 2.0.0
equals(
const person1: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
person1, 
const person2: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
person2))
15
// Output: false

The Schema.Data function can be used to enhance a schema by including the Equal and Hash traits. This allows the resulting objects to support value-based equality.

Example (Using Schema.Data to Add Equality)

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Equal
Equal } from "effect"
3

4
const 
const schema: Schema.SchemaClass<{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}, never>
schema = 
import Schema
Schema.
const Data: <never, {
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}>(item: Schema.Schema<{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}, never>) => Schema.SchemaClass<...>@since ― 3.10.0
Data(
5
  
import Schema
Schema.
function Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>(fields: {
    name: typeof Schema.String;
    age: typeof Schema.Number;
}): Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}> (+1 overload)@since ― 3.10.0
Struct({
6
    
name: typeof Schema.String
name: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
7
    
age: typeof Schema.Number
age: 
import Schema
Schema.
class Number
export Number@since ― 3.10.0
Number
8
  })
9
)
10

11
const 
const decode: (i: {
    readonly name: string;
    readonly age: number;
}, overrideOptions?: ParseOptions) => Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
decode = 
import Schema
Schema.
const decode: <{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}, never>(schema: Schema.Schema<{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}, never>, options?: ParseOptions) => (i: {
    readonly name: string;
    readonly age: number;
}, overrideOptions?: ParseOptions) => Effect<...>@since ― 3.10.0
decode(
const schema: Schema.SchemaClass<{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}, never>
schema)
12

13
const 
const person1: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
person1 = 
const decode: (i: {
    readonly name: string;
    readonly age: number;
}, overrideOptions?: ParseOptions) => Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
decode({ 
name: string
name: "Alice", 
age: number
age: 30 })
14
const 
const person2: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
person2 = 
const decode: (i: {
    readonly name: string;
    readonly age: number;
}, overrideOptions?: ParseOptions) => Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
decode({ 
name: string
name: "Alice", 
age: number
age: 30 })
15

16
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
import Equal
Equal.
function equals<Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>, Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>>(self: Effect<...>, that: Effect<...>): boolean (+1 overload)@since ― 2.0.0
equals(
const person1: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
person1, 
const person2: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>
person2))
17
// Output: true

Config

The Schema.Config function allows you to validate and manage application configuration settings using structured schemas. It ensures consistency in configuration data and provides detailed feedback for validation errors.

Syntax

Config: <A>(name: string, schema: Schema<A, string>) => Config<A>

This function requires two parameters:

name: Identifier for the configuration setting.
schema: Schema describing the expected data type and structure.

The function returns a Config object that is directly integrated with your application’s configuration management system.

The Schema.Config function operates through the following steps:

Fetching Configuration: The configuration value is retrieved based on its name.
Validation: The value is then validated against the schema. If the value does not conform to the schema, the function formats and returns detailed validation errors.
Error Formatting: Errors are formatted using TreeFormatter.formatErrorSync to provide clear, actionable error messages.

Example (Validating Configuration Settings)

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Effect@since ― 2.0.0
@since ― 2.0.0
@since ― 2.0.0
Effect } from "effect"
3

4
const 
const myconfig: Config<string>
myconfig = 
import Schema
Schema.
const Config: <string>(name: string, schema: Schema.Schema<string, string, never>) => Config<string>@since ― 3.10.0
Config(
5
  "Foo",
6
  
import Schema
Schema.
class String
export String@since ― 3.10.0
String.
Pipeable.pipe<typeof Schema.String, Schema.filter<Schema.Schema<string, string, never>>>(this: typeof Schema.String, ab: (_: typeof Schema.String) => Schema.filter<Schema.Schema<string, string, never>>): Schema.filter<...> (+21 overloads)
pipe(
import Schema
Schema.
const minLength: <string>(minLength: number, annotations?: Schema.Annotations.Filter<string, string> | undefined) => <I, R>(self: Schema.Schema<string, I, R>) => Schema.filter<...>@since ― 3.10.0
minLength(4))
7
)
8

9
const 
const program: Effect.Effect<void, ConfigError, never>
program = 
import Effect@since ― 2.0.0
@since ― 2.0.0
@since ― 2.0.0
Effect.
const gen: <YieldWrap<Effect.Effect<string, ConfigError, never>>, void>(f: (resume: Effect.Adapter) => Generator<YieldWrap<Effect.Effect<string, ConfigError, never>>, void, never>) => Effect.Effect<...> (+1 overload)
Provides a way to write effectful code using generator functions, simplifying
control flow and error handling.
When to Use
gen allows you to write code that looks and behaves like synchronous
code, but it can handle asynchronous tasks, errors, and complex control flow
(like loops and conditions). It helps make asynchronous code more readable
and easier to manage.
The generator functions work similarly to async/await but with more
explicit control over the execution of effects. You can yield* values from
effects and return the final result at the end.
@example 
import { Effect } from "effect"

const addServiceCharge = (amount: number) => amount + 1

const applyDiscount = (
  total: number,
  discountRate: number
): Effect.Effect<number, Error> =>
  discountRate === 0
    ? Effect.fail(new Error("Discount rate cannot be zero"))
    : Effect.succeed(total - (total * discountRate) / 100)

const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))

const fetchDiscountRate = Effect.promise(() => Promise.resolve(5))

export const program = Effect.gen(function* () {
  const transactionAmount = yield* fetchTransactionAmount
  const discountRate = yield* fetchDiscountRate
  const discountedAmount = yield* applyDiscount(
    transactionAmount,
    discountRate
  )
  const finalAmount = addServiceCharge(discountedAmount)
  return `Final amount to charge: ${finalAmount}`
})
@since ― 2.0.0
gen(function* () {
10
  const 
const foo: string
foo = yield* 
const myconfig: Config<string>
myconfig
11
  
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(`ok: ${
const foo: string
foo}`)
12
})
13

14
import Effect@since ― 2.0.0
@since ― 2.0.0
@since ― 2.0.0
Effect.
const runSync: <void, ConfigError>(effect: Effect.Effect<void, ConfigError, never>) => void
Executes an effect synchronously, running it immediately and returning the
result.
When to Use
Use runSync to run an effect that does not fail and does not include
any asynchronous operations.
If the effect fails or involves asynchronous work, it will throw an error,
and execution will stop where the failure or async operation occurs.
@see ― runSyncExit for a version that returns an Exit type instead of
throwing an error.
@example 
// Title: Synchronous Logging
import { Effect } from "effect"

const program = Effect.sync(() => {
  console.log("Hello, World!")
  return 1
})

const result = Effect.runSync(program)
// Output: Hello, World!

console.log(result)
// Output: 1
@example 
// Title: Incorrect Usage with Failing or Async Effects
import { Effect } from "effect"
try {
// Attempt to run an effect that fails
Effect.runSync(Effect.fail("my error"))
} catch (e) {
console.error(e)
}
// Output:
// (FiberFailure) Error: my error
try {
// Attempt to run an effect that involves async work
Effect.runSync(Effect.promise(() => Promise.resolve(1)))
} catch (e) {
console.error(e)
}
// Output:
// (FiberFailure) AsyncFiberException: Fiber #0 cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work
@since ― 2.0.0
runSync(
const program: Effect.Effect<void, ConfigError, never>
program)

To test the configuration, execute the following commands:

Test (with Missing Configuration Data)

npx tsx config.ts
# Output:
# [(Missing data at Foo: "Expected Foo to exist in the process context")]

Test (with Invalid Data)

Foo=bar npx tsx config.ts
# Output:
# [(Invalid data at Foo: "a string at least 4 character(s) long
# └─ Predicate refinement failure
#    └─ Expected a string at least 4 character(s) long, actual "bar"")]

Test (with Valid Data)

Foo=foobar npx tsx config.ts
# Output:
# ok: foobar

Option

The Schema.Option function is useful for converting an Option into a JSON-serializable format.

Syntax

Schema.Option(schema: Schema<A, I, R>)

Decoding

Input	Output
`{ _tag: "None" }`	Converted to `Option.none()`
`{ _tag: "Some", value: I }`	Converted to `Option.some(a)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Converted to `{ _tag: "None" }`
`Option.some(A)`	Converted to `{ _tag: "Some", value: I }`, where `A` is encoded into `I` using the inner schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Option@since ― 2.0.0
@since ― 2.0.0
Option } from "effect"
3

4
const 
const schema: Schema.Option<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const Option: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString) => Schema.Option<typeof Schema.NumberFromString>@since ― 3.10.0
Option(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString)
5

6
//     ┌─── OptionEncoded<string>
7
//     ▼
8
type 
type Encoded = {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}
Encoded = typeof 
const schema: Schema.Option<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, OptionEncoded<string>, never>.Encoded: Schema.OptionEncoded<string>
Encoded
9

10
//     ┌─── Option<number>
11
//     ▼
12
type 
type Type = Option.None<number> | Option.Some<number>
Type = typeof 
const schema: Schema.Option<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, OptionEncoded<string>, never>.Type: Option.Option<number>
Type
13

14
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode = 
import Schema
Schema.
decodeUnknownSync<Option.Option<number>, Schema.OptionEncoded<string>>(schema: Schema.Schema<Option.Option<number>, Schema.OptionEncoded<string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option.Option<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.Option<typeof Schema.NumberFromString>
schema)
15
const 
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => Schema.OptionEncoded<string>
encode = 
import Schema
Schema.
encodeSync<Option.Option<number>, Schema.OptionEncoded<string>>(schema: Schema.Schema<Option.Option<number>, Schema.OptionEncoded<string>, never>, options?: ParseOptions): (a: Option.Option<...>, overrideOptions?: ParseOptions) => Schema.OptionEncoded<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.Option<typeof Schema.NumberFromString>
schema)
16

17
// Decoding examples
18

19
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode({ 
_tag: string
_tag: "None" }))
20
// Output: { _id: 'Option', _tag: 'None' }
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode({ 
_tag: string
_tag: "Some", 
value: string
value: "1" }))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// Encoding examples
26

27
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => Schema.OptionEncoded<string>
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const none: <number>() => Option.Option<number>
Creates a new Option that represents the absence of a value.
@since ― 2.0.0
none()))
28
// Output: { _tag: 'None' }
29

30
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => Schema.OptionEncoded<string>
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const some: <number>(value: number) => Option.Option<number>
Creates a new Option that wraps the given value.
@param ― value - The value to wrap.
@since ― 2.0.0
some(1)))
31
// Output: { _tag: 'Some', value: '1' }

OptionFromSelf

The Schema.OptionFromSelf function is designed for scenarios where Option values are already in the Option format and need to be decoded or encoded while transforming the inner value according to the provided schema.

Syntax

Schema.OptionFromSelf(schema: Schema<A, I, R>)

Decoding

Input	Output
`Option.none()`	Remains as `Option.none()`
`Option.some(I)`	Converted to `Option.some(A)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Remains as `Option.none()`
`Option.some(A)`	Converted to `Option.some(I)`, where `A` is encoded into `I` using the inner schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Option@since ― 2.0.0
@since ― 2.0.0
Option } from "effect"
3

4
const 
const schema: Schema.OptionFromSelf<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const OptionFromSelf: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString) => Schema.OptionFromSelf<typeof Schema.NumberFromString>@since ― 3.10.0
OptionFromSelf(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString)
5

6
//     ┌─── Option<string>
7
//     ▼
8
type 
type Encoded = Option.None<string> | Option.Some<string>
Encoded = typeof 
const schema: Schema.OptionFromSelf<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, Option<string>, never>.Encoded: Option.Option<string>
Encoded
9

10
//     ┌─── Option<number>
11
//     ▼
12
type 
type Type = Option.None<number> | Option.Some<number>
Type = typeof 
const schema: Schema.OptionFromSelf<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, Option<string>, never>.Type: Option.Option<number>
Type
13

14
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode = 
import Schema
Schema.
decodeUnknownSync<Option.Option<number>, Option.Option<string>>(schema: Schema.Schema<Option.Option<number>, Option.Option<string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option.Option<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.OptionFromSelf<typeof Schema.NumberFromString>
schema)
15
const 
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => Option.Option<string>
encode = 
import Schema
Schema.
encodeSync<Option.Option<number>, Option.Option<string>>(schema: Schema.Schema<Option.Option<number>, Option.Option<string>, never>, options?: ParseOptions): (a: Option.Option<...>, overrideOptions?: ParseOptions) => Option.Option<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.OptionFromSelf<typeof Schema.NumberFromString>
schema)
16

17
// Decoding examples
18

19
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const none: <never>() => Option.Option<never>
Creates a new Option that represents the absence of a value.
@since ― 2.0.0
none()))
20
// Output: { _id: 'Option', _tag: 'None' }
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const some: <string>(value: string) => Option.Option<string>
Creates a new Option that wraps the given value.
@param ― value - The value to wrap.
@since ― 2.0.0
some("1")))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// Encoding examples
26

27
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => Option.Option<string>
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const none: <number>() => Option.Option<number>
Creates a new Option that represents the absence of a value.
@since ― 2.0.0
none()))
28
// Output: { _id: 'Option', _tag: 'None' }
29

30
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => Option.Option<string>
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const some: <number>(value: number) => Option.Option<number>
Creates a new Option that wraps the given value.
@param ― value - The value to wrap.
@since ― 2.0.0
some(1)))
31
// Output: { _id: 'Option', _tag: 'Some', value: '1' }

OptionFromUndefinedOr

The Schema.OptionFromUndefinedOr function handles cases where undefined is treated as Option.none(), and all other values are interpreted as Option.some() based on the provided schema.

Syntax

Schema.OptionFromUndefinedOr(schema: Schema<A, I, R>)

Decoding

Input	Output
`undefined`	Converted to `Option.none()`
`I`	Converted to `Option.some(A)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Converted to `undefined`
`Option.some(A)`	Converted to `I`, where `A` is encoded into `I` using the inner schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Option@since ― 2.0.0
@since ― 2.0.0
Option } from "effect"
3

4
const 
const schema: Schema.OptionFromUndefinedOr<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const OptionFromUndefinedOr: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString) => Schema.OptionFromUndefinedOr<typeof Schema.NumberFromString>@since ― 3.10.0
OptionFromUndefinedOr(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString)
5

6
//     ┌─── string | undefined
7
//     ▼
8
type 
type Encoded = string | undefined
Encoded = typeof 
const schema: Schema.OptionFromUndefinedOr<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, string | undefined, never>.Encoded: string | undefined
Encoded
9

10
//     ┌─── Option<number>
11
//     ▼
12
type 
type Type = Option.None<number> | Option.Some<number>
Type = typeof 
const schema: Schema.OptionFromUndefinedOr<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, string | undefined, never>.Type: Option.Option<number>
Type
13

14
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode = 
import Schema
Schema.
decodeUnknownSync<Option.Option<number>, string | undefined>(schema: Schema.Schema<Option.Option<number>, string | undefined, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option.Option<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.OptionFromUndefinedOr<typeof Schema.NumberFromString>
schema)
15
const 
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | undefined
encode = 
import Schema
Schema.
encodeSync<Option.Option<number>, string | undefined>(schema: Schema.Schema<Option.Option<number>, string | undefined, never>, options?: ParseOptions): (a: Option.Option<...>, overrideOptions?: ParseOptions) => string | undefined
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.OptionFromUndefinedOr<typeof Schema.NumberFromString>
schema)
16

17
// Decoding examples
18

19
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode(
var undefined
undefined))
20
// Output: { _id: 'Option', _tag: 'None' }
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode("1"))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// Encoding examples
26

27
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | undefined
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const none: <number>() => Option.Option<number>
Creates a new Option that represents the absence of a value.
@since ― 2.0.0
none()))
28
// Output: undefined
29

30
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | undefined
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const some: <number>(value: number) => Option.Option<number>
Creates a new Option that wraps the given value.
@param ― value - The value to wrap.
@since ― 2.0.0
some(1)))
31
// Output: "1"

OptionFromNullOr

The Schema.OptionFromUndefinedOr function handles cases where null is treated as Option.none(), and all other values are interpreted as Option.some() based on the provided schema.

Syntax

Schema.OptionFromNullOr(schema: Schema<A, I, R>)

Decoding

Input	Output
`null`	Converted to `Option.none()`
`I`	Converted to `Option.some(A)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Converted to `null`
`Option.some(A)`	Converted to `I`, where `A` is encoded into `I` using the inner schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Option@since ― 2.0.0
@since ― 2.0.0
Option } from "effect"
3

4
const 
const schema: Schema.OptionFromNullOr<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const OptionFromNullOr: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString) => Schema.OptionFromNullOr<typeof Schema.NumberFromString>@since ― 3.10.0
OptionFromNullOr(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString)
5

6
//     ┌─── string | null
7
//     ▼
8
type 
type Encoded = string | null
Encoded = typeof 
const schema: Schema.OptionFromNullOr<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, string | null, never>.Encoded: string | null
Encoded
9

10
//     ┌─── Option<number>
11
//     ▼
12
type 
type Type = Option.None<number> | Option.Some<number>
Type = typeof 
const schema: Schema.OptionFromNullOr<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, string | null, never>.Type: Option.Option<number>
Type
13

14
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode = 
import Schema
Schema.
decodeUnknownSync<Option.Option<number>, string | null>(schema: Schema.Schema<Option.Option<number>, string | null, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option.Option<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.OptionFromNullOr<typeof Schema.NumberFromString>
schema)
15
const 
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | null
encode = 
import Schema
Schema.
encodeSync<Option.Option<number>, string | null>(schema: Schema.Schema<Option.Option<number>, string | null, never>, options?: ParseOptions): (a: Option.Option<...>, overrideOptions?: ParseOptions) => string | null
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.OptionFromNullOr<typeof Schema.NumberFromString>
schema)
16

17
// Decoding examples
18

19
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode(null))
20
// Output: { _id: 'Option', _tag: 'None' }
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode("1"))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// Encoding examples
26

27
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | null
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const none: <number>() => Option.Option<number>
Creates a new Option that represents the absence of a value.
@since ― 2.0.0
none()))
28
// Output: null
29
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | null
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const some: <number>(value: number) => Option.Option<number>
Creates a new Option that wraps the given value.
@param ― value - The value to wrap.
@since ― 2.0.0
some(1)))
30
// Output: "1"

OptionFromNullishOr

The Schema.OptionFromNullishOr function handles cases where null or undefined are treated as Option.none(), and all other values are interpreted as Option.some() based on the provided schema. Additionally, it allows customization of how Option.none() is encoded (null or undefined).

Syntax

Schema.OptionFromNullishOr(
  schema: Schema<A, I, R>,
  onNoneEncoding: null | undefined
)

Decoding

Input	Output
`undefined`	Converted to `Option.none()`
`null`	Converted to `Option.none()`
`I`	Converted to `Option.some(A)`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`Option.none()`	Converted to `undefined` or `null` based on user choice (`onNoneEncoding`)
`Option.some(A)`	Converted to `I`, where `A` is encoded into `I` using the inner schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Option@since ― 2.0.0
@since ― 2.0.0
Option } from "effect"
3

4
const 
const schema: Schema.OptionFromNullishOr<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const OptionFromNullishOr: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString, onNoneEncoding: null | undefined) => Schema.OptionFromNullishOr<typeof Schema.NumberFromString>@since ― 3.10.0
OptionFromNullishOr(
5
  
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString,
6
  
var undefined
undefined // Encode Option.none() as undefined
7
)
8

9
//     ┌─── string | null | undefined
10
//     ▼
11
type 
type Encoded = string | null | undefined
Encoded = typeof 
const schema: Schema.OptionFromNullishOr<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, string | null | undefined, never>.Encoded: string | null | undefined
Encoded
12

13
//     ┌─── Option<number>
14
//     ▼
15
type 
type Type = Option.None<number> | Option.Some<number>
Type = typeof 
const schema: Schema.OptionFromNullishOr<typeof Schema.NumberFromString>
schema.
Schema<Option<number>, string | null | undefined, never>.Type: Option.Option<number>
Type
16

17
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode = 
import Schema
Schema.
decodeUnknownSync<Option.Option<number>, string | null | undefined>(schema: Schema.Schema<Option.Option<number>, string | null | undefined, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option.Option<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.OptionFromNullishOr<typeof Schema.NumberFromString>
schema)
18
const 
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | null | undefined
encode = 
import Schema
Schema.
encodeSync<Option.Option<number>, string | null | undefined>(schema: Schema.Schema<Option.Option<number>, string | null | undefined, never>, options?: ParseOptions): (a: Option.Option<...>, overrideOptions?: ParseOptions) => string | ... 1 more ... | undefined
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.OptionFromNullishOr<typeof Schema.NumberFromString>
schema)
19

20
// Decoding examples
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode(null))
23
// Output: { _id: 'Option', _tag: 'None' }
24

25
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode(
var undefined
undefined))
26
// Output: { _id: 'Option', _tag: 'None' }
27

28
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
decode("1"))
29
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
30

31
// Encoding examples
32

33
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | null | undefined
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const none: <number>() => Option.Option<number>
Creates a new Option that represents the absence of a value.
@since ― 2.0.0
none()))
34
// Output: undefined
35

36
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<number>, overrideOptions?: ParseOptions) => string | null | undefined
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const some: <number>(value: number) => Option.Option<number>
Creates a new Option that wraps the given value.
@param ― value - The value to wrap.
@since ― 2.0.0
some(1)))
37
// Output: "1"

OptionFromNonEmptyTrimmedString

The Schema.OptionFromNonEmptyTrimmedString schema is designed for handling strings where trimmed empty strings are treated as Option.none(), and all other strings are converted to Option.some().

Decoding

Input	Output
`s: string`	Converted to `Option.some(s)`, if `s.trim().length > 0`
	Converted to `Option.none()` otherwise

Encoding

Input	Output
`Option.none()`	Converted to `""`
`Option.some(s: string)`	Converted to `s`

Example

1
import { 
import Schema
Schema, 
import Option@since ― 2.0.0
@since ― 2.0.0
Option } from "effect"
2

3
//     ┌─── string
4
//     ▼
5
type 
type Encoded = Schema.transform<typeof Schema.String, Schema.OptionFromSelf<typeof Schema.NonEmptyTrimmedString>>
Encoded = typeof 
import Schema
Schema.
const OptionFromNonEmptyTrimmedString: Schema.transform<typeof Schema.String, Schema.OptionFromSelf<typeof Schema.NonEmptyTrimmedString>>
Transforms strings into an Option type, effectively filtering out empty or
whitespace-only strings by trimming them and checking their length. Returns
none for invalid inputs and some for valid non-empty strings.
@example 
import { Schema } from "effect"

console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("")) // Option.none()
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)(" a ")) // Option.some("a")
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("a")) // Option.some("a")
@since ― 3.10.0
OptionFromNonEmptyTrimmedString
6

7
//     ┌─── Option<string>
8
//     ▼
9
type 
type Type = Schema.transform<typeof Schema.String, Schema.OptionFromSelf<typeof Schema.NonEmptyTrimmedString>>
Type = typeof 
import Schema
Schema.
const OptionFromNonEmptyTrimmedString: Schema.transform<typeof Schema.String, Schema.OptionFromSelf<typeof Schema.NonEmptyTrimmedString>>
Transforms strings into an Option type, effectively filtering out empty or
whitespace-only strings by trimming them and checking their length. Returns
none for invalid inputs and some for valid non-empty strings.
@example 
import { Schema } from "effect"

console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("")) // Option.none()
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)(" a ")) // Option.some("a")
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("a")) // Option.some("a")
@since ― 3.10.0
OptionFromNonEmptyTrimmedString
10

11
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<string>
decode = 
import Schema
Schema.
decodeUnknownSync<Option.Option<string>, string>(schema: Schema.Schema<Option.Option<string>, string, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option.Option<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
12
  
import Schema
Schema.
const OptionFromNonEmptyTrimmedString: Schema.transform<typeof Schema.String, Schema.OptionFromSelf<typeof Schema.NonEmptyTrimmedString>>
Transforms strings into an Option type, effectively filtering out empty or
whitespace-only strings by trimming them and checking their length. Returns
none for invalid inputs and some for valid non-empty strings.
@example 
import { Schema } from "effect"

console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("")) // Option.none()
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)(" a ")) // Option.some("a")
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("a")) // Option.some("a")
@since ― 3.10.0
OptionFromNonEmptyTrimmedString
13
)
14
const 
const encode: (a: Option.Option<string>, overrideOptions?: ParseOptions) => string
encode = 
import Schema
Schema.
encodeSync<Option.Option<string>, string>(schema: Schema.Schema<Option.Option<string>, string, never>, options?: ParseOptions): (a: Option.Option<...>, overrideOptions?: ParseOptions) => string
export encodeSync@since ― 3.10.0
encodeSync(
import Schema
Schema.
const OptionFromNonEmptyTrimmedString: Schema.transform<typeof Schema.String, Schema.OptionFromSelf<typeof Schema.NonEmptyTrimmedString>>
Transforms strings into an Option type, effectively filtering out empty or
whitespace-only strings by trimming them and checking their length. Returns
none for invalid inputs and some for valid non-empty strings.
@example 
import { Schema } from "effect"

console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("")) // Option.none()
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)(" a ")) // Option.some("a")
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("a")) // Option.some("a")
@since ― 3.10.0
OptionFromNonEmptyTrimmedString)
15

16
// Decoding examples
17

18
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<string>
decode(""))
19
// Output: { _id: 'Option', _tag: 'None' }
20

21
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<string>
decode(" a "))
22
// Output: { _id: 'Option', _tag: 'Some', value: 'a' }
23

24
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Option.Option<string>
decode("a"))
25
// Output: { _id: 'Option', _tag: 'Some', value: 'a' }
26

27
// Encoding examples
28

29
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<string>, overrideOptions?: ParseOptions) => string
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const none: <string>() => Option.Option<string>
Creates a new Option that represents the absence of a value.
@since ― 2.0.0
none()))
30
// Output: ""
31

32
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Option.Option<string>, overrideOptions?: ParseOptions) => string
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const some: <string>(value: string) => Option.Option<string>
Creates a new Option that wraps the given value.
@param ― value - The value to wrap.
@since ― 2.0.0
some("example")))
33
// Output: "example"

Either

The Schema.Either function is useful for converting an Either into a JSON-serializable format.

Syntax

Schema.Either(options: {
  left: Schema<LA, LI, LR>,
  right: Schema<RA, RI, RR>
})

Decoding

Input	Output
`{ _tag: "Left", left: LI }`	Converted to `Either.left(LA)`, where `LI` is decoded into `LA` using the inner `left` schema
`{ _tag: "Right", right: RI }`	Converted to `Either.right(RA)`, where `RI` is decoded into `RA` using the inner `right` schema

Encoding

Input	Output
`Either.left(LA)`	Converted to `{ _tag: "Left", left: LI }`, where `LA` is encoded into `LI` using the inner `left` schema
`Either.right(RA)`	Converted to `{ _tag: "Right", right: RI }`, where `RA` is encoded into `RI` using the inner `right` schema

Example

1
import { 
import Schema
Schema, 
import Either@since ― 2.0.0
@since ― 2.0.0
Either } from "effect"
2

3
const 
const schema: Schema.Either<typeof Schema.NumberFromString, typeof Schema.Trim>
schema = 
import Schema
Schema.
const Either: <typeof Schema.NumberFromString, typeof Schema.Trim>({ left, right }: {
    readonly left: typeof Schema.Trim;
    readonly right: typeof Schema.NumberFromString;
}) => Schema.Either<typeof Schema.NumberFromString, typeof Schema.Trim>@since ― 3.10.0
Either({
4
  
left: typeof Schema.Trim
left: 
import Schema
Schema.
class Trim
This schema allows removing whitespaces from the beginning and end of a string.
@since ― 3.10.0
Trim,
5
  
right: typeof Schema.NumberFromString
right: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString
6
})
7

8
//     ┌─── EitherEncoded<string, string>
9
//     ▼
10
type 
type Encoded = Schema.RightEncoded<string> | Schema.LeftEncoded<string>
Encoded = typeof 
const schema: Schema.Either<typeof Schema.NumberFromString, typeof Schema.Trim>
schema.
Schema<Either<number, string>, EitherEncoded<string, string>, never>.Encoded: Schema.EitherEncoded<string, string>
Encoded
11

12
//     ┌─── Either<number, string>
13
//     ▼
14
type 
type Type = Either.Left<string, number> | Either.Right<string, number>
Type = typeof 
const schema: Schema.Either<typeof Schema.NumberFromString, typeof Schema.Trim>
schema.
Schema<Either<number, string>, EitherEncoded<string, string>, never>.Type: Either.Either<number, string>
Type
15

16
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, string>
decode = 
import Schema
Schema.
decodeUnknownSync<Either.Either<number, string>, Schema.EitherEncoded<string, string>>(schema: Schema.Schema<Either.Either<number, string>, Schema.EitherEncoded<string, string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Either.Either<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.Either<typeof Schema.NumberFromString, typeof Schema.Trim>
schema)
17
const 
const encode: (a: Either.Either<number, string>, overrideOptions?: ParseOptions) => Schema.EitherEncoded<string, string>
encode = 
import Schema
Schema.
encodeSync<Either.Either<number, string>, Schema.EitherEncoded<string, string>>(schema: Schema.Schema<Either.Either<number, string>, Schema.EitherEncoded<string, string>, never>, options?: ParseOptions): (a: Either.Either<...>, overrideOptions?: ParseOptions) => Schema.EitherEncoded<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.Either<typeof Schema.NumberFromString, typeof Schema.Trim>
schema)
18

19
// Decoding examples
20

21
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, string>
decode({ 
_tag: string
_tag: "Left", 
left: string
left: " a " }))
22
// Output: { _id: 'Either', _tag: 'Left', left: 'a' }
23

24
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, string>
decode({ 
_tag: string
_tag: "Right", 
right: string
right: "1" }))
25
// Output: { _id: 'Either', _tag: 'Right', right: 1 }
26

27
// Encoding examples
28

29
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Either.Either<number, string>, overrideOptions?: ParseOptions) => Schema.EitherEncoded<string, string>
encode(
import Either@since ― 2.0.0
@since ― 2.0.0
Either.
const left: <string>(left: string) => Either.Either<never, string>
Constructs a new Either holding a Left value. This usually represents a failure, due to the right-bias of this
structure.
@since ― 2.0.0
left("a")))
30
// Output: { _tag: 'Left', left: 'a' }
31

32
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Either.Either<number, string>, overrideOptions?: ParseOptions) => Schema.EitherEncoded<string, string>
encode(
import Either@since ― 2.0.0
@since ― 2.0.0
Either.
const right: <number>(right: number) => Either.Either<number, never>
Constructs a new Either holding a Right value. This usually represents a successful value due to the right bias
of this structure.
@since ― 2.0.0
right(1)))
33
// Output: { _tag: 'Right', right: '1' }

EitherFromSelf

The Schema.EitherFromSelf function is designed for scenarios where Either values are already in the Either format and need to be decoded or encoded while transforming the inner valued according to the provided schemas.

Syntax

Schema.EitherFromSelf(options: {
  left: Schema<LA, LI, LR>,
  right: Schema<RA, RI, RR>
})

Decoding

Input	Output
`Either.left(LI)`	Converted to `Either.left(LA)`, where `LI` is decoded into `LA` using the inner `left` schema
`Either.right(RI)`	Converted to `Either.right(RA)`, where `RI` is decoded into `RA` using the inner `right` schema

Encoding

Input	Output
`Either.left(LA)`	Converted to `Either.left(LI)`, where `LA` is encoded into `LI` using the inner `left` schema
`Either.right(RA)`	Converted to `Either.right(RI)`, where `RA` is encoded into `RI` using the inner `right` schema

Example

1
import { 
import Schema
Schema, 
import Either@since ― 2.0.0
@since ― 2.0.0
Either } from "effect"
2

3
const 
const schema: Schema.EitherFromSelf<typeof Schema.NumberFromString, typeof Schema.Trim>
schema = 
import Schema
Schema.
const EitherFromSelf: <typeof Schema.NumberFromString, typeof Schema.Trim>({ left, right }: {
    readonly left: typeof Schema.Trim;
    readonly right: typeof Schema.NumberFromString;
}) => Schema.EitherFromSelf<typeof Schema.NumberFromString, typeof Schema.Trim>@since ― 3.10.0
EitherFromSelf({
4
  
left: typeof Schema.Trim
left: 
import Schema
Schema.
class Trim
This schema allows removing whitespaces from the beginning and end of a string.
@since ― 3.10.0
Trim,
5
  
right: typeof Schema.NumberFromString
right: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString
6
})
7

8
//     ┌─── Either<string, string>
9
//     ▼
10
type 
type Encoded = Either.Left<string, string> | Either.Right<string, string>
Encoded = typeof 
const schema: Schema.EitherFromSelf<typeof Schema.NumberFromString, typeof Schema.Trim>
schema.
Schema<Either<number, string>, Either<string, string>, never>.Encoded: Either.Either<string, string>
Encoded
11

12
//     ┌─── Either<number, string>
13
//     ▼
14
type 
type Type = Either.Left<string, number> | Either.Right<string, number>
Type = typeof 
const schema: Schema.EitherFromSelf<typeof Schema.NumberFromString, typeof Schema.Trim>
schema.
Schema<Either<number, string>, Either<string, string>, never>.Type: Either.Either<number, string>
Type
15

16
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, string>
decode = 
import Schema
Schema.
decodeUnknownSync<Either.Either<number, string>, Either.Either<string, string>>(schema: Schema.Schema<Either.Either<number, string>, Either.Either<string, string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Either.Either<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.EitherFromSelf<typeof Schema.NumberFromString, typeof Schema.Trim>
schema)
17
const 
const encode: (a: Either.Either<number, string>, overrideOptions?: ParseOptions) => Either.Either<string, string>
encode = 
import Schema
Schema.
encodeSync<Either.Either<number, string>, Either.Either<string, string>>(schema: Schema.Schema<Either.Either<number, string>, Either.Either<string, string>, never>, options?: ParseOptions): (a: Either.Either<...>, overrideOptions?: ParseOptions) => Either.Either<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.EitherFromSelf<typeof Schema.NumberFromString, typeof Schema.Trim>
schema)
18

19
// Decoding examples
20

21
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, string>
decode(
import Either@since ― 2.0.0
@since ― 2.0.0
Either.
const left: <string>(left: string) => Either.Either<never, string>
Constructs a new Either holding a Left value. This usually represents a failure, due to the right-bias of this
structure.
@since ― 2.0.0
left(" a ")))
22
// Output: { _id: 'Either', _tag: 'Left', left: 'a' }
23

24
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, string>
decode(
import Either@since ― 2.0.0
@since ― 2.0.0
Either.
const right: <string>(right: string) => Either.Either<string, never>
Constructs a new Either holding a Right value. This usually represents a successful value due to the right bias
of this structure.
@since ― 2.0.0
right("1")))
25
// Output: { _id: 'Either', _tag: 'Right', right: 1 }
26

27
// Encoding examples
28

29
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Either.Either<number, string>, overrideOptions?: ParseOptions) => Either.Either<string, string>
encode(
import Either@since ― 2.0.0
@since ― 2.0.0
Either.
const left: <string>(left: string) => Either.Either<never, string>
Constructs a new Either holding a Left value. This usually represents a failure, due to the right-bias of this
structure.
@since ― 2.0.0
left("a")))
30
// Output: { _id: 'Either', _tag: 'Left', left: 'a' }
31

32
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Either.Either<number, string>, overrideOptions?: ParseOptions) => Either.Either<string, string>
encode(
import Either@since ― 2.0.0
@since ― 2.0.0
Either.
const right: <number>(right: number) => Either.Either<number, never>
Constructs a new Either holding a Right value. This usually represents a successful value due to the right bias
of this structure.
@since ― 2.0.0
right(1)))
33
// Output: { _id: 'Either', _tag: 'Right', right: '1' }

EitherFromUnion

The Schema.EitherFromUnion function is designed to decode and encode Either values where the left and right sides are represented as distinct types. This schema enables conversions between raw union types and structured Either types.

Syntax

Schema.EitherFromUnion(options: {
  left: Schema<LA, LI, LR>,
  right: Schema<RA, RI, RR>
})

Decoding

Input	Output
`LI`	Converted to `Either.left(LA)`, where `LI` is decoded into `LA` using the inner `left` schema
`RI`	Converted to `Either.right(RA)`, where `RI` is decoded into `RA` using the inner `right` schema

Encoding

Input	Output
`Either.left(LA)`	Converted to `LI`, where `LA` is encoded into `LI` using the inner `left` schema
`Either.right(RA)`	Converted to `RI`, where `RA` is encoded into `RI` using the inner `right` schema

Example

1
import { 
import Schema
Schema, 
import Either@since ― 2.0.0
@since ― 2.0.0
Either } from "effect"
2

3
const 
const schema: Schema.EitherFromUnion<typeof Schema.NumberFromString, typeof Schema.Boolean>
schema = 
import Schema
Schema.
const EitherFromUnion: <typeof Schema.NumberFromString, typeof Schema.Boolean>({ left, right }: {
    readonly left: typeof Schema.Boolean;
    readonly right: typeof Schema.NumberFromString;
}) => Schema.EitherFromUnion<typeof Schema.NumberFromString, typeof Schema.Boolean>@example 
import * as Schema from "effect/Schema"

// Schema<string | number, Either<string, number>>
Schema.EitherFromUnion({ left: Schema.String, right: Schema.Number })
@since ― 3.10.0
EitherFromUnion({
4
  
left: typeof Schema.Boolean
left: 
import Schema
Schema.
class Boolean
export Boolean@since ― 3.10.0
Boolean,
5
  
right: typeof Schema.NumberFromString
right: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString
6
})
7

8
//     ┌─── string | boolean
9
//     ▼
10
type 
type Encoded = string | boolean
Encoded = typeof 
const schema: Schema.EitherFromUnion<typeof Schema.NumberFromString, typeof Schema.Boolean>
schema.
Schema<Either<number, boolean>, string | boolean, never>.Encoded: string | boolean
Encoded
11

12
//     ┌─── Either<number, boolean>
13
//     ▼
14
type 
type Type = Either.Left<boolean, number> | Either.Right<boolean, number>
Type = typeof 
const schema: Schema.EitherFromUnion<typeof Schema.NumberFromString, typeof Schema.Boolean>
schema.
Schema<Either<number, boolean>, string | boolean, never>.Type: Either.Either<number, boolean>
Type
15

16
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, boolean>
decode = 
import Schema
Schema.
decodeUnknownSync<Either.Either<number, boolean>, string | boolean>(schema: Schema.Schema<Either.Either<number, boolean>, string | boolean, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Either.Either<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.EitherFromUnion<typeof Schema.NumberFromString, typeof Schema.Boolean>
schema)
17
const 
const encode: (a: Either.Either<number, boolean>, overrideOptions?: ParseOptions) => string | boolean
encode = 
import Schema
Schema.
encodeSync<Either.Either<number, boolean>, string | boolean>(schema: Schema.Schema<Either.Either<number, boolean>, string | boolean, never>, options?: ParseOptions): (a: Either.Either<...>, overrideOptions?: ParseOptions) => string | boolean
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.EitherFromUnion<typeof Schema.NumberFromString, typeof Schema.Boolean>
schema)
18

19
// Decoding examples
20

21
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, boolean>
decode(true))
22
// Output: { _id: 'Either', _tag: 'Left', left: true }
23

24
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, boolean>
decode("1"))
25
// Output: { _id: 'Either', _tag: 'Right', right: 1 }
26

27
// Encoding examples
28

29
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Either.Either<number, boolean>, overrideOptions?: ParseOptions) => string | boolean
encode(
import Either@since ― 2.0.0
@since ― 2.0.0
Either.
const left: <boolean>(left: boolean) => Either.Either<never, boolean>
Constructs a new Either holding a Left value. This usually represents a failure, due to the right-bias of this
structure.
@since ― 2.0.0
left(true)))
30
// Output: true
31

32
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Either.Either<number, boolean>, overrideOptions?: ParseOptions) => string | boolean
encode(
import Either@since ― 2.0.0
@since ― 2.0.0
Either.
const right: <number>(right: number) => Either.Either<number, never>
Constructs a new Either holding a Right value. This usually represents a successful value due to the right bias
of this structure.
@since ― 2.0.0
right(1)))
33
// Output: "1"

Exit

The Schema.Exit function is useful for converting an Exit into a JSON-serializable format.

Syntax

Schema.Exit(options: {
  failure: Schema<FA, FI, FR>,
  success: Schema<SA, SI, SR>,
  defect: Schema<DA, DI, DR>
})

Decoding

Input	Output
`{ _tag: "Failure", cause: CauseEncoded<FI, DI> }`	Converted to `Exit.failCause(Cause<FA>)`, where `CauseEncoded<FI, DI>` is decoded into `Cause<FA>` using the inner `failure` and `defect` schemas
`{ _tag: "Success", value: SI }`	Converted to `Exit.succeed(SA)`, where `SI` is decoded into `SA` using the inner `success` schema

Encoding

Input	Output
`Exit.failCause(Cause<FA>)`	Converted to `{ _tag: "Failure", cause: CauseEncoded<FI, DI> }`, where `Cause<FA>` is encoded into `CauseEncoded<FI, DI>` using the inner `failure` and `defect` schemas
`Exit.succeed(SA)`	Converted to `{ _tag: "Success", value: SI }`, where `SA` is encoded into `SI` using the inner `success` schema

Example

1
import { 
import Schema
Schema, 
import Exit
Exit } from "effect"
2

3
const 
const schema: Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema = 
import Schema
Schema.
const Exit: <typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>({ defect, failure, success }: {
    readonly failure: typeof Schema.String;
    readonly success: typeof Schema.NumberFromString;
    readonly defect: typeof Schema.String;
}) => Schema.Exit<...>@since ― 3.10.0
Exit({
4
  
failure: typeof Schema.String
failure: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
5
  
success: typeof Schema.NumberFromString
success: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString,
6
  
defect: typeof Schema.String
defect: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String
7
})
8

9
//     ┌─── ExitEncoded<string, string, string>
10
//     ▼
11
type 
type Encoded = {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}
Encoded = typeof 
const schema: Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema.
Schema<Exit<number, string>, ExitEncoded<string, string, string>, never>.Encoded: Schema.ExitEncoded<string, string, string>
Encoded
12

13
//     ┌─── Exit<number, string>
14
//     ▼
15
type 
type Type = Exit.Success<number, string> | Exit.Failure<number, string>
Type = typeof 
const schema: Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema.
Schema<Exit<number, string>, ExitEncoded<string, string, string>, never>.Type: Exit.Exit<number, string>
Type
16

17
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Exit.Exit<number, string>
decode = 
import Schema
Schema.
decodeUnknownSync<Exit.Exit<number, string>, Schema.ExitEncoded<string, string, string>>(schema: Schema.Schema<Exit.Exit<number, string>, Schema.ExitEncoded<string, string, string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Exit.Exit<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema)
18
const 
const encode: (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => Schema.ExitEncoded<string, string, string>
encode = 
import Schema
Schema.
encodeSync<Exit.Exit<number, string>, Schema.ExitEncoded<string, string, string>>(schema: Schema.Schema<Exit.Exit<number, string>, Schema.ExitEncoded<string, string, string>, never>, options?: ParseOptions): (a: Exit.Exit<...>, overrideOptions?: ParseOptions) => Schema.ExitEncoded<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema)
19

20
// Decoding examples
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
23
  
const decode: (u: unknown, overrideOptions?: ParseOptions) => Exit.Exit<number, string>
decode({ 
_tag: string
_tag: "Failure", 
cause: {
    _tag: string;
    error: string;
}
cause: { 
_tag: string
_tag: "Fail", 
error: string
error: "a" } })
24
)
25
/*
26
Output:
27
{
28
  _id: 'Exit',
29
  _tag: 'Failure',
30
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'a' }
31
}
32
*/
33

34
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Exit.Exit<number, string>
decode({ 
_tag: string
_tag: "Success", 
value: string
value: "1" }))
35
/*
36
Output:
37
{ _id: 'Exit', _tag: 'Success', value: 1 }
38
*/
39

40
// Encoding examples
41

42
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => Schema.ExitEncoded<string, string, string>
encode(
import Exit
Exit.
const fail: <string>(error: string) => Exit.Exit<never, string>
Constructs a new Exit.Failure from the specified recoverable error of type
E.
@since ― 2.0.0
fail("a")))
43
/*
44
Output:
45
{ _tag: 'Failure', cause: { _tag: 'Fail', error: 'a' } }
46
 */
47

48
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => Schema.ExitEncoded<string, string, string>
encode(
import Exit
Exit.
const succeed: <number>(value: number) => Exit.Exit<number, never>
Constructs a new Exit.Success containing the specified value of type A.
@since ― 2.0.0
succeed(1)))
49
/*
50
Output:
51
{ _tag: 'Success', value: '1' }
52
*/

ExitFromSelf

The Schema.ExitFromSelf function is designed for scenarios where Exit values are already in the Exit format and need to be decoded or encoded while transforming the inner valued according to the provided schemas.

Syntax

Schema.ExitFromSelf(options: {
  failure: Schema<FA, FI, FR>,
  success: Schema<SA, SI, SR>,
  defect: Schema<DA, DI, DR>
})

Decoding

Input	Output
`Exit.failCause(Cause<FI>)`	Converted to `Exit.failCause(Cause<FA>)`, where `Cause<FI>` is decoded into `Cause<FA>` using the inner `failure` and `defect` schemas
`Exit.succeed(SI)`	Converted to `Exit.succeed(SA)`, where `SI` is decoded into `SA` using the inner `success` schema

Encoding

Input	Output
`Exit.failCause(Cause<FA>)`	Converted to `Exit.failCause(Cause<FI>)`, where `Cause<FA>` is decoded into `Cause<FI>` using the inner `failure` and `defect` schemas
`Exit.succeed(SA)`	Converted to `Exit.succeed(SI)`, where `SA` is encoded into `SI` using the inner `success` schema

Example

1
import { 
import Schema
Schema, 
import Exit
Exit } from "effect"
2

3
const 
const schema: Schema.ExitFromSelf<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema = 
import Schema
Schema.
const ExitFromSelf: <typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>({ defect, failure, success }: {
    readonly failure: typeof Schema.String;
    readonly success: typeof Schema.NumberFromString;
    readonly defect: typeof Schema.String;
}) => Schema.ExitFromSelf<...>@since ― 3.10.0
ExitFromSelf({
4
  
failure: typeof Schema.String
failure: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
5
  
success: typeof Schema.NumberFromString
success: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString,
6
  
defect: typeof Schema.String
defect: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String
7
})
8

9
//     ┌─── Exit<string, string>
10
//     ▼
11
type 
type Encoded = Exit.Success<string, string> | Exit.Failure<string, string>
Encoded = typeof 
const schema: Schema.ExitFromSelf<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema.
Schema<Exit<number, string>, Exit<string, string>, never>.Encoded: Exit.Exit<string, string>
Encoded
12

13
//     ┌─── Exit<number, string>
14
//     ▼
15
type 
type Type = Exit.Success<number, string> | Exit.Failure<number, string>
Type = typeof 
const schema: Schema.ExitFromSelf<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema.
Schema<Exit<number, string>, Exit<string, string>, never>.Type: Exit.Exit<number, string>
Type
16

17
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Exit.Exit<number, string>
decode = 
import Schema
Schema.
decodeUnknownSync<Exit.Exit<number, string>, Exit.Exit<string, string>>(schema: Schema.Schema<Exit.Exit<number, string>, Exit.Exit<string, string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Exit.Exit<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.ExitFromSelf<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema)
18
const 
const encode: (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => Exit.Exit<string, string>
encode = 
import Schema
Schema.
encodeSync<Exit.Exit<number, string>, Exit.Exit<string, string>>(schema: Schema.Schema<Exit.Exit<number, string>, Exit.Exit<string, string>, never>, options?: ParseOptions): (a: Exit.Exit<...>, overrideOptions?: ParseOptions) => Exit.Exit<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ExitFromSelf<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema)
19

20
// Decoding examples
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Exit.Exit<number, string>
decode(
import Exit
Exit.
const fail: <string>(error: string) => Exit.Exit<never, string>
Constructs a new Exit.Failure from the specified recoverable error of type
E.
@since ― 2.0.0
fail("a")))
23
/*
24
Output:
25
{
26
  _id: 'Exit',
27
  _tag: 'Failure',
28
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'a' }
29
}
30
*/
31

32
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Exit.Exit<number, string>
decode(
import Exit
Exit.
const succeed: <string>(value: string) => Exit.Exit<string, never>
Constructs a new Exit.Success containing the specified value of type A.
@since ― 2.0.0
succeed("1")))
33
/*
34
Output:
35
{ _id: 'Exit', _tag: 'Success', value: 1 }
36
*/
37

38
// Encoding examples
39

40
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => Exit.Exit<string, string>
encode(
import Exit
Exit.
const fail: <string>(error: string) => Exit.Exit<never, string>
Constructs a new Exit.Failure from the specified recoverable error of type
E.
@since ― 2.0.0
fail("a")))
41
/*
42
Output:
43
{
44
  _id: 'Exit',
45
  _tag: 'Failure',
46
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'a' }
47
}
48
*/
49

50
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => Exit.Exit<string, string>
encode(
import Exit
Exit.
const succeed: <number>(value: number) => Exit.Exit<number, never>
Constructs a new Exit.Success containing the specified value of type A.
@since ― 2.0.0
succeed(1)))
51
/*
52
Output:
53
{ _id: 'Exit', _tag: 'Success', value: '1' }
54
*/

ReadonlySet

The Schema.ReadonlySet function is useful for converting a ReadonlySet into a JSON-serializable format.

Syntax

Schema.ReadonlySet(schema: Schema<A, I, R>)

Decoding

Input	Output
`ReadonlyArray<I>`	Converted to `ReadonlySet<A>`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`ReadonlySet<A>`	`ReadonlyArray<I>`, where `A` is encoded into `I` using the inner schema

Example

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: Schema.ReadonlySet$<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const ReadonlySet: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString) => Schema.ReadonlySet$<typeof Schema.NumberFromString>@since ― 3.10.0
ReadonlySet(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString)
4

5
//     ┌─── readonly string[]
6
//     ▼
7
type 
type Encoded = readonly string[]
Encoded = typeof 
const schema: Schema.ReadonlySet$<typeof Schema.NumberFromString>
schema.
Schema<ReadonlySet<number>, readonly string[], never>.Encoded: readonly string[]
Encoded
8

9
//     ┌─── ReadonlySet<number>
10
//     ▼
11
type 
type Type = ReadonlySet<number>
Type = typeof 
const schema: Schema.ReadonlySet$<typeof Schema.NumberFromString>
schema.
Schema<ReadonlySet<number>, readonly string[], never>.Type: ReadonlySet<number>
Type
12

13
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlySet<number>
decode = 
import Schema
Schema.
decodeUnknownSync<ReadonlySet<number>, readonly string[]>(schema: Schema.Schema<ReadonlySet<number>, readonly string[], never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => ReadonlySet<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.ReadonlySet$<typeof Schema.NumberFromString>
schema)
14
const 
const encode: (a: ReadonlySet<number>, overrideOptions?: ParseOptions) => readonly string[]
encode = 
import Schema
Schema.
encodeSync<ReadonlySet<number>, readonly string[]>(schema: Schema.Schema<ReadonlySet<number>, readonly string[], never>, options?: ParseOptions): (a: ReadonlySet<...>, overrideOptions?: ParseOptions) => readonly string[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ReadonlySet$<typeof Schema.NumberFromString>
schema)
15

16
// Decoding examples
17

18
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlySet<number>
decode(["1", "2", "3"]))
19
// Output: Set(3) { 1, 2, 3 }
20

21
// Encoding examples
22

23
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: ReadonlySet<number>, overrideOptions?: ParseOptions) => readonly string[]
encode(new 
var Set: SetConstructor
new <number>(iterable?: Iterable<number> | null | undefined) => Set<number> (+1 overload)
Set([1, 2, 3])))
24
// Output: [ '1', '2', '3' ]

ReadonlySetFromSelf

The Schema.ReadonlySetFromSelf function is designed for scenarios where ReadonlySet values are already in the ReadonlySet format and need to be decoded or encoded while transforming the inner values according to the provided schema.

Syntax

Schema.ReadonlySetFromSelf(schema: Schema<A, I, R>)

Decoding

Input	Output
`ReadonlySet<I>`	Converted to `ReadonlySet<A>`, where `I` is decoded into `A` using the inner schema

Encoding

Input	Output
`ReadonlySet<A>`	`ReadonlySet<I>`, where `A` is encoded into `I` using the inner schema

Example

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: Schema.ReadonlySetFromSelf<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const ReadonlySetFromSelf: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString) => Schema.ReadonlySetFromSelf<typeof Schema.NumberFromString>@since ― 3.10.0
ReadonlySetFromSelf(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString)
4

5
//     ┌─── ReadonlySet<string>
6
//     ▼
7
type 
type Encoded = ReadonlySet<string>
Encoded = typeof 
const schema: Schema.ReadonlySetFromSelf<typeof Schema.NumberFromString>
schema.
Schema<ReadonlySet<number>, ReadonlySet<string>, never>.Encoded: ReadonlySet<string>
Encoded
8

9
//     ┌─── ReadonlySet<number>
10
//     ▼
11
type 
type Type = ReadonlySet<number>
Type = typeof 
const schema: Schema.ReadonlySetFromSelf<typeof Schema.NumberFromString>
schema.
Schema<ReadonlySet<number>, ReadonlySet<string>, never>.Type: ReadonlySet<number>
Type
12

13
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlySet<number>
decode = 
import Schema
Schema.
decodeUnknownSync<ReadonlySet<number>, ReadonlySet<string>>(schema: Schema.Schema<ReadonlySet<number>, ReadonlySet<string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => ReadonlySet<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.ReadonlySetFromSelf<typeof Schema.NumberFromString>
schema)
14
const 
const encode: (a: ReadonlySet<number>, overrideOptions?: ParseOptions) => ReadonlySet<string>
encode = 
import Schema
Schema.
encodeSync<ReadonlySet<number>, ReadonlySet<string>>(schema: Schema.Schema<ReadonlySet<number>, ReadonlySet<string>, never>, options?: ParseOptions): (a: ReadonlySet<...>, overrideOptions?: ParseOptions) => ReadonlySet<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ReadonlySetFromSelf<typeof Schema.NumberFromString>
schema)
15

16
// Decoding examples
17

18
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlySet<number>
decode(new 
var Set: SetConstructor
new <string>(iterable?: Iterable<string> | null | undefined) => Set<string> (+1 overload)
Set(["1", "2", "3"])))
19
// Output: Set(3) { 1, 2, 3 }
20

21
// Encoding examples
22

23
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: ReadonlySet<number>, overrideOptions?: ParseOptions) => ReadonlySet<string>
encode(new 
var Set: SetConstructor
new <number>(iterable?: Iterable<number> | null | undefined) => Set<number> (+1 overload)
Set([1, 2, 3])))
24
// Output: Set(3) { '1', '2', '3' }

ReadonlyMap

The Schema.ReadonlyMap function is useful for converting a ReadonlyMap into a JSON-serializable format.

ReadonlyMap

Syntax

Schema.ReadonlyMap(options: {
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Decoding

Input	Output
`ReadonlyArray<readonly [KI, VI]>`	Converted to `ReadonlyMap<KA, VA>`, where `KI` is decoded into `KA` using the inner `key` schema and `VI` is decoded into `VA` using the inner `value` schema

Encoding

Input	Output
`ReadonlyMap<KA, VA>`	Converted to `ReadonlyArray<readonly [KI, VI]>`, where `KA` is decoded into `KI` using the inner `key` schema and `VA` is decoded into `VI` using the inner `value` schema

Example

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: Schema.ReadonlyMap$<typeof Schema.String, typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const ReadonlyMap: <typeof Schema.String, typeof Schema.NumberFromString>({ key, value }: {
    readonly key: typeof Schema.String;
    readonly value: typeof Schema.NumberFromString;
}) => Schema.ReadonlyMap$<typeof Schema.String, typeof Schema.NumberFromString>@since ― 3.10.0
ReadonlyMap({
4
  
key: typeof Schema.String
key: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
5
  
value: typeof Schema.NumberFromString
value: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString
6
})
7

8
//     ┌─── readonly (readonly [string, string])[]
9
//     ▼
10
type 
type Encoded = readonly (readonly [string, string])[]
Encoded = typeof 
const schema: Schema.ReadonlyMap$<typeof Schema.String, typeof Schema.NumberFromString>
schema.
Schema<ReadonlyMap<string, number>, readonly (readonly [string, string])[], never>.Encoded: readonly (readonly [string, string])[]
Encoded
11

12
//     ┌─── ReadonlyMap<string, number>
13
//     ▼
14
type 
type Type = ReadonlyMap<string, number>
Type = typeof 
const schema: Schema.ReadonlyMap$<typeof Schema.String, typeof Schema.NumberFromString>
schema.
Schema<ReadonlyMap<string, number>, readonly (readonly [string, string])[], never>.Type: ReadonlyMap<string, number>
Type
15

16
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<string, number>
decode = 
import Schema
Schema.
decodeUnknownSync<ReadonlyMap<string, number>, readonly (readonly [string, string])[]>(schema: Schema.Schema<ReadonlyMap<string, number>, readonly (readonly [string, string])[], never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.ReadonlyMap$<typeof Schema.String, typeof Schema.NumberFromString>
schema)
17
const 
const encode: (a: ReadonlyMap<string, number>, overrideOptions?: ParseOptions) => readonly (readonly [string, string])[]
encode = 
import Schema
Schema.
encodeSync<ReadonlyMap<string, number>, readonly (readonly [string, string])[]>(schema: Schema.Schema<ReadonlyMap<string, number>, readonly (readonly [string, string])[], never>, options?: ParseOptions): (a: ReadonlyMap<...>, overrideOptions?: ParseOptions) => readonly (readonly [...])[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ReadonlyMap$<typeof Schema.String, typeof Schema.NumberFromString>
schema)
18

19
// Decoding examples
20

21
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
22
  
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<string, number>
decode([
23
    ["a", "2"],
24
    ["b", "2"],
25
    ["c", "3"]
26
  ])
27
)
28
// Output: Map(3) { 'a' => 2, 'b' => 2, 'c' => 3 }
29

30
// Encoding examples
31

32
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
33
  
const encode: (a: ReadonlyMap<string, number>, overrideOptions?: ParseOptions) => readonly (readonly [string, string])[]
encode(
34
    new 
var Map: MapConstructor
new <string, number>(iterable?: Iterable<readonly [string, number]> | null | undefined) => Map<string, number> (+3 overloads)
Map([
35
      ["a", 1],
36
      ["b", 2],
37
      ["c", 3]
38
    ])
39
  )
40
)
41
// Output: [ [ 'a', '1' ], [ 'b', '2' ], [ 'c', '3' ] ]

ReadonlyMapFromSelf

The Schema.ReadonlyMapFromSelf function is designed for scenarios where ReadonlyMap values are already in the ReadonlyMap format and need to be decoded or encoded while transforming the inner values according to the provided schemas.

Syntax

Schema.ReadonlyMapFromSelf(options: {
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Decoding

Input	Output
`ReadonlyMap<KI, VI>`	Converted to `ReadonlyMap<KA, VA>`, where `KI` is decoded into `KA` using the inner `key` schema and `VI` is decoded into `VA` using the inner `value` schema

Encoding

Input	Output
`ReadonlyMap<KA, VA>`	Converted to `ReadonlyMap<KI, VI>`, where `KA` is decoded into `KI` using the inner `key` schema and `VA` is decoded into `VI` using the inner `value` schema

Example

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: Schema.ReadonlyMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const ReadonlyMapFromSelf: <typeof Schema.String, typeof Schema.NumberFromString>({ key, value }: {
    readonly key: typeof Schema.String;
    readonly value: typeof Schema.NumberFromString;
}) => Schema.ReadonlyMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>@since ― 3.10.0
ReadonlyMapFromSelf({
4
  
key: typeof Schema.String
key: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
5
  
value: typeof Schema.NumberFromString
value: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString
6
})
7

8
//     ┌─── ReadonlyMap<string, string>
9
//     ▼
10
type 
type Encoded = ReadonlyMap<string, string>
Encoded = typeof 
const schema: Schema.ReadonlyMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema.
Schema<ReadonlyMap<string, number>, ReadonlyMap<string, string>, never>.Encoded: ReadonlyMap<string, string>
Encoded
11

12
//     ┌─── ReadonlyMap<string, number>
13
//     ▼
14
type 
type Type = ReadonlyMap<string, number>
Type = typeof 
const schema: Schema.ReadonlyMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema.
Schema<ReadonlyMap<string, number>, ReadonlyMap<string, string>, never>.Type: ReadonlyMap<string, number>
Type
15

16
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<string, number>
decode = 
import Schema
Schema.
decodeUnknownSync<ReadonlyMap<string, number>, ReadonlyMap<string, string>>(schema: Schema.Schema<ReadonlyMap<string, number>, ReadonlyMap<string, string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.ReadonlyMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema)
17
const 
const encode: (a: ReadonlyMap<string, number>, overrideOptions?: ParseOptions) => ReadonlyMap<string, string>
encode = 
import Schema
Schema.
encodeSync<ReadonlyMap<string, number>, ReadonlyMap<string, string>>(schema: Schema.Schema<ReadonlyMap<string, number>, ReadonlyMap<string, string>, never>, options?: ParseOptions): (a: ReadonlyMap<...>, overrideOptions?: ParseOptions) => ReadonlyMap<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ReadonlyMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema)
18

19
// Decoding examples
20

21
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
22
  
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<string, number>
decode(
23
    new 
var Map: MapConstructor
new <string, string>(iterable?: Iterable<readonly [string, string]> | null | undefined) => Map<string, string> (+3 overloads)
Map([
24
      ["a", "2"],
25
      ["b", "2"],
26
      ["c", "3"]
27
    ])
28
  )
29
)
30
// Output: Map(3) { 'a' => 2, 'b' => 2, 'c' => 3 }
31

32
// Encoding examples
33

34
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
35
  
const encode: (a: ReadonlyMap<string, number>, overrideOptions?: ParseOptions) => ReadonlyMap<string, string>
encode(
36
    new 
var Map: MapConstructor
new <string, number>(iterable?: Iterable<readonly [string, number]> | null | undefined) => Map<string, number> (+3 overloads)
Map([
37
      ["a", 1],
38
      ["b", 2],
39
      ["c", 3]
40
    ])
41
  )
42
)
43
// Output: Map(3) { 'a' => '1', 'b' => '2', 'c' => '3' }

ReadonlyMapFromRecord

The Schema.ReadonlyMapFromRecord function is a utility to transform a ReadonlyMap into an object format, where keys are strings and values are serializable, and vice versa.

Syntax

Schema.ReadonlyMapFromRecord({
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Decoding

Input	Output
`{ readonly [x: string]: VI }`	Converts to `ReadonlyMap<KA, VA>`, where `x` is decoded into `KA` using the `key` schema and `VI` into `VA` using the `value` schema

Encoding

Input	Output
`ReadonlyMap<KA, VA>`	Converts to `{ readonly [x: string]: VI }`, where `KA` is encoded into `x` using the `key` schema and `VA` into `VI` using the `value` schema

Example

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: Schema.Schema<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, never>
schema = 
import Schema
Schema.
const ReadonlyMapFromRecord: <number, never, number, string, never>({ key, value }: {
    key: Schema.Schema<number, string, never>;
    value: Schema.Schema<number, string, never>;
}) => Schema.Schema<ReadonlyMap<number, number>, {
    ...;
}, never>@since ― 3.10.0
ReadonlyMapFromRecord({
4
  
key: Schema.Schema<number, string, never>
key: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString,
5
  
value: Schema.Schema<number, string, never>
value: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString
6
})
7

8
//     ┌─── { readonly [x: string]: string; }
9
//     ▼
10
type 
type Encoded = {
    readonly [x: string]: string;
}
Encoded = typeof 
const schema: Schema.Schema<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, never>
schema.
Schema<ReadonlyMap<number, number>, { readonly [x: string]: string; }, never>.Encoded: {
    readonly [x: string]: string;
}
Encoded
11

12
//     ┌─── ReadonlyMap<number, number>
13
//     ▼
14
type 
type Type = ReadonlyMap<number, number>
Type = typeof 
const schema: Schema.Schema<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, never>
schema.
Schema<ReadonlyMap<number, number>, { readonly [x: string]: string; }, never>.Type: ReadonlyMap<number, number>
Type
15

16
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<number, number>
decode = 
import Schema
Schema.
decodeUnknownSync<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}>(schema: Schema.Schema<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.Schema<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, never>
schema)
17
const 
const encode: (a: ReadonlyMap<number, number>, overrideOptions?: ParseOptions) => {
    readonly [x: string]: string;
}
encode = 
import Schema
Schema.
encodeSync<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}>(schema: Schema.Schema<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, never>, options?: ParseOptions): (a: ReadonlyMap<...>, overrideOptions?: ParseOptions) => {
    readonly [x: string]: string;
}
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.Schema<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, never>
schema)
18

19
// Decoding examples
20

21
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
22
  
const decode: (u: unknown, overrideOptions?: ParseOptions) => ReadonlyMap<number, number>
decode({
23
    "1": "4",
24
    "2": "5",
25
    "3": "6"
26
  })
27
)
28
// Output: Map(3) { 1 => 4, 2 => 5, 3 => 6 }
29

30
// Encoding examples
31

32
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
33
  
const encode: (a: ReadonlyMap<number, number>, overrideOptions?: ParseOptions) => {
    readonly [x: string]: string;
}
encode(
34
    new 
var Map: MapConstructor
new <number, number>(iterable?: Iterable<readonly [number, number]> | null | undefined) => Map<number, number> (+3 overloads)
Map([
35
      [1, 4],
36
      [2, 5],
37
      [3, 6]
38
    ])
39
  )
40
)
41
// Output: { '1': '4', '2': '5', '3': '6' }

HashSet

The Schema.HashSet function provides a way to map between HashSet and an array representation, allowing for JSON serialization and deserialization.

Syntax

Schema.HashSet(schema: Schema<A, I, R>)

Decoding

Input	Output
`ReadonlyArray<I>`	Converts to `HashSet<A>`, where each element in the array is decoded into type `A` using the schema

Encoding

Input	Output
`HashSet<A>`	Converts to `ReadonlyArray<I>`, where each element in the `HashSet` is encoded into type `I` using the schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import HashSet
HashSet } from "effect"
3

4
const 
const schema: Schema.HashSet<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const HashSet: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString) => Schema.HashSet<typeof Schema.NumberFromString>@since ― 3.10.0
HashSet(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString)
5

6
//     ┌─── readonly string[]
7
//     ▼
8
type 
type Encoded = readonly string[]
Encoded = typeof 
const schema: Schema.HashSet<typeof Schema.NumberFromString>
schema.
Schema<HashSet<number>, readonly string[], never>.Encoded: readonly string[]
Encoded
9

10
//     ┌─── HashSet<number>
11
//     ▼
12
type 
type Type = HashSet.HashSet<number>
Type = typeof 
const schema: Schema.HashSet<typeof Schema.NumberFromString>
schema.
Schema<HashSet<number>, readonly string[], never>.Type: HashSet.HashSet<number>
Type
13

14
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => HashSet.HashSet<number>
decode = 
import Schema
Schema.
decodeUnknownSync<HashSet.HashSet<number>, readonly string[]>(schema: Schema.Schema<HashSet.HashSet<number>, readonly string[], never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => HashSet.HashSet<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.HashSet<typeof Schema.NumberFromString>
schema)
15
const 
const encode: (a: HashSet.HashSet<number>, overrideOptions?: ParseOptions) => readonly string[]
encode = 
import Schema
Schema.
encodeSync<HashSet.HashSet<number>, readonly string[]>(schema: Schema.Schema<HashSet.HashSet<number>, readonly string[], never>, options?: ParseOptions): (a: HashSet.HashSet<...>, overrideOptions?: ParseOptions) => readonly string[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.HashSet<typeof Schema.NumberFromString>
schema)
16

17
// Decoding examples
18

19
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => HashSet.HashSet<number>
decode(["1", "2", "3"]))
20
// Output: { _id: 'HashSet', values: [ 1, 2, 3 ] }
21

22
// Encoding examples
23

24
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: HashSet.HashSet<number>, overrideOptions?: ParseOptions) => readonly string[]
encode(
import HashSet
HashSet.
const fromIterable: <number>(elements: Iterable<number>) => HashSet.HashSet<number>
Creates a new HashSet from an iterable collection of values.
@since ― 2.0.0
fromIterable([1, 2, 3])))
25
// Output: [ '1', '2', '3' ]

HashSetFromSelf

The Schema.HashSetFromSelf function is designed for scenarios where HashSet values are already in the HashSet format and need to be decoded or encoded while transforming the inner values according to the provided schema.

Syntax

Schema.HashSetFromSelf(schema: Schema<A, I, R>)

Decoding

Input	Output
`HashSet<I>`	Converts to `HashSet<A>`, decoding each element from type `I` to type `A` using the schema

Encoding

Input	Output
`HashSet<A>`	Converts to `HashSet<I>`, encoding each element from type `A` to type `I` using the schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import HashSet
HashSet } from "effect"
3

4
const 
const schema: Schema.HashSetFromSelf<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const HashSetFromSelf: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString) => Schema.HashSetFromSelf<typeof Schema.NumberFromString>@since ― 3.10.0
HashSetFromSelf(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString)
5

6
//     ┌─── HashSet<string>
7
//     ▼
8
type 
type Encoded = HashSet.HashSet<string>
Encoded = typeof 
const schema: Schema.HashSetFromSelf<typeof Schema.NumberFromString>
schema.
Schema<HashSet<number>, HashSet<string>, never>.Encoded: HashSet.HashSet<string>
Encoded
9

10
//     ┌─── HashSet<number>
11
//     ▼
12
type 
type Type = HashSet.HashSet<number>
Type = typeof 
const schema: Schema.HashSetFromSelf<typeof Schema.NumberFromString>
schema.
Schema<HashSet<number>, HashSet<string>, never>.Type: HashSet.HashSet<number>
Type
13

14
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => HashSet.HashSet<number>
decode = 
import Schema
Schema.
decodeUnknownSync<HashSet.HashSet<number>, HashSet.HashSet<string>>(schema: Schema.Schema<HashSet.HashSet<number>, HashSet.HashSet<string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => HashSet.HashSet<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.HashSetFromSelf<typeof Schema.NumberFromString>
schema)
15
const 
const encode: (a: HashSet.HashSet<number>, overrideOptions?: ParseOptions) => HashSet.HashSet<string>
encode = 
import Schema
Schema.
encodeSync<HashSet.HashSet<number>, HashSet.HashSet<string>>(schema: Schema.Schema<HashSet.HashSet<number>, HashSet.HashSet<string>, never>, options?: ParseOptions): (a: HashSet.HashSet<...>, overrideOptions?: ParseOptions) => HashSet.HashSet<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.HashSetFromSelf<typeof Schema.NumberFromString>
schema)
16

17
// Decoding examples
18

19
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => HashSet.HashSet<number>
decode(
import HashSet
HashSet.
const fromIterable: <string>(elements: Iterable<string>) => HashSet.HashSet<string>
Creates a new HashSet from an iterable collection of values.
@since ― 2.0.0
fromIterable(["1", "2", "3"])))
20
// Output: { _id: 'HashSet', values: [ 1, 2, 3 ] }
21

22
// Encoding examples
23

24
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: HashSet.HashSet<number>, overrideOptions?: ParseOptions) => HashSet.HashSet<string>
encode(
import HashSet
HashSet.
const fromIterable: <number>(elements: Iterable<number>) => HashSet.HashSet<number>
Creates a new HashSet from an iterable collection of values.
@since ― 2.0.0
fromIterable([1, 2, 3])))
25
// Output: { _id: 'HashSet', values: [ '1', '3', '2' ] }

HashMap

The Schema.HashMap function is useful for converting a HashMap into a JSON-serializable format.

Syntax

Schema.HashMap(options: {
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Input	Output
`ReadonlyArray<readonly [KI, VI]>`	Converts to `HashMap<KA, VA>`, where `KI` is decoded into `KA` and `VI` is decoded into `VA` using the specified schemas

Encoding

Input	Output
`HashMap<KA, VA>`	Converts to `ReadonlyArray<readonly [KI, VI]>`, where `KA` is encoded into `KI` and `VA` is encoded into `VI` using the specified schemas

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import HashMap
HashMap } from "effect"
3

4
const 
const schema: Schema.HashMap<typeof Schema.String, typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const HashMap: <typeof Schema.String, typeof Schema.NumberFromString>({ key, value }: {
    readonly key: typeof Schema.String;
    readonly value: typeof Schema.NumberFromString;
}) => Schema.HashMap<typeof Schema.String, typeof Schema.NumberFromString>@since ― 3.10.0
HashMap({
5
  
key: typeof Schema.String
key: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
6
  
value: typeof Schema.NumberFromString
value: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString
7
})
8

9
//     ┌─── readonly (readonly [string, string])[]
10
//     ▼
11
type 
type Encoded = readonly (readonly [string, string])[]
Encoded = typeof 
const schema: Schema.HashMap<typeof Schema.String, typeof Schema.NumberFromString>
schema.
Schema<HashMap<string, number>, readonly (readonly [string, string])[], never>.Encoded: readonly (readonly [string, string])[]
Encoded
12

13
//     ┌─── HashMap<string, number>
14
//     ▼
15
type 
type Type = HashMap.HashMap<string, number>
Type = typeof 
const schema: Schema.HashMap<typeof Schema.String, typeof Schema.NumberFromString>
schema.
Schema<HashMap<string, number>, readonly (readonly [string, string])[], never>.Type: HashMap.HashMap<string, number>
Type
16

17
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => HashMap.HashMap<string, number>
decode = 
import Schema
Schema.
decodeUnknownSync<HashMap.HashMap<string, number>, readonly (readonly [string, string])[]>(schema: Schema.Schema<HashMap.HashMap<string, number>, readonly (readonly [string, string])[], never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => HashMap.HashMap<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.HashMap<typeof Schema.String, typeof Schema.NumberFromString>
schema)
18
const 
const encode: (a: HashMap.HashMap<string, number>, overrideOptions?: ParseOptions) => readonly (readonly [string, string])[]
encode = 
import Schema
Schema.
encodeSync<HashMap.HashMap<string, number>, readonly (readonly [string, string])[]>(schema: Schema.Schema<HashMap.HashMap<string, number>, readonly (readonly [string, string])[], never>, options?: ParseOptions): (a: HashMap.HashMap<...>, overrideOptions?: ParseOptions) => readonly (readonly [...])[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.HashMap<typeof Schema.String, typeof Schema.NumberFromString>
schema)
19

20
// Decoding examples
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
23
  
const decode: (u: unknown, overrideOptions?: ParseOptions) => HashMap.HashMap<string, number>
decode([
24
    ["a", "2"],
25
    ["b", "2"],
26
    ["c", "3"]
27
  ])
28
)
29
// Output: { _id: 'HashMap', values: [ [ 'a', 2 ], [ 'c', 3 ], [ 'b', 2 ] ] }
30

31
// Encoding examples
32

33
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
34
  
const encode: (a: HashMap.HashMap<string, number>, overrideOptions?: ParseOptions) => readonly (readonly [string, string])[]
encode(
35
    
import HashMap
HashMap.
const fromIterable: <string, number>(entries: Iterable<readonly [string, number]>) => HashMap.HashMap<string, number>
Creates a new HashMap from an iterable collection of key/value pairs.
@since ― 2.0.0
fromIterable([
36
      ["a", 1],
37
      ["b", 2],
38
      ["c", 3]
39
    ])
40
  )
41
)
42
// Output: [ [ 'a', '1' ], [ 'c', '3' ], [ 'b', '2' ] ]

HashMapFromSelf

The Schema.HashMapFromSelf function is designed for scenarios where HashMap values are already in the HashMap format and need to be decoded or encoded while transforming the inner values according to the provided schemas.

Syntax

Schema.HashMapFromSelf(options: {
  key: Schema<KA, KI, KR>,
  value: Schema<VA, VI, VR>
})

Decoding

Input	Output
`HashMap<KI, VI>`	Converts to `HashMap<KA, VA>`, where `KI` is decoded into `KA` and `VI` is decoded into `VA` using the specified schemas

Encoding

Input	Output
`HashMap<KA, VA>`	Converts to `HashMap<KI, VI>`, where `KA` is encoded into `KI` and `VA` is encoded into `VI` using the specified schemas

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import HashMap
HashMap } from "effect"
3

4
const 
const schema: Schema.HashMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const HashMapFromSelf: <typeof Schema.String, typeof Schema.NumberFromString>({ key, value }: {
    readonly key: typeof Schema.String;
    readonly value: typeof Schema.NumberFromString;
}) => Schema.HashMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>@since ― 3.10.0
HashMapFromSelf({
5
  
key: typeof Schema.String
key: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
6
  
value: typeof Schema.NumberFromString
value: 
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString
7
})
8

9
//     ┌─── HashMap<string, string>
10
//     ▼
11
type 
type Encoded = HashMap.HashMap<string, string>
Encoded = typeof 
const schema: Schema.HashMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema.
Schema<HashMap<string, number>, HashMap<string, string>, never>.Encoded: HashMap.HashMap<string, string>
Encoded
12

13
//     ┌─── HashMap<string, number>
14
//     ▼
15
type 
type Type = HashMap.HashMap<string, number>
Type = typeof 
const schema: Schema.HashMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema.
Schema<HashMap<string, number>, HashMap<string, string>, never>.Type: HashMap.HashMap<string, number>
Type
16

17
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => HashMap.HashMap<string, number>
decode = 
import Schema
Schema.
decodeUnknownSync<HashMap.HashMap<string, number>, HashMap.HashMap<string, string>>(schema: Schema.Schema<HashMap.HashMap<string, number>, HashMap.HashMap<string, string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => HashMap.HashMap<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.HashMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema)
18
const 
const encode: (a: HashMap.HashMap<string, number>, overrideOptions?: ParseOptions) => HashMap.HashMap<string, string>
encode = 
import Schema
Schema.
encodeSync<HashMap.HashMap<string, number>, HashMap.HashMap<string, string>>(schema: Schema.Schema<HashMap.HashMap<string, number>, HashMap.HashMap<string, string>, never>, options?: ParseOptions): (a: HashMap.HashMap<...>, overrideOptions?: ParseOptions) => HashMap.HashMap<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.HashMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema)
19

20
// Decoding examples
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
23
  
const decode: (u: unknown, overrideOptions?: ParseOptions) => HashMap.HashMap<string, number>
decode(
24
    
import HashMap
HashMap.
const fromIterable: <string, string>(entries: Iterable<readonly [string, string]>) => HashMap.HashMap<string, string>
Creates a new HashMap from an iterable collection of key/value pairs.
@since ― 2.0.0
fromIterable([
25
      ["a", "2"],
26
      ["b", "2"],
27
      ["c", "3"]
28
    ])
29
  )
30
)
31
// Output: { _id: 'HashMap', values: [ [ 'a', 2 ], [ 'c', 3 ], [ 'b', 2 ] ] }
32

33
// Encoding examples
34

35
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
36
  
const encode: (a: HashMap.HashMap<string, number>, overrideOptions?: ParseOptions) => HashMap.HashMap<string, string>
encode(
37
    
import HashMap
HashMap.
const fromIterable: <string, number>(entries: Iterable<readonly [string, number]>) => HashMap.HashMap<string, number>
Creates a new HashMap from an iterable collection of key/value pairs.
@since ― 2.0.0
fromIterable([
38
      ["a", 1],
39
      ["b", 2],
40
      ["c", 3]
41
    ])
42
  )
43
)
44
// Output: { _id: 'HashMap', values: [ [ 'a', '1' ], [ 'c', '3' ], [ 'b', '2' ] ] }

SortedSet

The Schema.SortedSet function provides a way to map between SortedSet and an array representation, allowing for JSON serialization and deserialization.

Syntax

Schema.SortedSet(schema: Schema<A, I, R>, order: Order<A>)

Decoding

Input	Output
`ReadonlyArray<I>`	Converts to `SortedSet<A>`, where each element in the array is decoded into type `A` using the schema

Encoding

Input	Output
`SortedSet<A>`	Converts to `ReadonlyArray<I>`, where each element in the `SortedSet` is encoded into type `I` using the schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Number
Number, 
import SortedSet
SortedSet } from "effect"
3

4
const 
const schema: Schema.SortedSet<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const SortedSet: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString, ordA: Order<number>) => Schema.SortedSet<typeof Schema.NumberFromString>@since ― 3.10.0
SortedSet(
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString, 
import Number
Number.
const Order: Order<number>@since ― 2.0.0
Order)
5

6
//     ┌─── readonly string[]
7
//     ▼
8
type 
type Encoded = readonly string[]
Encoded = typeof 
const schema: Schema.SortedSet<typeof Schema.NumberFromString>
schema.
Schema<SortedSet<number>, readonly string[], never>.Encoded: readonly string[]
Encoded
9

10
//     ┌─── SortedSet<number>
11
//     ▼
12
type 
type Type = SortedSet.SortedSet<number>
Type = typeof 
const schema: Schema.SortedSet<typeof Schema.NumberFromString>
schema.
Schema<SortedSet<number>, readonly string[], never>.Type: SortedSet.SortedSet<number>
Type
13

14
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => SortedSet.SortedSet<number>
decode = 
import Schema
Schema.
decodeUnknownSync<SortedSet.SortedSet<number>, readonly string[]>(schema: Schema.Schema<SortedSet.SortedSet<number>, readonly string[], never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => SortedSet.SortedSet<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.SortedSet<typeof Schema.NumberFromString>
schema)
15
const 
const encode: (a: SortedSet.SortedSet<number>, overrideOptions?: ParseOptions) => readonly string[]
encode = 
import Schema
Schema.
encodeSync<SortedSet.SortedSet<number>, readonly string[]>(schema: Schema.Schema<SortedSet.SortedSet<number>, readonly string[], never>, options?: ParseOptions): (a: SortedSet.SortedSet<...>, overrideOptions?: ParseOptions) => readonly string[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.SortedSet<typeof Schema.NumberFromString>
schema)
16

17
// Decoding examples
18

19
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => SortedSet.SortedSet<number>
decode(["1", "2", "3"]))
20
// Output: { _id: 'SortedSet', values: [ 1, 2, 3 ] }
21

22
// Encoding examples
23

24
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: SortedSet.SortedSet<number>, overrideOptions?: ParseOptions) => readonly string[]
encode(
import SortedSet
SortedSet.
const fromIterable: <number>(ord: Order<number>) => <A>(iterable: Iterable<A>) => SortedSet.SortedSet<A> (+1 overload)
Creates a new SortedSet from an iterable collection of values.
@since ― 2.0.0
fromIterable(
import Number
Number.
const Order: Order<number>@since ― 2.0.0
Order)([1, 2, 3])))
25
// Output: [ '1', '2', '3' ]

SortedSetFromSelf

The Schema.SortedSetFromSelf function is designed for scenarios where SortedSet values are already in the SortedSet format and need to be decoded or encoded while transforming the inner values according to the provided schema.

Syntax

Schema.SortedSetFromSelf(
  schema: Schema<A, I, R>,
  decodeOrder: Order<A>,
  encodeOrder: Order<I>
)

Decoding

Input	Output
`SortedSet<I>`	Converts to `SortedSet<A>`, decoding each element from type `I` to type `A` using the schema

Encoding

Input	Output
`SortedSet<A>`	Converts to `SortedSet<I>`, encoding each element from type `A` to type `I` using the schema

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Number
Number, 
import SortedSet
SortedSet, 
import String
String } from "effect"
3

4
const 
const schema: Schema.SortedSetFromSelf<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
const SortedSetFromSelf: <typeof Schema.NumberFromString>(value: typeof Schema.NumberFromString, ordA: Order<number>, ordI: Order<string>) => Schema.SortedSetFromSelf<typeof Schema.NumberFromString>@since ― 3.10.0
SortedSetFromSelf(
5
  
import Schema
Schema.
class NumberFromString
This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.
It returns an error if the value can't be converted (for example when non-numeric characters are provided).
The following special string values are supported: "NaN", "Infinity", "-Infinity".
@since ― 3.10.0
NumberFromString,
6
  
import Number
Number.
const Order: Order<number>@since ― 2.0.0
Order,
7
  
import String
String.
const Order: Order<string>@since ― 2.0.0
Order
8
)
9

10
//     ┌─── SortedSet<string>
11
//     ▼
12
type 
type Encoded = SortedSet.SortedSet<string>
Encoded = typeof 
const schema: Schema.SortedSetFromSelf<typeof Schema.NumberFromString>
schema.
Schema<SortedSet<number>, SortedSet<string>, never>.Encoded: SortedSet.SortedSet<string>
Encoded
13

14
//     ┌─── SortedSet<number>
15
//     ▼
16
type 
type Type = SortedSet.SortedSet<number>
Type = typeof 
const schema: Schema.SortedSetFromSelf<typeof Schema.NumberFromString>
schema.
Schema<SortedSet<number>, SortedSet<string>, never>.Type: SortedSet.SortedSet<number>
Type
17

18
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => SortedSet.SortedSet<number>
decode = 
import Schema
Schema.
decodeUnknownSync<SortedSet.SortedSet<number>, SortedSet.SortedSet<string>>(schema: Schema.Schema<SortedSet.SortedSet<number>, SortedSet.SortedSet<string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => SortedSet.SortedSet<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.SortedSetFromSelf<typeof Schema.NumberFromString>
schema)
19
const 
const encode: (a: SortedSet.SortedSet<number>, overrideOptions?: ParseOptions) => SortedSet.SortedSet<string>
encode = 
import Schema
Schema.
encodeSync<SortedSet.SortedSet<number>, SortedSet.SortedSet<string>>(schema: Schema.Schema<SortedSet.SortedSet<number>, SortedSet.SortedSet<string>, never>, options?: ParseOptions): (a: SortedSet.SortedSet<...>, overrideOptions?: ParseOptions) => SortedSet.SortedSet<...>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.SortedSetFromSelf<typeof Schema.NumberFromString>
schema)
20

21
// Decoding examples
22

23
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => SortedSet.SortedSet<number>
decode(
import SortedSet
SortedSet.
const fromIterable: <string>(ord: Order<string>) => <A>(iterable: Iterable<A>) => SortedSet.SortedSet<A> (+1 overload)
Creates a new SortedSet from an iterable collection of values.
@since ― 2.0.0
fromIterable(
import String
String.
const Order: Order<string>@since ― 2.0.0
Order)(["1", "2", "3"])))
24
// Output: { _id: 'SortedSet', values: [ 1, 2, 3 ] }
25

26
// Encoding examples
27

28
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const encode: (a: SortedSet.SortedSet<number>, overrideOptions?: ParseOptions) => SortedSet.SortedSet<string>
encode(
import SortedSet
SortedSet.
const fromIterable: <number>(ord: Order<number>) => <A>(iterable: Iterable<A>) => SortedSet.SortedSet<A> (+1 overload)
Creates a new SortedSet from an iterable collection of values.
@since ― 2.0.0
fromIterable(
import Number
Number.
const Order: Order<number>@since ― 2.0.0
Order)([1, 2, 3])))
29
// Output: { _id: 'SortedSet', values: [ '1', '2', '3' ] }

Duration

The Duration schema family enables the transformation and validation of duration values across various formats, including hrtime, milliseconds, and nanoseconds.

Duration

Converts an hrtime(i.e. [seconds: number, nanos: number]) into a Duration.

Example

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: typeof Schema.Duration
schema = 
import Schema
Schema.
class Duration
A schema that transforms a [number, number] tuple into a Duration.
@since ― 3.10.0
Duration
4

5
//     ┌─── readonly [seconds: number, nanos: number]
6
//     ▼
7
type 
type Encoded = readonly [seconds: number, nanos: number]
Encoded = typeof 
const schema: typeof Schema.Duration
schema.
Schema<Duration, readonly [seconds: number, nanos: number], never>.Encoded: readonly [seconds: number, nanos: number]
Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type 
type Type = Duration
Type = typeof 
const schema: typeof Schema.Duration
schema.
Schema<Duration, readonly [seconds: number, nanos: number], never>.Type: Duration
Type
12

13
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode = 
import Schema
Schema.
decodeUnknownSync<Duration, readonly [seconds: number, nanos: number]>(schema: Schema.Schema<Duration, readonly [seconds: number, nanos: number], never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Duration
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: typeof Schema.Duration
schema)
14

15
// Decoding examples
16

17
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode([0, 0]))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 0 }
19

20
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode([5000, 0]))
21
// Output: { _id: 'Duration', _tag: 'Nanos', hrtime: [ 5000, 0 ] }

DurationFromSelf

The DurationFromSelf schema is designed to validate that a given value conforms to the Duration type.

Example

1
import { 
import Schema
Schema, 
import Duration
Duration } from "effect"
2

3
const 
const schema: typeof Schema.DurationFromSelf
schema = 
import Schema
Schema.
class DurationFromSelf@since ― 3.10.0
DurationFromSelf
4

5
//     ┌─── Duration
6
//     ▼
7
type 
type Encoded = Duration.Duration
Encoded = typeof 
const schema: typeof Schema.DurationFromSelf
schema.
Schema<Duration, Duration, never>.Encoded: Duration.Duration
Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type 
type Type = Duration.Duration
Type = typeof 
const schema: typeof Schema.DurationFromSelf
schema.
Schema<Duration, Duration, never>.Type: Duration.Duration
Type
12

13
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
decode = 
import Schema
Schema.
decodeUnknownSync<Duration.Duration, Duration.Duration>(schema: Schema.Schema<Duration.Duration, Duration.Duration, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: typeof Schema.DurationFromSelf
schema)
14

15
// Decoding examples
16

17
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
decode(
import Duration
Duration.
const seconds: (seconds: number) => Duration.Duration@since ― 2.0.0
seconds(2)))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 2000 }
19

20
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
decode(null))
21
/*
22
throws:
23
ParseError: Expected DurationFromSelf, actual null
24
*/

DurationFromMillis

Converts a number into a Duration where the number represents the number of milliseconds.

Example

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: typeof Schema.DurationFromMillis
schema = 
import Schema
Schema.
class DurationFromMillis
A schema that transforms a number tuple into a Duration.
Treats the value as the number of milliseconds.
@since ― 3.10.0
DurationFromMillis
4

5
//     ┌─── number
6
//     ▼
7
type 
type Encoded = number
Encoded = typeof 
const schema: typeof Schema.DurationFromMillis
schema.
Schema<Duration, number, never>.Encoded: number
Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type 
type Type = Duration
Type = typeof 
const schema: typeof Schema.DurationFromMillis
schema.
Schema<Duration, number, never>.Type: Duration
Type
12

13
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode = 
import Schema
Schema.
decodeUnknownSync<Duration, number>(schema: Schema.Schema<Duration, number, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Duration
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: typeof Schema.DurationFromMillis
schema)
14

15
// Decoding examples
16

17
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode(0))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 0 }
19

20
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode(5000))
21
// Output: { _id: 'Duration', _tag: 'Millis', millis: 5000 }

DurationFromNanos

Converts a BigInt into a Duration where the number represents the number of nanoseconds.

Example

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: typeof Schema.DurationFromNanos
schema = 
import Schema
Schema.
class DurationFromNanos
A schema that transforms a bigint tuple into a Duration.
Treats the value as the number of nanoseconds.
@since ― 3.10.0
DurationFromNanos
4

5
//     ┌─── bigint
6
//     ▼
7
type 
type Encoded = bigint
Encoded = typeof 
const schema: typeof Schema.DurationFromNanos
schema.
Schema<Duration, bigint, never>.Encoded: bigint
Encoded
8

9
//     ┌─── Duration
10
//     ▼
11
type 
type Type = Duration
Type = typeof 
const schema: typeof Schema.DurationFromNanos
schema.
Schema<Duration, bigint, never>.Type: Duration
Type
12

13
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode = 
import Schema
Schema.
decodeUnknownSync<Duration, bigint>(schema: Schema.Schema<Duration, bigint, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Duration
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: typeof Schema.DurationFromNanos
schema)
14

15
// Decoding examples
16

17
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode(0n))
18
// Output: { _id: 'Duration', _tag: 'Millis', millis: 0 }
19

20
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration
decode(5000000000n))
21
// Output: { _id: 'Duration', _tag: 'Nanos', hrtime: [ 5, 0 ] }

clampDuration

Clamps a Duration between a minimum and a maximum value.

Example

1
import { 
import Schema
Schema, 
import Duration
Duration } from "effect"
2

3
const 
const schema: Schema.transform<Schema.Schema<Duration.Duration, Duration.Duration, never>, Schema.filter<Schema.Schema<Duration.Duration, Duration.Duration, never>>>
schema = 
import Schema
Schema.
class DurationFromSelf@since ― 3.10.0
DurationFromSelf.
Pipeable.pipe<typeof Schema.DurationFromSelf, Schema.transform<Schema.Schema<Duration.Duration, Duration.Duration, never>, Schema.filter<Schema.Schema<Duration.Duration, Duration.Duration, never>>>>(this: typeof Schema.DurationFromSelf, ab: (_: typeof Schema.DurationFromSelf) => Schema.transform<...>): Schema.transform<...> (+21 overloads)
pipe(
4
  
import Schema
Schema.
const clampDuration: (minimum: Duration.DurationInput, maximum: Duration.DurationInput) => <A extends Duration.Duration, I, R>(self: Schema.Schema<A, I, R>) => Schema.transform<Schema.Schema<A, I, R>, Schema.filter<Schema.Schema<A>>>
Clamps a Duration between a minimum and a maximum value.
@since ― 3.10.0
clampDuration("5 seconds", "10 seconds")
5
)
6

7
//     ┌─── Duration
8
//     ▼
9
type 
type Encoded = Duration.Duration
Encoded = typeof 
const schema: Schema.transform<Schema.Schema<Duration.Duration, Duration.Duration, never>, Schema.filter<Schema.Schema<Duration.Duration, Duration.Duration, never>>>
schema.
Schema<Duration, Duration, never>.Encoded: Duration.Duration
Encoded
10

11
//     ┌─── Duration
12
//     ▼
13
type 
type Type = Duration.Duration
Type = typeof 
const schema: Schema.transform<Schema.Schema<Duration.Duration, Duration.Duration, never>, Schema.filter<Schema.Schema<Duration.Duration, Duration.Duration, never>>>
schema.
Schema<Duration, Duration, never>.Type: Duration.Duration
Type
14

15
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
decode = 
import Schema
Schema.
decodeUnknownSync<Duration.Duration, Duration.Duration>(schema: Schema.Schema<Duration.Duration, Duration.Duration, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.transform<Schema.Schema<Duration.Duration, Duration.Duration, never>, Schema.filter<Schema.Schema<Duration.Duration, Duration.Duration, never>>>
schema)
16

17
// Decoding examples
18

19
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
decode(
import Duration
Duration.
const decode: (input: Duration.DurationInput) => Duration.Duration@since ― 2.0.0
decode("2 seconds")))
20
// Output: { _id: 'Duration', _tag: 'Millis', millis: 5000 }
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
decode(
import Duration
Duration.
const decode: (input: Duration.DurationInput) => Duration.Duration@since ― 2.0.0
decode("6 seconds")))
23
// Output: { _id: 'Duration', _tag: 'Millis', millis: 6000 }
24

25
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Duration.Duration
decode(
import Duration
Duration.
const decode: (input: Duration.DurationInput) => Duration.Duration@since ― 2.0.0
decode("11 seconds")))
26
// Output: { _id: 'Duration', _tag: 'Millis', millis: 10000 }

Redacted

The Schema.Redacted function is specifically designed to handle sensitive information by converting a string into a Redacted object. This transformation ensures that the sensitive data is not exposed in the application’s output.

Example (Basic Redacted Schema)

1
import { 
import Schema
Schema } from "effect"
2

3
const 
const schema: Schema.Redacted<typeof Schema.String>
schema = 
import Schema
Schema.
const Redacted: <typeof Schema.String>(value: typeof Schema.String) => Schema.Redacted<typeof Schema.String>
A schema that transforms any type A into a Redacted<A>.
@since ― 3.10.0
Redacted(
import Schema
Schema.
class String
export String@since ― 3.10.0
String)
4

5
//     ┌─── string
6
//     ▼
7
type 
type Encoded = string
Encoded = typeof 
const schema: Schema.Redacted<typeof Schema.String>
schema.
Schema<Redacted<string>, string, never>.Encoded: string
Encoded
8

9
//     ┌─── Redacted<string>
10
//     ▼
11
type 
type Type = Redacted<string>
Type = typeof 
const schema: Schema.Redacted<typeof Schema.String>
schema.
Schema<Redacted<string>, string, never>.Type: Redacted<string>
Type
12

13
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Redacted<string>
decode = 
import Schema
Schema.
decodeUnknownSync<Redacted<string>, string>(schema: Schema.Schema<Redacted<string>, string, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Redacted<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.Redacted<typeof Schema.String>
schema)
14

15
// Decoding examples
16

17
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Redacted<string>
decode("keep it secret, keep it safe"))
18
// Output: <redacted>

It’s important to note that when successfully decoding a Redacted, the output is intentionally obscured (<redacted>) to prevent the actual secret from being revealed in logs or console outputs.

Example (Exposure Risks During Errors)

In the example below, if the input string does not meet the criteria (e.g., contains spaces), the error message generated might inadvertently expose sensitive information included in the input.

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Redacted
Redacted } from "effect"
3

4
const 
const schema: Schema.SchemaClass<Redacted.Redacted<string>, string, never>
schema = 
import Schema
Schema.
class Trimmed@since ― 3.10.0
Trimmed.
Pipeable.pipe<typeof Schema.Trimmed, Schema.SchemaClass<Redacted.Redacted<string>, string, never>>(this: typeof Schema.Trimmed, ab: (_: typeof Schema.Trimmed) => Schema.SchemaClass<Redacted.Redacted<string>, string, never>): Schema.SchemaClass<...> (+21 overloads)
pipe(
5
  
import Schema
Schema.
const compose: <Redacted.Redacted<string>, string, never, string>(to: Schema.Schema<Redacted.Redacted<string>, string, never>) => <A, R1>(from: Schema.Schema<string, A, R1>) => Schema.SchemaClass<...> (+7 overloads)@since ― 3.10.0
compose(
import Schema
Schema.
const Redacted: <typeof Schema.String>(value: typeof Schema.String) => Schema.Redacted<typeof Schema.String>
A schema that transforms any type A into a Redacted<A>.
@since ― 3.10.0
Redacted(
import Schema
Schema.
class String
export String@since ― 3.10.0
String))
6
)
7

8
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
import Schema
Schema.
const decodeUnknownEither: <Redacted.Redacted<string>, string>(schema: Schema.Schema<Redacted.Redacted<string>, string, never>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Either<...>@since ― 3.10.0
decodeUnknownEither(
const schema: Schema.SchemaClass<Redacted.Redacted<string>, string, never>
schema)(" SECRET"))
9
/*
10
{
11
  _id: 'Either',
12
  _tag: 'Left',
13
  left: {
14
    _id: 'ParseError',
15
    message: '(Trimmed <-> (string <-> Redacted(<redacted>)))\n' +
16
      '└─ Encoded side transformation failure\n' +
17
      '   └─ Trimmed\n' +
18
      '      └─ Predicate refinement failure\n' +
19
      '         └─ Expected Trimmed (a string with no leading or trailing whitespace), actual " SECRET"'
20
  }
21
}
22
*/
23

24
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
import Schema
Schema.
const encodeEither: <Redacted.Redacted<string>, string>(schema: Schema.Schema<Redacted.Redacted<string>, string, never>, options?: ParseOptions) => (a: Redacted.Redacted<...>, overrideOptions?: ParseOptions) => Either<...>@since ― 3.10.0
encodeEither(
const schema: Schema.SchemaClass<Redacted.Redacted<string>, string, never>
schema)(
import Redacted
Redacted.
const make: <string>(value: string) => Redacted.Redacted<string>
This function creates a Redacted<A> instance from a given value A,
securely hiding its content.
@example 
import { Redacted } from "effect"

const API_KEY = Redacted.make("1234567890")
@since ― 3.3.0
make(" SECRET")))
25
/*
26
{
27
  _id: 'Either',
28
  _tag: 'Left',
29
  left: {
30
    _id: 'ParseError',
31
    message: '(Trimmed <-> (string <-> Redacted(<redacted>)))\n' +
32
      '└─ Encoded side transformation failure\n' +
33
      '   └─ Trimmed\n' +
34
      '      └─ Predicate refinement failure\n' +
35
      '         └─ Expected Trimmed (a string with no leading or trailing whitespace), actual " SECRET"'
36
  }
37
}
38
*/

Mitigating Exposure Risks

To reduce the risk of sensitive information leakage in error messages, you can customize the error messages to obscure sensitive details:

Example (Customizing Error Messages)

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Redacted
Redacted } from "effect"
3

4
const 
const schema: Schema.SchemaClass<Redacted.Redacted<string>, string, never>
schema = 
import Schema
Schema.
class Trimmed@since ― 3.10.0
Trimmed.
Annotable<refine<string, Schema<string, string, never>>, string, string, never>.annotations(annotations: Schema.Annotations.GenericSchema<string>): Schema.refine<string, Schema.Schema<string, string, never>>
Merges a set of new annotations with existing ones, potentially overwriting
any duplicates.
annotations({
5
  
Annotations.Schema<string, readonly []>.message?: MessageAnnotation
message: () => "Expected Trimmed, actual <redacted>"
6
}).
Pipeable.pipe<Schema.refine<string, Schema.Schema<string, string, never>>, Schema.SchemaClass<Redacted.Redacted<string>, string, never>>(this: Schema.refine<...>, ab: (_: Schema.refine<string, Schema.Schema<...>>) => Schema.SchemaClass<...>): Schema.SchemaClass<...> (+21 overloads)
pipe(
import Schema
Schema.
const compose: <Redacted.Redacted<string>, string, never, string>(to: Schema.Schema<Redacted.Redacted<string>, string, never>) => <A, R1>(from: Schema.Schema<string, A, R1>) => Schema.SchemaClass<...> (+7 overloads)@since ― 3.10.0
compose(
import Schema
Schema.
const Redacted: <typeof Schema.String>(value: typeof Schema.String) => Schema.Redacted<typeof Schema.String>
A schema that transforms any type A into a Redacted<A>.
@since ― 3.10.0
Redacted(
import Schema
Schema.
class String
export String@since ― 3.10.0
String)))
7

8
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
import Schema
Schema.
const decodeUnknownEither: <Redacted.Redacted<string>, string>(schema: Schema.Schema<Redacted.Redacted<string>, string, never>, options?: ParseOptions) => (u: unknown, overrideOptions?: ParseOptions) => Either<...>@since ― 3.10.0
decodeUnknownEither(
const schema: Schema.SchemaClass<Redacted.Redacted<string>, string, never>
schema)(" SECRET"))
9
/*
10
{
11
  _id: 'Either',
12
  _tag: 'Left',
13
  left: {
14
    _id: 'ParseError',
15
    message: '(Trimmed <-> (string <-> Redacted(<redacted>)))\n' +
16
      '└─ Encoded side transformation failure\n' +
17
      '   └─ Expected Trimmed, actual <redacted>'
18
  }
19
}
20
*/
21

22
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
import Schema
Schema.
const encodeEither: <Redacted.Redacted<string>, string>(schema: Schema.Schema<Redacted.Redacted<string>, string, never>, options?: ParseOptions) => (a: Redacted.Redacted<...>, overrideOptions?: ParseOptions) => Either<...>@since ― 3.10.0
encodeEither(
const schema: Schema.SchemaClass<Redacted.Redacted<string>, string, never>
schema)(
import Redacted
Redacted.
const make: <string>(value: string) => Redacted.Redacted<string>
This function creates a Redacted<A> instance from a given value A,
securely hiding its content.
@example 
import { Redacted } from "effect"

const API_KEY = Redacted.make("1234567890")
@since ― 3.3.0
make(" SECRET")))
23
/*
24
{
25
  _id: 'Either',
26
  _tag: 'Left',
27
  left: {
28
    _id: 'ParseError',
29
    message: '(Trimmed <-> (string <-> Redacted(<redacted>)))\n' +
30
      '└─ Encoded side transformation failure\n' +
31
      '   └─ Expected Trimmed, actual <redacted>'
32
  }
33
}
34
*/

RedactedFromSelf

The Schema.RedactedFromSelf schema is designed to validate that a given value conforms to the Redacted type from the effect library.

Example

1
import { 
import Schema
Schema } from "effect"
2
import { 
import Redacted
Redacted } from "effect"
3

4
const 
const schema: Schema.RedactedFromSelf<typeof Schema.String>
schema = 
import Schema
Schema.
const RedactedFromSelf: <typeof Schema.String>(value: typeof Schema.String) => Schema.RedactedFromSelf<typeof Schema.String>@since ― 3.10.0
RedactedFromSelf(
import Schema
Schema.
class String
export String@since ― 3.10.0
String)
5

6
//     ┌─── Redacted<string>
7
//     ▼
8
type 
type Encoded = Redacted.Redacted<string>
Encoded = typeof 
const schema: Schema.RedactedFromSelf<typeof Schema.String>
schema.
Schema<Redacted<string>, Redacted<string>, never>.Encoded: Redacted.Redacted<string>
Encoded
9

10
//     ┌─── Redacted<string>
11
//     ▼
12
type 
type Type = Redacted.Redacted<string>
Type = typeof 
const schema: Schema.RedactedFromSelf<typeof Schema.String>
schema.
Schema<Redacted<string>, Redacted<string>, never>.Type: Redacted.Redacted<string>
Type
13

14
const 
const decode: (u: unknown, overrideOptions?: ParseOptions) => Redacted.Redacted<string>
decode = 
import Schema
Schema.
decodeUnknownSync<Redacted.Redacted<string>, Redacted.Redacted<string>>(schema: Schema.Schema<Redacted.Redacted<string>, Redacted.Redacted<string>, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Redacted.Redacted<...>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.RedactedFromSelf<typeof Schema.String>
schema)
15

16
// Decoding examples
17

18
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Redacted.Redacted<string>
decode(
import Redacted
Redacted.
const make: <string>(value: string) => Redacted.Redacted<string>
This function creates a Redacted<A> instance from a given value A,
securely hiding its content.
@example 
import { Redacted } from "effect"

const API_KEY = Redacted.make("1234567890")
@since ― 3.3.0
make("mysecret")))
19
// Output: <redacted>
20

21
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 and
process.stderr. 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 for
more information.
Example using the global console:
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:
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
@see ― source
console.
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)
(the arguments are all passed to util.format()).
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() for more information.
@since ― v0.1.100
log(
const decode: (u: unknown, overrideOptions?: ParseOptions) => Redacted.Redacted<string>
decode(null))
22
/*
23
throws:
24
ParseError: Expected Redacted(<redacted>), actual null
25
*/

It’s important to note that when successfully decoding a Redacted, the output is intentionally obscured (<redacted>) to prevent the actual secret from being revealed in logs or console outputs.