Data.AttoLisp

Efficient parsing and serialisation of S-Expressions (as used by Lisp).

This module is intended to be imported qualified, e.g.:

import qualified Data.AttoLisp as L

Core Lisp Types

data Lisp

A Lisp expression (S-expression).

Symbols are case-sensitive.

NOTE: The Number type is deprecated in "attoparsec", so a future version of "atto-lisp" will switch to the Scientific type from the "scientific" package.

Constructors

Symbol Text

A symbol (including keyword)

String Text

A string.

Number Number

A number

List [Lisp]

A proper list: (foo x 42)

DotList [Lisp] Lisp

A list with a non-nil tail: (foo x . 42). The list argument must be non-empty and the tail must be non-nil.

Instances

Eq Lisp

Defined in Data.AttoLisp

Methods

(==) :: Lisp -> Lisp -> Bool

(/=) :: Lisp -> Lisp -> Bool

Data Lisp

Defined in Data.AttoLisp

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lisp -> c Lisp

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lisp

toConstr :: Lisp -> Constr

dataTypeOf :: Lisp -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Lisp)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lisp)

gmapT :: (forall b. Data b => b -> b) -> Lisp -> Lisp

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lisp -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lisp -> r

gmapQ :: (forall d. Data d => d -> u) -> Lisp -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Lisp -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lisp -> m Lisp

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lisp -> m Lisp

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lisp -> m Lisp

Ord Lisp

Defined in Data.AttoLisp

Methods

compare :: Lisp -> Lisp -> Ordering

(<) :: Lisp -> Lisp -> Bool

(<=) :: Lisp -> Lisp -> Bool

(>) :: Lisp -> Lisp -> Bool

(>=) :: Lisp -> Lisp -> Bool

max :: Lisp -> Lisp -> Lisp

min :: Lisp -> Lisp -> Lisp

Show Lisp

Defined in Data.AttoLisp

Methods

showsPrec :: Int -> Lisp -> ShowS

show :: Lisp -> String

showList :: [Lisp] -> ShowS

IsString Lisp

Defined in Data.AttoLisp

Methods

fromString :: String -> Lisp

NFData Lisp

Defined in Data.AttoLisp

Methods

rnf :: Lisp -> ()

FromLisp Lisp

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Lisp

ToLisp Lisp

Defined in Data.AttoLisp

Methods

toLisp :: Lisp -> Lisp

nil :: Lisp

The empty list.

isNull :: Lisp -> Bool

Returns True if the expression is nil or the empty list.

Type Conversion

class FromLisp a where

A type that can be converted from an S-expression, with the possibility of failure.

When writing an instance, use mzero or fail to make a conversion fail, e.g. the value is of the wrong type.

An example type and instance:

@data Coord { x :: Double, y :: Double }

instance FromLisp Coord where parseLisp (DotList [x] y) = pure (Coord x y) -- A non-DotList value is of the wrong shape, so use mzero to fail. parseLisp _ = mzero @

The above instance expects that Coord 4 5 is encoded as (4 . 5). This makes sense for a few special types, but most of the time the standard encoding should be used: (coord 4 5). The struct combinator provides special support for this use case:

instance FromLisp Coord where
   parseLisp = struct "coord" Coord

It uses some special type class magic to figure out the arity of its second argument.

Minimal complete definition

parseLisp

Methods

parseLisp :: Lisp -> Parser a

Instances

FromLisp Bool

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Bool

FromLisp Char

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Char

FromLisp Double

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Double

FromLisp Float

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Float

FromLisp Int

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Int

FromLisp Int8

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Int8

FromLisp Int16

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Int16

FromLisp Int32

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Int32

FromLisp Int64

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Int64

FromLisp Integer

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Integer

FromLisp Word

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Word

FromLisp Word8

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Word8

FromLisp Word16

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Word16

FromLisp Word32

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Word32

FromLisp Word64

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Word64

FromLisp ()

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser ()

FromLisp Text

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Text

FromLisp Number

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Number

FromLisp Lisp

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser Lisp

FromLisp [Char]

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser [Char]

FromLisp a => FromLisp [a]

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser [a]

FromLisp a => FromLisp (Maybe a)

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser (Maybe a)

FromLisp (Ratio Integer)

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser (Ratio Integer)

(FromLisp a, FromLisp b) => FromLisp (Either a b)

Tries to parse a or, if that fails, parses a b.

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser (Either a b)

(FromLisp a, FromLisp b) => FromLisp (a, b)

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser (a, b)

(Ord a, FromLisp a, FromLisp b) => FromLisp (Map a b)

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser (Map a b)

(FromLisp a, FromLisp b, FromLisp c) => FromLisp (a, b, c)

Defined in Data.AttoLisp

Methods

parseLisp :: Lisp -> Parser (a, b, c)

data Result a

The result of running a Parser.

Constructors

Error String

Success a

Instances

Monad Result

Defined in Data.AttoLisp

Methods

(>>=) :: Result a -> (a -> Result b) -> Result b

(>>) :: Result a -> Result b -> Result b

return :: a -> Result a

fail :: String -> Result a

Functor Result

Defined in Data.AttoLisp

Methods

fmap :: (a -> b) -> Result a -> Result b

(<$) :: a -> Result b -> Result a

Applicative Result

Defined in Data.AttoLisp

Methods

pure :: a -> Result a

(<*>) :: Result (a -> b) -> Result a -> Result b

liftA2 :: (a -> b -> c) -> Result a -> Result b -> Result c

(*>) :: Result a -> Result b -> Result b

(<*) :: Result a -> Result b -> Result a

Alternative Result

Defined in Data.AttoLisp

Methods

empty :: Result a

(<|>) :: Result a -> Result a -> Result a

some :: Result a -> Result [a]

many :: Result a -> Result [a]

MonadPlus Result

Defined in Data.AttoLisp

Methods

mzero :: Result a

mplus :: Result a -> Result a -> Result a

Eq a => Eq (Result a)

Defined in Data.AttoLisp

Methods

(==) :: Result a -> Result a -> Bool

(/=) :: Result a -> Result a -> Bool

Show a => Show (Result a)

Defined in Data.AttoLisp

Methods

showsPrec :: Int -> Result a -> ShowS

show :: Result a -> String

showList :: [Result a] -> ShowS

Semigroup (Result a)

Defined in Data.AttoLisp

Methods

(<>) :: Result a -> Result a -> Result a

sconcat :: NonEmpty (Result a) -> Result a

stimes :: Integral b => b -> Result a -> Result a

Monoid (Result a)

Defined in Data.AttoLisp

Methods

mempty :: Result a

mappend :: Result a -> Result a -> Result a

mconcat :: [Result a] -> Result a

NFData a => NFData (Result a)

Defined in Data.AttoLisp

Methods

rnf :: Result a -> ()

fromLisp :: FromLisp a => Lisp -> Result a

type Failure f r = String -> f r

Failure continuation.

type Success a f r = a -> f r

Success continuation.

data Parser a

A continuation-based parser type.

Instances

Monad Parser

Defined in Data.AttoLisp

Methods

(>>=) :: Parser a -> (a -> Parser b) -> Parser b

(>>) :: Parser a -> Parser b -> Parser b

return :: a -> Parser a

fail :: String -> Parser a

Functor Parser

Defined in Data.AttoLisp

Methods

fmap :: (a -> b) -> Parser a -> Parser b

(<$) :: a -> Parser b -> Parser a

Applicative Parser

Defined in Data.AttoLisp

Methods

pure :: a -> Parser a

(<*>) :: Parser (a -> b) -> Parser a -> Parser b

liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c

(*>) :: Parser a -> Parser b -> Parser b

(<*) :: Parser a -> Parser b -> Parser a

Alternative Parser

Defined in Data.AttoLisp

Methods

empty :: Parser a

(<|>) :: Parser a -> Parser a -> Parser a

some :: Parser a -> Parser [a]

many :: Parser a -> Parser [a]

MonadPlus Parser

Defined in Data.AttoLisp

Methods

mzero :: Parser a

mplus :: Parser a -> Parser a -> Parser a

Semigroup (Parser a)

Defined in Data.AttoLisp

Methods

(<>) :: Parser a -> Parser a -> Parser a

sconcat :: NonEmpty (Parser a) -> Parser a

stimes :: Integral b => b -> Parser a -> Parser a

Monoid (Parser a)

Defined in Data.AttoLisp

Methods

mempty :: Parser a

mappend :: Parser a -> Parser a -> Parser a

mconcat :: [Parser a] -> Parser a

parse :: (a -> Parser b) -> a -> Result b

Run a Parser.

parseMaybe :: (a -> Parser b) -> a -> Maybe b

Run a Parser with a Maybe result type.

parseEither :: (a -> Parser b) -> a -> Either String b

Run a Parser with an Either result type.

typeMismatch

Arguments

:: String

The name of the type you are trying to parse.

-> Lisp

The actual value encountered.

-> Parser a

Fail parsing due to a type mismatch, with a descriptive message.

class ToLisp a where

A type that can be converted to an S-expression.

An example type and instance:

@data Coord { x :: Double, y :: Double }

instance ToLisp Coord where toLisp (Coord x y) = struct "coord" [toLisp x, toLisp y] @

Minimal complete definition

toLisp

Methods

toLisp :: a -> Lisp

Instances

ToLisp Bool

Defined in Data.AttoLisp

Methods

toLisp :: Bool -> Lisp

ToLisp Char

Defined in Data.AttoLisp

Methods

toLisp :: Char -> Lisp

ToLisp Double

Defined in Data.AttoLisp

Methods

toLisp :: Double -> Lisp

ToLisp Float

Defined in Data.AttoLisp

Methods

toLisp :: Float -> Lisp

ToLisp Int

Defined in Data.AttoLisp

Methods

toLisp :: Int -> Lisp

ToLisp Int8

Defined in Data.AttoLisp

Methods

toLisp :: Int8 -> Lisp

ToLisp Int16

Defined in Data.AttoLisp

Methods

toLisp :: Int16 -> Lisp

ToLisp Int32

Defined in Data.AttoLisp

Methods

toLisp :: Int32 -> Lisp

ToLisp Int64

Defined in Data.AttoLisp

Methods

toLisp :: Int64 -> Lisp

ToLisp Integer

Defined in Data.AttoLisp

Methods

toLisp :: Integer -> Lisp

ToLisp Word

Defined in Data.AttoLisp

Methods

toLisp :: Word -> Lisp

ToLisp Word8

Defined in Data.AttoLisp

Methods

toLisp :: Word8 -> Lisp

ToLisp Word16

Defined in Data.AttoLisp

Methods

toLisp :: Word16 -> Lisp

ToLisp Word32

Defined in Data.AttoLisp

Methods

toLisp :: Word32 -> Lisp

ToLisp Word64

Defined in Data.AttoLisp

Methods

toLisp :: Word64 -> Lisp

ToLisp ()

Defined in Data.AttoLisp

Methods

toLisp :: () -> Lisp

ToLisp Text

Defined in Data.AttoLisp

Methods

toLisp :: Text -> Lisp

ToLisp Number

Defined in Data.AttoLisp

Methods

toLisp :: Number -> Lisp

ToLisp Lisp

Defined in Data.AttoLisp

Methods

toLisp :: Lisp -> Lisp

ToLisp [Char]

Defined in Data.AttoLisp

Methods

toLisp :: [Char] -> Lisp

ToLisp a => ToLisp [a]

Defined in Data.AttoLisp

Methods

toLisp :: [a] -> Lisp

ToLisp a => ToLisp (Maybe a)

Defined in Data.AttoLisp

Methods

toLisp :: Maybe a -> Lisp

ToLisp (Ratio Integer)

Defined in Data.AttoLisp

Methods

toLisp :: Ratio Integer -> Lisp

(ToLisp a, ToLisp b) => ToLisp (Either a b)

No tag is used, hence type a and b must be different.

Defined in Data.AttoLisp

Methods

toLisp :: Either a b -> Lisp

(ToLisp a, ToLisp b) => ToLisp (a, b)

Defined in Data.AttoLisp

Methods

toLisp :: (a, b) -> Lisp

(ToLisp a, ToLisp b) => ToLisp (Map a b)

Defined in Data.AttoLisp

Methods

toLisp :: Map a b -> Lisp

(ToLisp a, ToLisp b, ToLisp c) => ToLisp (a, b, c)

Defined in Data.AttoLisp

Methods

toLisp :: (a, b, c) -> Lisp

Constructors and destructors

mkStruct :: Text -> [Lisp] -> Lisp

Create a Lisp struct in a standardised format.

Fields in a struct are accessed by position.

struct :: ParseList f a => Text -> f -> Lisp -> Parser a

Decode structure serialised with mkStruct.

The second argument should be a function, usually a constructor. The resulting parser automatically figures out the arity of the function. For example:

@data Foo = Foo Int deriving (Eq, Show)

parseFoo :: Lisp -> Parser Foo parseFoo = struct "foo" Foo

test = parseMaybe parseFoo val == Just (Foo 23) where val = List [Symbol "foo", Number 23] @

Encoding and parsing

encode :: ToLisp a => a -> ByteString

fromLispExpr :: Lisp -> Builder

lisp :: Parser Lisp

Parse an arbitrary lisp expression.

atom :: Parser Lisp

Parse a symbol or a number. Symbols are expected to be utf8.