| 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_exnregisters exception S-expression
      convertersexp_of_exnfor exceptions having same constructor as
      templatetempl, unless the number of stored handlers for the given
      template exceedsget_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_slow [Conv.Exn_converter] | add_slow sexp_of_exnregisters exception S-expression convertersexp_of_exnand returns a handle. | 
| advance [Sexp_with_layout.Render] | |
| array_of_sexp [Std] | |
| array_of_sexp [Conv] | array_of_sexp conv sexpconverts S-expressionsexpto a value
    of type'a arrayusing conversion functionconv, which converts
    an S-expression to a value of type'a. | 
| B | |
| big_int_of_sexp [Big_int] | |
| big_int_of_sexp [Conv] | big_int_of_sexp sexpconverts S-expressionsexpto a value
    of typeBig_int.big_int. | 
| bigstring_of_sexp [Conv] | bigstring_of_sexp sexpconverts S-expressionsexpto 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 sexpconverts S-expressionsexpto a value of typebool. | 
| 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 sexpconverts S-expressionsexpto a value of typechar. | 
| check_str_bounds [Pre_sexp] | |
| conv [Sexp_intf.S.Annotated] | conv f annot_sexpconverts the S-expression associated with
        annotated S-expressionannot_sexpusingf. | 
| 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_indentreference to default indentation level for
      human-readable conversions. | 
| default_indent [Pre_sexp] | |
| default_string_of_float [Conv] | default_string_of_floatreference to the default function used
    to convert floats to strings. | 
| del_slow [Conv.Exn_converter] | del_slow handleunregisters exception S-expression converter with
      handlehandle. | 
| 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] | |
| 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 sexpconverts S-expressionsexpto a
    two-dimensional bigarray of 32-bit floats in Fortran-layout. | 
| float32_vec_of_sexp [Conv] | float32_vec_of_sexp sexpconverts S-expressionsexpto a
    one-dimensional bigarray of 32-bit floats in Fortran-layout. | 
| float64_mat_of_sexp [Conv] | float64_mat_of_sexp sexpconverts S-expressionsexpto a
    two-dimensional bigarray of 64-bit floats in Fortran-layout. | 
| float64_vec_of_sexp [Conv] | float64_vec_of_sexp sexpconverts S-expressionsexpto a
    one-dimensional bigarray of 64-bit floats in Fortran-layout. | 
| float_of_sexp [Std] | |
| float_of_sexp [Conv] | float_of_sexp sexpconverts S-expressionsexpto a value of typefloat. | 
| 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 sexpifpathis 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] | |
| H | |
| hashtbl_of_sexp [Conv] | hashtbl_of_sexp conv_key conv_value sexpconverts S-expressionsexpto a value of type('a, 'b) Hashtbl.tusing conversion
    functionconv_key, which converts an S-expression to hashtable
    key of type'a, and functionconv_value, which converts an
    S-expression to hashtable value of type'b. | 
| I | |
| init_annot_pstate [Pre_sexp] | |
| input_rev_sexps [Sexp_intf.S.Annotated] | input_sexps ?parse_pos ?buf iclikeSexp_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 icsame asSexp.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 iclikeSexp_intf.S.Annotated.input_sexp, but returns an
        annotated S-expression instead. | 
| input_sexp [Sexp_intf.S] | input_sexp ?parse_pos icparses an S-expression from input channelicusing initial position information inparse_pos. | 
| input_sexp [Pre_sexp.Annotated] | |
| input_sexp [Pre_sexp] | |
| input_sexps [Sexp_intf.S.Annotated] | input_sexps ?parse_pos ?buf iclikeSexp_intf.S.Annotated.input_sexps, but returns
        a list of annotated S-expressions. | 
| input_sexps [Sexp_intf.S] | input_sexps ?parse_pos ?buf icparses whitespace separated
      S-expressions from input channelicuntil EOF is reached. | 
| input_sexps [Pre_sexp.Annotated] | |
| input_sexps [Pre_sexp] | |
| int32_of_sexp [Std] | |
| int32_of_sexp [Conv] | int32_of_sexp sexpconverts S-expressionsexpto a value of typeint32. | 
| int64_of_sexp [Std] | |
| int64_of_sexp [Conv] | int64_of_sexp sexpconverts S-expressionsexpto a value of typeint64. | 
| int_of_sexp [Std] | |
| int_of_sexp [Conv] | int_of_sexp sexpconverts S-expressionsexpto a value of typeint. | 
| iter [Sexp_with_layout.List] | |
| L | |
| lazy_t_of_sexp [Std] | |
| lazy_t_of_sexp [Conv] | lazy_t_of_sexp conv sexpconverts S-expressionsexpto a value
    of type'a lazy_tusing conversion functionconv, 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 sexpconverts S-expressionsexpto a value
    of type'a listusing conversion functionconv, which converts
    an S-expression to a value of type'a. | 
| load_rev_sexps [Sexp_intf.S.Annotated] | load_rev_sexps ?buf filelikeSexp_intf.S.Annotated.load_rev_sexps, but returns a
        list of annotated S-expressions. | 
| load_rev_sexps [Sexp_intf.S] | load_rev_sexps ?buf filesame asSexp.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 filelikeSexp_intf.S.Annotated.load_sexp, but returns an
        annotated S-expression. | 
| load_sexp [Sexp_intf.S] | load_sexp ?strict ?buf filereads one S-expression fromfileusing
      bufferbuffor storing intermediate data. | 
| load_sexp [Pre_sexp.Annotated] | |
| load_sexp [Pre_sexp] | |
| load_sexp_conv [Sexp_intf.S] | load_sexp_conv ?strict ?buf file flikeSexp.load_sexp, but
      performs a conversion on the fly usingf. | 
| load_sexp_conv [Pre_sexp] | |
| load_sexp_conv_exn [Sexp_intf.S] | load_sexp_conv_exn ?strict ?buf file flikeSexp_intf.S.load_sexp_conv,
      but returns the converted value or raisesOf_sexp_errorwith exact
      location information in the case of a conversion error. | 
| load_sexp_conv_exn [Pre_sexp] | |
| load_sexps [Sexp_intf.S.Annotated] | load_sexps ?buf filelikeSexp_intf.S.Annotated.load_sexps, but returns a list of
        annotated S-expressions. | 
| load_sexps [Sexp_intf.S] | load_sexps ?buf filereads a list of whitespace separated S-expressions
      fromfileusing bufferbuffor storing intermediate data. | 
| load_sexps [Pre_sexp.Annotated] | |
| load_sexps [Pre_sexp] | |
| load_sexps_conv [Sexp_intf.S] | load_sexps_conv ?buf file flikeSexp.load_sexps, but performs
      a conversion on the fly usingf. | 
| load_sexps_conv [Pre_sexp] | |
| load_sexps_conv_exn [Sexp_intf.S] | load_sexps_conv_exn ?buf file flikeSexp_intf.S.load_sexps_conv, but returns
      the converted value or raisesOf_sexp_errorwith exact location
      information in the case of a conversion error. | 
| load_sexps_conv_exn [Pre_sexp] | |
| M | |
| main [Lexer] | |
| main [Sexp_with_layout.Lexer] | |
| main [Sexp_intf.S.With_layout.Lexer] | |
| main_with_layout [Lexer] | |
| map [Sexp_with_layout.List] | |
| mat_of_sexp [Conv] | mat_of_sexp sexpsame asConv.float64_mat_of_sexp. | 
| maybe_esc_str [Pre_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 | |
| nat_of_sexp [Nat] | |
| nat_of_sexp [Conv] | nat_of_sexp sexpconverts S-expressionsexpto a value
    of typeNat.nat. | 
| nativeint_of_sexp [Std] | |
| nativeint_of_sexp [Conv] | nativeint_of_sexp sexpconverts S-expressionsexpto a value
    of typenativeint. | 
| nested_list_invalid_poly_var [Conv_error] | |
| nested_list_invalid_sum [Conv_error] | |
| no_matching_variant_found [Conv_error] | |
| no_variant_match [Conv_error] | |
| num_of_sexp [Num] | |
| num_of_sexp [Conv] | num_of_sexp sexpconverts S-expressionsexpto a value
    of typeNat.num. | 
| O | |
| of_bigstring [Sexp_intf.S.Annotated] | of_bigstring bstrsame asSexp_intf.S.Annotated.of_string, but operates on bigstrings. | 
| of_bigstring [Sexp_intf.S] | of_bigstring bstrsame asSexp_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 convlikeSexp_intf.S.of_bigstring_conv, but raisesSexp_intf.S.Of_string_conv_exn.Eif 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 strsame asSexp_intf.S.Annotated.of_string, but returns an annotated
        S-expression. | 
| of_string [Sexp_intf.S] | of_string strconverts stringstrto an S-expression. | 
| of_string [Pre_sexp.Annotated] | |
| of_string [Pre_sexp] | |
| of_string__of__of_sexp [Conv] | of_string__of__of_sexp conv strconverts the S-expressionstrrepresented as a string to an OCaml-value by using conversion functionconv. | 
| 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 convlikeSexp_intf.S.of_string_conv, but raisesSexp_intf.S.Of_string_conv_exn.Eif 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 sexpconverts S-expressionsexpto a value
    of type'a optionusing conversion functionconv, which converts
    an S-expression to a value of type'a. | 
| origin [Src_pos.Absolute] | |
| output [Sexp_intf.S] | output oc sexpsame asoutput_mach. | 
| output [Pre_sexp] | |
| output_hum [Sexp_intf.S] | output_hum oc sexpoutputs S-expressionsexpto output channelocin human readable form. | 
| output_hum [Pre_sexp] | |
| output_hum_indent [Sexp_intf.S] | output_hum_indent indent oc sexpoutputs S-expressionsexpto output channelocin human readable form using indentation levelindent. | 
| output_hum_indent [Pre_sexp] | |
| output_mach [Sexp_intf.S] | output_mach oc sexpoutputs S-expressionsexpto output channelocin 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 sexpconverts S-expressionsexpto a pair
    of type'a * 'busing conversion functionsconv1andconv2,
    which convert S-expressions to values of type'aand'brespectively. | 
| parse [Sexp_intf.S.Annotated] | parse ?parse_pos ?len strsame asSexp_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 bufferstrstarting out with position information provided inparse_posand reading at mostlencharacters. | 
| 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 strsame asSexp_intf.S.Annotated.parse_bigstring,
        but returns an S-expression annotated with location information. | 
| parse_bigstring [Sexp_intf.S] | parse_bigstring ?parse_pos ?len strsame asSexp_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 sexpsame aspp_mach. | 
| pp [Pre_sexp] | |
| pp_hum [Sexp_intf.S] | pp_hum ppf sexpoutputs S-expressionsexpto formatterppfin human readable form. | 
| pp_hum [Pre_sexp] | |
| pp_hum_indent [Sexp_intf.S] | pp_hum_indent n ppf sexpoutputs S-expressionsexpto formatterppfin human readable form and indentation leveln. | 
| pp_hum_indent [Pre_sexp] | |
| pp_hum_rest [Pre_sexp] | |
| pp_mach [Sexp_intf.S] | pp_mach ppf sexpoutputs S-expressionsexpto formatterppfin machine readable (i.e. | 
| pp_mach [Pre_sexp] | |
| pp_mach_internal [Pre_sexp] | |
| pp_mach_rest [Pre_sexp] | |
| pp_maybe_esc_str [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] | |
| ratio_of_sexp [Ratio] | |
| ratio_of_sexp [Conv] | ratio_of_sexp sexpconverts S-expressionsexpto a value
    of typeNat.ratio. | 
| read_old_option_format [Conv] | read_old_option_formatreference for the default option format
    used to read option values. | 
| record_check_extra_fields [Conv] | record_check_extra_fieldschecks 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 sexpconverts S-expressionsexpto a value
    of type'a refusing conversion functionconv, 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 ~substlikeget, but does not extract
    a sub-expression but substitutes it withsubst. | 
| replace_no_path [Path] | replace_no_path ~str sexp ~substlikereplace, but does not take
    optional arguments. | 
| return [Sexp_with_layout.Render] | |
| return [Sexp_intf.S.With_layout.Render] | |
| 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 sexpsame asSexp_intf.S.save_mach. | 
| save [Pre_sexp] | |
| save_hum [Sexp_intf.S] | save_hum ?perm file sexpoutputs S-expressionsexptofilein human
      readable form. | 
| save_hum [Pre_sexp] | |
| save_mach [Sexp_intf.S] | save_mach ?perm file sexpoutputs S-expressionsexptofilein machine readable (i.e. | 
| save_mach [Pre_sexp] | |
| save_of_output [Pre_sexp] | |
| save_sexps [Sexp_intf.S] | save_sexps ?perm file sexpsame asSexp_intf.S.save_sexps_mach. | 
| save_sexps [Pre_sexp] | |
| save_sexps_hum [Sexp_intf.S] | save_sexps_hum ?perm file sexpsoutputs S-expression listsexpstofilein 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 sexpsoutputs S-expression listsexpstofilein 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 lexbuffolds over all whitespace
      separated S-expressions scanned from lex bufferlexbufusing
      functionf, initial stateinit, and the optional string bufferbuffor storing intermediate strings. | 
| scan_fold_sexps [Pre_sexp] | |
| scan_iter_sexps [Sexp_intf.S] | scan_iter_sexps ?buf ~f lexbufiterates over all whitespace
      separated S-expressions scanned from lex bufferlexbufusing
      functionf, and the optional string bufferbuffor storing
      intermediate strings. | 
| scan_iter_sexps [Pre_sexp] | |
| scan_rev_sexps [Sexp_intf.S] | scan_rev_sexps ?buf lexbufsame asSexp_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 lexbufscans an S-expression from lex bufferlexbufusing the optional string bufferbuffor storing
      intermediate strings. | 
| scan_sexp [Pre_sexp] | |
| scan_sexp_opt [Sexp_intf.S] | scan_sexp_opt ?buf lexbufis equivalent toscan_sexp ?buf lexbufexcept that it returnsNonewhen the eof is reached. | 
| scan_sexp_opt [Pre_sexp] | |
| scan_sexps [Sexp_intf.S] | scan_sexps ?buf lexbufreads a list of whitespace separated
      S-expressions from lex bufferlexbufusing the optional string
      bufferbuffor storing intermediate strings. | 
| scan_sexps [Pre_sexp] | |
| scan_sexps_conv [Sexp_intf.S] | scan_sexps_conv ?buf ~f lexbufmaps all whitespace separated
      S-expressions scanned from lex bufferlexbufto some list using
      functionf, and the optional string bufferbuffor 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 nsets the maximum number of converters for exceptions
      with the same template ton. | 
| 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 arconverts the valuearof type'a
    arrayto an S-expression. | 
| sexp_of_big_int [Big_int] | |
| sexp_of_big_int [Conv] | sexp_of_big_int nconverts the valuenof typeBig_int.big_intto an S-expression. | 
| sexp_of_bigstring [Conv] | sexp_of_bigstring bstrconverts a bigstring (character bigarray
    in C-layout) to an S-expression. | 
| sexp_of_bool [Std] | |
| sexp_of_bool [Conv] | sexp_of_bool bconverts the valuexof typeboolto an
    S-expression. | 
| sexp_of_char [Std] | |
| sexp_of_char [Conv] | sexp_of_char cconverts the valuecof typecharto 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 excconverts exceptionexcto an S-expression. | 
| sexp_of_exn_opt [Conv] | sexp_of_exn_opt excconverts exceptionexctoSome sexp. | 
| sexp_of_float [Std] | |
| sexp_of_float [Conv] | sexp_of_float nconverts the valuenof typefloatto an
    S-expression. | 
| sexp_of_float32_mat [Conv] | sexp_of_float32_mat matconverts the two-dimensional bigarraymatof 32-bit floats in Fortran-layout to an S-expression. | 
| sexp_of_float32_vec [Conv] | sexp_of_float32_vec vecconverts the one-dimensional bigarrayvecof 32-bit floats in Fortran-layout to an S-expression. | 
| sexp_of_float64_mat [Conv] | sexp_of_float64_mat matconverts the two-dimensional bigarraymatof 64-bit floats in Fortran-layout to an S-expression. | 
| sexp_of_float64_vec [Conv] | sexp_of_float64_vec vecconverts the one-dimensional bigarrayvecof 64-bit floats in Fortran-layout to an S-expression. | 
| sexp_of_fun [Conv] | sexp_of_fun fconverts the valuefof function type to a
    dummy S-expression. | 
| sexp_of_hashtbl [Conv] | sexp_of_hashtbl conv_key conv_value htblconverts the valuehtblof type('a, 'b) Hashtbl.tto an S-expression. | 
| sexp_of_int [Std] | |
| sexp_of_int [Conv] | sexp_of_int nconverts the valuenof typeintto an
    S-expression. | 
| sexp_of_int32 [Std] | |
| sexp_of_int32 [Conv] | sexp_of_int32 nconverts the valuenof typeint32to an
    S-expression. | 
| sexp_of_int64 [Std] | |
| sexp_of_int64 [Conv] | sexp_of_int64 nconverts the valuenof typeint64to an
    S-expression. | 
| sexp_of_lazy_t [Std] | |
| sexp_of_lazy_t [Conv] | sexp_of_lazy_t conv lconverts the valuelof type'a lazy_tto
    an S-expression. | 
| sexp_of_list [Std] | |
| sexp_of_list [Conv] | sexp_of_list conv lstconverts the valuelstof type'a
    listto an S-expression. | 
| sexp_of_mat [Conv] | sexp_of_mat matsame asConv.sexp_of_float64_mat. | 
| sexp_of_nat [Nat] | |
| sexp_of_nat [Conv] | sexp_of_nat nconverts the valuenof typeNat.natto an
    S-expression. | 
| sexp_of_nativeint [Std] | |
| sexp_of_nativeint [Conv] | sexp_of_nativeint nconverts the valuenof typenativeintto an
    S-expression. | 
| sexp_of_num [Num] | |
| sexp_of_num [Conv] | sexp_of_num nconverts the valuenof typeNum.numto an
    S-expression. | 
| sexp_of_opaque [Conv] | sexp_of_opaque xconverts the valuexof opaque type to an
    S-expression. | 
| sexp_of_option [Std] | |
| sexp_of_option [Conv] | sexp_of_option conv optconverts the valueoptof type'a
    optionto an S-expression. | 
| sexp_of_pair [Conv] | sexp_of_pair conv1 conv2 pairconverts a pair to an S-expression. | 
| sexp_of_pos [Sexp_with_layout] | |
| sexp_of_pos [Sexp_intf.S.With_layout] | |
| sexp_of_ratio [Ratio] | |
| sexp_of_ratio [Conv] | sexp_of_ratio nconverts the valuenof typeRatio.ratioto an
    S-expression. | 
| sexp_of_ref [Std] | |
| sexp_of_ref [Conv] | sexp_of_ref conv rconverts the valuerof type'a refto
    an S-expression. | 
| sexp_of_string [Std] | |
| sexp_of_string [Conv] | sexp_of_bool strconverts the valuestrof typestringto 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 sexpmaps 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 tripleconverts a triple to
    an S-expression usingconv1,conv2, andconv3to convert its
    elements. | 
| sexp_of_unit [Std] | |
| sexp_of_unit [Conv] | sexp_of_unit ()converts a value of typeunitto an S-expression. | 
| sexp_of_vec [Conv] | sexp_of_vec vecsame asConv.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 xconverts the OCaml-valuexto
    an S-expression represented as a string by using conversion functionconv. | 
| string_of_sexp [Std] | |
| string_of_sexp [Conv] | string_of_sexp sexpconverts S-expressionsexpto a value of typestring. | 
| 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 sexpmaps 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 sexpsame asSexp_intf.S.to_buffer_mach. | 
| to_buffer [Pre_sexp] | |
| to_buffer_gen [Sexp_intf.S] | to_buffer_gen ~buf ~add_char ~add_string sexpoutputs the S-expressionsexpconverted to a string to bufferbufusing the output functionsadd_charandadd_string. | 
| to_buffer_gen [Pre_sexp] | |
| to_buffer_hum [Sexp_intf.S] | to_buffer_hum ~buf ?indent sexpoutputs the S-expressionsexpconverted to a string in human readable form to bufferbuf. | 
| to_buffer_hum [Pre_sexp] | |
| to_buffer_mach [Sexp_intf.S] | to_buffer_mach ~buf sexpoutputs the S-expressionsexpconverted
      to a string in machine readable (i.e. | 
| to_buffer_mach [Pre_sexp] | |
| to_string [Sexp_intf.S.Cont_state] | to_string cont_stateconverts state of parser continuationcont_stateto a string. | 
| to_string [Sexp_intf.S] | to_string sexpsame asto_string_mach. | 
| to_string [Pre_sexp.Cont_state] | |
| to_string [Pre_sexp] | |
| to_string_hum [Sexp_intf.S] | to_string_hum ?indent sexpconverts S-expressionsexpto a
      string in human readable form with indentation levelindent. | 
| to_string_hum [Pre_sexp] | |
| to_string_mach [Sexp_intf.S] | to_string_mach sexpconverts S-expressionsexpto a string in
      machine readable (i.e. | 
| to_string_mach [Pre_sexp] | |
| triple_of_sexp [Conv] | triple_of_sexp conv1 conv2 conv3 sexpconverts S-expressionsexpto a triple of type'a * 'b * 'cusing conversion functionsconv1,conv2, andconv3, which convert S-expressions to values of type'a,'b, and'crespectively. | 
| tuple_of_size_n_expected [Conv_error] | |
| U | |
| unexpected_stag [Conv_error] | |
| unit [Sexp_intf.S] | unitthe unit-value as expressed by an S-expression. | 
| unit [Pre_sexp] | |
| unit_of_sexp [Std] | |
| unit_of_sexp [Conv] | unit_of_sexp sexpconverts S-expressionsexpto a value of typeunit. | 
| V | |
| vec_of_sexp [Conv] | vec_of_sexp sexpsame asConv.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_formatreference for the default option format
    used to write option values. | 
| Z | |
| zero [Src_pos.Relative] |