Skip to content

Hash

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

The primary purpose of the Hash interface is to provide a quick and efficient way to determine if two values are definitely not equal, thereby complementing the Equal interface. When two values implement the Equal interface, their hash values (computed using the Hash interface) 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 interface 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.

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 interfaces, you can efficiently manage these checks:

Example (Implementing Equal and Hash for a Custom Class)

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
6
readonly
(property) Person.name: string
name
: string,
7
readonly
(property) Person.age: number
age
: number
8
) {}
9
10
// Define 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
// Generate a hash code based 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: 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`](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[]): 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)`](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)))
30
// Output: true
31
32
const
const bob: Person
bob
= new
constructor Person(id: number, name: string, age: number): Person
Person
(2, "Bob", 40)
33
namespace console 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`](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[]): 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)`](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
))
34
// Output: false

Explanation:

  • 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.