Hash

The Hash trait in Effect is closely tied to the Equal trait and serves a supportive role in optimizing equality checks by providing a mechanism for hashing. Hashing is a crucial step in the efficient determination of equality between two values, particularly when used with data structures like hash tables.

Role of Hash in Equality Checking

The main function of the Hash trait is to provide a quick and efficient way to determine if two values are definitely not equal, thereby complementing the Equal trait. When two values implement the Equal trait, their hash values (computed using the Hash trait) are compared first:

Different Hash Values: If the hash values are different, it is guaranteed that the values themselves are different. This quick check allows the system to avoid a potentially expensive equality check.
Same Hash Values: If the hash values are the same, it does not guarantee that the values are equal, only that they might be. In this case, a more thorough comparison using the Equal trait is performed to determine actual equality.

This method dramatically speeds up the equality checking process, especially in collections where quick look-up and insertion times are crucial, such as in hash sets or hash maps.

Practical Example and Explanation

Consider a scenario where you have a custom Person class, and you want to check if two instances are equal based on their properties. By implementing both the Equal and Hash traits, you can efficiently manage these checks:

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

3
class class Person
Person implements import Equal
Equal.interface Equal
Equal {
4
  constructor(
5
    readonly (property) Person.id: number
id: number, // Unique identifier for each person
6
    readonly (property) Person.name: string
name: string,
7
    readonly (property) Person.age: number
age: number
8
  ) {}
9

10
  // Defines equality based on id, name, and age
11
  [import Equal
Equal.const symbol: typeof Equal.symbol
symbol]((parameter) that: Equal.Equal
that: import Equal
Equal.interface Equal
Equal): boolean {
12
    if ((parameter) that: Equal.Equal
that instanceof class Person
Person) {
13
      return (
14
        import Equal
Equal.function equals<number, number>(self: number, that: number): boolean (+1 overload)
equals(this.(property) Person.id: number
id, (parameter) that: Person
that.(property) Person.id: number
id) &&
15
        import Equal
Equal.function equals<string, string>(self: string, that: string): boolean (+1 overload)
equals(this.(property) Person.name: string
name, (parameter) that: Person
that.(property) Person.name: string
name) &&
16
        import Equal
Equal.function equals<number, number>(self: number, that: number): boolean (+1 overload)
equals(this.(property) Person.age: number
age, (parameter) that: Person
that.(property) Person.age: number
age)
17
      )
18
    }
19
    return false
20
  }
21

22
  // Generates a hash code based primarily on the unique id
23
  [import Hash
Hash.const symbol: typeof Hash.symbol
symbol](): number {
24
    return import Hash
Hash.const hash: <number>(self: number) => number
hash(this.(property) Person.id: number
id)
25
  }
26
}
27

28
const const alice: Person
alice = new constructor Person(id: number, name: string, age: number): Person
Person(1, "Alice", 30)
29
namespace console
var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): voidPrints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log(import Equal
Equal.function equals<Person, Person>(self: Person, that: Person): boolean (+1 overload)
equals(const alice: Person
alice, new constructor Person(id: number, name: string, age: number): Person
Person(1, "Alice", 30))) // Output: true
30

31
const const bob: Person
bob = new constructor Person(id: number, name: string, age: number): Person
Person(2, "Bob", 40)
32
namespace console
var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): voidPrints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log(import Equal
Equal.function equals<Person, Person>(self: Person, that: Person): boolean (+1 overload)
equals(const alice: Person
alice, const bob: Person
bob)) // Output: false

In this code snippet:

The [Equal.symbol] method determines equality by comparing the id, name, and age fields of Person instances. This approach ensures that the equality check is comprehensive and considers all relevant attributes.
The [Hash.symbol] method computes a hash code using the id of the person. This value is used to quickly differentiate between instances in hashing operations, optimizing the performance of data structures that utilize hashing.
The equality check returns true when comparing alice to a new Person object with identical property values and false when comparing alice to bob due to their differing property values.