conan

Identify type of your file (such as the MIME type)
Library conan
Module Conan . Fmt
type ('a, 'b) refl =
| Refl : ( 'a, 'a ) refl
type formatter = Format.formatter
module Hmap : sig ... end
val invalid_arg : ( 'a, Format.formatter, unit, 'b ) format4 -> 'c
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 : Format.formatter -> ( 'a, Format.formatter, unit ) format -> 'a
val strf : ( 'a, Format.formatter, unit, string ) 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. 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 -> Format.formatter -> char -> unit
val pp_int : conv:'a -> ?padding:[< `Left of int | `Right of int | `Zero of int ] -> ?precision:int -> Format.formatter -> int -> unit
val pp_int32 : conv:'a -> ?padding:[< `Left of int | `Right of int | `Zero of int ] -> ?precision:int -> Format.formatter -> int32 -> unit
val pp_int64 : conv:'a -> ?padding:[< `Left of int | `Right of int | `Zero of int ] -> ?precision:int -> Format.formatter -> int64 -> unit
val pp_float : ?padding:[< `Left of int | `Right of int | `Zero of int ] -> ?precision:int -> Format.formatter -> float -> unit
val pp_string : ?padding:[> `Left of int | `Right of int ] -> 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, '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