| (>>=) [Macro.Sexp_loader.Monad.Monad_infix] | |
A | |
| add [Src_pos.Absolute] | |
| add [Src_pos.Relative] | |
| add_annot_pos [Pre_sexp] | |
| add_annot_pos1 [Pre_sexp] | |
| add_auto [Conv.Exn_converter] | add_auto ?finalise templ sexp_of_exn registers exception S-expression
converter sexp_of_exn for exceptions having same constructor as
template templ, unless the number of stored handlers for the given
template exceeds get_max_exn_tags (), in which case the handler will
never be called.
|
| add_bump [Pre_sexp] | |
| add_bump_line [Pre_sexp] | |
| add_bump_pos [Pre_sexp] | |
| add_error_location [Macro] | |
| add_slow [Conv.Exn_converter] | add_slow sexp_of_exn registers exception S-expression converter
sexp_of_exn and returns a handle.
|
| advance [Sexp_with_layout.Render] | |
| array_of_sexp [Std] | |
| array_of_sexp [Conv] | array_of_sexp conv sexp converts S-expression sexp to a value
of type 'a array using conversion function conv, which converts
an S-expression to a value of type 'a.
|
B | |
| bigstring_of_sexp [Conv] | bigstring_of_sexp sexp converts S-expression sexp to a
bigstring (character bigarray in C-layout).
|
| bind [Sexp_with_layout.Render] | |
| bind [Sexp_intf.S.With_layout.Render] | |
| bool_of_sexp [Std] | |
| bool_of_sexp [Conv] | bool_of_sexp sexp converts S-expression sexp to a value of type
bool.
|
| bstr_ws_buf [Pre_sexp] | |
| buffer [Pre_sexp] | |
| bump_found_atom [Pre_sexp] | |
| bump_line_cont [Pre_sexp] | |
| bump_pos_cont [Pre_sexp] | |
| bump_text_line [Pre_sexp] | |
| bump_text_pos [Pre_sexp] | |
C | |
| char_of_sexp [Std] | |
| char_of_sexp [Conv] | char_of_sexp sexp converts S-expression sexp to a value of type
char.
|
| check_str_bounds [Pre_sexp] | |
| conv [Sexp_intf.S.Annotated] | conv f annot_sexp converts the S-expression associated with
annotated S-expression annot_sexp using f.
|
| conv [Pre_sexp.Annotated] | |
| create [Sexp_intf.S.Parse_pos] | create ?text_line ?text_char ?buf_pos ?global_offset ()
|
| create [Pre_sexp.Parse_pos] | |
D | |
| default_indent [Sexp_intf.S] | default_indent reference to default indentation level for
human-readable conversions.
|
| default_indent [Pre_sexp] | |
| default_string_of_float [Conv] | default_string_of_float reference to the default function used
to convert floats to strings.
|
| del_slow [Conv.Exn_converter] | del_slow handle unregisters exception S-expression converter with
handle handle.
|
| diff [Src_pos.Absolute] | |
E | |
| emit_char [Sexp_with_layout.Render] | |
| emit_chars [Sexp_with_layout.Render] | |
| emit_string [Sexp_with_layout.Render] | |
| empty_list_invalid_poly_var [Conv_error] | |
| empty_list_invalid_sum [Conv_error] | |
| empty_type [Conv_error] | |
| esc_str [Pre_sexp] | |
| extract_match [Path] | extract_match tag n sexp
|
| extract_pos [Path] | extract_pos n sexp
|
| extract_rec [Path] | extract_rec name sexp
|
F | |
| find_sexp [Sexp_intf.S.Annotated] | find_sexp annot_sexp sexp
|
| find_sexp [Pre_sexp.Annot] | |
| float32_mat_of_sexp [Conv] | float32_mat_of_sexp sexp converts S-expression sexp to a
two-dimensional bigarray of 32-bit floats in Fortran-layout.
|
| float32_vec_of_sexp [Conv] | float32_vec_of_sexp sexp converts S-expression sexp to a
one-dimensional bigarray of 32-bit floats in Fortran-layout.
|
| float64_mat_of_sexp [Conv] | float64_mat_of_sexp sexp converts S-expression sexp to a
two-dimensional bigarray of 64-bit floats in Fortran-layout.
|
| float64_vec_of_sexp [Conv] | float64_vec_of_sexp sexp converts S-expression sexp to a
one-dimensional bigarray of 64-bit floats in Fortran-layout.
|
| float_of_sexp [Std] | |
| float_of_sexp [Conv] | float_of_sexp sexp converts S-expression sexp to a value of type
float.
|
| forget_t [Sexp_with_layout.Forget.Cps] | |
| forget_toc [Sexp_with_layout.Forget.Cps] | |
| forget_tocs [Sexp_with_layout.Forget.Cps] | |
| fun_of_sexp [Conv] | fun_of_sexp sexp
|
G | |
| gen_input_rev_sexps [Pre_sexp] | |
| gen_input_sexp [Pre_sexp] | |
| gen_load_rev_sexps [Pre_sexp] | |
| gen_load_sexp [Pre_sexp] | |
| gen_load_sexp_loc [Pre_sexp] | |
| gen_of_string_conv [Pre_sexp] | |
| gen_of_string_conv_exn [Pre_sexp] | |
| geq [Src_pos.Absolute] | |
| get [Path] | get ?path ?str sexp if path is provided, use it as path.
|
| get_annot_range [Pre_sexp] | |
| get_bstr_sub_str [Pre_sexp] | |
| get_conv_exn [Sexp_intf.S.Annotated] | get_conv_exn ~file ~exc annot_sexp
|
| get_conv_exn [Pre_sexp.Annotated] | |
| get_glob_ofs [Pre_sexp] | |
| get_main_buf [Pre_sexp] | |
| get_max_exn_tags [Conv.Exn_converter] | set_max_exn_tags () return the maximum number of converters for
exceptions with the same template.
|
| get_range [Sexp_intf.S.Annotated] | get_range annot_sexp
|
| get_range [Pre_sexp.Annot] | |
| get_sexp [Sexp_intf.S.Annotated] | get_sexp annot_sexp
|
| get_sexp [Pre_sexp.Annot] | |
| get_substring [Pre_sexp] | |
H | |
| hashtbl_of_sexp [Conv] | hashtbl_of_sexp conv_key conv_value sexp converts S-expression
sexp to a value of type ('a, 'b) Hashtbl.t using conversion
function conv_key, which converts an S-expression to hashtable
key of type 'a, and function conv_value, which converts an
S-expression to hashtable value of type 'b.
|
I | |
| index_of_newline [Pre_sexp] | |
| init_annot_pstate [Pre_sexp] | |
| input_rev_sexps [Sexp_intf.S.Annotated] | input_sexps ?parse_pos ?buf ic like Sexp_intf.S.Annotated.input_rev_sexps, but
returns a list of annotated S-expressions.
|
| input_rev_sexps [Sexp_intf.S] | 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.
|
| input_rev_sexps [Pre_sexp.Annotated] | |
| input_rev_sexps [Pre_sexp] | |
| input_sexp [Sexp_intf.S.Annotated] | input_sexp ?parse_pos ic like Sexp_intf.S.Annotated.input_sexp, but returns an
annotated S-expression instead.
|
| input_sexp [Sexp_intf.S] | input_sexp ?parse_pos ic parses an S-expression from input channel
ic using initial position information in parse_pos.
|
| input_sexp [Pre_sexp.Annotated] | |
| input_sexp [Pre_sexp] | |
| input_sexps [Sexp_intf.S.Annotated] | input_sexps ?parse_pos ?buf ic like Sexp_intf.S.Annotated.input_sexps, but returns
a list of annotated S-expressions.
|
| input_sexps [Sexp_intf.S] | input_sexps ?parse_pos ?buf ic parses whitespace separated
S-expressions from input channel ic until EOF is reached.
|
| input_sexps [Pre_sexp.Annotated] | |
| input_sexps [Pre_sexp] | |
| int32_of_sexp [Std] | |
| int32_of_sexp [Conv] | int32_of_sexp sexp converts S-expression sexp to a value of type
int32.
|
| int64_of_sexp [Std] | |
| int64_of_sexp [Conv] | int64_of_sexp sexp converts S-expression sexp to a value of type
int64.
|
| int_of_sexp [Std] | |
| int_of_sexp [Conv] | int_of_sexp sexp converts S-expression sexp to a value of type
int.
|
| is_one_line [Pre_sexp] | |
| iter [Sexp_with_layout.List] | |
| iter [Macro.Sexp_loader.Monad.List] | |
L | |
| lazy_t_of_sexp [Std] | |
| lazy_t_of_sexp [Conv] | lazy_t_of_sexp conv sexp converts S-expression sexp to a value
of type 'a lazy_t using conversion function conv, which converts
an S-expression to a value of type 'a.
|
| list_map [Conv] |
We re-export a tail recursive map function, because some modules
override the standard library functions (e.g.
|
| list_of_sexp [Std] | |
| list_of_sexp [Conv] | list_of_sexp conv sexp converts S-expression sexp to a value
of type 'a list using conversion function conv, which converts
an S-expression to a value of type 'a.
|
| load_annotated_sexps [Macro.Sexp_loader] | |
| load_rev_sexps [Sexp_intf.S.Annotated] | load_rev_sexps ?buf file like Sexp_intf.S.Annotated.load_rev_sexps, but returns a
list of annotated S-expressions.
|
| load_rev_sexps [Sexp_intf.S] | load_rev_sexps ?buf file same as Sexp.load_sexps, but returns a
reversed list of S-expressions, which is slightly more efficient.
|
| load_rev_sexps [Pre_sexp.Annotated] | |
| load_rev_sexps [Pre_sexp] | |
| load_sexp [Sexp_intf.S.Annotated] | load_sexp ?strict ?buf file like Sexp_intf.S.Annotated.load_sexp, but returns an
annotated S-expression.
|
| load_sexp [Sexp_intf.S] | load_sexp ?strict ?buf file reads one S-expression from file using
buffer buf for storing intermediate data.
|
| load_sexp [Pre_sexp.Annotated] | |
| load_sexp [Pre_sexp] | |
| load_sexp [Macro] | load_sexp file like {!Sexp.load_sexp} file, but resolves the macros
contained in file.
|
| load_sexp_conv [Sexp_intf.S] | load_sexp_conv ?strict ?buf file f like Sexp.load_sexp, but
performs a conversion on the fly using f.
|
| load_sexp_conv [Pre_sexp] | |
| load_sexp_conv [Macro.Loader] | |
| load_sexp_conv [Macro] | |
| load_sexp_conv_exn [Sexp_intf.S] | load_sexp_conv_exn ?strict ?buf file f like Sexp_intf.S.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_sexp_conv_exn [Pre_sexp] | |
| load_sexp_conv_exn [Macro] | load_sexp_conv_exn file f like Macro.load_sexp_conv, but raises an exception
in case of conversion error.
|
| load_sexps [Sexp_intf.S.Annotated] | load_sexps ?buf file like Sexp_intf.S.Annotated.load_sexps, but returns a list of
annotated S-expressions.
|
| load_sexps [Sexp_intf.S] | load_sexps ?buf file reads a list of whitespace separated S-expressions
from file using buffer buf for storing intermediate data.
|
| load_sexps [Pre_sexp.Annotated] | |
| load_sexps [Pre_sexp] | |
| load_sexps [Macro.Sexp_loader] | |
| load_sexps [Macro] | load_sexps file like {!Sexp.load_sexps} file, but resolves the macros
contained in file.
|
| load_sexps_conv [Sexp_intf.S] | load_sexps_conv ?buf file f like Sexp.load_sexps, but performs
a conversion on the fly using f.
|
| load_sexps_conv [Pre_sexp] | |
| load_sexps_conv [Macro.Loader] | |
| load_sexps_conv [Macro] | |
| load_sexps_conv_exn [Sexp_intf.S] | load_sexps_conv_exn ?buf file f like Sexp_intf.S.load_sexps_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_exn [Pre_sexp] | |
| load_sexps_conv_exn [Macro] | load_sexps_conv_exn file f like Macro.load_sexps_conv, but raises an
exception in case of conversion error.
|
M | |
| mach_maybe_esc_str [Pre_sexp] | |
| main [Lexer] | |
| main [Sexp_with_layout.Lexer] | |
| main [Sexp_intf.S.With_layout.Lexer] | |
| main_with_layout [Lexer] | |
| map [Sexp_with_layout.List] | |
| map [Macro.Sexp_loader.Monad.List] | |
| mat_of_sexp [Conv] | mat_of_sexp sexp same as Conv.float64_mat_of_sexp.
|
| maybe_parse_bad_atom_hash [Pre_sexp] | |
| maybe_parse_bad_atom_pipe [Pre_sexp] | |
| maybe_parse_close_comment [Pre_sexp] | |
| maybe_parse_comment [Pre_sexp] | |
| mk_annot_atom [Pre_sexp] | |
| mk_annot_list [Pre_sexp] | |
| mk_annot_pos [Pre_sexp] | |
| mk_annot_pos1 [Pre_sexp] | |
| mk_cont [Pre_sexp] | |
| mk_cont_parser [Pre_sexp] | |
| mk_cont_state [Pre_sexp] | |
| mk_parse_pos [Pre_sexp] | |
| mk_this_parse [Pre_sexp] | |
| must_escape [Pre_sexp] | |
N | |
| nativeint_of_sexp [Std] | |
| nativeint_of_sexp [Conv] | nativeint_of_sexp sexp converts S-expression sexp to a value
of type nativeint.
|
| nested_list_invalid_poly_var [Conv_error] | |
| nested_list_invalid_sum [Conv_error] | |
| no_matching_variant_found [Conv_error] | |
| no_variant_match [Conv_error] | |
O | |
| of_bigstring [Sexp_intf.S.Annotated] | of_bigstring bstr same as Sexp_intf.S.Annotated.of_string, but operates on bigstrings.
|
| of_bigstring [Sexp_intf.S] | of_bigstring bstr same as Sexp_intf.S.of_string, but operates on bigstrings.
|
| of_bigstring [Pre_sexp.Annotated] | |
| of_bigstring [Pre_sexp] | |
| of_bigstring_conv [Sexp_intf.S] | |
| of_bigstring_conv [Pre_sexp] | |
| of_bigstring_conv_exn [Sexp_intf.S] | of_bigstring_conv_exn bstr conv like Sexp_intf.S.of_bigstring_conv, but raises
Sexp_intf.S.Of_string_conv_exn.E if type conversion fails.
|
| of_bigstring_conv_exn [Pre_sexp] | |
| of_lexing [Src_pos.Absolute] | |
| of_sexp_error [Conv] | of_sexp_error reason sexp
|
| of_sexp_error_exn [Conv] | of_sexp_error exc sexp
|
| of_string [Sexp_intf.S.Annotated] | of_string str same as Sexp_intf.S.Annotated.of_string, but returns an annotated
S-expression.
|
| of_string [Sexp_intf.S] | of_string str converts string str to an S-expression.
|
| of_string [Pre_sexp.Annotated] | |
| of_string [Pre_sexp] | |
| of_string__of__of_sexp [Conv] | of_string__of__of_sexp conv str converts the S-expression str
represented as a string to an OCaml-value by using conversion function
conv.
|
| of_string_bigstring [Pre_sexp] | |
| of_string_conv [Sexp_intf.S] | |
| of_string_conv [Pre_sexp] | |
| of_string_conv_exn [Sexp_intf.S] | of_string_conv_exn str conv like Sexp_intf.S.of_string_conv, but raises
Sexp_intf.S.Of_string_conv_exn.E if type conversion fails.
|
| of_string_conv_exn [Pre_sexp] | |
| opaque_of_sexp [Conv] | opaque_of_sexp sexp
|
| open_temp_file [Pre_sexp.Tmp_file] | |
| option_of_sexp [Std] | |
| option_of_sexp [Conv] | option_of_sexp conv sexp converts S-expression sexp to a value
of type 'a option using conversion function conv, which converts
an S-expression to a value of type 'a.
|
| origin [Src_pos.Absolute] | |
| output [Sexp_intf.S] | output oc sexp same as output_mach.
|
| output [Pre_sexp] | |
| output_hum [Sexp_intf.S] | output_hum oc sexp outputs S-expression sexp to output channel
oc in human readable form.
|
| output_hum [Pre_sexp] | |
| output_hum_indent [Sexp_intf.S] | output_hum_indent indent oc sexp outputs S-expression sexp
to output channel oc in human readable form using indentation level
indent.
|
| output_hum_indent [Pre_sexp] | |
| output_mach [Sexp_intf.S] | output_mach oc sexp outputs S-expression sexp to output channel
oc in machine readable (i.e.
|
| output_mach [Pre_sexp] | |
| output_sexp_nl [Pre_sexp] | |
| output_sexps_nl [Pre_sexp] | |
P | |
| pair_of_sexp [Conv] | pair_of_sexp conv1 conv2 sexp converts S-expression sexp to a pair
of type 'a * 'b using conversion functions conv1 and conv2,
which convert S-expressions to values of type 'a and 'b
respectively.
|
| parse [Sexp_intf.S.Annotated] | parse ?parse_pos ?len str same as Sexp_intf.S.Annotated.parse, but returns an
S-expression annotated with location information.
|
| parse [Sexp_intf.S] | 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.
|
| parse [Pre_sexp.Annotated] | |
| parse [Pre_sexp] | |
| parse [Path] | parse str
|
| parse_atom [Pre_sexp] | |
| parse_bigstring [Sexp_intf.S.Annotated] | parse_bigstring ?parse_pos ?len str same as Sexp_intf.S.Annotated.parse_bigstring,
but returns an S-expression annotated with location information.
|
| parse_bigstring [Sexp_intf.S] | parse_bigstring ?parse_pos ?len str same as Sexp_intf.S.parse, but operates on
bigstrings.
|
| parse_bigstring [Pre_sexp.Annotated] | |
| parse_bigstring [Pre_sexp] | |
| parse_bigstring_annot [Pre_sexp] | |
| parse_block_comment [Pre_sexp] | |
| parse_comment [Pre_sexp] | |
| parse_dec [Pre_sexp] | |
| parse_escaped [Pre_sexp] | |
| parse_hex [Pre_sexp] | |
| parse_nl [Pre_sexp] | |
| parse_quoted [Pre_sexp] | |
| parse_sexp_comment [Pre_sexp] | |
| parse_skip_ws [Pre_sexp] | |
| parse_skip_ws_nl [Pre_sexp] | |
| parse_str [Pre_sexp] | |
| parse_str_annot [Pre_sexp] | |
| pp [Sexp_intf.S] | pp ppf sexp same as pp_mach.
|
| pp [Pre_sexp] | |
| pp_hum [Sexp_intf.S] | pp_hum ppf sexp outputs S-expression sexp to formatter ppf
in human readable form.
|
| pp_hum [Pre_sexp] | |
| pp_hum_indent [Sexp_intf.S] | pp_hum_indent n ppf sexp outputs S-expression sexp to formatter
ppf in human readable form and indentation level n.
|
| pp_hum_indent [Pre_sexp] | |
| pp_hum_maybe_esc_str [Pre_sexp] | |
| pp_hum_rest [Pre_sexp] | |
| pp_mach [Sexp_intf.S] | pp_mach ppf sexp outputs S-expression sexp to formatter ppf
in machine readable (i.e.
|
| pp_mach [Pre_sexp] | |
| pp_mach_internal [Pre_sexp] | |
| pp_mach_rest [Pre_sexp] | |
| prng [Pre_sexp.Tmp_file] | |
| ptag_incorrect_n_args [Conv_error] | |
| ptag_no_args [Conv_error] | |
| ptag_takes_args [Conv_error] | |
R | |
| raise_conv_exn [Pre_sexp] | |
| raise_parse_error [Pre_sexp] | |
| raise_unexpected_char [Pre_sexp] | |
| read_old_option_format [Conv] | read_old_option_format reference for the default option format
used to read option values.
|
| record_check_extra_fields [Conv] | record_check_extra_fields checks for extra (= unknown) fields
in record S-expressions.
|
| record_duplicate_fields [Conv_error] | |
| record_extra_fields [Conv_error] | |
| record_get_undefined_loop [Conv_error] | |
| record_list_instead_atom [Conv_error] | |
| record_only_pairs_expected [Conv_error] | |
| record_poly_field_value [Conv_error] | |
| record_superfluous_fields [Conv_error] | |
| record_undefined_elements [Conv_error] | |
| ref_of_sexp [Std] | |
| ref_of_sexp [Conv] | ref_of_sexp conv sexp converts S-expression sexp to a value
of type 'a ref using conversion function conv, which converts
an S-expression to a value of type 'a.
|
| reg_parse_quoted [Pre_sexp] | |
| register [Exn_magic] | |
| register1 [Exn_magic] | |
| register10 [Exn_magic] | |
| register2 [Exn_magic] | |
| register3 [Exn_magic] | |
| register4 [Exn_magic] | |
| register5 [Exn_magic] | |
| register6 [Exn_magic] | |
| register7 [Exn_magic] | |
| register8 [Exn_magic] | |
| register9 [Exn_magic] | |
| relativize [Type_with_layout] | |
| render [Sexp_with_layout.Render] | |
| render_c [Sexp_with_layout.Render] | |
| render_t [Sexp_with_layout.Render] | |
| render_toc [Sexp_with_layout.Render] | |
| replace [Path] | replace ?path ?str sexp ~subst like get, but does not extract
a sub-expression but substitutes it with subst.
|
| replace_no_path [Path] | replace_no_path ~str sexp ~subst like replace, but does not take
optional arguments.
|
| return [Sexp_with_layout.Render] | |
| return [Sexp_intf.S.With_layout.Render] | |
| return [Macro.Sexp_loader.Monad] | |
| rev_sexps [Parser] | |
| rev_sexps [Parser_with_layout] | |
| rev_sexps [Sexp_intf.S.With_layout.Parser] | |
| run [Sexp_with_layout.Render] | |
| run [Sexp_intf.S.With_layout.Render] | |
S | |
| save [Sexp_intf.S] | save ?perm file sexp same as Sexp_intf.S.save_mach.
|
| save [Pre_sexp] | |
| save_hum [Sexp_intf.S] | save_hum ?perm file sexp outputs S-expression sexp to file in human
readable form.
|
| save_hum [Pre_sexp] | |
| save_mach [Sexp_intf.S] | save_mach ?perm file sexp outputs S-expression sexp to file
in machine readable (i.e.
|
| save_mach [Pre_sexp] | |
| save_of_output [Pre_sexp] | |
| save_sexps [Sexp_intf.S] | save_sexps ?perm file sexp same as Sexp_intf.S.save_sexps_mach.
|
| save_sexps [Pre_sexp] | |
| save_sexps_hum [Sexp_intf.S] | 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_hum [Pre_sexp] | |
| save_sexps_mach [Sexp_intf.S] | 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_mach [Pre_sexp] | |
| scan_fold_sexps [Sexp_intf.S] | scan_fold_sexps ?buf ~f ~init lexbuf folds over all whitespace
separated S-expressions scanned from lex buffer lexbuf using
function f, initial state init, and the optional string buffer
buf for storing intermediate strings.
|
| scan_fold_sexps [Pre_sexp] | |
| scan_iter_sexps [Sexp_intf.S] | scan_iter_sexps ?buf ~f lexbuf iterates over all whitespace
separated S-expressions scanned from lex buffer lexbuf using
function f, and the optional string buffer buf for storing
intermediate strings.
|
| scan_iter_sexps [Pre_sexp] | |
| scan_rev_sexps [Sexp_intf.S] | scan_rev_sexps ?buf lexbuf same as Sexp_intf.S.scan_sexps, but returns the
reversed list and is slightly more efficient.
|
| scan_rev_sexps [Pre_sexp] | |
| scan_sexp [Sexp_intf.S] | scan_sexp ?buf lexbuf scans an S-expression from lex buffer
lexbuf using the optional string buffer buf for storing
intermediate strings.
|
| scan_sexp [Pre_sexp] | |
| scan_sexp_opt [Sexp_intf.S] | scan_sexp_opt ?buf lexbuf is equivalent to scan_sexp ?buf lexbuf
except that it returns None when the eof is reached.
|
| scan_sexp_opt [Pre_sexp] | |
| scan_sexps [Sexp_intf.S] | scan_sexps ?buf lexbuf reads a list of whitespace separated
S-expressions from lex buffer lexbuf using the optional string
buffer buf for storing intermediate strings.
|
| scan_sexps [Pre_sexp] | |
| scan_sexps_conv [Sexp_intf.S] | scan_sexps_conv ?buf ~f lexbuf maps all whitespace separated
S-expressions scanned from lex buffer lexbuf to some list using
function f, and the optional string buffer buf for storing
intermediate strings.
|
| scan_sexps_conv [Pre_sexp] | |
| search_physical [Sexp_intf.S] | search_physical sexp ~contained
|
| search_physical [Pre_sexp] | |
| set_max_exn_tags [Conv.Exn_converter] | set_max_exn_tags n sets the maximum number of converters for exceptions
with the same template to n.
|
| set_parse_pos [Pre_sexp] | |
| sexp [Parser] | |
| sexp [Sexp_with_layout.Render] | |
| sexp [Parser_with_layout] | |
| sexp [Sexp_intf.S.With_layout.Parser] | |
| sexp [Sexp_intf.S.With_layout.Render] | |
| sexp_of_array [Std] | |
| sexp_of_array [Conv] | sexp_of_array conv ar converts the value ar of type 'a
array to an S-expression.
|
| sexp_of_bigstring [Conv] | sexp_of_bigstring bstr converts a bigstring (character bigarray
in C-layout) to an S-expression.
|
| sexp_of_bool [Std] | |
| sexp_of_bool [Conv] | sexp_of_bool b converts the value x of type bool to an
S-expression.
|
| sexp_of_char [Std] | |
| sexp_of_char [Conv] | sexp_of_char c converts the value c of type char to an
S-expression.
|
| sexp_of_comment [Type_with_layout.Make.S] | |
| sexp_of_comment [Sexp_intf.S.With_layout] | |
| sexp_of_exn [Std] | |
| sexp_of_exn [Conv] | sexp_of_exn exc converts exception exc to an S-expression.
|
| sexp_of_exn_opt [Conv] | sexp_of_exn_opt exc converts exception exc to Some sexp.
|
| sexp_of_float [Std] | |
| sexp_of_float [Conv] | sexp_of_float n converts the value n of type float to an
S-expression.
|
| sexp_of_float32_mat [Conv] | sexp_of_float32_mat mat converts the two-dimensional bigarray
mat of 32-bit floats in Fortran-layout to an S-expression.
|
| sexp_of_float32_vec [Conv] | sexp_of_float32_vec vec converts the one-dimensional bigarray
vec of 32-bit floats in Fortran-layout to an S-expression.
|
| sexp_of_float64_mat [Conv] | sexp_of_float64_mat mat converts the two-dimensional bigarray
mat of 64-bit floats in Fortran-layout to an S-expression.
|
| sexp_of_float64_vec [Conv] | sexp_of_float64_vec vec converts the one-dimensional bigarray
vec of 64-bit floats in Fortran-layout to an S-expression.
|
| sexp_of_fun [Conv] | sexp_of_fun f converts the value f of function type to a
dummy S-expression.
|
| sexp_of_hashtbl [Conv] | sexp_of_hashtbl conv_key conv_value htbl converts the value htbl
of type ('a, 'b) Hashtbl.t to an S-expression.
|
| sexp_of_int [Std] | |
| sexp_of_int [Conv] | sexp_of_int n converts the value n of type int to an
S-expression.
|
| sexp_of_int32 [Std] | |
| sexp_of_int32 [Conv] | sexp_of_int32 n converts the value n of type int32 to an
S-expression.
|
| sexp_of_int64 [Std] | |
| sexp_of_int64 [Conv] | sexp_of_int64 n converts the value n of type int64 to an
S-expression.
|
| sexp_of_lazy_t [Std] | |
| sexp_of_lazy_t [Conv] | sexp_of_lazy_t conv l converts the value l of type 'a lazy_t to
an S-expression.
|
| sexp_of_list [Std] | |
| sexp_of_list [Conv] | sexp_of_list conv lst converts the value lst of type 'a
list to an S-expression.
|
| sexp_of_mat [Conv] | sexp_of_mat mat same as Conv.sexp_of_float64_mat.
|
| sexp_of_nativeint [Std] | |
| sexp_of_nativeint [Conv] | sexp_of_nativeint n converts the value n of type nativeint to an
S-expression.
|
| sexp_of_opaque [Conv] | sexp_of_opaque x converts the value x of opaque type to an
S-expression.
|
| sexp_of_option [Std] | |
| sexp_of_option [Conv] | sexp_of_option conv opt converts the value opt of type 'a
option to an S-expression.
|
| sexp_of_pair [Conv] | sexp_of_pair conv1 conv2 pair converts a pair to an S-expression.
|
| sexp_of_pos [Sexp_with_layout] | |
| sexp_of_pos [Sexp_intf.S.With_layout] | |
| sexp_of_ref [Std] | |
| sexp_of_ref [Conv] | sexp_of_ref conv r converts the value r of type 'a ref to
an S-expression.
|
| sexp_of_string [Std] | |
| sexp_of_string [Conv] | sexp_of_bool str converts the value str of type string to an
S-expression.
|
| sexp_of_t [Type_with_layout.Make.S] | |
| sexp_of_t [Lazy] | |
| sexp_of_t [Hashtbl] | |
| sexp_of_t [Src_pos.Absolute] | |
| sexp_of_t [Src_pos.Relative] | |
| sexp_of_t [Sexp_intf.S.With_layout] | |
| sexp_of_t [Sexp_intf.S] | sexp_of_t sexp maps S-expressions which are part of a type with
automated S-expression conversion to themselves.
|
| sexp_of_t [Pre_sexp] | |
| sexp_of_t_or_comment [Type_with_layout.Make.S] | |
| sexp_of_t_or_comment [Sexp_intf.S.With_layout] | |
| sexp_of_triple [Conv] | sexp_of_triple conv1 conv2 conv3 triple converts a triple to
an S-expression using conv1, conv2, and conv3 to convert its
elements.
|
| sexp_of_unit [Std] | |
| sexp_of_unit [Conv] | sexp_of_unit () converts a value of type unit to an S-expression.
|
| sexp_of_vec [Conv] | sexp_of_vec vec same as Conv.sexp_of_float64_vec.
|
| sexp_opt [Parser] | |
| sexp_opt [Parser_with_layout] | |
| sexp_opt [Sexp_intf.S.With_layout.Parser] | |
| sexps [Parser] | |
| sexps [Parser_with_layout] | |
| sexps [Sexp_intf.S.With_layout.Parser] | |
| sexps_abs [Parser_with_layout] | |
| sexps_abs [Sexp_intf.S.With_layout.Parser] | |
| silly_type [Conv_error] | |
| size [Sexp_intf.S] | size sexp
|
| size [Pre_sexp] | |
| size_loop [Pre_sexp] | |
| stag_incorrect_n_args [Conv_error] | |
| stag_no_args [Conv_error] | |
| stag_takes_args [Conv_error] | |
| string_of__of__sexp_of [Conv] | string_of__of__sexp_of conv x converts the OCaml-value x to
an S-expression represented as a string by using conversion function
conv.
|
| string_of_sexp [Std] | |
| string_of_sexp [Conv] | string_of_sexp sexp converts S-expression sexp to a value of type
string.
|
| sub [Src_pos.Absolute] | |
| sub [Src_pos.Relative] | |
| subst_found [Sexp_intf.S] | subst_found sexp ~subst found
|
| subst_found [Pre_sexp] | |
| subst_path [Path] | subst_path sexp path
|
T | |
| t [Sexp_with_layout.Forget] | |
| t [Sexp_intf.S.With_layout.Forget] | |
| t_of_sexp [Lazy] | |
| t_of_sexp [Hashtbl] | |
| t_of_sexp [Sexp_intf.S] | t_of_sexp sexp maps S-expressions which are part of a type with
automated S-expression conversion to themselves.
|
| t_of_sexp [Pre_sexp] | |
| t_or_comment [Sexp_with_layout.Forget] | |
| t_or_comment [Sexp_intf.S.With_layout.Forget] | |
| t_or_comments [Sexp_with_layout.Forget] | |
| t_or_comments [Sexp_intf.S.With_layout.Forget] | |
| temp_file_name [Pre_sexp.Tmp_file] | |
| to_buffer [Sexp_intf.S] | to_buffer ~buf sexp same as Sexp_intf.S.to_buffer_mach.
|
| to_buffer [Pre_sexp] | |
| to_buffer_gen [Sexp_intf.S] | to_buffer_gen ~buf ~add_char ~add_string sexp outputs the S-expression
sexp converted to a string to buffer buf using the output functions
add_char and add_string.
|
| to_buffer_gen [Pre_sexp] | |
| to_buffer_hum [Sexp_intf.S] | to_buffer_hum ~buf ?indent sexp outputs the S-expression sexp
converted to a string in human readable form to buffer buf.
|
| to_buffer_hum [Pre_sexp] | |
| to_buffer_mach [Sexp_intf.S] | to_buffer_mach ~buf sexp outputs the S-expression sexp converted
to a string in machine readable (i.e.
|
| to_buffer_mach [Pre_sexp] | |
| to_string [Sexp_intf.S.Cont_state] | to_string cont_state converts state of parser continuation
cont_state to a string.
|
| to_string [Sexp_intf.S] | to_string sexp same as to_string_mach.
|
| to_string [Pre_sexp.Cont_state] | |
| to_string [Pre_sexp] | |
| to_string_hum [Sexp_intf.S] | to_string_hum ?indent sexp converts S-expression sexp to a
string in human readable form with indentation level indent.
|
| to_string_hum [Pre_sexp] | |
| to_string_mach [Sexp_intf.S] | to_string_mach sexp converts S-expression sexp to a string in
machine readable (i.e.
|
| to_string_mach [Pre_sexp] | |
| triple_of_sexp [Conv] | triple_of_sexp conv1 conv2 conv3 sexp converts S-expression sexp
to a triple of type 'a * 'b * 'c using conversion functions conv1,
conv2, and conv3, which convert S-expressions to values of type
'a, 'b, and 'c respectively.
|
| tuple_of_size_n_expected [Conv_error] | |
U | |
| unexpected_stag [Conv_error] | |
| unit [Sexp_intf.S] | unit the unit-value as expressed by an S-expression.
|
| unit [Pre_sexp] | |
| unit_of_sexp [Std] | |
| unit_of_sexp [Conv] | unit_of_sexp sexp converts S-expression sexp to a value of type
unit.
|
V | |
| vec_of_sexp [Conv] | vec_of_sexp sexp same as Conv.float64_vec_of_sexp.
|
W | |
| with_buf_pos [Sexp_intf.S.Parse_pos] | with_buf_pos t pos
|
| with_buf_pos [Pre_sexp.Parse_pos] | |
| with_new_buffer [Pre_sexp] | |
| write_old_option_format [Conv] | write_old_option_format reference for the default option format
used to write option values.
|
Z | |
| zero [Src_pos.Relative] |