The type of colorschemes.

colorscheme_of_array arr returns a colorscheme from an array of 256 elements. Otherwise, it returns an invalid argument.

lowercase c style sets lowercase ASCII values to the style style.

uppercase c style sets uppercase ASCII values to the style style.

digit c style sets digit ASCII values to the style style.

code c code style sets a specific ASCII code c to the style style.

The type of configurations.

xxd ?cols ?groupsize ?long ?uppercase colorscheme returns a configuration which can be used by generate then.

• cols: octets per line (default to 16)
• groupsize: Separate the output of every groupsize bytes by a whitespace (default to 2).
• long: stop after reading len octets.
• uppercase: use upper case hex letters (default is lower case).
• colorscheme: colorscheme used if the given Format.formatter supports it.

caml ?with_comments ?cols ?long ?uppercase k returns a configuration which can be used by generate then. It allows to produces a caml value from something.

• cols: octets per line (default to 16)
• with_comments: add a comment which pretty-line the group in a comment
• long: stop after reading len octets.
• k: if the user wants to produce a list of strings or an array of strings.

A default XXD configuration.

generate cfg scheduler input output ic oc seek pos ppf is the most abstract way to produce an hex-dump output. According to arguments, we are able to read into ic and write into oc with respectively input and output.

seek is used to manipulate the position in ic according to the given position pos.

ppf is used to know if we support colors or not. generate writes on it too and it takes care about pretty-printing boxes.

scheduler depends on which scheduler you use. You need to create one over monads:

  module Unix_scheduler = Hxd.Make(struct type 'a t = 'a end)

  let unix_scheduler =
    let open Unix_scheduler in
    { Hxd.bind= (fun x f -> f (prj x))
    ; return= inj }

  generate cfg unix_scheduler ...

You can abstract LWT monads too:

  module Lwt_scheduler = Hxd.Make (struct type 'a t = 'a Lwt.t end)

  let lwt_scheduler =
    let open Lwt.Infix in
    let open Lwt_scheduler in
    {
      Hxd.bind= (fun f x -> inj (prj x >>= fun x -> prj (f x)))
    ; return= (fun x -> inj (Lwt.return x))
    }
      generate cfg lwt_scheduler

Such layers exist with hxd.unix and hxd.lwt.