Module Base.Hash

module type S = Base__.Hash_intf.S
module F : functor (Hash : S) -> Full with type hash_value = Hash.hash_value and type state = Hash.state and type seed = Hash.seed
include Full with type Full.state = private int and type Full.seed = int and type Full.hash_value = int
val description : string

Name of the hash-function, e.g., "internalhash", "siphash"

type state = private int
val fold_int : state -> int -> state

fold_<T> state v incorporates a value v of type <T> into the hash-state, returning a modified hash-state. Implementations of the fold_<T> functions may mutate the state argument in place, and return a reference to it. Implementations of the fold_<T> functions should not allocate.

val fold_int64 : state -> int64 -> state
val fold_float : state -> float -> state
val fold_string : state -> string -> state
type seed = int
val alloc : unit -> state

alloc () returns a fresh uninitialized hash-state. May allocate.

val reset : ?⁠seed:seed -> state -> state

reset ?seed state initializes/resets a hash-state with the given seed, or else a default-seed. Argument state may be mutated. Should not allocate.

type hash_value = int
val get_hash_value : state -> hash_value

get_hash_value extracts a hash-value from the hash-state.

module For_tests : sig ... end
type 'a folder = state -> 'a -> state
val create : ?⁠seed:seed -> unit -> state

create ?seed () is a convenience. Equivalent to reset ?seed (alloc ()).

val of_fold : (state -> 'a -> state) -> 'a -> hash_value

of_fold fold constructs a standard hash function from an existing fold function.

module Builtin : sig ... end
val run : ?⁠seed:seed -> 'a folder -> 'a -> hash_value

run ?seed folder x runs folder on x in a newly allocated hash-state, initialized using optional seed or a default-seed.

The following identity exists: run [%hash_fold: T] == [%hash: T]

run can be used if we wish to run a hash-folder with a non-default seed.