Decode several S-expressions according to a given SExprParser. This will return a list of every S-expression that appears at the top-level of the document.

Decode a single S-expression. If any trailing input is left after the S-expression (ignoring comments or whitespace) then this will fail: for those cases, use decode, which returns a list of all the S-expressions found at the top level.

Turn a list of s-expressions into a single string according to a given SExprPrinter.

Turn a single s-expression into a string according to a given SExprPrinter.

A SExprParser describes a parser for a particular value that has been serialized as an s-expression. The atom parameter corresponds to a Haskell type used to represent the atoms, and the carrier parameter corresponds to the parsed S-Expression structure.

A Reader represents a reader macro: it takes a parser for the S-Expression type and performs as much or as little parsing as it would like, and then returns an S-expression.

A Comment represents any kind of skippable comment. This parser must be able to fail if a comment is not being recognized, and it must not consume any input in case of failure.

Create a basic SExprParser when given a parser for an atom type.

>>> import Text.Parsec (alphaNum, many1)
>>> let parser = mkParser (many1 alphaNum)
>>> decode parser "(ele phant)"
Right [SCons (SAtom "ele") (SCons (SAtom "phant") SNil)]

Modify the carrier type for a SExprParser. This is used internally to convert between various SExpr representations, but could also be used externally to add an extra conversion layer onto a SExprParser.

>>> import Text.Parsec (alphaNum, many1)
>>> import Data.SCargot.Repr (toRich)
>>> let parser = setCarrier (return . toRich) (mkParser (many1 alphaNum))
>>> decode parser "(ele phant)"
Right [RSlist [RSAtom "ele",RSAtom "phant"]]

Add the ability to execute some particular reader macro, as defined by its initial character and the Parser which returns the parsed S-Expression. The Reader is passed a Parser which can be recursively called to parse more S-Expressions, and begins parsing after the reader character has been removed from the stream.

>>> import Text.Parsec (alphaNum, char, many1)
>>> let vecReader p = (char ']' *> pure SNil) <|> (SCons <$> p <*> vecReader p)
>>> let parser = addReader '[' vecReader (mkParser (many1 alphaNum))
>>> decode parser "(an [ele phant])"
Right [SCons (SAtom "an") (SCons (SCons (SAtom "ele") (SCons (SAtom "phant") SNil)) SNil)]

Add the ability to ignore some kind of comment. This gets factored into whitespace parsing, and it's very important that the parser supplied be able to fail (as otherwise it will cause an infinite loop), and also that it not consume any input (which may require it to be wrapped in try.)

>>> import Text.Parsec (alphaNum, anyChar, manyTill, many1, string)
>>> let comment = string "//" *> manyTill anyChar newline *> pure ()
>>> let parser = setComment comment (mkParser (many1 alphaNum))
>>> decode parser "(ele //a comment\n  phant)"
Right [SCons (SAtom "ele") (SCons (SAtom "phant") SNil)]

Convert the final output representation from the SExpr type to the RichSExpr type.

>>> import Text.Parsec (alphaNum, many1)
>>> let parser = asRich (mkParser (many1 alphaNum))
>>> decode parser "(ele phant)"
Right [RSlist [RSAtom "ele",RSAtom "phant"]]

Convert the final output representation from the SExpr type to the WellFormedSExpr type.

>>> import Text.Parsec (alphaNum, many1)
>>> let parser = asWellFormed (mkParser (many1 alphaNum))
>>> decode parser "(ele phant)"
Right [WFSList [WFSAtom "ele",WFSAtom "phant"]]

Add the ability to understand a quoted S-Expression. Many Lisps use 'sexpr as sugar for (quote sexpr). This assumes that the underlying atom type implements the IsString class, and will create the quote atom using fromString "quote".

>>> import Text.Parsec (alphaNum, many1)
>>> let parser = withQuote (mkParser (many1 alphaNum))
>>> decode parser "'elephant"
Right [SCons (SAtom "quote") (SCons (SAtom "foo") SNil)]

A SExprPrinter value describes how to print a given value as an s-expression. The carrier type parameter indicates the value that will be printed, and the atom parameter indicates the type that will represent tokens in an s-expression structure.

The Indent type is used to determine how to indent subsequent s-expressions in a list, after printing the head of the list.

A default SExprPrinter struct that will always swing subsequent expressions onto later lines if they're too long, indenting them by two spaces, and uses a soft maximum width of 80 characters

A default SExprPrinter struct that will always print a SExpr as a single line.

A default SExprPrinter struct that will always swing subsequent expressions onto later lines if they're too long, indenting them by two spaces, but makes no effort to keep the pretty-printed sources inside a maximum width. In the case that we want indented printing but don't care about a "maximum" width, we can print more efficiently than in other situations.

Modify the carrier type of a SExprPrinter by describing how to convert the new type back to the previous type. For example, to pretty-print a well-formed s-expression, we can modify the SExprPrinter value as follows:

>>> let printer = setFromCarrier fromWellFormed (basicPrint id)
>>> encodeOne printer (WFSList [WFSAtom "ele", WFSAtom "phant"])
"(ele phant)"

Dictate a maximum width for pretty-printed s-expressions.

>>> let printer = setMaxWidth 8 (basicPrint id)
>>> encodeOne printer (L [A "one", A "two", A "three"])
"(one \n  two\n  three)"

Allow the serialized s-expression to be arbitrarily wide. This makes all pretty-printing happen on a single line.

>>> let printer = removeMaxWidth (basicPrint id)
>>> encodeOne printer (L [A "one", A "two", A "three"])
"(one two three)"

Set the number of spaces that a subsequent line will be indented after a swing indentation.

>>> let printer = setMaxWidth 12 (basicPrint id)
>>> encodeOne printer (L [A "elephant", A "pachyderm"])
"(elephant \n  pachyderm)"
>>> encodeOne (setIndentAmount 4) (L [A "elephant", A "pachyderm"])
"(elephant \n    pachyderm)"

Dictate how to indent subsequent lines based on the leading subexpression in an s-expression. For details on how this works, consult the documentation of the Indent type.

>>> let indent (A "def") = SwingAfter 1; indent _ = Swing
>>> let printer = setIndentStrategy indent (setMaxWidth 8 (basicPrint id))
>>> encodeOne printer (L [ A "def", L [ A "func", A "arg" ], A "body" ])
"(def (func arg)\n  body)"
>>> encodeOne printer (L [ A "elephant", A "among", A "pachyderms" ])
"(elephant \n  among\n  pachyderms)"