Effect 数据类型

与Data的互操作

Effect生态系统中的Data模块通过自动实现Equal和Hash特征简化了值比较。这消除了手动实现的需要，使等值检查变得简单。

示例（使用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 * as assert from "node:assert"
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 * as assert from "node:assert"
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

默认情况下，像Schema.Struct这样的模式不实现Equal和Hash特征。这意味着具有相同值的两个解码对象不会被认为相等。

示例（没有Equal和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<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>@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<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>, that: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>): 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

Schema.Data函数可用于通过包含Equal和Hash特征来增强模式。这允许结果对象支持基于值的等值。

示例（使用Schema.Data添加等值）

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

4
const 
const schema: Schema.Data<Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>>
schema = 
import Schema
Schema.
const Data: <Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>, {
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}>(value: Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}> & Schema.Schema<{
    readonly name: string;
    readonly age: number;
}, {
    readonly name: string;
    readonly age: number;
}, never>) => Schema.Data<Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>>
Type and Encoded must extend Readonly<Record<string, any>> | ReadonlyArray<any> to be compatible with this API.
@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<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>@since ― 3.10.0
decode(
const schema: Schema.Data<Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>>
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<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>, that: Effect<{
    readonly name: string;
    readonly age: number;
}, ParseError, never>): 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

配置

Schema.Config函数允许您使用结构化模式解码和管理应用程序配置设置。它确保配置数据的一致性，并为解码错误提供详细反馈。

语法

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

此函数接受两个参数：

name：配置设置的标识符。
schema：描述预期数据类型和结构的模式。

它返回一个与您的应用程序配置系统集成的Config对象。

编码类型I必须扩展string，因此模式必须能够从字符串解码，这包括像Schema.String、Schema.Literal("...")或Schema.NumberFromString这样的模式，可能应用了细化。

在幕后，Schema.Config遵循以下步骤：

获取值使用提供的名称（例如从环境变量）。
解码值使用给定的模式。如果值无效，解码失败。
格式化任何错误使用TreeFormatter.formatErrorSync，这有助于产生可读和详细的错误消息。

示例（解码配置值）

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

3
// 定义期望至少4个字符的字符串的配置
4
const 
const myConfig: Config<string>
myConfig = 
import Schema
Schema.
const Config: <string, 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<typeof Schema.String>>(this: typeof Schema.String, ab: (_: typeof Schema.String) => Schema.filter<typeof Schema.String>): Schema.filter<typeof Schema.String> (+21 overloads)
pipe(
import Schema
Schema.
const minLength: <typeof Schema.String>(minLength: number, annotations?: Schema.Annotations.Filter<string, string> | undefined) => <A>(self: typeof Schema.String & Schema.Schema<A, string, never>) => Schema.filter<typeof Schema.String>@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<void, ConfigError, never> (+1 overload)
Provides a way to write effectful code using generator functions, simplifying
control flow and error handling.
When to Use
Effect.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.
Details
This function evaluates the provided effect synchronously, returning its
result directly. It is ideal for effects that do not fail or include
asynchronous operations. If the effect does fail or involves async tasks, it
will throw an error. Execution stops at the point of failure or asynchronous
operation, making it unsuitable for effects that require asynchronous
handling.
Important: Attempting to run effects that involve asynchronous operations
or failures will result in exceptions being thrown, so use this function with
care for purely synchronous and error-free effects.
When to Use
Use this function when:

You are sure that the effect will not fail or involve asynchronous
operations.
You need a direct, synchronous result from the effect.
You are working within a context where asynchronous effects are not
allowed.

Avoid using this function for effects that can fail or require asynchronous
handling. For such cases, consider using
runPromise
or
runSyncExit
.
Example (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 (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
@see ― runSyncExit for a version that returns an Exit type instead of
throwing an error.
@since ― 2.0.0
runSync(
const program: Effect.Effect<void, ConfigError, never>
program)

要测试配置，请执行以下命令：

测试（缺少配置数据）

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

测试（无效数据）

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"")]

测试（有效数据）

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

Option

Schema.Option函数对于将Option转换为JSON可序列化格式很有用。

语法

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

解码

输入	输出
`{ _tag: "None" }`	转换为`Option.none()`
`{ _tag: "Some", value: I }`	转换为`Option.some(a)`，其中`I`使用内部模式解码为`A`

编码

输入	输出
`Option.none()`	转换为`{ _tag: "None" }`
`Option.some(A)`	转换为`{ _tag: "Some", value: I }`，其中`A`使用内部模式编码为`I`

示例

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.
function 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>, { readonly _tag: "None"; } | { readonly _tag: "Some"; readonly value: string; }, never>.Encoded: {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: 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>, { readonly _tag: "None"; } | { readonly _tag: "Some"; readonly value: 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>, {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}>(schema: Schema.Schema<Option.Option<number>, {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option.Option<number>
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) => {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}
encode = 
import Schema
Schema.
encodeSync<Option.Option<number>, {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}>(schema: Schema.Schema<Option.Option<number>, {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}, never>, options?: ParseOptions): (a: Option.Option<number>, overrideOptions?: ParseOptions) => {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.Option<typeof Schema.NumberFromString>
schema)
16

17
// 解码示例
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
// 编码示例
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) => {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const none: <number>() => Option.Option<number>
Represents the absence of a value by creating an empty Option.
Option.none returns an Option<never>, which is a subtype of Option<A>.
This means you can use it in place of any Option<A> regardless of the type
A.
Example (Creating an Option with No Value)
import { Option } from "effect"

// An Option holding no value
//
//      ┌─── Option<never>
//      ▼
const noValue = Option.none()

console.log(noValue)
// Output: { _id: 'Option', _tag: 'None' }
@see ― some for the opposite operation.
@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) => {
    readonly _tag: "None";
} | {
    readonly _tag: "Some";
    readonly value: string;
}
encode(
import Option@since ― 2.0.0
@since ― 2.0.0
Option.
const some: <number>(value: number) => Option.Option<number>
Wraps the given value into an Option to represent its presence.
Example (Creating an Option with a Value)
import { Option } from "effect"

// An Option holding the number 1
//
//      ┌─── Option<number>
//      ▼
const value = Option.some(1)

console.log(value)
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
@see ― none for the opposite operation.
@since ― 2.0.0
some(1)))
31
// Output: { _tag: 'Some', value: '1' }

OptionFromSelf

Schema.OptionFromSelf函数专为Option值已经是Option格式并需要根据提供的模式解码或编码同时转换内部值的场景而设计。

语法

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

解码

输入	输出
`Option.none()`	保持为`Option.none()`
`Option.some(I)`	转换为`Option.some(A)`，其中`I`使用内部模式解码为`A`

编码

输入	输出
`Option.none()`	保持为`Option.none()`
`Option.some(A)`	转换为`Option.some(I)`，其中`A`使用内部模式编码为`I`

示例

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<number>
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<number>, overrideOptions?: ParseOptions) => Option.Option<string>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.OptionFromSelf<typeof Schema.NumberFromString>
schema)
16

17
// 解码示例
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>
Represents the absence of a value by creating an empty Option.
Option.none returns an Option<never>, which is a subtype of Option<A>.
This means you can use it in place of any Option<A> regardless of the type
A.
Example (Creating an Option with No Value)
import { Option } from "effect"

// An Option holding no value
//
//      ┌─── Option<never>
//      ▼
const noValue = Option.none()

console.log(noValue)
// Output: { _id: 'Option', _tag: 'None' }
@see ― some for the opposite operation.
@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>
Wraps the given value into an Option to represent its presence.
Example (Creating an Option with a Value)
import { Option } from "effect"

// An Option holding the number 1
//
//      ┌─── Option<number>
//      ▼
const value = Option.some(1)

console.log(value)
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
@see ― none for the opposite operation.
@since ― 2.0.0
some("1")))
23
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
24

25
// 编码示例
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>
Represents the absence of a value by creating an empty Option.
Option.none returns an Option<never>, which is a subtype of Option<A>.
This means you can use it in place of any Option<A> regardless of the type
A.
Example (Creating an Option with No Value)
import { Option } from "effect"

// An Option holding no value
//
//      ┌─── Option<never>
//      ▼
const noValue = Option.none()

console.log(noValue)
// Output: { _id: 'Option', _tag: 'None' }
@see ― some for the opposite operation.
@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>
Wraps the given value into an Option to represent its presence.
Example (Creating an Option with a Value)
import { Option } from "effect"

// An Option holding the number 1
//
//      ┌─── Option<number>
//      ▼
const value = Option.some(1)

console.log(value)
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
@see ― none for the opposite operation.
@since ― 2.0.0
some(1)))
31
// Output: { _id: 'Option', _tag: 'Some', value: '1' }

OptionFromUndefinedOr

Schema.OptionFromUndefinedOr函数处理将undefined视为Option.none()，所有其他值根据提供的模式解释为Option.some()的情况。

语法

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

解码

输入	输出
`undefined`	转换为`Option.none()`
`I`	转换为`Option.some(A)`，其中`I`使用内部模式解码为`A`

编码

输入	输出
`Option.none()`	转换为`undefined`
`Option.some(A)`	转换为`I`，其中`A`使用内部模式编码为`I`

示例

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.
function 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<number>
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<number>, overrideOptions?: ParseOptions) => string | undefined
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.OptionFromUndefinedOr<typeof Schema.NumberFromString>
schema)
16

17
// 解码示例
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
// 编码示例
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>
Represents the absence of a value by creating an empty Option.
Option.none returns an Option<never>, which is a subtype of Option<A>.
This means you can use it in place of any Option<A> regardless of the type
A.
Example (Creating an Option with No Value)
import { Option } from "effect"

// An Option holding no value
//
//      ┌─── Option<never>
//      ▼
const noValue = Option.none()

console.log(noValue)
// Output: { _id: 'Option', _tag: 'None' }
@see ― some for the opposite operation.
@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>
Wraps the given value into an Option to represent its presence.
Example (Creating an Option with a Value)
import { Option } from "effect"

// An Option holding the number 1
//
//      ┌─── Option<number>
//      ▼
const value = Option.some(1)

console.log(value)
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
@see ― none for the opposite operation.
@since ― 2.0.0
some(1)))
31
// Output: "1"

OptionFromNullOr

Schema.OptionFromNullOr函数处理将null视为Option.none()，所有其他值根据提供的模式解释为Option.some()的情况。

语法

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

解码

输入	输出
`null`	转换为`Option.none()`
`I`	转换为`Option.some(A)`，其中`I`使用内部模式解码为`A`

编码

输入	输出
`Option.none()`	转换为`null`
`Option.some(A)`	转换为`I`，其中`A`使用内部模式编码为`I`

示例

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.
function 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<number>
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<number>, overrideOptions?: ParseOptions) => string | null
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.OptionFromNullOr<typeof Schema.NumberFromString>
schema)
16

17
// 解码示例
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
// 编码示例
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>
Represents the absence of a value by creating an empty Option.
Option.none returns an Option<never>, which is a subtype of Option<A>.
This means you can use it in place of any Option<A> regardless of the type
A.
Example (Creating an Option with No Value)
import { Option } from "effect"

// An Option holding no value
//
//      ┌─── Option<never>
//      ▼
const noValue = Option.none()

console.log(noValue)
// Output: { _id: 'Option', _tag: 'None' }
@see ― some for the opposite operation.
@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>
Wraps the given value into an Option to represent its presence.
Example (Creating an Option with a Value)
import { Option } from "effect"

// An Option holding the number 1
//
//      ┌─── Option<number>
//      ▼
const value = Option.some(1)

console.log(value)
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
@see ― none for the opposite operation.
@since ― 2.0.0
some(1)))
30
// Output: "1"

OptionFromNullishOr

Schema.OptionFromNullishOr函数处理将null或undefined视为Option.none()，所有其他值根据提供的模式解释为Option.some()的情况。此外，它允许自定义Option.none()的编码方式（null或undefined）。

语法

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

解码

输入	输出
`undefined`	转换为`Option.none()`
`null`	转换为`Option.none()`
`I`	转换为`Option.some(A)`，其中`I`使用内部模式解码为`A`

编码

输入	输出
`Option.none()`	根据用户选择（`onNoneEncoding`）转换为`undefined`或`null`
`Option.some(A)`	转换为`I`，其中`A`使用内部模式编码为`I`

示例

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.
function 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<number>
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<number>, overrideOptions?: ParseOptions) => string | null | undefined
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.OptionFromNullishOr<typeof Schema.NumberFromString>
schema)
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(
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
// 编码示例
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>
Represents the absence of a value by creating an empty Option.
Option.none returns an Option<never>, which is a subtype of Option<A>.
This means you can use it in place of any Option<A> regardless of the type
A.
Example (Creating an Option with No Value)
import { Option } from "effect"

// An Option holding no value
//
//      ┌─── Option<never>
//      ▼
const noValue = Option.none()

console.log(noValue)
// Output: { _id: 'Option', _tag: 'None' }
@see ― some for the opposite operation.
@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>
Wraps the given value into an Option to represent its presence.
Example (Creating an Option with a Value)
import { Option } from "effect"

// An Option holding the number 1
//
//      ┌─── Option<number>
//      ▼
const value = Option.some(1)

console.log(value)
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
@see ― none for the opposite operation.
@since ― 2.0.0
some(1)))
37
// Output: "1"

OptionFromNonEmptyTrimmedString

Schema.OptionFromNonEmptyTrimmedString模式专为处理字符串而设计，其中修剪后的空字符串被视为Option.none()，所有其他字符串都转换为Option.some()。

解码

输入	输出
`s: string`	如果`s.trim().length > 0`，转换为`Option.some(s)`
	否则转换为`Option.none()`

编码

输入	输出
`Option.none()`	转换为`""`
`Option.some(s: string)`	转换为`s`

示例

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 = typeof Schema.OptionFromNonEmptyTrimmedString
Encoded = typeof 
import Schema
Schema.
class OptionFromNonEmptyTrimmedString
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 = typeof Schema.OptionFromNonEmptyTrimmedString
Type = typeof 
import Schema
Schema.
class OptionFromNonEmptyTrimmedString
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<string>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
12
  
import Schema
Schema.
class OptionFromNonEmptyTrimmedString
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<string>, overrideOptions?: ParseOptions) => string
export encodeSync@since ― 3.10.0
encodeSync(
import Schema
Schema.
class OptionFromNonEmptyTrimmedString
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
// 解码示例
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
// 编码示例
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>
Represents the absence of a value by creating an empty Option.
Option.none returns an Option<never>, which is a subtype of Option<A>.
This means you can use it in place of any Option<A> regardless of the type
A.
Example (Creating an Option with No Value)
import { Option } from "effect"

// An Option holding no value
//
//      ┌─── Option<never>
//      ▼
const noValue = Option.none()

console.log(noValue)
// Output: { _id: 'Option', _tag: 'None' }
@see ― some for the opposite operation.
@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>
Wraps the given value into an Option to represent its presence.
Example (Creating an Option with a Value)
import { Option } from "effect"

// An Option holding the number 1
//
//      ┌─── Option<number>
//      ▼
const value = Option.some(1)

console.log(value)
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
@see ― none for the opposite operation.
@since ― 2.0.0
some("example")))
33
// Output: "example"

Either

Schema.Either函数对于将Either转换为JSON可序列化格式很有用。

语法

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

解码

输入	输出
`{ _tag: "Left", left: LI }`	转换为`Either.left(LA)`，其中`LI`使用内部`left`模式解码为`LA`
`{ _tag: "Right", right: RI }`	转换为`Either.right(RA)`，其中`RI`使用内部`right`模式解码为`RA`

编码

输入	输出
`Either.left(LA)`	转换为`{ _tag: "Left", left: LI }`，其中`LA`使用内部`left`模式编码为`LI`
`Either.right(RA)`	转换为`{ _tag: "Right", right: RI }`，其中`RA`使用内部`right`模式编码为`RI`

示例

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 = {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: string;
}
Encoded = typeof 
const schema: Schema.Either<typeof Schema.NumberFromString, typeof Schema.Trim>
schema.
Schema<Either<number, string>, { readonly _tag: "Right"; readonly right: string; } | { readonly _tag: "Left"; readonly left: string; }, never>.Encoded: {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: 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>, { readonly _tag: "Right"; readonly right: string; } | { readonly _tag: "Left"; readonly left: 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>, {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: string;
}>(schema: Schema.Schema<Either.Either<number, string>, {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: string;
}, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Either.Either<number, string>
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) => {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: string;
}
encode = 
import Schema
Schema.
encodeSync<Either.Either<number, string>, {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: string;
}>(schema: Schema.Schema<Either.Either<number, string>, {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: string;
}, never>, options?: ParseOptions): (a: Either.Either<number, string>, overrideOptions?: ParseOptions) => {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: string;
}
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.Either<typeof Schema.NumberFromString, typeof Schema.Trim>
schema)
18

19
// 解码示例
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
// 编码示例
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) => {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: 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) => {
    readonly _tag: "Right";
    readonly right: string;
} | {
    readonly _tag: "Left";
    readonly left: 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

Schema.EitherFromSelf函数专为Either值已经是Either格式并需要根据提供的模式解码或编码同时转换内部值的场景而设计。

语法

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

解码

输入	输出
`Either.left(LI)`	转换为`Either.left(LA)`，其中`LI`使用内部`left`模式解码为`LA`
`Either.right(RI)`	转换为`Either.right(RA)`，其中`RI`使用内部`right`模式解码为`RA`

编码

输入	输出
`Either.left(LA)`	转换为`Either.left(LI)`，其中`LA`使用内部`left`模式编码为`LI`
`Either.right(RA)`	转换为`Either.right(RI)`，其中`RA`使用内部`right`模式编码为`RI`

示例

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<number, string>
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<number, string>, overrideOptions?: ParseOptions) => Either.Either<string, string>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.EitherFromSelf<typeof Schema.NumberFromString, typeof Schema.Trim>
schema)
18

19
// 解码示例
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
// 编码示例
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

Schema.EitherFromUnion函数专为解码和编码Either值而设计，其中left和right侧表示为不同的类型。此模式支持原始联合类型和结构化Either类型之间的转换。

语法

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

解码

输入	输出
`LI`	转换为`Either.left(LA)`，其中`LI`使用内部`left`模式解码为`LA`
`RI`	转换为`Either.right(RA)`，其中`RI`使用内部`right`模式解码为`RA`

编码

输入	输出
`Either.left(LA)`	转换为`LI`，其中`LA`使用内部`left`模式编码为`LI`
`Either.right(RA)`	转换为`RI`，其中`RA`使用内部`right`模式编码为`RI`

示例

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<number, boolean>
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<number, boolean>, overrideOptions?: ParseOptions) => string | boolean
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.EitherFromUnion<typeof Schema.NumberFromString, typeof Schema.Boolean>
schema)
18

19
// 解码示例
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
// 编码示例
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

Schema.Exit函数对于将Exit转换为JSON可序列化格式很有用。

语法

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

解码

输入	输出
`{ _tag: "Failure", cause: CauseEncoded<FI, DI> }`	转换为`Exit.failCause(Cause<FA>)`，其中`CauseEncoded<FI, DI>`使用内部`failure`和`defect`模式解码为`Cause<FA>`
`{ _tag: "Success", value: SI }`	转换为`Exit.succeed(SA)`，其中`SI`使用内部`success`模式解码为`SA`

编码

输入	输出
`Exit.failCause(Cause<FA>)`	转换为`{ _tag: "Failure", cause: CauseEncoded<FI, DI> }`，其中`Cause<FA>`使用内部`failure`和`defect`模式编码为`CauseEncoded<FI, DI>`
`Exit.succeed(SA)`	转换为`{ _tag: "Success", value: SI }`，其中`SA`使用内部`success`模式编码为`SI`

示例

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<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>@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>, { readonly _tag: "Failure"; readonly cause: CauseEncoded<string, string>; } | { readonly _tag: "Success"; readonly value: string; }, never>.Encoded: {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: 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>, { readonly _tag: "Failure"; readonly cause: CauseEncoded<string, string>; } | { readonly _tag: "Success"; readonly value: 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>, {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}>(schema: Schema.Schema<Exit.Exit<number, string>, {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: 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) => {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}
encode = 
import Schema
Schema.
encodeSync<Exit.Exit<number, string>, {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}>(schema: Schema.Schema<Exit.Exit<number, string>, {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}, never>, options?: ParseOptions): (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema)
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(
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
// 编码示例
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) => {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: 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) => {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, string>;
} | {
    readonly _tag: "Success";
    readonly value: 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
*/

处理序列化中的缺陷

Effect提供了内置的Defect模式来处理JavaScript错误（Error实例）和其他类型的不可恢复缺陷。

解码时，如果输入具有message以及可选的name和stack，它会重构Error实例。
编码时，它将Error实例转换为仅保留基本属性的普通对象。

这在通过网络请求传输错误或在Error对象默认不序列化的日志系统中很有用。

示例（编码和解码缺陷）

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.Defect>
schema = 
import Schema
Schema.
const Exit: <typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.Defect>({ defect, failure, success }: {
    readonly failure: typeof Schema.String;
    readonly success: typeof Schema.NumberFromString;
    readonly defect: typeof Schema.Defect;
}) => Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.Defect>@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.Defect
defect: 
import Schema
Schema.
class Defect
Defines a schema for handling JavaScript errors (Error instances) and other types of defects.
It decodes objects into Error instances if they match the expected structure (i.e., have a message and optionally a name and stack),
or converts other values to their string representations.
When encoding, it converts Error instances back into plain objects containing only the error's name and message,
or other values into their string forms.
This is useful for serializing and deserializing errors across network boundaries where error objects do not natively serialize.
@since ― 3.10.0
Defect
7
})
8

9
const 
const decode: (i: {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}, overrideOptions?: ParseOptions) => Exit.Exit<number, string>
decode = 
import Schema
Schema.
decodeSync<Exit.Exit<number, string>, {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}>(schema: Schema.Schema<Exit.Exit<number, string>, {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}, never>, options?: ParseOptions): (i: {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}, overrideOptions?: ParseOptions) => Exit.Exit<...>
export decodeSync@since ― 3.10.0
decodeSync(
const schema: Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.Defect>
schema)
10
const 
const encode: (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}
encode = 
import Schema
Schema.
encodeSync<Exit.Exit<number, string>, {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}>(schema: Schema.Schema<Exit.Exit<number, string>, {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}, never>, options?: ParseOptions): (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.Exit<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.Defect>
schema)
11

12
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) => {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}
encode(
import Exit
Exit.
const die: (defect: unknown) => Exit.Exit<never>
Constructs a new Exit.Failure from the specified unrecoverable defect.
@since ― 2.0.0
die(new 
var Error: ErrorConstructor
new (message?: string) => Error
Error("Message"))))
13
/*
14
Output:
15
{
16
  _tag: 'Failure',
17
  cause: { _tag: 'Die', defect: { name: 'Error', message: 'Message' } }
18
}
19
*/
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 encode: (a: Exit.Exit<number, string>, overrideOptions?: ParseOptions) => {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: 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")))
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(
24
  
const decode: (i: {
    readonly _tag: "Failure";
    readonly cause: Schema.CauseEncoded<string, unknown>;
} | {
    readonly _tag: "Success";
    readonly value: string;
}, overrideOptions?: ParseOptions) => Exit.Exit<number, string>
decode({
25
    
_tag: "Failure"
_tag: "Failure",
26
    
cause: Schema.CauseEncoded<string, unknown>
cause: { 
_tag: "Die"
_tag: "Die", 
defect: unknown
defect: { 
name: string
name: "Error", 
message: string
message: "Message" } }
27
  })
28
)
29
/*
30
Output:
31
{
32
  _id: 'Exit',
33
  _tag: 'Failure',
34
  cause: {
35
    _id: 'Cause',
36
    _tag: 'Die',
37
    defect: [Error: Message] { [cause]: [Object] }
38
  }
39
}
40
*/

ExitFromSelf

Schema.ExitFromSelf函数专为Exit值已经是Exit格式并需要根据提供的模式解码或编码同时转换内部值的场景而设计。

语法

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

解码

输入	输出
`Exit.failCause(Cause<FI>)`	转换为`Exit.failCause(Cause<FA>)`，其中`Cause<FI>`使用内部`failure`和`defect`模式解码为`Cause<FA>`
`Exit.succeed(SI)`	转换为`Exit.succeed(SA)`，其中`SI`使用内部`success`模式解码为`SA`

编码

输入	输出
`Exit.failCause(Cause<FA>)`	转换为`Exit.failCause(Cause<FI>)`，其中`Cause<FA>`使用内部`failure`和`defect`模式解码为`Cause<FI>`
`Exit.succeed(SA)`	转换为`Exit.succeed(SI)`，其中`SA`使用内部`success`模式编码为`SI`

示例

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<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>@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<number, string>
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<number, string>, overrideOptions?: ParseOptions) => Exit.Exit<string, string>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ExitFromSelf<typeof Schema.NumberFromString, typeof Schema.String, typeof Schema.String>
schema)
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(
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
// 编码示例
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

Schema.ReadonlySet函数对于将ReadonlySet转换为JSON可序列化格式很有用。

语法

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

解码

输入	输出
`ReadonlyArray<I>`	转换为`ReadonlySet<A>`，其中`I`使用内部模式解码为`A`

编码

输入	输出
`ReadonlySet<A>`	`ReadonlyArray<I>`，其中`A`使用内部模式编码为`I`

示例

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

3
const 
const schema: Schema.ReadonlySet$<typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
function 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<number>
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<number>, overrideOptions?: ParseOptions) => readonly string[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ReadonlySet$<typeof Schema.NumberFromString>
schema)
15

16
// 解码示例
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
// 编码示例
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

Schema.ReadonlySetFromSelf函数专为ReadonlySet值已经是ReadonlySet格式并需要根据提供的模式解码或编码同时转换内部值的场景而设计。

语法

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

解码

输入	输出
`ReadonlySet<I>`	转换为`ReadonlySet<A>`，其中`I`使用内部模式解码为`A`

编码

输入	输出
`ReadonlySet<A>`	`ReadonlySet<I>`，其中`A`使用内部模式编码为`I`

示例

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<number>
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<number>, overrideOptions?: ParseOptions) => ReadonlySet<string>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ReadonlySetFromSelf<typeof Schema.NumberFromString>
schema)
15

16
// 解码示例
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
// 编码示例
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

Schema.ReadonlyMap函数对于将ReadonlyMap转换为JSON可序列化格式很有用。

ReadonlyMap

语法

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

解码

输入	输出
`ReadonlyArray<readonly [KI, VI]>`	转换为`ReadonlyMap<KA, VA>`，其中`KI`使用内部`key`模式解码为`KA`，`VI`使用内部`value`模式解码为`VA`

编码

输入	输出
`ReadonlyMap<KA, VA>`	转换为`ReadonlyArray<readonly [KI, VI]>`，其中`KA`使用内部`key`模式解码为`KI`，`VA`使用内部`value`模式解码为`VI`

示例

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

3
const 
const schema: Schema.ReadonlyMap$<typeof Schema.String, typeof Schema.NumberFromString>
schema = 
import Schema
Schema.
function 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<string, number>
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<string, number>, overrideOptions?: ParseOptions) => readonly (readonly [string, string])[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ReadonlyMap$<typeof Schema.String, typeof Schema.NumberFromString>
schema)
18

19
// 解码示例
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
// 编码示例
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

Schema.ReadonlyMapFromSelf函数专为ReadonlyMap值已经是ReadonlyMap格式并需要根据提供的模式解码或编码同时转换内部值的场景而设计。

语法

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

解码

输入	输出
`ReadonlyMap<KI, VI>`	转换为`ReadonlyMap<KA, VA>`，其中`KI`使用内部`key`模式解码为`KA`，`VI`使用内部`value`模式解码为`VA`

编码

输入	输出
`ReadonlyMap<KA, VA>`	转换为`ReadonlyMap<KI, VI>`，其中`KA`使用内部`key`模式解码为`KI`，`VA`使用内部`value`模式解码为`VI`

示例

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<string, number>
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<string, number>, overrideOptions?: ParseOptions) => ReadonlyMap<string, string>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.ReadonlyMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema)
18

19
// 解码示例
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
// 编码示例
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

Schema.ReadonlyMapFromRecord函数是一个实用工具，用于将ReadonlyMap转换为对象格式（其中键是字符串，值是可序列化的），反之亦然。

语法

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

解码

输入	输出
`{ readonly [x: string]: VI }`	转换为`ReadonlyMap<KA, VA>`，其中`x`使用`key`模式解码为`KA`，`VI`使用`value`模式解码为`VA`

编码

输入	输出
`ReadonlyMap<KA, VA>`	转换为`{ readonly [x: string]: VI }`，其中`KA`使用`key`模式编码为`x`，`VA`使用`value`模式编码为`VI`

示例

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

3
const 
const schema: Schema.SchemaClass<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.SchemaClass<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, 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.SchemaClass<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.SchemaClass<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<number, number>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.SchemaClass<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<number, number>, overrideOptions?: ParseOptions) => {
    readonly [x: string]: string;
}
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.SchemaClass<ReadonlyMap<number, number>, {
    readonly [x: string]: string;
}, never>
schema)
18

19
// 解码示例
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
// 编码示例
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

Schema.HashSet函数提供了在HashSet和数组表示之间映射的方法，允许JSON序列化和反序列化。

语法

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

解码

输入	输出
`ReadonlyArray<I>`	转换为`HashSet<A>`，其中数组中的每个元素使用模式解码为类型`A`

编码

输入	输出
`HashSet<A>`	转换为`ReadonlyArray<I>`，其中`HashSet`中的每个元素使用模式编码为类型`I`

示例

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.
function 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<number>
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<number>, overrideOptions?: ParseOptions) => readonly string[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.HashSet<typeof Schema.NumberFromString>
schema)
16

17
// 解码示例
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
// 编码示例
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.
Time complexity: O(n) where n is the number of elements in the iterable
@memberof ― HashSet
@since ― 2.0.0
@example 
// Creating a HashSet from an Array
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    [1, 2, 3, 4, 5, 1, 2, 3], // Array<number> is an Iterable<number>;  Note the duplicates.
    HashSet.fromIterable,
    HashSet.toValues
  )
) // Output: [1, 2, 3, 4, 5]
@example 
// Creating a HashSet from a Set
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    new Set(["apple", "banana", "orange", "apple"]), // Set<string> is an Iterable<string>
    HashSet.fromIterable,
    HashSet.toValues
  )
) // Output: ["apple", "banana", "orange"]
@example 
// Creating a HashSet from a Generator
import { HashSet } from "effect"

// Generator functions return iterables
function* fibonacci(n: number): Generator<number, void, unknown> {
  let [a, b] = [0, 1]
  for (let i = 0; i < n; i++) {
    yield a
    ;[a, b] = [b, a + b]
  }
}

// Create a HashSet from the first 10 Fibonacci numbers
const fibonacciSet = HashSet.fromIterable(fibonacci(10))

console.log(HashSet.toValues(fibonacciSet))
// Outputs: [0, 1, 2, 3, 5, 8, 13, 21, 34] but in unsorted order
@example 
//  Creating a HashSet from another HashSet
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    // since HashSet implements the Iterable interface, we can use it to create a new HashSet
    HashSet.make(1, 2, 3, 4),
    HashSet.fromIterable,
    HashSet.toValues // turns the HashSet back into an array
  )
) // Output: [1, 2, 3, 4]
@example 
// Creating a HashSet from other Effect's data structures like Chunk
import { Chunk, HashSet, pipe } from "effect"

console.log(
  pipe(
    Chunk.make(1, 2, 3, 4), // Iterable<number>
    HashSet.fromIterable,
    HashSet.toValues // turns the HashSet back into an array
  )
) // Outputs: [1, 2, 3, 4]
@see ― Other HashSet constructors are module:HashSet.empty module:HashSet.make
fromIterable([1, 2, 3])))
25
// Output: [ '1', '2', '3' ]

HashSetFromSelf

Schema.HashSetFromSelf函数专为HashSet值已经是HashSet格式并需要根据提供的模式解码或编码同时转换内部值的场景而设计。

语法

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

解码

输入	输出
`HashSet<I>`	转换为`HashSet<A>`，使用模式将每个元素从类型`I`解码为类型`A`

编码

输入	输出
`HashSet<A>`	转换为`HashSet<I>`，使用模式将每个元素从类型`A`编码为类型`I`

示例

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<number>
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<number>, overrideOptions?: ParseOptions) => HashSet.HashSet<string>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.HashSetFromSelf<typeof Schema.NumberFromString>
schema)
16

17
// 解码示例
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.
Time complexity: O(n) where n is the number of elements in the iterable
@memberof ― HashSet
@since ― 2.0.0
@example 
// Creating a HashSet from an Array
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    [1, 2, 3, 4, 5, 1, 2, 3], // Array<number> is an Iterable<number>;  Note the duplicates.
    HashSet.fromIterable,
    HashSet.toValues
  )
) // Output: [1, 2, 3, 4, 5]
@example 
// Creating a HashSet from a Set
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    new Set(["apple", "banana", "orange", "apple"]), // Set<string> is an Iterable<string>
    HashSet.fromIterable,
    HashSet.toValues
  )
) // Output: ["apple", "banana", "orange"]
@example 
// Creating a HashSet from a Generator
import { HashSet } from "effect"

// Generator functions return iterables
function* fibonacci(n: number): Generator<number, void, unknown> {
  let [a, b] = [0, 1]
  for (let i = 0; i < n; i++) {
    yield a
    ;[a, b] = [b, a + b]
  }
}

// Create a HashSet from the first 10 Fibonacci numbers
const fibonacciSet = HashSet.fromIterable(fibonacci(10))

console.log(HashSet.toValues(fibonacciSet))
// Outputs: [0, 1, 2, 3, 5, 8, 13, 21, 34] but in unsorted order
@example 
//  Creating a HashSet from another HashSet
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    // since HashSet implements the Iterable interface, we can use it to create a new HashSet
    HashSet.make(1, 2, 3, 4),
    HashSet.fromIterable,
    HashSet.toValues // turns the HashSet back into an array
  )
) // Output: [1, 2, 3, 4]
@example 
// Creating a HashSet from other Effect's data structures like Chunk
import { Chunk, HashSet, pipe } from "effect"

console.log(
  pipe(
    Chunk.make(1, 2, 3, 4), // Iterable<number>
    HashSet.fromIterable,
    HashSet.toValues // turns the HashSet back into an array
  )
) // Outputs: [1, 2, 3, 4]
@see ― Other HashSet constructors are module:HashSet.empty module:HashSet.make
fromIterable(["1", "2", "3"])))
20
// Output: { _id: 'HashSet', values: [ 1, 2, 3 ] }
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(
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.
Time complexity: O(n) where n is the number of elements in the iterable
@memberof ― HashSet
@since ― 2.0.0
@example 
// Creating a HashSet from an Array
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    [1, 2, 3, 4, 5, 1, 2, 3], // Array<number> is an Iterable<number>;  Note the duplicates.
    HashSet.fromIterable,
    HashSet.toValues
  )
) // Output: [1, 2, 3, 4, 5]
@example 
// Creating a HashSet from a Set
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    new Set(["apple", "banana", "orange", "apple"]), // Set<string> is an Iterable<string>
    HashSet.fromIterable,
    HashSet.toValues
  )
) // Output: ["apple", "banana", "orange"]
@example 
// Creating a HashSet from a Generator
import { HashSet } from "effect"

// Generator functions return iterables
function* fibonacci(n: number): Generator<number, void, unknown> {
  let [a, b] = [0, 1]
  for (let i = 0; i < n; i++) {
    yield a
    ;[a, b] = [b, a + b]
  }
}

// Create a HashSet from the first 10 Fibonacci numbers
const fibonacciSet = HashSet.fromIterable(fibonacci(10))

console.log(HashSet.toValues(fibonacciSet))
// Outputs: [0, 1, 2, 3, 5, 8, 13, 21, 34] but in unsorted order
@example 
//  Creating a HashSet from another HashSet
import { HashSet, pipe } from "effect"

console.log(
  pipe(
    // since HashSet implements the Iterable interface, we can use it to create a new HashSet
    HashSet.make(1, 2, 3, 4),
    HashSet.fromIterable,
    HashSet.toValues // turns the HashSet back into an array
  )
) // Output: [1, 2, 3, 4]
@example 
// Creating a HashSet from other Effect's data structures like Chunk
import { Chunk, HashSet, pipe } from "effect"

console.log(
  pipe(
    Chunk.make(1, 2, 3, 4), // Iterable<number>
    HashSet.fromIterable,
    HashSet.toValues // turns the HashSet back into an array
  )
) // Outputs: [1, 2, 3, 4]
@see ― Other HashSet constructors are module:HashSet.empty module:HashSet.make
fromIterable([1, 2, 3])))
25
// Output: { _id: 'HashSet', values: [ '1', '3', '2' ] }

HashMap

Schema.HashMap函数对于将HashMap转换为JSON可序列化格式很有用。

语法

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

输入	输出
`ReadonlyArray<readonly [KI, VI]>`	转换为`HashMap<KA, VA>`，其中`KI`使用指定模式解码为`KA`，`VI`解码为`VA`

编码

输入	输出
`HashMap<KA, VA>`	转换为`ReadonlyArray<readonly [KI, VI]>`，其中`KA`使用指定模式编码为`KI`，`VA`编码为`VI`

示例

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<string, number>
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<string, number>, overrideOptions?: ParseOptions) => readonly (readonly [string, string])[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.HashMap<typeof Schema.String, typeof Schema.NumberFromString>
schema)
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(
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
// 编码示例
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

Schema.HashMapFromSelf函数专为HashMap值已经是HashMap格式并需要根据提供的模式解码或编码同时转换内部值的场景而设计。

语法

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

解码

输入	输出
`HashMap<KI, VI>`	转换为`HashMap<KA, VA>`，其中`KI`使用指定模式解码为`KA`，`VI`解码为`VA`

编码

输入	输出
`HashMap<KA, VA>`	转换为`HashMap<KI, VI>`，其中`KA`使用指定模式编码为`KI`，`VA`编码为`VI`

示例

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<string, number>
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<string, number>, overrideOptions?: ParseOptions) => HashMap.HashMap<string, string>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.HashMapFromSelf<typeof Schema.String, typeof Schema.NumberFromString>
schema)
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(
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
// 编码示例
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

Schema.SortedSet函数提供了在SortedSet和数组表示之间映射的方法，允许JSON序列化和反序列化。

语法

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

解码

输入	输出
`ReadonlyArray<I>`	转换为`SortedSet<A>`，其中数组中的每个元素使用模式解码为类型`A`

编码

输入	输出
`SortedSet<A>`	转换为`ReadonlyArray<I>`，其中`SortedSet`中的每个元素使用模式编码为类型`I`

示例

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.
function 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>@memberof ― 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<number>
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<number>, overrideOptions?: ParseOptions) => readonly string[]
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.SortedSet<typeof Schema.NumberFromString>
schema)
16

17
// 解码示例
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
// 编码示例
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>@memberof ― Number
@since ― 2.0.0
Order)([1, 2, 3])))
25
// Output: [ '1', '2', '3' ]

SortedSetFromSelf

Schema.SortedSetFromSelf函数专为SortedSet值已经是SortedSet格式并需要根据提供的模式解码或编码同时转换内部值的场景而设计。

语法

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

解码

输入	输出
`SortedSet<I>`	转换为`SortedSet<A>`，使用模式将每个元素从类型`I`解码为类型`A`

编码

输入	输出
`SortedSet<A>`	转换为`SortedSet<I>`，使用模式将每个元素从类型`A`编码为类型`I`

示例

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>@memberof ― 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<number>
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<number>, overrideOptions?: ParseOptions) => SortedSet.SortedSet<string>
export encodeSync@since ― 3.10.0
encodeSync(
const schema: Schema.SortedSetFromSelf<typeof Schema.NumberFromString>
schema)
20

21
// 解码示例
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
// 编码示例
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>@memberof ― Number
@since ― 2.0.0
Order)([1, 2, 3])))
29
// Output: { _id: 'SortedSet', values: [ '1', '2', '3' ] }

Duration

Duration模式系列支持跨各种格式（包括hrtime、毫秒和纳秒）的持续时间值的转换和验证。

Duration

将hrtime（即[seconds: number, nanos: number]）转换为Duration。

示例

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

3
const 
const schema: typeof Schema.Duration
schema = 
import Schema
Schema.
class Duration
A schema that converts a JSON-compatible tagged union into a Duration.
@since ― 3.10.0
Duration
4

5
//     ┌─── readonly [seconds: number, nanos: number]
6
//     ▼
7
type 
type Encoded = Schema.DurationEncoded | readonly [seconds: number, nanos: number]
Encoded = typeof 
const schema: typeof Schema.Duration
schema.
Schema<Duration, DurationEncoded | readonly [seconds: number, nanos: number], never>.Encoded: Schema.DurationEncoded | 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, DurationEncoded | 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, Schema.DurationEncoded | readonly [seconds: number, nanos: number]>(schema: Schema.Schema<Duration, Schema.DurationEncoded | 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
// 解码示例
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

DurationFromSelf模式旨在验证给定值是否符合Duration类型。

示例

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
// 解码示例
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

将number转换为Duration，其中数字表示毫秒数。

示例

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 (possibly Infinite) non negative number 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
// 解码示例
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

将BigInt转换为Duration，其中数字表示纳秒数。

示例

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 non negative bigint 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
// 解码示例
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

将Duration限制在最小值和最大值之间。

示例

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

3
const 
const schema: Schema.transform<typeof Schema.DurationFromSelf, Schema.filter<Schema.SchemaClass<Duration.Duration, Duration.Duration, never>>>
schema = 
import Schema
Schema.
class DurationFromSelf@since ― 3.10.0
DurationFromSelf.
Pipeable.pipe<typeof Schema.DurationFromSelf, Schema.transform<typeof Schema.DurationFromSelf, Schema.filter<Schema.SchemaClass<Duration.Duration, Duration.Duration, never>>>>(this: typeof Schema.DurationFromSelf, ab: (_: typeof Schema.DurationFromSelf) => Schema.transform<typeof Schema.DurationFromSelf, Schema.filter<Schema.SchemaClass<Duration.Duration, Duration.Duration, never>>>): Schema.transform<typeof Schema.DurationFromSelf, Schema.filter<Schema.SchemaClass<Duration.Duration, Duration.Duration, never>>> (+21 overloads)
pipe(
4
  
import Schema
Schema.
const clampDuration: (minimum: Duration.DurationInput, maximum: Duration.DurationInput) => <S extends Schema.Schema<in out A, in out I = A, out R = never>.Any, A extends Duration.Duration>(self: S & Schema.Schema<A, Schema.Schema.Encoded<S>, Schema.Schema.Context<S>>) => Schema.transform<S, Schema.filter<Schema.SchemaClass<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<typeof Schema.DurationFromSelf, Schema.filter<Schema.SchemaClass<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<typeof Schema.DurationFromSelf, Schema.filter<Schema.SchemaClass<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<typeof Schema.DurationFromSelf, Schema.filter<Schema.SchemaClass<Duration.Duration, Duration.Duration, never>>>
schema)
16

17
// 解码示例
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

Schema.Redacted函数专门设计用于通过将string转换为Redacted对象来处理敏感信息。此转换确保敏感数据不会在应用程序的输出中暴露。

示例（基本Redacted模式）

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

3
const 
const schema: Schema.Redacted<typeof Schema.String>
schema = 
import Schema
Schema.
function Redacted<typeof Schema.String>(value: typeof Schema.String): Schema.Redacted<typeof Schema.String>
A transformation that transform a Schema<A, I, R> into a
RedactedFromSelf<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<string>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.Redacted<typeof Schema.String>
schema)
14

15
// 解码示例
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>

需要注意的是，当成功解码Redacted时，输出会被故意模糊化（<redacted>），以防止实际的秘密在日志或控制台输出中被泄露。

示例（错误期间的暴露风险）

在下面的示例中，如果输入字符串不符合条件（例如，包含空格），生成的错误消息可能会无意中暴露输入中包含的敏感信息。

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

4
const 
const schema: Schema.transform<typeof Schema.Trimmed, Schema.Redacted<typeof Schema.String>>
schema = 
import Schema
Schema.
class Trimmed@since ― 3.10.0
Trimmed.
Pipeable.pipe<typeof Schema.Trimmed, Schema.transform<typeof Schema.Trimmed, Schema.Redacted<typeof Schema.String>>>(this: typeof Schema.Trimmed, ab: (_: typeof Schema.Trimmed) => Schema.transform<typeof Schema.Trimmed, Schema.Redacted<typeof Schema.String>>): Schema.transform<typeof Schema.Trimmed, Schema.Redacted<typeof Schema.String>> (+21 overloads)
pipe(
5
  
import Schema
Schema.
const compose: <Schema.Redacted<typeof Schema.String>, typeof Schema.Trimmed, string>(to: Schema.Redacted<typeof Schema.String> & Schema.Schema<Redacted.Redacted<string>, string, never>) => (from: typeof Schema.Trimmed) => Schema.transform<typeof Schema.Trimmed, Schema.Redacted<typeof Schema.String>> (+7 overloads)@since ― 3.10.0
compose(
import Schema
Schema.
function Redacted<typeof Schema.String>(value: typeof Schema.String): Schema.Redacted<typeof Schema.String>
A transformation that transform a Schema<A, I, R> into a
RedactedFromSelf<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<Redacted.Redacted<string>, ParseError>@since ― 3.10.0
decodeUnknownEither(
const schema: Schema.transform<typeof Schema.Trimmed, Schema.Redacted<typeof Schema.String>>
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<string>, overrideOptions?: ParseOptions) => Either<string, ParseError>@since ― 3.10.0
encodeEither(
const schema: Schema.transform<typeof Schema.Trimmed, Schema.Redacted<typeof Schema.String>>
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
*/

缓解暴露风险

为了减少错误消息中敏感信息泄露的风险，您可以自定义错误消息以模糊敏感细节：

示例（自定义错误消息）

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

4
const 
const schema: Schema.transform<Schema.refine<string, typeof Schema.String>, Schema.Redacted<typeof Schema.String>>
schema = 
import Schema
Schema.
class Trimmed@since ― 3.10.0
Trimmed.
Annotable<refine<string, typeof String$>, string, string, never>.annotations(annotations: Schema.Annotations.GenericSchema<string>): Schema.refine<string, typeof Schema.String>
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, typeof Schema.String>, Schema.transform<Schema.refine<string, typeof Schema.String>, Schema.Redacted<typeof Schema.String>>>(this: Schema.refine<string, typeof Schema.String>, ab: (_: Schema.refine<string, typeof Schema.String>) => Schema.transform<Schema.refine<string, typeof Schema.String>, Schema.Redacted<typeof Schema.String>>): Schema.transform<Schema.refine<string, typeof Schema.String>, Schema.Redacted<typeof Schema.String>> (+21 overloads)
pipe(
import Schema
Schema.
const compose: <Schema.Redacted<typeof Schema.String>, Schema.refine<string, typeof Schema.String>, string>(to: Schema.Redacted<typeof Schema.String> & Schema.Schema<Redacted.Redacted<string>, string, never>) => (from: Schema.refine<string, typeof Schema.String>) => Schema.transform<Schema.refine<string, typeof Schema.String>, Schema.Redacted<typeof Schema.String>> (+7 overloads)@since ― 3.10.0
compose(
import Schema
Schema.
function Redacted<typeof Schema.String>(value: typeof Schema.String): Schema.Redacted<typeof Schema.String>
A transformation that transform a Schema<A, I, R> into a
RedactedFromSelf<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<Redacted.Redacted<string>, ParseError>@since ― 3.10.0
decodeUnknownEither(
const schema: Schema.transform<Schema.refine<string, typeof Schema.String>, Schema.Redacted<typeof Schema.String>>
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<string>, overrideOptions?: ParseOptions) => Either<string, ParseError>@since ― 3.10.0
encodeEither(
const schema: Schema.transform<Schema.refine<string, typeof Schema.String>, Schema.Redacted<typeof Schema.String>>
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

Schema.RedactedFromSelf模式旨在验证给定值是否符合effect库中的Redacted类型。

示例

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<string>
export decodeUnknownSync@throws ― ParseError
@since ― 3.10.0
decodeUnknownSync(
const schema: Schema.RedactedFromSelf<typeof Schema.String>
schema)
15

16
// 解码示例
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
*/

需要注意的是，当成功解码Redacted时，输出会被故意模糊化（<redacted>），以防止实际的秘密在日志或控制台输出中被泄露。