S-expression type annotated with positions. Useful for further parsing.

Position: file name, line number, column number

A common type of grammar that operates on S-expressions. This grammar accepts a single Sexp value and converts it into a value of type a.

Representation of an invertible grammar -- a grammar that can be run either "forwards" and "backwards".

For a grammar Grammar p a b, running it forwards will take a value of type a and possibly produce a value of type b. Running it backwards will take a value of type b and possibly produce an a. If a value cannot be produced, an error message is generated.

As a common example, running a Grammar forwards corresponds to parsing and running backwards corresponds to prettyprinting.

That is, the grammar defines a partial isomorphism between two values.

"Cons" pair of a heterogenous list or a stack with potentially polymophic tail. E.g. "first" :- 2 :- (3,4) :- t

Isomorphic to a tuple with two elments, but is much more convenient for nested pairs.

A class for types that could be converted to and inferred from s-expressions defined by Sexp.

Run grammar in generating (right-to-left) direction

toSexp g = runGrammarString Sexp.dummyPos . backward (sealed g)

Serialize a value using SexpIso instance

Serialise a value using a provided grammar

Serialise and pretty-print a value using its SexpIso instance

Serialise and pretty-print a value using a provided grammar

Run grammar in parsing (left-to-right) direction

fromSexp g = runGrammarString Sexp.dummyPos . forward (sealed g)

Deserialise a value using its SexpIso instance

Deserialise a value using provided grammar, use a provided file name for error messages

Left-to-right composition

Right-to-left composition

Extract/inject a position from/to a Sexp.

Grammar matching fractional number atoms to Scientific values.

>>> encodeWith real (3.141592653589793^3)
Right "31.006276680299813114880451174049119330924860257"

Grammar matching fractional number atoms to Double values.

>>> encodeWith double (3.141592653589793^3)
Right "31.006276680299816"

Grammar matching integer number atoms to Int values.

>>> encodeWith int (2^63)
Right "-9223372036854775808"

>>> encodeWith int (2^63-1)
Right "9223372036854775807"

Grammar matching integer number atoms to Integer values.

>>> encodeWith integer (2^100)
Right "1267650600228229401496703205376"

Grammar matching string literal atoms to Text values.

>>> let grammar = list (el string >>> el int) >>> pair
>>> encodeWith grammar ("some-string", 42)
Right "(\"some-string\" 42)"

Grammar matching symbol literal atoms to Text values.

>>> encodeWith symbol "some-symbol"
Right "some-symbol"

Grammar matching symbol literal atoms starting with ':' to Text values without the colon char.

>>> encodeWith keyword "username"
Right ":username"

Grammar matching symbol literal atoms to a specified symbol.

>>> let grammar = list (el (sym "username") >>> el string)
>>> encodeWith grammar "Julius Caesar"
Right "(username \"Julius Caesar\")"

Grammar matching symbol literal atoms to a specified symbol prepended with ':'.

>>> let grammar = list (el (kwd "password") >>> el int)
>>> encodeWith grammar 42
Right "(:password 42)"

Elements of a list that is being parsed/constructed.

Parenthesis list grammar. Runs a specified grammar on a sequence of S-exps in a parenthesized list.

>>> let grammar = list (el symbol >>> el int) >>> pair
>>> encodeWith grammar ("foo", 42)
Right "(foo 42)"

Bracket list grammar. Runs a specified grammar on a sequence of S-exps in a bracketed list.

>>> let grammar = bracketList (rest int)
>>> encodeWith grammar [2, 3, 5, 7, 11, 13]
Right "[2 3 5 7 11 13]"

Brace list grammar. Runs a specified grammar on a sequence of S-exps in a list enclosed in braces.

>>> let grammar = braceList (props (key "x" real >>> key "y" real)) >>> pair
>>> encodeWith grammar (3.1415, -1)
Right "{:x 3.1415 :y -1}"

Element of a sequence grammar. Runs a specified grammar on a next element of a sequence. The underlying grammar can produce zero or more values on the stack.

E.g.:

• el (sym "lambda") consumes a symbol "lambda" and produces no values on the stack.
• el symbol consumes a symbol and produces a Text value corresponding to the symbol.

The rest of a sequence grammar. Runs a specified grammar on each of remaining elements of a sequence and collect them. Expects zero or more elements in the sequence.

>>> let grammar = list (el (sym "check-primes") >>> rest int)
>>> encodeWith grammar [2, 3, 5, 7, 11, 13]
Right "(check-primes 2 3 5 7 11 13)"

Key/value pairs of a property list that is being parsed/constructed.

Property list in a sequence grammar. Collects pairs of keywords and S-expressions from remaining sequence elements and runs a specified grammar on them. Expects zero or more pairs in the sequence. If sequence of pairs interrupts with a non-keyword, the rest of this sequence is left untouched.

Collected PropertyList is then available for random-access lookup combinators key, optKey, .:, .:? or bulk extraction restKeys combinator.

>>> :{
 let grammar = braceList (
       props (key "real" real >>> key "img" real) >>> onTail pair >>> el (sym "/") >>>
       props (key "real" real >>> key "img" real) >>> onTail pair) >>> pair
 in encodeWith grammar ((0, -1), (1, 0))
:}
Right "{:real 0 :img -1 / :real 1 :img 0}"

Property by a key grammar. Looks up an S-expression by a specified key and runs a specified grammar on it. Expects the key to be present.

Note: performs linear lookup, O(n)

Optional property by a key grammar. Like key but puts Nothing in correspondence to the missing key and Just to the present.

Note: performs linear lookup, O(n)

Property by a key grammar. Infix version of key.

Optional property by a key grammar. Infix version of optKey.

Remaining properties grammar. Extracts all key-value pairs and applies a grammar on every element.

S-expression quotation type

Grammar matching a prefixed S-expression, runs a sub-grammar on a Sexp under the prefix.

>>> encodeWith (prefixed Backtick symbol) "foo"
Right "`foo"

Grammar matching a prefixed S-expression, runs a sub-grammar on a Sexp under the quotation.

>>> encodeWith (quoted symbol) "foo"
Right "'foo"

Grammar matching a prefixed S-expression, runs a sub-grammar on a Sexp under the hash prefix.

>>> encodeWith (hashed symbol) "foo"
Right "#foo"

Data type to encode mismatches during parsing or generation, kept abstract. Use expected and unexpected constructors to build a mismatch report.

Construct a mismatch report with specified expectation. Can be appended to other expectations and unexpected reports to clarify a mismatch.

Construct a mismatch report with information what occurred during the processing but was not expected.