Vocabulary
kernel

Inputs and outputs

depth	an integer
obj	an object
code	a fixnum

Generic word contract
Outputs the hashcode of an object. The hashcode operation must satisfy the following properties:

•	If two objects are equal under =, they must have equal hashcodes.
•	If the hashcode of an object depends on the values of its slots, the hashcode of the slots must be computed recursively by calling hashcode* with a level parameter decremented by one. This avoids excessive work while still computing well-distributed hashcodes. The recursive-hashcode combinator can help with implementing this logic,
•	The hashcode should be a fixnum, however returning a bignum will not cause any problems other than potential performance degradation.
•	The hashcode is only permitted to change between two invocations if the object or one of its slot values was mutated.

If mutable objects are used as hashtable keys, they must not be mutated in such a way that their hashcode changes. Doing so will violate bucket sorting invariants and result in undefined behavior. See Hashtable keys for details.

See also
hashcode, identity-hashcode

Definition

IN: kernel

GENERIC: hashcode* ( depth obj -- code )

Methods

USING: arrays combinators kernel sequences ;

M: array hashcode* [ sequence-hashcode ] recursive-hashcode ;

USING: kernel math math.private ;

M: bignum hashcode* nip bignum>fixnum ;

USING: combinators grouping kernel sequences ;

M: circular-slice hashcode*
[ sequence-hashcode ] recursive-hashcode ;

USING: accessors benchmark.hashtables kernel math ;

M: collision hashcode* value>> hashcode* 15 bitand ;

USING: classes.tuple kernel math.combinatorics ;

M: combinations hashcode* tuple-hashcode ;

USING: kernel math ;

M: complex hashcode* nip >rect [ hashcode ] bi@ bitxor ; inline

USING: accessors bootstrap.image.private kernel ;

M: eq-wrapper hashcode* nip obj>> identity-hashcode ;

USING: accessors bootstrap.image.private kernel ;

M: eql-wrapper hashcode* obj>> hashcode* ;

USING: kernel ;

M: f hashcode* 2drop 31337 ; inline

USING: kernel math ;

M: fixnum hashcode* nip ; inline

USING: kernel math ;

M: float hashcode* nip float>bits ; inline

USING: kernel ui.gadgets ;

M: gadget hashcode* nip identity-hashcode ;

USING: combinators hash-sets kernel sets ;

M: hash-set hashcode*
[
dup cardinality 1 eq?
[ members hashcode* ] [ nip cardinality ] if
] recursive-hashcode ;

USING: assocs combinators hashtables kernel ;

M: hashtable hashcode*
[
dup assoc-size 1 eq?
[ assoc-hashcode ] [ nip assoc-size ] if
] recursive-hashcode ;

USING: kernel ;

M: identity-tuple hashcode* nip identity-hashcode ; inline

USING: accessors hashtables.identity.private kernel ;

M: identity-wrapper hashcode* nip identity-hashcode>> ; inline

USING: accessors hash-sets.identity.private kernel ;

M: identity-wrapper hashcode* nip identity-hashcode>> ; inline

USING: kernel math sequences sequences.private ;

M: iota hashcode*
over 0 <=
[ 2drop 0 ] [
nip length 0 swap
[ sequence-hashcode-step ] each-integer
] if ;

USING: classes.tuple kernel math.combinatorics ;

M: k-permutations hashcode* tuple-hashcode ;

USING: accessors kernel stack-checker.values ;

M: literal-tuple hashcode* nip value>> identity-hashcode ;

USING: accessors compiler.cfg.linear-scan.resolve kernel ;

M: location hashcode* reg>> hashcode* ;

USING: accessors kernel libc.private ;

M: malloc-ptr hashcode* value>> hashcode* ;

USING: accessors hash-sets.numbers.private kernel math.hashcodes
;

M: number-wrapper hashcode* nip underlying>> number-hashcode
; inline

USING: accessors hashtables.numbers.private kernel
math.hashcodes ;

M: number-wrapper hashcode* nip underlying>> number-hashcode
; inline

USING: kernel ;

M: object hashcode* 2drop 0 ; inline

USING: accessors kernel peg ;

M: parser hashcode* id>> hashcode* ;

USING: classes.tuple kernel math.combinatorics ;

M: permutations hashcode* tuple-hashcode ;

USING: assocs kernel persistent.hashtables ;

M: persistent-hash hashcode* nip assoc-size ;

USING: accessors alien kernel ;

M: pinned-alien hashcode*
nip dup expired>> [ drop 1234 ] [ alien-address ] if ;

USING: classes.tuple kernel math.ranges ;

M: range hashcode* tuple-hashcode ;

USING: kernel math ;

M: ratio hashcode* nip >fraction [ hashcode ] bi@ bitxor ;

USING: assocs kernel redis ;

M: redis hashcode* assoc-hashcode ;

USING: accessors compiler.cfg.value-numbering.expressions kernel
math ;

M: reference-expr hashcode*
nip value>> dup float?
[ double>bits ] [ identity-hashcode ] if ;

USING: accessors compiler.cfg.gvn.expressions kernel math ;

M: reference-expr hashcode*
nip value>> dup float?
[ double>bits ] [ identity-hashcode ] if ;

USING: combinators kernel sequences ;

M: reversed hashcode* [ sequence-hashcode ] recursive-hashcode ;

USING: accessors combinators hashtables.sequences.private kernel
sequences ;

M: sequence-wrapper hashcode*
underlying>> [ sequence-hashcode ] recursive-hashcode ;
inline

USING: accessors combinators hash-sets.sequences.private kernel
sequences ;

M: sequence-wrapper hashcode*
underlying>> [ sequence-hashcode ] recursive-hashcode ;
inline

USING: combinators kernel sequences ;

M: sequence hashcode* [ sequence-hashcode ] recursive-hashcode ;

USING: accessors kernel math.vectors.simd ;

M: simd-128 hashcode* underlying>> hashcode* ; inline

USING: combinators kernel sequences ;

M: slice hashcode* [ sequence-hashcode ] recursive-hashcode ;

USING: kernel strings strings.private ;

M: string hashcode*
nip dup string-hashcode
[ ] [ dup rehash-string string-hashcode ] ?if ;

USING: alien classes.struct kernel ;

M: struct hashcode*
nip dup >c-ptr [ struct-slot-values hashcode ] [ drop 0 ] if
; inline

USING: assocs kernel tokyo.abstractdb ;

M: tokyo-abstractdb hashcode* assoc-hashcode ;

USING: assocs kernel tokyo.remotedb ;

M: tokyo-remotedb hashcode* assoc-hashcode ;

USING: classes.tuple combinators kernel ;

M: tuple hashcode* [ tuple-hashcode ] recursive-hashcode ;

USING: kernel kernel.private math slots.private words ;

M: word hashcode* nip 1 slot { fixnum } declare ; inline
foldable flushable