package csexp

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature
1. Serialising

package csexp

csexp
- Csexp
  - Make
    
    Sexp
  - Sexp

Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

module Sexp : Sexp

Signature

Parsing

include module type of Result

include module type of struct include Result end

Results

type ('a, 'e) t = ('a, 'e) result =

| Ok of 'a
| Error of 'e

The type for result values. Either a value Ok v or an error Error e.

val ok : 'a -> ('a, 'e) result

ok v is Ok v.

val error : 'e -> ('a, 'e) result

error e is Error e.

val value : ('a, 'e) result -> default:'a -> 'a

value r ~default is v if r is Ok v and default otherwise.

val get_ok : ('a, 'e) result -> 'a

get_ok r is v if r is Ok v and raise otherwise.

raises Invalid_argument
if r is Error _.

val get_error : ('a, 'e) result -> 'e

get_error r is e if r is Error e and raise otherwise.

raises Invalid_argument
if r is Ok _.

val bind : ('a, 'e) result -> ('a -> ('b, 'e) result) -> ('b, 'e) result

bind r f is f v if r is Ok v and r if r is Error _.

val join : (('a, 'e) result, 'e) result -> ('a, 'e) result

join rr is r if rr is Ok r and rr if rr is Error _.

val map : ('a -> 'b) -> ('a, 'e) result -> ('b, 'e) result

map f r is Ok (f v) if r is Ok v and r if r is Error _.

val map_error : ('e -> 'f) -> ('a, 'e) result -> ('a, 'f) result

map_error f r is Error (f e) if r is Error e and r if r is Ok _.

val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c

fold ~ok ~error r is ok v if r is Ok v and error e if r is Error e.

val iter : ('a -> unit) -> ('a, 'e) result -> unit

iter f r is f v if r is Ok v and () otherwise.

val iter_error : ('e -> unit) -> ('a, 'e) result -> unit

iter_error f r is f e if r is Error e and () otherwise.

Predicates and comparisons

val is_ok : ('a, 'e) result -> bool

is_ok r is true if and only if r is Ok _.

val is_error : ('a, 'e) result -> bool

is_error r is true if and only if r is Error _.

val equal : 
  ok:('a -> 'a -> bool) ->
  error:('e -> 'e -> bool) ->
  ('a, 'e) result ->
  ('a, 'e) result ->
  bool

equal ~ok ~error r0 r1 tests equality of r0 and r1 using ok and error to respectively compare values wrapped by Ok _ and Error _.

val compare : 
  ok:('a -> 'a -> int) ->
  error:('e -> 'e -> int) ->
  ('a, 'e) result ->
  ('a, 'e) result ->
  int

compare ~ok ~error r0 r1 totally orders r0 and r1 using ok and error to respectively compare values wrapped by Ok _ and Error _. Ok _ values are smaller than Error _ values.

Converting

val to_option : ('a, 'e) result -> 'a option

to_option r is r as an option, mapping Ok v to Some v and Error _ to None.

val to_list : ('a, 'e) result -> 'a list

to_list r is [v] if r is Ok v and [] otherwise.

val to_seq : ('a, 'e) result -> 'a Seq.t

to_seq r is r as a sequence. Ok v is the singleton sequence containing v and Error _ is the empty sequence.

type ('a, 'b) result = ('a, 'b) Result.t =

| Ok of 'a
| Error of 'b

val parse_string : string -> (Sexp.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 -> (Sexp.t list, int * string) result

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

val input : in_channel -> (Sexp.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 -> (Sexp.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 -> (Sexp.t list, string) result

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

Serialising

val serialised_length : Sexp.t -> int

The length of the serialised representation of a S-expression

val to_string : Sexp.t -> string

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

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

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

val to_channel : out_channel -> Sexp.t -> unit

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