package conan

  1. Overview
  2. Docs
type ('a, 'b) refl =
  1. | Refl : ('a, 'a) refl
type formatter = Stdlib.Format.formatter
module Hmap : sig ... end
val invalid_arg : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'c
type 'a t = formatter -> 'a -> unit
type ('ty, 'v) padding =
  1. | Nop : ('v, 'v) padding
  2. | Lit : [ `Left | `Right | `Zero ] * int -> ('v, 'v) padding
  3. | Arg : [ `Left | `Right | `Zero ] -> (int -> 'v, 'v) padding
type ('ty, 'v) precision =
  1. | Nop : ('v, 'v) precision
  2. | Lit : int -> ('v, 'v) precision
  3. | Arg : (int -> 'v, 'v) precision
type _ conv =
  1. | Conv_c : char conv
  2. | Conv_d : int conv
  3. | Conv_x : int conv
  4. | Conv_Cx : int conv
  5. | Conv_X : int conv
  6. | Conv_CX : int conv
type ('ty, 'v) order =
  1. | Byte : char conv * ('u, 'v) padding * ('v, char -> 'w) precision -> ('u, 'w) order
  2. | Short : bool * int conv * ('u, 'v) padding * ('v, int -> 'w) precision -> ('u, 'w) order
  3. | Long : bool * int conv * ('u, 'v) padding * ('v, int32 -> 'w) precision -> ('u, 'w) order
  4. | Quad : bool * int conv * ('u, 'v) padding * ('v, int64 -> 'w) precision -> ('u, 'w) order
  5. | Float : ('u, 'v) padding * ('v, float -> 'w) precision -> ('u, 'w) order
  6. | String : ('u, string -> 'v) padding -> ('u, 'v) order
  7. | Const : 'a t * 'a -> ('v, 'v) order
  8. | Noop : ('v, 'v) order
  9. | Atom : ('u, 'v) padding * ('v, 'a -> 'w) precision * 'a Hmap.key -> ('u, 'w) order
  10. | Param : ('a t -> 'a -> 'v, 'v) order
  11. | Ignore : ('a -> 'v, 'v) order
and ('ty, 'v) fmt =
  1. | [] : ('v, 'v) fmt
  2. | :: : ('ty, 'v) order * ('v, 'r) fmt -> ('ty, 'r) fmt
type ('ty, 'v) ty = ('ty, 'v, 'ty, 'v) tyrel
and ('ty0, 'v0, 'ty1, 'v1) tyrel =
  1. | Char : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (char -> 'ty0, 'v0, char -> 'ty1, 'v1) tyrel
  2. | Int : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (int -> 'ty0, 'v0, int -> 'ty1, 'v1) tyrel
  3. | Int32 : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (int32 -> 'ty0, 'v0, int32 -> 'ty1, 'v1) tyrel
  4. | Int64 : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (int64 -> 'ty0, 'v0, int64 -> 'ty1, 'v1) tyrel
  5. | Float : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (float -> 'ty0, 'v0, float -> 'ty1, 'v1) tyrel
  6. | String : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (string -> 'ty0, 'v0, string -> 'ty1, 'v1) tyrel
  7. | Param : ('ty0, 'v0, 'ty1, 'v1) tyrel -> ('a t -> 'a -> 'ty0, 'v0, 'a t -> 'a -> 'ty1, 'v1) tyrel
  8. | Any : 'a Hmap.key * ('ty0, 'v0, 'ty1, 'v1) tyrel -> ('a -> 'ty0, 'v0, 'a -> 'ty1, 'v1) tyrel
  9. | Ignore : ('ty0, 'v0, 'ty1, 'v1) tyrel -> ('a -> 'ty0, 'v0, 'a -> 'ty1, 'v1) tyrel
  10. | End : ('v0, 'v0, 'v1, 'v1) tyrel
type ('v, 'r) tw =
  1. | T : ('u, 'v) fmt * ('v, 'w) ty -> ('u, 'w) tw
type ('v, 'r) pw =
  1. | P : ('u, 'v) padding * ('v, 'w) ty -> ('u, 'w) pw
type ('v, 'r) ppw =
  1. | V : ('a, 'b) padding * ('b, 'c) precision * ('c, 'd) ty -> ('a, 'd) ppw
type v =
  1. | Fmt : ('ty, 'v) fmt -> v
type w =
  1. | Ty : ('ty, 'v) ty -> w
val pf : Stdlib.Format.formatter -> ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a
val strf : ('a, Stdlib.Format.formatter, unit, string) Stdlib.format4 -> 'a
val padding_and_precision_to_padding : 'u 'v 'w. ('u, 'v) padding -> ('v, 'w) precision -> ('u, 'w) padding
val pp_ty : 'v 'r. Stdlib.Format.formatter -> ('v, 'r) ty -> unit
val ty_of_padding : 'v 'r. ('v, 'r) padding -> ('v, 'r) ty
val ty_of_precision : 'v 'r. ('v, 'r) precision -> ('v, 'r) ty
val concat_ty : 'u 'v 'w. ('u, 'v) ty -> ('v, 'w) ty -> ('u, 'w) ty
val (@) : ('a, 'b) ty -> ('b, 'c) ty -> ('a, 'c) ty
val ty_of_fmt : 'v 'r. ('v, 'r) fmt -> ('v, 'r) ty
exception Invalid_type
exception Invalid_key
val gen_padding : 'ty0 'v0 'ty1 'v1. ('ty0, 'v0) padding -> ('ty1, 'v1) ty -> ('ty1, 'v1) pw
val gen_padding_precision : 'u 'v 'w 'ty0 'v0. ('u, 'v) padding -> ('v, 'w) precision -> ('ty0, 'v0) ty -> ('ty0, 'v0) ppw
val gen : 'ty0 'v0 'ty1 'v1. ('ty0, 'v0) fmt -> ('ty1, 'v1) ty -> ('ty1, 'v1) tw
val concat : 'u 'v 'w. ('u, 'v) fmt -> ('v, 'w) fmt -> ('u, 'w) fmt
val (^^) : ('a, 'b) fmt -> ('b, 'c) fmt -> ('a, 'c) fmt
val pp_char : conv:'a -> ?padding:[> `Left of int | `Zero of 'b ] -> ?precision:'c -> Stdlib.Format.formatter -> char -> unit
val pp_int : unsigned:bool -> conv:'a -> ?padding:[< `Left of int | `Right of int | `Zero of int ] -> ?precision:int -> Stdlib.Format.formatter -> int -> unit
val pp_int32 : unsigned:bool -> conv:'a -> ?padding:[< `Left of int | `Right of int | `Zero of int ] -> ?precision:int -> Stdlib.Format.formatter -> int32 -> unit
val pp_int64 : unsigned:bool -> conv:'a -> ?padding:[< `Left of int | `Right of int | `Zero of int ] -> ?precision:int -> Stdlib.Format.formatter -> int64 -> unit
val pp_float : ?padding:[< `Left of int | `Right of int | `Zero of int ] -> ?precision:int -> Stdlib.Format.formatter -> float -> unit
val pp_string : ?padding:[> `Left of int | `Right of int ] -> Stdlib.Format.formatter -> string -> unit
type wpd =
  1. | Pd : ('v, 'r) padding -> wpd
type wpr =
  1. | Pr : ('v, 'r) precision -> wpr
val is_flag : char -> bool
val is_dash : char -> bool
val is_zero : char -> bool
val is_digit : char -> bool
val is_hash : char -> bool
type s
type 'r ebb =
  1. | Ebb : ('x, 'r) fmt -> 'r ebb
type ('x, 'r) pdebb =
  1. | PdEbb : (_, 'x -> 'a) padding * ('a, 'r) fmt -> ('x, 'r) pdebb
type ('x, 'r) prebb =
  1. | PrEbb : (_, 'x -> 'a) precision * ('a, 'r) fmt -> ('x, 'r) prebb
type ('x, 'r) pdprebb =
  1. | PdPrEbb : ('u, 'v) padding * ('v, 'w -> 'a) precision * ('a, 'r) fmt -> ('w, 'r) pdprebb
val make_prebb : 'a 'b. ('a, 'b) precision -> ('c, 'd) fmt -> ('e, 'f) prebb
val make_pdebb : 'a 'b. ('a, 'b) padding -> ('c, 'd) fmt -> ('e, 'f) pdebb
val make_pdprebb : 'a 'b 'c 'd. ('a, 'b) padding -> ('c, 'd) precision -> ('e, 'f) fmt -> ('g, 'h) pdprebb
val parse_precision : 'x 'v 'r. any:'x Hmap.key -> bool -> ('v, 'a) padding -> s -> 'r ebb
val parse_padding : 'x 'r. any:'x Hmap.key -> s -> 'r ebb
val parse_flag : 'x 'a 'b 'c 'd 'r. any:'x Hmap.key -> bool -> ('a, 'b) padding -> ('c, 'd) precision -> s -> 'r ebb
val go : 'x 'r. any:'x Hmap.key -> s -> 'r ebb
val parse : any:'a Hmap.key -> string -> 'b ebb
val coerce : 'v0 'r0 'v1 'r1. ('v0, 'r0) fmt -> ('v1, 'r1) ty -> ('v1, 'r1) fmt
val of_string : 'x 'v 'r. any:'x Hmap.key -> string -> ('v, 'r) ty -> ('v, 'r) fmt
val ty_of_string : 'x. any:'x Hmap.key -> string -> w
val noop : ('a, 'b) order
val ignore : ('a -> 'b, 'c) order
val const : 'a t -> 'b -> ('c, 'c) order
val ($) : 'a t -> 'a -> ('b, 'b) order
val padding : [< `Left | `Right | `Zero ] -> 'a -> [> `Left of 'a | `Right of 'a | `Zero of 'a ]
val keval_padding : 'ty 'v. formatter -> ('ty, 'v) padding -> (formatter -> [ `Left of int | `Right of int | `Zero of int ] option -> 'v) -> 'ty
val keval_precision : 'ty 'v. formatter -> ('ty, 'v) precision -> (formatter -> int option -> 'v) -> 'ty
val keval_order : 'ty 'v. Hmap.t -> formatter -> ('ty, 'v) order -> (formatter -> 'v) -> 'ty
val keval : 'ty 'v. Hmap.t -> formatter -> ('ty, 'v) fmt -> (formatter -> 'v) -> 'ty