package csexp

You can search for identifiers within the package.

in-package search v0.2.0

csexp
- Csexp
  - Input
    
    Monad
  - Make
    
    Input
    
    Monad
    
    Make_parser
    
    Input
    
    Monad
    
    Parser
    
    Lexer
    
    Stack
    
    Sexp
  - Make_parser
    
    Input
    
    Monad
  - Parser
    
    Lexer
    
    Stack
  - S
    
    Input
    
    Monad
    
    Make_parser
    
    Input
    
    Monad
    
    Parser
    
    Lexer
    
    Stack
  - Sexp

Legend:
Library
Module
Module type
Parameter
Class
Class type

Canonical S-expressions

This module provides minimal support for reading and writing S-expressions in canonical form.

https://en.wikipedia.org/wiki/Canonical_S-expressions

Note that because the canonical representation of S-expressions is so simple, this module doesn't go out of his way to provide a fully generic parser and printer and instead just provides a few simple functions. If you are using fancy input sources, simply copy the parser and adapt it. The format is so simple that it's pretty difficult to get it wrong by accident.

To avoid a dependency on a particular S-expression library, the only module of this library is parameterised by the type of S-expressions.

let rec print = function
  | Atom str -> Printf.printf "%d:%s" (String.length s)
  | List l -> List.iter print l

module type Sexp = sig ... end

module type S = sig ... end

module Make (Sexp : Sexp) : S with type sexp := Sexp.t

include Sexp

type t =

| Atom of string
| List of t list

include S with type sexp := t

val parse_string : string -> (t, int * string) result

parse_string s parses a single S-expression encoded in canonical form in s. It is an error for s to contain a S-expression followed by more data. In case of error, the offset of the error as well as an error message is returned.

val parse_string_many : string -> (t list, int * string) result

parse_string s parses a sequence of S-expressions encoded in canonical form in s

val input : in_channel -> (t, string) result

Read exactly one canonical S-expressions from the given channel. Note that this function never raises End_of_file. Instead, it returns Error.

val input_opt : in_channel -> (t option, string) result

Same as input but returns Ok None if the end of file has already been reached. If some more characters are available but the end of file is reached before reading a complete S-expression, this function returns Error.

val input_many : in_channel -> (t list, string) result

Read many S-expressions until the end of input is reached.

Serialising

val serialised_length : t -> int

The length of the serialised representation of a S-expression

val to_string : t -> string

to_string sexp converts S-expression sexp to a string in canonical form.

val to_buffer : Buffer.t -> t -> unit

to_buffer buf sexp outputs the S-expression sexp converted to its canonical form to buffer buf.

val to_channel : out_channel -> t -> unit

output oc sexp outputs the S-expression sexp converted to its canonical form to channel oc.

Low level parser

For efficiently parsing from sources other than strings or input channel. For instance in Lwt or Async programs.

module Parser : sig ... end

The Parser module offers an API that is a balance between sharing the common logic of parsing canonical S-expressions while allowing to write parsers that are as efficient as possible, both in terms of speed and allocations. A carefully written parser using this API will be:

Deprecated low-level parser

The above are deprecated as the Input signature does not allow to distinguish between IO errors and end of input conditions. Additionally, the use of monads tend to produce parsers that allocates a lot.

It is recommended to use the Parser module instead.

module type Input = sig ... end

module Make_parser (Input : Input) : sig ... end