package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type

This module implements the MD5 message-digest algorithm as described IETF RFC 1321. t is the result type and val digest_string : string -> t is the implementation of the algorithm itself.

This is currently a thin wrapper over the Digest module in INRIA's standard library.

module Stable : sig ... end
module As_binary_string : sig ... end

Both bin_io and sexp serializations produce a binary 16-character string.

type t = Stable.V1.t

Intended to represent a 16-byte string that is the output of MD5 algorithm.

Note that any 16-byte string can be converted to this type, so a value of type t is not an evidence of someone having found an input corresponding to this output.

include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
val t_sexp_grammar : t Sexplib0.Sexp_grammar.t
include Ppx_hash_lib.Hashable.S with type t := t
include Interfaces.Comparable with type t := t
include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix with type t := t
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
type comparator_witness
val validate_lbound : min:t Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Maybe_bound.t -> t Validate.check
val validate_bound : min:t Maybe_bound.t -> max:t Maybe_bound.t -> t Validate.check
module Map : Map.S with type Key.t = t with type Key.comparator_witness = comparator_witness
module Set : Set.S with type Elt.t = t with type Elt.comparator_witness = comparator_witness
include Interfaces.Binable with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
include Interfaces.Hashable with type t := t
include Ppx_compare_lib.Comparable.S with type t := t
val compare : t -> t -> int
include Ppx_hash_lib.Hashable.S with type t := t
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
val hashable : t Base.Hashable.t
module Table : Hashtbl.S with type key = t
module Hash_set : Hash_set.S with type elt = t
module Hash_queue : Hash_queue.S with type key = t
val digest_num_bytes : int

digest_num_bytes = 16 is the size of the digest in bytes.

val to_binary : t -> string

Binary representations are 16 bytes long, and not human readable.

val of_binary_exn : string -> t
val to_hex : t -> string

to_hex prints each byte of t as a big-endian sequence of 2 hex digits (e.g. byte 31 is written as "1f") and then concatenates them. For example,

Md5.to_hex (Md5.digest_string "a") =
Md5.to_hex (
  Md5.of_binary_exn
    "\x0c\xc1\x75\xb9\xc0\xf1\xb6\xa8\x31\xc3\x99\xe2\x69\x77\x26\x61") =
"0cc175b9c0f1b6a831c399e269772661"
val of_hex_exn : string -> t

The inverse of to_hex. This function ignores case. It will raise an exception if the string is not a 32-byte-long string of hex digits.

val digest_string : string -> t
val digest_bytes : bytes -> t
val digest_subbytes : bytes -> pos:int -> len:int -> t

digest_subbytes m ~pos ~len computes Md5 digest of the substring of m of length len starting at pos.

val digest_file_blocking : string -> t

digest_file_blocking filename reads the contents of file filename and computes its digest.

val digest_channel_blocking_without_releasing_runtime_lock : in_channel -> len:int -> t

Reads len bytes from the given channel and computes md5 digest of that.

WARNING: This function does digest computation with OCaml global lock held, so it can be slow and make the other threads starve. See digest_file_blocking.

val input_blocking : in_channel -> t

Reads an Md5 digest from the given channel (in a format written by output_blocking)

val output_blocking : t -> out_channel -> unit

Writes the Md5 digest to the given channel.

val string : string -> t
  • deprecated [since 2017-07] use [Md5.digest_string].
val bytes : bytes -> t
  • deprecated [since 2017-07] use [Md5.digest_bytes].
val subbytes : bytes -> int -> int -> t
  • deprecated [since 2017-07] use [Md5.digest_subbytes].
val from_hex : string -> t
  • deprecated [since 2017-07] use [of_hex_exn].
val file : string -> t
  • deprecated [since 2017-07] blocking functions should be avoided. Use [file_blocking] if you really want this.
val channel : in_channel -> int -> t
  • deprecated [since 2017-07] blocking functions should be avoided. Use [channel_blocking] if you really want this.
val output : out_channel -> t -> unit
  • deprecated [since 2017-07] Use [to_binary] together with [Out_channel.output_string]
val input : in_channel -> t
  • deprecated [since 2017-07] blocking functions should be avoided. Use [input_blocking] if you really want this.
val digest_bin_prot : 'a Bin_prot.Type_class.writer -> 'a -> t

digest_bin_prot w x digests the serialization of x by w. It is a cheap way (in dev time) to compute the digest of an ocaml value, for a fixed and deterministic serialization function. It is currently implemented inefficiently and allocates large strings.

For a more efficient and resource-aware version, use Bigbuffer.add_bin_prot and Bigbuffer_blocking.md5.

val digest_bigstring : Bigstring.t -> t
val digest_subbigstring : Bigstring.t -> pos:int -> len:int -> t
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct