Documentation

a heterogenous list.

a Lisp-2 S-expression, where:

• f is the function namespace
• a is the atom namespace

you could define type Lisp1 a = Sexp a a. with some caveats:

• f is ignored by Monadic methods like joinSexp
• plate doesn't reach the f, even when f ~ a, as the Plated instance is manual, not automatic via Data.

the List case is just a specialized Sexp (), but easier to work with than:

• Sexp (Maybe f) [Sexp f a] (where Nothing would represent List)
• forcing each concrete f to hold a unit case (which would represent List)

examples:

>>> 'toList' (List [Atom "f",Atom "x",List [Atom "g",Atom "y"],Atom "z"])
["f","x","g","y","z"]

>>> :{
let doubleSexp e = do
                    x <- e
                    listSexp [x,x]
:} 
>>> doubleSexp (List [Atom "f", Sexp () [Atom "a", Atom "b"]])
List [List [Atom "f",Atom "f"],Sexp () [List [Atom "a",Atom "a"],List [Atom "b",Atom "b"]]]

isomorphic to:

data Sexp_ a
 = Atom_ a 
 | List_ [Sexp_ a]

when you only care about lists (e.g. to interface with other s-expression libraries).

data ByteSexp
 = Atom ByteString
 | List [ByteSexp]

bytesexp2sexp :: ByteSexp -> Sexp_ ByteString
bytesexp2sexp = toSexp $ case
 Atom s  -> Left  s 
 List es -> Right es 

pureSexp = Atom

refines any Sexp to a list, which can be given to the List.

>>> appendSexp (Atom "f") (List [Atom "x"])
List [Atom "f",Atom "x"]

emptySexp = List []

fold over an sexp.

i.e. strictly evaluate a sexp ("all the way") to an atom, within any monadic context.

>>> data ArithFunc = Add | Multiply | Negate deriving Show
>>> let badArith  = Sexp Negate [Atom 1, Atom 2, Atom 3] :: Sexp ArithFunc Integer
>>> let goodArith = Sexp Add [Sexp Multiply [], Sexp Negate [Atom (10::Integer)], Sexp Multiply [Atom 2, Atom 3, Atom 4]]
>>> :set -XLambdaCase
>>> :{
let evalArith = \case
                 Add      -> \case
                              xs    -> Just [sum xs]
                 Multiply -> \case
                              xs    -> Just [product xs]
                 Negate   -> \case
                              [x]   -> Just [negate x] 
                              _     -> Nothing 
:}
>>> evalSplatSexp (flip evalArith) (fmap (:[]) badArith)  -- wrong arity
Nothing 
>>> evalSplatSexp (flip evalArith) (fmap (:[]) goodArith) -- (+ (*) (- 10) (* 2 3 4))
Just [15] 

specializing, as above, (m ~ Maybe), (b ~ [Integer]), (g ~ ArithFunc):

evalSplatSexp :: ([Integer] -> ArithFunc -> Maybe [Integer]) -> (Sexp ArithFunc [Integer] -> Maybe [Integer])

evalSplatSexp apply = evalSexp ('pure'.'fold') (apply.fold)

when a Sexp's atoms are Monoidal ("list-like"), after evaluating some expressions into atoms, we can "splat" them back together.

splatList takes:

• an evaluator eval
• and a list of s-expressions es to evaluate in sequence.

inject a list of atoms.

>>> listSexp [1,2,3]
List [Atom 1,Atom 2,Atom 3]