hashcode* ( depth obj -- code )
Factor handbook » The language » Collections » Hashtables » Hashtable keys

Prev:	hashcode ( obj -- code )
Next:	identity-hashcode ( obj -- code )

Vocabulary
kernel

Inputs

depth	an integer
obj	an object

Outputs

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

Methods

USING: arrays kernel math sequences ;

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


USING: kernel math math.private ;

M: bignum hashcode* nip bignum>fixnum ;


USING: byte-arrays kernel math sequences ;

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


USING: grouping kernel math 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: hash-sets kernel math sets ;

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


USING: assocs hashtables kernel math ;

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 ;

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


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 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.gvn.expressions kernel math ;

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


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

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


USING: kernel math sequences ;

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


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

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


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

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


USING: kernel math sequences ;

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


USING: accessors kernel math.vectors.simd ;

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


USING: kernel math sequences ;

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


USING: kernel strings strings.private ;

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


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 kernel math ;

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