`Bytesrw_xxhash.Xxh3_64`

`XXH3-64`

hash.

`module State : sig ... end`

Hashing state.

`value state`

is the hash of `state`

. This has no effect on `state`

which can still be `State.update`

d.

`val slice : ?seed:seed -> Bytesrw.Bytes.Slice.t -> t`

`slice s`

is the hash of `s`

with seed `seed`

(if any).

`val reader : ?seed:seed -> Bytesrw.Bytes.Reader.t -> t`

`reader r`

hashes the stream of `r`

with seed `seed`

(if any). See also `reads`

.

```
val reads :
?state:State.t ->
Bytesrw.Bytes.Reader.t ->
Bytesrw.Bytes.Reader.t * State.t
```

`reads r`

is `hr, hstate`

with:

`hr`

a reader that taps the reads of`r`

to update`hstate`

.`hstate`

, a hash state of the reads made on`hr`

so far. This is`state`

if explicitely given, otherwise defaults to a fresh`State.make`

.

To get intermediate or final hash results use `value`

on `hstate`

.

```
val writes :
?state:State.t ->
Bytesrw.Bytes.Writer.t ->
Bytesrw.Bytes.Writer.t * State.t
```

`writes ?state w`

is `hw, hstate`

with:

`hw`

a writer that taps the writes to update`hstate`

before giving them to`w`

.`hstate`

, a hash state of the writes made on`wr`

so far. This is`state`

if explicitely given, otherwise defaults to a fresh`State.make`

.

To get intermediate or final hash results use `value`

on `hstate`

.

`val to_binary_string : t -> string`

`to_binary_string s`

is a big-endian binary representation of `s`

of length `length`

.

`val of_binary_string : string -> (t, string) Stdlib.result`

`of_binary_string s`

is a hash from the big-endian binary representation stored in `s`

.

`val to_hex : t -> string`

`to_hex t`

is the binary representation of `h`

using lowercase US-ASCII hex digits.

`val of_hex : string -> (t, string) Stdlib.result`

`to_hex t`

parses a sequence of hex digits into a hash.

`val pp : Stdlib.Format.formatter -> t -> unit`

`pp`

formats hashes for inspection.

`val to_uint64 : t -> int64`

`to_int64 h`

is `h`

as an unsigned `int64`

number.

`val of_uint64 : int64 -> t`

`of_uint64 u`

is `u`

as a hash.