Module B0_std.Conv.Txt

module Txt: sig .. end

Textual codecs


Textual encoders and decoders

type 'a enc = Stdlib.Format.formatter -> 'a -> unit 

The type for textual encoders. enc ppf v textually encodes the value v on ppf. Raises B0_std.Conv.Error in case of error.

type 'a dec = string -> start:int -> int * 'a 

The type for textual decoders. dec s ~start textually decodes a value at start in s. start is either the first textual input bytes to consider (which may be whitespace or a commenet) or the length of s. The function returns (i, v) with v the decoded value and i the first index after the decoded value or the lenght of s if there is no such index. Raises B0_std.Conv.Error in case of error.

XXX. In the end this signature is showing its limits for error reporting. Maybe we should have an abstraction here.

Encoding

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

enc_err ~kind fmt raises a textual encoding error message for kind kind formatted according to fmt.

val enc_atom : string enc

enc_atom ppf s encodes s as an atom on ppf quoting it as needed.

val enc_list : 'a enc -> 'a list enc

enc_list enc_v encodes a list of values encoded with enc_v.

Decoding

type lexeme = [ `Atom of string | `Le | `Ls ] 

The type for s-expressions lexemes.

val dec_err : kind:string ->
int -> ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a

dec_err ~kind i fmt raises a textual decoding error message for kind kind at input byte index i formatted according to fmt.

val dec_err_eoi : kind:string -> int -> 'a

dec_err_eoi ~kind i raises a textual error message for kind kind at input byte index i indicating an unexpected end of input.

val dec_err_lexeme : kind:string ->
int -> lexeme -> exp:lexeme list -> 'a

dec_err_case ~kind i raises a textual error message for kind kind at input byte index i indicating one of exp was expected.

val dec_err_atom : kind:string -> int -> string -> exp:string list -> 'a

dec_err_atom ~kind i a exp raises a textual error message for kind kind at input byte index i and atom a indicating one of exp atoms was expected.

val dec_skip : kind:string -> string -> start:int -> int

dec_skip ~kind s ~start starting at start (which can be out of bounds) is the first non-white, non-comment, byte index or the length of s if there is no such index.

val dec_lexeme : kind:string -> (int * lexeme) dec

dec_case ~kind s ~start starting at start (which can be out of bounds), skips whitespace and comment, looks for either a left parenthesis, right parenthesis or an atom and returns the index of their first position. Errors if end of input is is found.

val dec_ls : kind:string -> string -> start:int -> int

dec_ls ~kind s ~start starting at start (which can be out of bounds), skips whitespace and comments, parses a list start and returns the index after it or the length of s.

val dec_le : kind:string -> string -> start:int -> int

dec_le ~kind s ~start starting at start (which can be out of bounds), skips whitespace and comments, parses a list end and returns the index after it or the length of s.

val dec_atom : kind:string -> string dec

dec_atom ~kind s ~start starting at start (which can be out of bounds), skips whitespace and comments, parses an atom and returns the index after it or the length of s.

val dec_list : 'a dec -> kind:string -> 'a list dec

dec_list dec_v ~kind decodes a list of values decoded with dec_v for the given kind.

val dec_list_tail : 'a dec ->
kind:string -> ls:int -> 'a list dec

dec_list_tail dec_v ~kind ~lstart decodes list elements decoded with dec_v and an the end of list for the given kind, ls is the position of the list start.