Skip to content
Effect Documentation

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.

Role of Hash in Equality Checking

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.

Implementing the Hash Interface

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)

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


class 
class Person
Person implements 
import Equal
Equal.
interface Equal
@since ― 2.0.0
Equal {
  constructor(
    readonly 
Person.id: number
id: number, // Unique identifier
    readonly 
Person.name: string
name: string,
    readonly 
Person.age: number
age: number
  ) {}


  // Define equality based on id, name, and age
  [
import Equal
Equal.
const symbol: typeof Equal.symbol
@since ― 2.0.0
symbol](
that: Equal.Equal
that: 
import Equal
Equal.
interface Equal
@since ― 2.0.0
Equal): boolean {
    if (
that: Equal.Equal
that instanceof 
class Person
Person) {
      return (
        
import Equal
Equal.
function equals<number, number>(self: number, that: number): boolean (+1 overload)
@since ― 2.0.0
equals(this.
Person.id: number
id, 
that: Person
that.
Person.id: number
id) &&
        
import Equal
Equal.
function equals<string, string>(self: string, that: string): boolean (+1 overload)
@since ― 2.0.0
equals(this.
Person.name: string
name, 
that: Person
that.
Person.name: string
name) &&
        
import Equal
Equal.
function equals<number, number>(self: number, that: number): boolean (+1 overload)
@since ― 2.0.0
equals(this.
Person.age: number
age, 
that: Person
that.
Person.age: number
age)
      )
    }
    return false
  }


  // Generate a hash code based on the unique id
  [
import Hash
Hash.
const symbol: typeof Hash.symbol
@since ― 2.0.0
symbol](): number {
    return 
import Hash
Hash.
const hash: <number>(self: number) => number
@since ― 2.0.0
hash(this.
Person.id: number
id)
  }
}


const 
const alice: Person
alice = new 
constructor Person(id: number, name: string, age: number): Person
Person(1, "Alice", 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(
import Equal
Equal.
function equals<Person, Person>(self: Person, that: Person): boolean (+1 overload)
@since ― 2.0.0
equals(
const alice: Person
alice, new 
constructor Person(id: number, name: string, age: number): Person
Person(1, "Alice", 30)))
// Output: true


const 
const bob: Person
bob = new 
constructor Person(id: number, name: string, age: number): Person
Person(2, "Bob", 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(
import Equal
Equal.
function equals<Person, Person>(self: Person, that: Person): boolean (+1 overload)
@since ― 2.0.0
equals(
const alice: Person
alice, 
const bob: Person
bob))
// 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.