Schema到等值

Schema.equivalence函数允许您基于模式定义生成等值。此函数旨在根据模式中定义的规则比较数据结构的等值性。

示例（比较结构体的等值性）

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

3
const 
const Person: Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>
Person = 
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({
4
  
name: typeof Schema.String
name: 
import Schema
Schema.
class String
export String@since ― 3.10.0
String,
5
  
age: typeof Schema.Number
age: 
import Schema
Schema.
class Number
export Number@since ― 3.10.0
Number
6
})
7

8
// 基于模式生成等值函数
9
const 
const PersonEquivalence: Equivalence<{
    readonly name: string;
    readonly age: number;
}>
PersonEquivalence = 
import Schema
Schema.
const equivalence: <{
    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>) => Equivalence<{
    readonly name: string;
    readonly age: number;
}>
Given a schema Schema<A, I, R>, returns an Equivalence instance for A.
@since ― 3.10.0
equivalence(
const Person: Schema.Struct<{
    name: typeof Schema.String;
    age: typeof Schema.Number;
}>
Person)
10

11
const 
const john: {
    name: string;
    age: number;
}
john = { 
name: string
name: "John", 
age: number
age: 23 }
12
const 
const alice: {
    name: string;
    age: number;
}
alice = { 
name: string
name: "Alice", 
age: number
age: 30 }
13

14
// 使用等值函数比较对象
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(
const PersonEquivalence: Equivalence
(self: {
    readonly name: string;
    readonly age: number;
}, that: {
    readonly name: string;
    readonly age: number;
}) => boolean
PersonEquivalence(
const john: {
    name: string;
    age: number;
}
john, { 
name: string
name: "John", 
age: number
age: 23 }))
17
// Output: true
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 PersonEquivalence: Equivalence
(self: {
    readonly name: string;
    readonly age: number;
}, that: {
    readonly name: string;
    readonly age: number;
}) => boolean
PersonEquivalence(
const john: {
    name: string;
    age: number;
}
john, 
const alice: {
    name: string;
    age: number;
}
alice))
20
// Output: false

Any、Unknown和Object的等值

当使用以下模式时：

Schema.Any
Schema.Unknown
Schema.Object
Schema.Struct({})（表示广泛的{}TypeScript类型）

最合理的等值形式是使用Equal模块中的Equal.equals，它默认为引用等值（===）。这是因为这些类型可以容纳几乎任何类型的值。

示例（使用引用等值比较空对象）

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

3
const 
const schema: Schema.Struct<{}>
schema = 
import Schema
Schema.
function Struct<{}>(fields: {}): Schema.Struct<{}> (+1 overload)@since ― 3.10.0
Struct({})
4

5
const 
const input1: {}
input1 = {}
6
const 
const input2: {}
input2 = {}
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 equivalence: <{}, {}, never>(schema: Schema.Schema<{}, {}, never>) => Equivalence<{}>
Given a schema Schema<A, I, R>, returns an Equivalence instance for A.
@since ― 3.10.0
equivalence(
const schema: Schema.Struct<{}>
schema)(
const input1: {}
input1, 
const input2: {}
input2))
9
// Output: false（因为它们是不同的引用）

自定义等值生成

您可以通过在模式定义中提供equivalence注解来自定义等值逻辑。

equivalence注解接受提供的任何类型参数（typeParameters）和两个用于比较的值，根据所需的等值条件返回布尔值。

示例（字符串的自定义等值）

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

3
// 定义带有自定义等值注解的模式
4
const 
const schema: Schema.SchemaClass<string, string, never>
schema = 
import Schema
Schema.
class String
export String@since ― 3.10.0
String.
Annotable<SchemaClass<string, string, never>, string, string, never>.annotations(annotations: Schema.Annotations.GenericSchema<string>): Schema.SchemaClass<string, string, never>
Merges a set of new annotations with existing ones, potentially overwriting
any duplicates.
annotations({
5
  
Annotations.GenericSchema<string>.equivalence?: (..._: any) => Equivalence<string>
equivalence: (/**typeParameters**/) => (
s1: string
s1, 
s2: string
s2) =>
6
    // 自定义规则：仅比较字符串的第一个字符
7
    
s1: string
s1.
String.charAt(pos: number): string
Returns the character at the specified index.
@param ― pos The zero-based index of the desired character.
charAt(0) === 
s2: string
s2.
String.charAt(pos: number): string
Returns the character at the specified index.
@param ― pos The zero-based index of the desired character.
charAt(0)
8
})
9

10
// 生成等值函数
11
const 
const customEquivalence: Equivalence<string>
customEquivalence = 
import Schema
Schema.
const equivalence: <string, string, never>(schema: Schema.Schema<string, string, never>) => Equivalence<string>
Given a schema Schema<A, I, R>, returns an Equivalence instance for A.
@since ― 3.10.0
equivalence(
const schema: Schema.SchemaClass<string, string, never>
schema)
12

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(
const customEquivalence: Equivalence
(self: string, that: string) => boolean
customEquivalence("aaa", "abb"))
15
// Output: true（都以'a'开头）
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 customEquivalence: Equivalence
(self: string, that: string) => boolean
customEquivalence("aaa", "bba"))
18
// Output: false（字符串以不同字符开头）