All S-Expressions can be understood as a sequence of cons cells (represented here by SCons), the empty list nil (represented by SNil) or an atom.

Combine the two s-expressions into a new one.

>>> cons (A "el") (L ["eph", A "ant"])
SCons (SAtom "el) (SCons (SAtom "eph") (SCons (SAtom "ant") SNil))

Produce the head and tail of the s-expression (if possible).

>>> uncons (A "el" ::: A "eph" ::: A "ant" ::: Nil)
Just (A "el",SCons (SAtom "eph") (SCons (SAtom "ant") SNil))

A shorter infix alias for SCons

>>> A "pachy" ::: A "derm"
SCons (SAtom "pachy") (SAtom "derm")

A shorter alias for SAtom

>>> A "elephant"
SAtom "elephant"

An alias for matching a proper list.

>>> L [A "pachy", A "derm"]
SExpr (SAtom "pachy") (SExpr (SAtom "derm") SNil)

An alias for matching a dotted list.

>>> DL [A "pachy"] A "derm"
SExpr (SAtom "pachy") (SAtom "derm")

A (slightly) shorter alias for SNil

>>> Nil
SNil

A traversal with access to the first element of a pair.

>>> import Lens.Family
>>> set _car (A "elephant") (A "one" ::: A "two" ::: A "three" ::: Nil)
A "elelphant" ::: A "two" ::: A "three" ::: Nil
>>> set _car (A "two" ::: A "three" ::: Nil) (A "one" ::: A "elephant")
(A "two" ::: A "three" ::: Nil) ::: A "elephant"

A traversal with access to the second element of a pair.

>>> import Lens.Family
>>> set _cdr (A "elephant") (A "one" ::: A "two" ::: A "three" ::: Nil)
A "one" ::: A "elephant"
>>> set _cdr (A "two" ::: A "three" ::: Nil) (A "one" ::: A "elephant")
A "one" ::: A "two" ::: A "three" ::: Nil

Utility function for parsing a pair of things.

>>> fromPair (isAtom "pachy") (asAtom return) (A "pachy" ::: A "derm" ::: Nil)
Right ((), "derm")
>>> fromPair (isAtom "pachy") fromAtom (A "pachy" ::: Nil)
Left "Expected two-element list"

Utility function for parsing a list of things.

Utility function for parsing a single atom

Parse a two-element list (NOT a dotted pair) using the provided function.

>>> let go (A l) (A r) = return (l ++ r); go _ _ = Left "expected atoms"
>>> asPair go (A "pachy" ::: A "derm" ::: Nil)
Right "pachyderm"
>>> asPair go (A "elephant" ::: Nil)
Left "asPair: expected two-element list; found list of length 1"

Parse an arbitrary-length list using the provided function.

>>> let go xs = concat <$> mapM fromAtom xs
>>> asList go (A "el" ::: A "eph" ::: A "ant" ::: Nil)
Right "elephant"
>>> asList go (A "el" ::: A "eph" ::: A "ant")
Left "asList: expected list; found dotted list of length 3"

Match a given literal atom, failing otherwise.

>>> isAtom "elephant" (A "elephant")
Right ()
>>> isAtom "elephant" (A "elephant" ::: Nil)
Left "isAtom: expected atom; found list"

Parse an atom using the provided function.

>>> import Data.Char (toUpper)
>>> asAtom (return . map toUpper) (A "elephant")
Right "ELEPHANT"
>>> asAtom (return . map toUpper) Nil
Left "asAtom: expected atom; found empty list"

Parse an assoc-list using the provided function.

>>> let def (x, y) = do { a <- fromAtom x; b <- fromAtom y; return (a ++ ": " ++ b) }
>>> let defList xs = do { defs <- mapM def xs; return (unlines defs) }
>>> asAssoc defList ((A "legs" ::: A "four" ::: Nil) ::: (A "trunk" ::: A "one" ::: Nil) ::: Nil)
Right "legs: four\ntrunk: one\n"
>>> asAssoc defList ((A "legs" ::: A "four" ::: Nil) ::: (A "elephant") ::: Nil)
Left "asAssoc: expected pair; found list of length 1"