Core.Sexp
SourceCode for managing s-expressions.
include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
This function only needs implementation if t
exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t
afterwards.
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_compare_lib.Equal.S with type t := t
include Sexplib0.Sexpable.S with type t := t
include Comparable.S with type t := t
include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
ascending
is identical to compare
. descending x y = ascending y x
. These are intended to be mnemonic when used like List.sort ~compare:ascending
and List.sort ~cmp:descending
, since they cause the list to be sorted in ascending or descending order, respectively.
clamp_exn t ~min ~max
returns t'
, the closest value to t
such that between t' ~low:min ~high:max
is true.
Raises if not (min <= max)
.
include Base.Stringable.S with type t := t
include module type of struct include Sexplib.Sexp end with type t := t
include Sexplib.Sexp_intf.S with type t := t
Type of bigstrings
scan_sexp ?buf lexbuf
scans an S-expression from lex buffer lexbuf
using the optional string buffer buf
for storing intermediate strings.
scan_sexps ?buf lexbuf
reads a list of S-expressions from lex buffer lexbuf
using the optional string buffer buf
for storing intermediate strings.
scan_rev_sexps ?buf lexbuf
same as scan_sexps
, but returns the reversed list and is slightly more efficient.
scan_sexp_opt ?buf lexbuf
is equivalent to scan_sexp ?buf lexbuf
except that it returns None
when the eof is reached.
scan_iter_sexps ?buf ~f lexbuf
iterates over all S-expressions scanned from lex buffer lexbuf
using function f
, and the optional string buffer buf
for storing intermediate strings.
scan_fold_sexps ?buf ~f ~init lexbuf
folds over all S-expressions scanned from lex buffer lexbuf
using function f
, initial state init
, and the optional string buffer buf
for storing intermediate strings.
scan_sexps_conv ?buf ~f lexbuf
maps all S-expressions scanned from lex buffer lexbuf
to some list using function f
, and the optional string buffer buf
for storing intermediate strings.
type ('a, 't) parse_result = ('a, 't) Sexplib.Pre_sexp.parse_result =
| Done of 't * Parse_pos.t
Done (t, parse_pos)
finished parsing an S-expression. Current parse position is parse_pos
.
| Cont of Cont_state.t * ('a, 't) parse_fun
Cont (cont_state, parse_fun)
met the end of input before completely parsing an S-expression. The user has to call parse_fun
to continue parsing the S-expression in another buffer. cont_state
is the current parsing state of the continuation. NOTE: the continuation may only be called once and will raise Failure
otherwise!
Type of result from calling Sexp.parse
.
Type of parsing functions with given offsets and lengths.
Module for parsing S-expressions annotated with location information
type 't parse_state = private 't Sexplib.Pre_sexp.parse_state = {
parse_pos : Parse_pos.t;
Current parse position
*)}
Type of state maintained during parsing
type parse_error = Sexplib.Pre_sexp.parse_error = {
err_msg : string;
Reason why parsing failed
*)parse_state : [ `Sexp of t list list parse_state
| `Annot of Annotated.stack parse_state ];
State of parser
*)}
Type of parse errors
Exception raised during partial parsing
parse ?parse_pos ?len str
(partially) parses an S-expression in string buffer str
starting out with position information provided in parse_pos
and reading at most len
characters. To parse a single atom that is not delimited by whitespace it is necessary to call this function a second time with the returned continuation, and a dummy buffer that contains whitespace.
parse
starts parsing str
at position parse_pos.buf_pos
. Each subsequent parse_fun
from a Cont
uses the buf
and pos
that is supplied to it. The final parse_fun
that returns Done
mutates the buf_pos
in the originally supplied parse_pos
, and then returns it.
val parse_bigstring :
?parse_pos:Parse_pos.t ->
?len:int ->
bigstring ->
(bigstring, t) parse_result
parse_bigstring ?parse_pos ?len str
same as parse
, but operates on bigstrings.
input_sexp ?parse_pos ic
parses an S-expression from input channel ic
using initial position information in parse_pos
. NOTE: this function is not as fast on files as Sexp.load_sexp
, and is also slightly slower than the scan-functions. But it is guaranteed that input_sexp
is only going to read data parseable as an S-expression. Thus, subsequent input functions will see the data immediately following it.
input_sexps ?parse_pos ?buf ic
parses S-expressions from input channel ic
until EOF is reached. Faster than the scan-functions.
input_rev_sexps ?parse_pos ?buf ic
same as Sexp.input_sexps
, but returns a reversed list of S-expressions, which is slightly more efficient.
load_sexp ?strict ?buf file
reads one S-expression from file
using buffer buf
for storing intermediate data. Faster than the scan-functions.
load_sexps ?buf file
reads a list of S-expressions from file
using buffer buf
for storing intermediate data. Faster than the scan-functions.
load_rev_sexps ?buf file
same as Sexp.load_sexps
, but returns a reversed list of S-expressions, which is slightly more efficient.
load_sexp_conv ?strict ?buf file f
like Sexp.load_sexp
, but performs a conversion on the fly using f
. Performance is equivalent to executing Sexp.load_sexp
and performing conversion when there are no errors. In contrast to the plain S-expression loader, this function not only performs the conversion, it will give exact error ranges for conversion errors.
load_sexp_conv_exn ?strict ?buf file f
like load_sexp_conv
, but returns the converted value or raises Of_sexp_error
with exact location information in the case of a conversion error.
load_sexps_conv ?buf file f
like Sexp.load_sexps
, but performs a conversion on the fly using f
. Performance is equivalent to executing Sexp.load_sexps
and performing conversion when there are no errors. In contrast to the plain S-expression loader, this function not only performs the conversion, it will give exact error ranges for conversion errors.
load_sexps_conv_exn ?buf file f
like load_sexps_conv
, but returns the converted value or raises Of_sexp_error
with exact location information in the case of a conversion error.
NOTE: for performance reasons these output functions may need to allocate large strings to write out huge S-expressions. This may cause problems on 32-bit platforms. If you think that you may need to write huge S-expressions on such platforms, you might want to use the pretty-printers that write to formatters instead (see further below).
output_hum oc sexp
outputs S-expression sexp
to output channel oc
in human readable form.
output_hum_indent indent oc sexp
outputs S-expression sexp
to output channel oc
in human readable form using indentation level indent
.
output_mach oc sexp
outputs S-expression sexp
to output channel oc
in machine readable (i.e. most compact) form.
output oc sexp
same as output_mach
.
All save-functions write to a temporary file before moving it into place to avoid intermittent garbling of existing files, which may cause problems for other processes that try to read.
save_hum ?perm file sexp
outputs S-expression sexp
to file
in human readable form.
save_mach ?perm file sexp
outputs S-expression sexp
to file
in machine readable (i.e. most compact) form.
save_sexps_hum ?perm file sexps
outputs S-expression list sexps
to file
in human readable form, each sexp being followed by a newline.
save_sexps_mach ?perm file sexps
outputs S-expression list sexps
to file
in machine readable form, each sexp being followed by a newline.
save_sexps ?perm file sexp
same as save_sexps_mach
.
pp_hum ppf sexp
outputs S-expression sexp
to formatter ppf
in human readable form.
pp_hum_indent n ppf sexp
outputs S-expression sexp
to formatter ppf
in human readable form and indentation level n
.
pp_mach ppf sexp
outputs S-expression sexp
to formatter ppf
in machine readable (i.e. most compact) form.
pp ppf sexp
same as pp_mach
.
Module encapsulating the exception raised by string converters when type conversions fail.
of_string_many
parses a string containing zero or more S-expressions.
Unlike many other functions in this module, on parse failure it raises Parsexp.Parse_error
rather than a native Sexplib.Sexp.Parse_error
.
of_string_conv str conv
like of_string
, but performs type conversion with conv
.
of_string_many_conv_exn str conv
like of_string_many
, but performs type conversion with conv
. Raises if type conversion fails.
Unlike many other functions in this module, on parse failure it raises Parsexp.Parse_error
rather than a native Sexplib.Sexp.Parse_error
.
It still raises Sexplib.Sexp.Of_string_conv_exn
on sexp conversion errors.
of_string_conv_exn str conv
like of_string_conv
, but raises Of_string_conv_exn.E
if type conversion fails.
of_bigstring bstr
same as of_string
, but operates on bigstrings.
of_bigstring_conv bstr conv
like of_bigstring
, but performs type conversion with conv
.
of_bigstring_conv_exn bstr conv
like of_bigstring_conv
, but raises Of_string_conv_exn.E
if type conversion fails.
to_string_hum ?indent sexp
converts S-expression sexp
to a string in human readable form with indentation level indent
.
to_string_mach sexp
converts S-expression sexp
to a string in machine readable (i.e. most compact) form.
to_buffer_hum ~buf ?indent sexp
outputs the S-expression sexp
converted to a string in human readable form to buffer buf
.
to_buffer_mach ~buf sexp
outputs the S-expression sexp
converted to a string in machine readable (i.e. most compact) form to buffer buf
.
to_buffer ~buf sexp
same as to_buffer_mach
.
sexp_of_t sexp
maps S-expressions which are part of a type with automated S-expression conversion to themselves.
t_of_sexp sexp
maps S-expressions which are part of a type with automated S-expression conversion to themselves.
Type of successful search results. `Found
means that an S-expression was found at the immediate position, and `Pos (pos, found)
indicates that it was found at position pos
within a structure (= S-expression list) where found
describes recursively where it was found in that structure.
Type of search results. `Not_found
means that an S-expression was not found within another S-expression.
search_physical sexp ~contained
S-expressions annotated with relative source positions and comments
no_raise
is the identity, but by using 'a no_raise
in a sexpable type, the resulting use sexp_of_no_raise
protects the conversion of 'a
to a sexp so that if it fails, one gets a sexp with an error message about the failure, rather than an exception being raised.
WARNING: The resulting no_raise_of_sexp
can still raise.
val bin_writer_no_raise :
'a Bin_prot.Type_class.writer ->
'a no_raise Bin_prot.Type_class.writer
val __bin_read_no_raise__ :
'a Bin_prot.Read.reader ->
(Base.Int.t -> 'a no_raise) Bin_prot.Read.reader
val bin_reader_no_raise :
'a Bin_prot.Type_class.reader ->
'a no_raise Bin_prot.Type_class.reader
If sexp_of_t fails
, it returns Error
rather than raising. You can convert values of this type to and from sexp in processes that can or cannot parse the underlying sexp in any combination and still recover the original value. Also, the Error
case contains a human-readable description of the error.
A With_text.t
is a value paired with the full textual representation of its sexp. This is useful for dealing with the case where you want to keep track of a value along with the format of the s-expression it was generated from, which allows you to maintain formatting details, comments, etc.
of_sexp_allow_extra_fields_recursively of_sexp sexp
uses of_sexp
to convert sexp
to a value, but will not fail if there are any extra fields in a record (even deeply nested records).
The implementation uses global state, so it is not thread safe.