package core

  1. Overview
  2. Docs
Industrial strength alternative to OCaml's standard library

Install 

dune-project
 Dependency

github.com Changelog MIT License Edit opam file Versions (13)

Authors

  1. J
    Jane Street Group, LLC

Maintainers

  1. J
    Jane Street developers

Sources

v0.17.1.tar.gz
md5=743a141234e04210e295980f7a78a6d9
sha512=61b415f4fb12c78d30649fff1aabe3a475eea926ce6edb7774031f4dc7f37ea51f5d9337ead6ec73cd93da5fd1ed0f2738c210c71ebc8fe9d7f6135a06bd176f

doc/core/Core/Md5/index.html

Module Core.Md5Source

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.

Sourcemodule Stable : sig ... end
Sourcemodule As_binary_string : sig ... end

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

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
Sourceval t_of_sexp : Sexplib0.Sexp.t -> t
Sourceval sexp_of_t : t -> Sexplib0.Sexp.t
Sourceval 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
Sourceval (>=) : t -> t -> bool
Sourceval (<=) : t -> t -> bool
Sourceval (=) : t -> t -> bool
Sourceval (>) : t -> t -> bool
Sourceval (<) : t -> t -> bool
Sourceval (<>) : t -> t -> bool
Sourceval equal : t -> t -> bool
Sourceval min : t -> t -> t
Sourceval max : t -> t -> t
Sourceval 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.

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

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

Sourceval 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).

Sourceval clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
Sourcetype comparator_witness
Sourceval validate_lbound : min:t Maybe_bound.t -> t Validate.check
Sourceval validate_ubound : max:t Maybe_bound.t -> t Validate.check
Sourceval validate_bound : min:t Maybe_bound.t -> max:t Maybe_bound.t -> t Validate.check
include Interfaces.Binable with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
Sourceval bin_size_t : t Bin_prot.Size.sizer
Sourceval bin_write_t : t Bin_prot.Write.writer
Sourceval bin_read_t : t Bin_prot.Read.reader
Sourceval __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.

Sourceval bin_shape_t : Bin_prot.Shape.t
include Interfaces.Hashable with type t := t
include Ppx_compare_lib.Comparable.S with type t := t
Sourceval compare : t -> t -> int
include Ppx_hash_lib.Hashable.S with type t := t
Sourceval hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
Sourceval hashable : t Base.Hashable.t
Sourcemodule Table : Hashtbl.S with type key = t
Sourcemodule Hash_set : Hash_set.S with type elt = t
Sourcemodule Hash_queue : Hash_queue.S with type key = t
Sourceval digest_num_bytes : int

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

Sourceval to_binary : t -> string

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

Sourceval of_binary_exn : string -> t
Sourceval 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"
Sourceval 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.

Sourceval digest_string : string -> t
Sourceval digest_bytes : bytes -> t
Sourceval 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.

Sourceval digest_file_blocking : string -> t

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

Sourceval 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.

Sourceval input_blocking : in_channel -> t

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

Sourceval output_blocking : t -> out_channel -> unit

Writes the Md5 digest to the given channel.

Sourceval string : string -> t
  • deprecated [since 2017-07] use [Md5.digest_string].
Sourceval bytes : bytes -> t
  • deprecated [since 2017-07] use [Md5.digest_bytes].
Sourceval subbytes : bytes -> int -> int -> t
  • deprecated [since 2017-07] use [Md5.digest_subbytes].
Sourceval from_hex : string -> t
  • deprecated [since 2017-07] use [of_hex_exn].
Sourceval file : string -> t
  • deprecated [since 2017-07] blocking functions should be avoided. Use [file_blocking] if you really want this.
Sourceval channel : in_channel -> int -> t
  • deprecated [since 2017-07] blocking functions should be avoided. Use [channel_blocking] if you really want this.
Sourceval output : out_channel -> t -> unit
  • deprecated [since 2017-07] Use [to_binary] together with [Out_channel.output_string]
Sourceval input : in_channel -> t
  • deprecated [since 2017-07] blocking functions should be avoided. Use [input_blocking] if you really want this.
Sourceval 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.

Sourceval digest_bigstring : Bigstring.t -> t
Sourceval 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