Schema to Equivalence

The Schema.equivalence function allows you to generate an Equivalence based on a schema definition. This function is designed to compare data structures for equivalence according to the rules defined in the schema.

Example (Comparing Structs for 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
// Generate an equivalence function based on the schema
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<...>
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
// Use the equivalence function to compare objects
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

Equivalence for Any, Unknown, and Object

When working with the following schemas:

Schema.Any
Schema.Unknown
Schema.Object
Schema.Struct({}) (representing the broad {} TypeScript type)

the most sensible form of equivalence is to use Equal.equals from the Equal module, which defaults to reference equality (===). This is because these types can hold almost any kind of value.

Example (Comparing Empty Objects Using Reference Equality)

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 (because they are different references)

Customizing Equivalence Generation

You can customize the equivalence logic by providing an equivalence annotation in the schema definition.

The equivalence annotation takes any type parameters provided (typeParameters) and two values for comparison, returning a boolean based on the desired condition of equivalence.

Example (Custom Equivalence for Strings)

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

3
// Define a schema with a custom equivalence annotation
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
    // Custom rule: Compare only the first character of the strings
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
// Generate the equivalence function
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
// Use the custom equivalence function
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 (both start with '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 (strings start with different characters)