conan 0.0.2 · OCaml Package

type ('a, 'b) refl =

| Refl : ('a, 'a) refl

type formatter = Stdlib.Format.formatter

module Hmap : sig ... end

val invalid_arg : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a

type 'a t = formatter -> 'a -> unit

type ('ty, 'v) padding =

| Nop : ('v, 'v) padding
| Lit : [ `Left | `Right | `Zero ] * int -> ('v, 'v) padding
| Arg : [ `Left | `Right | `Zero ] -> (int -> 'v, 'v) padding

type ('ty, 'v) precision =

| Nop : ('v, 'v) precision
| Lit : int -> ('v, 'v) precision
| Arg : (int -> 'v, 'v) precision

type _ conv =

| Conv_c : char conv
| Conv_d : int conv
| Conv_x : int conv
| Conv_Cx : int conv
| Conv_X : int conv
| Conv_CX : int conv

type ('ty, 'v) order =

| Byte : char conv * ('u, 'v) padding * ('v, char -> 'w) precision -> ('u, 'w) order
| Short : int conv * ('u, 'v) padding * ('v, int -> 'w) precision -> ('u, 'w) order
| Long : int conv * ('u, 'v) padding * ('v, int32 -> 'w) precision -> ('u, 'w) order
| Quad : int conv * ('u, 'v) padding * ('v, int64 -> 'w) precision -> ('u, 'w) order
| Float : ('u, 'v) padding * ('v, float -> 'w) precision -> ('u, 'w) order
| String : ('u, string -> 'v) padding -> ('u, 'v) order
| Const : 'a t * 'a -> ('v, 'v) order
| Noop : ('v, 'v) order
| Atom : ('u, 'v) padding * ('v, 'a -> 'w) precision * 'a Hmap.key -> ('u, 'w) order
| Param : ('a t -> 'a -> 'v, 'v) order
| Ignore : ('a -> 'v, 'v) order

and ('ty, 'v) fmt =

| [] : ('v, 'v) fmt
| :: : ('ty, 'v) order * ('v, 'r) fmt -> ('ty, 'r) fmt

type ('ty, 'v) ty = ('ty, 'v, 'ty, 'v) tyrel

and ('ty0, 'v0, 'ty1, 'v1) tyrel =

| Char : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (char -> 'ty0, 'v0, char -> 'ty1, 'v1) tyrel
| Int : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (int -> 'ty0, 'v0, int -> 'ty1, 'v1) tyrel
| Int32 : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (int32 -> 'ty0, 'v0, int32 -> 'ty1, 'v1) tyrel
| Int64 : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (int64 -> 'ty0, 'v0, int64 -> 'ty1, 'v1) tyrel
| Float : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (float -> 'ty0, 'v0, float -> 'ty1, 'v1) tyrel
| String : ('ty0, 'v0, 'ty1, 'v1) tyrel -> (string -> 'ty0, 'v0, string -> 'ty1, 'v1) tyrel
| Param : ('ty0, 'v0, 'ty1, 'v1) tyrel -> ('a t -> 'a -> 'ty0, 'v0, 'a t -> 'a -> 'ty1, 'v1) tyrel
| Any : 'a Hmap.key * ('ty0, 'v0, 'ty1, 'v1) tyrel -> ('a -> 'ty0, 'v0, 'a -> 'ty1, 'v1) tyrel
| Ignore : ('ty0, 'v0, 'ty1, 'v1) tyrel -> ('a -> 'ty0, 'v0, 'a -> 'ty1, 'v1) tyrel
| End : ('v0, 'v0, 'v1, 'v1) tyrel

type ('v, 'r) tw =

| T : ('u, 'v) fmt * ('v, 'w) ty -> ('u, 'w) tw

type ('v, 'r) pw =

| P : ('u, 'v) padding * ('v, 'w) ty -> ('u, 'w) pw

type ('v, 'r) ppw =

| V : ('a, 'b) padding * ('b, 'c) precision * ('c, 'd) ty -> ('a, 'd) ppw

type v =

| Fmt : ('ty, 'v) fmt -> v

type w =

| 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 : 
  conv:'a ->
  ?padding:[< `Left of int | `Right of int | `Zero of int ] ->
  ?precision:int ->
  Stdlib.Format.formatter ->
  int ->
  unit

val pp_int32 : 
  conv:'a ->
  ?padding:[< `Left of int | `Right of int | `Zero of int ] ->
  ?precision:int ->
  Stdlib.Format.formatter ->
  int32 ->
  unit

val pp_int64 : 
  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 =

| Pd : ('v, 'r) padding -> wpd

type wpr =

| 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 =

| Ebb : ('x, 'r) fmt -> 'r ebb

type ('x, 'r) pdebb =

| PdEbb : (_, 'x -> 'a) padding * ('a, 'r) fmt -> ('x, 'r) pdebb

type ('x, 'r) prebb =

| PrEbb : (_, 'x -> 'a) precision * ('a, 'r) fmt -> ('x, 'r) prebb

type ('x, 'r) pdprebb =

| 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, 'd) prebb

val make_pdebb : 'a 'b. ('a, 'b) padding -> ('c, 'd) fmt -> ('e, 'd) pdebb

val make_pdprebb : 
  'a 'b 'c 'd. ('a, 'b) padding ->
  ('c, 'd) precision ->
  ('e, 'f) fmt ->
  ('g, 'f) 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, 'a) order

val ignore : ('a -> 'b, 'b) order

val const : 'a t -> 'a -> ('b, 'b) 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

package conan