digestif 1.0.1 · OCaml Package

type bigstring =
  (char, Bigarray_compat.int8_unsigned_elt, Bigarray_compat.c_layout)
    Bigarray_compat.Array1.t

type 'a iter = ('a -> unit) -> unit

A general (inner) iterator. It applies the provided function to a collection of elements. For instance:

let iter_k : 'a -> 'a iter = fun x f -> f x
let iter_pair : 'a * 'a -> 'a iter = fun (x, y) -> f x; f y
let iter_list : 'a list -> 'a iter = fun l f -> List.iter f l

type 'a compare = 'a -> 'a -> int

type 'a equal = 'a -> 'a -> bool

type 'a pp = Format.formatter -> 'a -> unit

module type S = sig ... end

module type MAC = sig ... end

Some hash algorithms expose extra MAC constructs. The interface is similar to the hmac_* functions in S.

module MD5 : S

module SHA1 : S

module SHA224 : S

module SHA256 : S

module SHA384 : S

module SHA512 : S

module SHA3_224 : S

module SHA3_256 : S

module SHA3_384 : S

module SHA3_512 : S

module WHIRLPOOL : S

module BLAKE2B : sig ... end

module BLAKE2S : sig ... end

module RMD160 : S

module Make_BLAKE2B (D : sig ... end) : S

module Make_BLAKE2S (D : sig ... end) : S

type 'k hash =

| MD5 : MD5.t hash
| SHA1 : SHA1.t hash
| RMD160 : RMD160.t hash
| SHA224 : SHA224.t hash
| SHA256 : SHA256.t hash
| SHA384 : SHA384.t hash
| SHA512 : SHA512.t hash
| SHA3_224 : SHA3_224.t hash
| SHA3_256 : SHA3_256.t hash
| SHA3_384 : SHA3_384.t hash
| SHA3_512 : SHA3_512.t hash
| WHIRLPOOL : WHIRLPOOL.t hash
| BLAKE2B : BLAKE2B.t hash
| BLAKE2S : BLAKE2S.t hash

val md5 : MD5.t hash

val sha1 : SHA1.t hash

val rmd160 : RMD160.t hash

val sha224 : SHA224.t hash

val sha256 : SHA256.t hash

val sha384 : SHA384.t hash

val sha512 : SHA512.t hash

val sha3_224 : SHA3_224.t hash

val sha3_256 : SHA3_256.t hash

val sha3_384 : SHA3_384.t hash

val sha3_512 : SHA3_512.t hash

val whirlpool : WHIRLPOOL.t hash

val blake2b : BLAKE2B.t hash

val blake2s : BLAKE2S.t hash

type 'kind t

val module_of : 'k hash -> (module S with type t = 'k)

val digest_bytes : 'k hash -> Bytes.t -> 'k t

val digest_string : 'k hash -> String.t -> 'k t

val digest_bigstring : 'k hash -> bigstring -> 'k t

val digesti_bytes : 'k hash -> Bytes.t iter -> 'k t

val digesti_string : 'k hash -> String.t iter -> 'k t

val digesti_bigstring : 'k hash -> bigstring iter -> 'k t

val hmaci_bytes : 'k hash -> key:string -> Bytes.t iter -> 'k t

val hmaci_string : 'k hash -> key:string -> String.t iter -> 'k t

val hmaci_bigstring : 'k hash -> key:string -> bigstring iter -> 'k t

val pp : 'k hash -> 'k t pp

val equal : 'k hash -> 'k t equal

val unsafe_compare : 'k hash -> 'k t compare

val to_hex : 'k hash -> 'k t -> string

val of_hex : 'k hash -> string -> 'k t

val of_hex_opt : 'k hash -> string -> 'k t option

val consistent_of_hex : 'k hash -> string -> 'k t

val consistent_of_hex_opt : 'k hash -> string -> 'k t option

val of_raw_string : 'k hash -> string -> 'k t

val of_raw_string_opt : 'k hash -> string -> 'k t option

val to_raw_string : 'k hash -> 'k t -> string

val of_digest : (module S with type t = 'hash) -> 'hash -> 'hash t

val of_md5 : MD5.t -> MD5.t t

val of_sha1 : SHA1.t -> SHA1.t t

val of_rmd160 : RMD160.t -> RMD160.t t

val of_sha224 : SHA224.t -> SHA224.t t

val of_sha256 : SHA256.t -> SHA256.t t

val of_sha384 : SHA384.t -> SHA384.t t

val of_sha512 : SHA512.t -> SHA512.t t

val of_sha3_224 : SHA3_224.t -> SHA3_224.t t

val of_sha3_256 : SHA3_256.t -> SHA3_256.t t

val of_sha3_384 : SHA3_384.t -> SHA3_384.t t

val of_sha3_512 : SHA3_512.t -> SHA3_512.t t

val of_whirlpool : WHIRLPOOL.t -> WHIRLPOOL.t t

val of_blake2b : BLAKE2B.t -> BLAKE2B.t t

val of_blake2s : BLAKE2S.t -> BLAKE2S.t t

package digestif