JavaScript Object Notation (JSON) input scanner.
Functions that scan Unicode text for JSON interchange language syntax. A low-level lexical token scanner is provided for monadic parsing of any valid JSON text, including infinite streams. Higher-level scanners are provided for composing bespoke parsers according to a required schema. A scanner is also provided for input of arbitrary finite JSON values.
module Annot = Ucs_scan.UTF8.AnnotA convenient alias for the UTF-8 text annotation system.
val lexer : Json_event.t Annot.form Ucs_scan.UTF8.tThe lexical analyzer that recognizes JSON events.
Include the scanner profile.
include Cf_scan.Staging.Profile
with type symbol := Uchar.t
and type token := Json_event.t
and type position := Cf_annot.Textual.position
and type 'a form := 'a Annot.forminclude Cf_scan.Profile
with type symbol := Json_event.t
with type position := Cf_annot.Textual.position
with type 'a form := 'a Annot.forminclude Cf_monad.Unary.Profile with type +'r t := 'r tModule inclusions from Cf_monad_core and Cf_seqmonad.
include Cf_monad.Core.Unary.Profile with type 'r t := 'r tval return : 'r -> 'r tUse return a to apply the binding to a.
Use map m f to return the result of applying f to the value returned by m.
module Infix : Cf_monad_core.Unary.Infix with type 'r t := 'r tOpen Infix to include the infix monad operators.
include Cf_seqmonad.Functor.Unary with type 'r t := 'r tUse collect s to bind in sequence every monad value in the finite sequence s and collect all the returned values. Returns (n, s) where n is the number of values collected and s is the list of values in reverse order, i.e. from last collected to first collected. Never returns and exhausts all memory if s never terminates.
val nil : 'r tA scanner that never produces any value.
val fin : bool tA scanner that returns true at the end of the input sequence, otherwise returns false.
val pos : mark -> unit Annot.formUse pos mark to make a unit value attributed with the position of captured mark. Raises Not_found if mark was captured at the end of the input stream.
val any : Json_event.t Annot.form tThe universal symbol scanner. Recognizes any symbol in the input stream and produces its form. Does not produce anything at the end of input.
val one : Json_event.t -> Json_event.t Annot.form tThe literal symbol scanner. Use one symbol to make a scanner that recognizes symbol in the input stream and produces its form.
val sat : (Json_event.t -> bool) -> Json_event.t Annot.form tThe symbol satisfier scanner. Use sat f to make a scanner that recognizes any symbol for which applying f returns true and produces its form.
val ign : (Json_event.t -> bool) -> unit Annot.form tThe ignore scanner. Use ign f to make a scanner that scans the input while applying f to each symbol returns true, then produces a unit form that annotates the span of ignored symbols. Produces an implicit unit form if the end of input has already been reached.
val tok : (Json_event.t -> 'r option) -> 'r Annot.form tThe symbolic token scanner. Use tok f to make a scanner that recognizes any symbol for which applying f returns Some v, then produces the form of v.
val ntyp : 'r Cf_type.nym -> 'r Annot.form t -> Cf_type.opaque Annot.form tThe opaque value form scanner composer. Use ntyp n p to make a scanner that encloses the value contained in the form produced by p in an opaque value with the runtime type indicated by n and returns its form in the same position.
The default value scanner. Use dflt v p to produce the output of p or the default value v if p does not produce output.
The optional scanner composer. Use opt p to make a scanner that produces either Some v if p produces v otherwise None.
The visitor scanner composer. Use vis ?a ?b f v to compose a scanner that recognizes a sequence of elements in the input stream by applying a visitor function f at each element to obtain its scanner. The first element is visited with the initializer v, and each following element is visited with the value returned by the preceding scanner.
If ~a is used, then it specifies the minimum number of elements to visit. If ~b is used then it specifies the maximum number of elements to visit. Composition raises Invalid_argument if a < 0 or b < a.
The homogenous list scanner composer. Use seq ?a ?b p to create a new scanner that uses p to recognize and produce, in order, each element in a sequence of elements in the input stream.
If ~a is used, then it specifies the minimum number of elements that must be recognized and produced in the output. If ~b is used then it specifies the maximum number of elements to recognize. Composition raises Invalid_argument if a < 0 or b < a.
The bounded multiple choice scanner. Use alt ps to create a scanner that produces the output from the first scanner ps that produces. If no scanner in ps produces output, then the resulting scanner does not produce.
The unbounded multiple choice scanner. Use alt ps to create a scanner that produces the output from the first scanner ps that produces. If no scanner in ps produces output, then the resulting scanner does not produce.
A distinguished syntax failure exception.
val fail : string -> 'r tUse fail msg to raise Bad_syntax with msg optionally annotated with the current position.
Use or_fail msg p to make a scanner that raises Bad_syntax with msg if p does not recognize its input. It may be convenient to call this function with a pipeline operator, i.e. p |> or_fail "reasons".
val err : ?x:exn -> unit -> 'r tUse err ~x () to make a scanner that raises x. If ?x is not provided, then it raises Not_found.
Use errf ~xf () to make a scanner that captures a mark and applies it to xf to raise an exception. If ?xf is not provided, then raises Not_found.
Use req ~x p to make a scanner that either produces the output of p or raises x. If p does not produce and ?x is not provided, then it raises Not_found.
Use reqf ~xf p to make a scanner that either produces the output of p or captures a mark at the current input and applies it to xf to raise an exception. If ?xf is not provided, then raises Not_found.
The error check scanner. Use ck p to create a new scanner that either produces either Ok v if p produces v or Error x if scanning the input with p raises the exception x.
The error recovery scanner. Use sync p to scan the input with p until it produces or reaches the end of input. Produces Some v if p ever produces v, otherwise produces None if the end of input is reached without p producing a value.
val lift :
?start:Cf_annot.Textual.position ->
'r t ->
Json_event.t Seq.t ->
'r Seq.tUse lift p s to map s into a persistent sequence of the values produced by p. If ~start is provided, then it specifies the starting position of the first symbol in s.
val of_seq :
?start:Cf_annot.Textual.position ->
'r t ->
Json_event.t Seq.t ->
'rUse of_seq p s to parse s with p and return the result. Raises Not_found if p does not recognize the entire sequence of s. If ~start is provided, then it specifies the starting position of the first symbol in s.
module Affix : sig ... endCombinator operators
val lift_staged :
?start:Cf_annot.Textual.position ->
'r t ->
Uchar.t Seq.t ->
'r Seq.tUse lift_staged p s to lift s into the first stage token sequence, then map it into a persistent sequence of the values produced by p. If ~start is provided, then it specifies the starting position of the first symbol in s.
val of_seq_staged :
?start:Cf_annot.Textual.position ->
'r t ->
Uchar.t Seq.t ->
'rUse of_seq_staged p s to lift s into the first stage token sequence, then parse it with p, and return the result. Raises Not_found if p does not recognize the entire sequence of s. If ~start is provided, then it specifies the starting position of the first symbol in s.
val event : Json_event.t Annot.form tThe parser that returns the next annotated event that is not space.
val space : unit Annot.form tThe parser that recognizes a space event.
The following parsers all ignore any white space encountered in the input before recognizing the scalar value.
val null : unit Annot.form tA parser that recognizes the null literal.
val boolean : bool Annot.form tThe parser that recognizes either the true or false literal and returns the value of annotated boolean value accordingly.
val integer : int Annot.form tThe parser that recognizes an integer number within the range of Ocaml and returns the annotated integer value accordingly.
val float : float Annot.form tThe parser that recognizes a number within the range of Ocaml floating point numbers and returns the annotated float value accordingly.
val string : Ucs_text.t Annot.form tThe parser that recognizes a string literal and returns the annotated Unicode text with all the escaped sequences converted.
val signal : [< Json_event.signal ] -> unit Annot.form tUse signal x to make a parser that recognizes the event signal x.
The following interfaces are provided to facilitate various strategies for scanning arrays and objects.
module Chain :
Cf_chain_scan.Profile
with type symbol := Json_event.t Annot.form
and type mark := mark
and type 'a t := 'a t
and type 'a form := 'aThe chain scanner module.
val chain : ?xf:(mark -> 'x) -> unit -> Chain.chainUse chain () to make a chain discipline for array and object content, which is a list of elements separated by semi-colon characters.
module Object :
Cf_record_scan.Profile
with type index := Ucs_text.t
and type 'a form := 'a Annot.form
and type 'a t := 'a tThe record scanner module for JSON object content.
val group : [< `Array | `Object ] -> 'r t -> 'r Annot.form tUse group kind content to make a parser that recognizes an array or an object form according to kind with content that must be recognized by content.
For example, use float |> seq ~a:1 ?b |> group `Array to scan an array of one or more floating point numbers.
Alternatively, use Object.scan schema |> group `Object to scan an object according to schema.
val value : Cf_type.opaque Annot.form tA parser that recognizes any JSON encoded value and produces an annotated opaque value with encapsulated runtime type indication. The following table describes the runtime type indications produced for values decoded.
Cf_type.UnitCf_type.BoolCf_type.Int or Cf_type.FloatUcs_type.TextCf_type.Seq Cf_type.OpaqueCf_type.(Seq (Pair (Ucs_type.Text, Cf_type.Opaque))Use the Ucs_type module for unpacking.
Note well: the array and object containers are sequences of untyped values, which must be unpacked recursively.
val of_text : 'a t -> Ucs_text.t -> 'aUse of_text p t to parse the Unicode text s with p.