Serialkit_sexp.Sexp
S-expression definitions and codec.
type loc = Serialkit_text.Tloc.t
The type for source text locations.
val loc_nil : Serialkit_text.Tloc.t
loc_nil
is a source text location for non-parsed s-expressions.
val a_meta_nil : a_meta
a_meta_nil
is parse information for non-parsed atoms.
val l_meta_nil : l_meta
l_meta_nil
is parse information for non-parsed lists.
The type for generic s-expression representations. Either an atom or a list.
val atom : string -> t
atom a
is `A (a, a_meta_nil)
.
val to_atom : t -> (string, string) Stdlib.result
to_atom s
extracts an atom from s
. If s
is a list an error with the location formatted according to Tloc
.pp is returned.
val get_atom : t -> string
get_atom s
is like to_atom
but raises Invalid_argument
if s
is not an atom.
to_list s
extracts a list from s
. If s
is an atom an error with the location formatted according to Tloc
.pp is returned.
get_atom s
is like to_list
but raises Invalid_argument
if s
is not an list.
to_splice s
is the either the list of s
if s
is or or [s]
if s
is an atom.
pp_seq
formats an s-expression but if it is a list the outer list separators are not formatted in the output.
Warning. Assumes all OCaml strings in the formatted value are UTF-8 encoded.
val pp_error_kind : unit -> error_kind fmt
pp_error_kind ()
formats an error kind.
type error = error_kind * loc
The type for decoding errors.
val pp_error :
?pp_loc:loc fmt ->
?pp_error_kind:error_kind fmt ->
?pp_prefix:unit fmt ->
unit ->
error fmt
pp_error ~pp_loc ~pp_error_kind ~pp_prefix ()
formats errors using pp_loc
(defaults to pp_loc
), pp_error_kind
(defaults to pp_error_kind
) and pp_prefix
(defaults formats "Error: "
).
val error_to_string :
?pp_error:error fmt ->
('a, error) Stdlib.result ->
('a, string) Stdlib.result
error_to_string r
converts an error to a string using pp_error
(defaults to pp_error
).
val seq_of_string :
?file:Serialkit_text.Tloc.fpath ->
string ->
(t, error) Stdlib.result
seq_of_string ?file s
parses a sequence of s-expressions from s
. file
is the file for locations, defaults to "-"
. The sequence is returned as a fake s-expression list that spans from the start of the first s-expression in s
to the end of the last one; note that this list does not exist syntactically in s
.
If there are no s-expression in s
the list is empty its location has both start and end positions at byte 0
(which may not exist).
Note. All OCaml strings returned by this function are UTF-8 encoded.
val seq_of_string' :
?pp_error:error fmt ->
?file:Serialkit_text.Tloc.fpath ->
string ->
(t, string) Stdlib.result
seq_of_string'
s seq_of_string
composed with error_to_string
.
val seq_to_string : t -> string
seq_to_string s
encodes s
to a sequence of s-expressions. If s
is an s-expression list this wrapping list is not syntactically represented in the output (see also seq_of_string
), use to_string (list [l])
if you want to output l
as a list.
Warning. Assumes all OCaml strings in s
are UTF-8 encoded.
The type for s-expression indexing operations.
Nth n
, lookup zero-based element n
in a list. If n
is negative, counts the number of elements from the end of the list, i.e. -1
is the last list element.Key k
, lookup binding k
in an s-expression dictionary.val pp_key : string fmt
pp_key
formats a key, this is Format
.pp_print_string.
pp_index
formats indices. Keys are unbracketed and formatted with pp_key
, defaults to pp_key
.
type path = index list
The type for paths, a sequence of indexing operations in reverse order.
val path_of_string : string -> (path, string) Stdlib.result
path_of_string
parses a path from s
according to the syntax given here.
pp_path ?pp_key ()
is a formatter for paths using pp_key
to format keys (defaults to pp_key
).
The type for carets. A caret location and the path at which it applies.
val caret_of_string : string -> (caret, string) Stdlib.result
caret_of_string s
parses a caret from s
according to the syntax given here.