conan 0.0.6 · OCaml Package

Sourcetype ('a, 'b) refl =

| Refl : ('a, 'a) refl

Sourcetype formatter = Format.formatter

Sourcemodule Hmap : sig ... end

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

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

Sourcetype ('ty, 'v) padding =

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

Sourcetype ('ty, 'v) precision =

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

Sourcetype _ 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

Sourcetype ('ty, 'v) order =

| Byte : char conv * ('u, 'v) padding * ('v, char -> 'w) precision -> ('u, 'w) order
| Short : bool * int conv * ('u, 'v) padding * ('v, int -> 'w) precision -> ('u, 'w) order
| Long : bool * int conv * ('u, 'v) padding * ('v, int32 -> 'w) precision -> ('u, 'w) order
| Quad : bool * 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

Sourceand ('ty, 'v) fmt =

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

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

Sourceand ('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

Sourcetype ('v, 'r) tw =

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

Sourcetype ('v, 'r) pw =

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

Sourcetype ('v, 'r) ppw =

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

Sourcetype v =

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

Sourcetype w =

| Ty : ('ty, 'v) ty -> w

Sourceval pf : Format.formatter -> ('a, Format.formatter, unit) format -> 'a

Sourceval strf : ('a, Format.formatter, unit, string) format4 -> 'a

Source

val padding_and_precision_to_padding : 
  'u 'v 'w. ('u, 'v) padding ->
  ('v, 'w) precision ->
  ('u, 'w) padding

Sourceval pp_ty : 'v 'r. Format.formatter -> ('v, 'r) ty -> unit

Sourceval ty_of_padding : 'v 'r. ('v, 'r) padding -> ('v, 'r) ty

Sourceval ty_of_precision : 'v 'r. ('v, 'r) precision -> ('v, 'r) ty

Sourceval concat_ty : 'u 'v 'w. ('u, 'v) ty -> ('v, 'w) ty -> ('u, 'w) ty

Sourceval (@) : ('a, 'b) ty -> ('b, 'c) ty -> ('a, 'c) ty

Sourceval ty_of_fmt : 'v 'r. ('v, 'r) fmt -> ('v, 'r) ty

Sourceexception Invalid_type

Sourceexception Invalid_key

Source

val gen_padding : 
  'ty0 'v0 'ty1 'v1. ('ty0, 'v0) padding ->
  ('ty1, 'v1) ty ->
  ('ty1, 'v1) pw

Source

val gen_padding_precision : 
  'u 'v 'w 'ty0 'v0. ('u, 'v) padding ->
  ('v, 'w) precision ->
  ('ty0, 'v0) ty ->
  ('ty0, 'v0) ppw

Source

val gen : 
  'ty0 'v0 'ty1 'v1. ('ty0, 'v0) fmt ->
  ('ty1, 'v1) ty ->
  ('ty1, 'v1) tw

Sourceval concat : 'u 'v 'w. ('u, 'v) fmt -> ('v, 'w) fmt -> ('u, 'w) fmt

Sourceval (^^) : ('a, 'b) fmt -> ('b, 'c) fmt -> ('a, 'c) fmt

Source

val pp_char : 
  conv:'a ->
  ?padding:[> `Left of int | `Zero of 'b ] ->
  ?precision:'c ->
  Format.formatter ->
  char ->
  unit

Source

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

Source

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

Source

val pp_int64 : 
  unsigned:bool ->
  conv:'a ->
  ?padding:[< `Left of int | `Right of int | `Zero of int ] ->
  ?precision:int ->
  Format.formatter ->
  int64 ->
  unit

Source

val pp_float : 
  ?padding:[< `Left of int | `Right of int | `Zero of int ] ->
  ?precision:int ->
  Format.formatter ->
  float ->
  unit

Source

val pp_string : 
  ?padding:[> `Left of int | `Right of int ] ->
  Format.formatter ->
  string ->
  unit

Sourcetype wpd =

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

Sourcetype wpr =

| Pr : ('v, 'r) precision -> wpr

Sourceval is_flag : char -> bool

Sourceval is_dash : char -> bool

Sourceval is_zero : char -> bool

Sourceval is_digit : char -> bool

Sourceval is_hash : char -> bool

Sourcetype s

Sourcetype 'r ebb =

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

Sourcetype ('x, 'r) pdebb =

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

Sourcetype ('x, 'r) prebb =

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

Sourcetype ('x, 'r) pdprebb =

| PdPrEbb : ('u, 'v) padding * ('v, 'w -> 'a) precision * ('a, 'r) fmt -> ('w, 'r) pdprebb

Sourceval make_prebb : 'a 'b. ('a, 'b) precision -> ('c, 'd) fmt -> ('e, 'd) prebb

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

Source

val make_pdprebb : 
  'a 'b 'c 'd. ('a, 'b) padding ->
  ('c, 'd) precision ->
  ('e, 'f) fmt ->
  ('g, 'f) pdprebb

Source

val parse_precision : 
  'x 'v 'r. any:'x Hmap.key ->
  bool ->
  ('v, 'a) padding ->
  s ->
  'r ebb

Sourceval parse_padding : 'x 'r. any:'x Hmap.key -> s -> 'r ebb

Source

val parse_flag : 
  'x 'a 'b 'c 'd 'r. any:'x Hmap.key ->
  bool ->
  ('a, 'b) padding ->
  ('c, 'd) precision ->
  s ->
  'r ebb

Sourceval go : 'x 'r. any:'x Hmap.key -> s -> 'r ebb

Sourceval parse : any:'a Hmap.key -> string -> 'b ebb

Sourceval coerce : 'v0 'r0 'v1 'r1. ('v0, 'r0) fmt -> ('v1, 'r1) ty -> ('v1, 'r1) fmt

Source

val of_string : 
  'x 'v 'r. any:'x Hmap.key ->
  string ->
  ('v, 'r) ty ->
  ('v, 'r) fmt

Sourceval ty_of_string : 'x. any:'x Hmap.key -> string -> w

Sourceval noop : ('a, 'a) order

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

Sourceval const : 'a t -> 'a -> ('b, 'b) order

Sourceval ($) : 'a t -> 'a -> ('b, 'b) order

Source

val padding : 
  [< `Left | `Right | `Zero ] ->
  'a ->
  [> `Left of 'a | `Right of 'a | `Zero of 'a ]

Source

val keval_padding : 
  'ty 'v. formatter ->
  ('ty, 'v) padding ->
  (formatter -> [ `Left of int | `Right of int | `Zero of int ] option -> 'v) ->
  'ty

Source

val keval_precision : 
  'ty 'v. formatter ->
  ('ty, 'v) precision ->
  (formatter -> int option -> 'v) ->
  'ty

Source

val keval_order : 
  'ty 'v. Hmap.t ->
  formatter ->
  ('ty, 'v) order ->
  (formatter -> 'v) ->
  'ty

Source

val keval : 
  'ty 'v. Hmap.t ->
  formatter ->
  ('ty, 'v) fmt ->
  (formatter -> 'v) ->
  'ty

package conan

Module Conan.FmtSource

Module `Conan.Fmt`Source