úÎ.(+b     0<A type that can be converted from an S-expression, with the  possibility of failure. When writing an instance, use  or   to make a 7 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 (  [x] y) = pure (Coord x y)  -C- A non-DotList value is of the wrong shape, so use mzero to fail.  parseLisp _ =   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  8 combinator provides special support for this use case:  instance FromLisp Coord where  parseLisp =  "coord" Coord AIt uses some special type class magic to figure out the arity of  its second argument. 1A 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) =  "coord" [toLisp x, toLisp y] The result of running a . "A continuation-based parser type. !"Success continuation. Failure continuation. "A Lisp expression (S-expression). Symbols are case-sensitive. A list with a non-nil tail: (foo x  . 42). The list argument must be $ non-empty and the tail must be non-. A proper list:  (foo x 42)  A number  A string. A symbol (including keyword) #Returns $ if the expression is nil or the empty list. The empty list. %Run a . Run a  with a & result type. Run a  with an ' result type. /Create a Lisp struct in a standardised format. -Fields in a struct are accessed by position. (AFail parsing due to a type mismatch, with a descriptive message. .The name of the type you are trying to parse. The actual value encountered. !Decode structure serialised with . AThe second argument should be a function, usually a constructor. A The resulting parser automatically figures out the arity of the  function. For example: 'data Foo = Foo Int deriving (Eq, Show)  parseFoo :: Lisp ->  Foo parseFoo = struct "foo" Foo  test =  parseFoo val == Just (Foo 23)  where val =   [ "foo",  ) 23] $Parse an arbitrary lisp expression. >Parse a symbol or a number. Symbols are expected to be utf8. !TODO: support escapes in symbols *+,-./0(Parse a string without a leading quote. 1234Tries to parse a or, if that fails, parses a b. 5No tag is used, hence type a and b must be different.       6      !" #$ %&'()* +, -./0123456789:;<=> atto-lisp-0.2 Data.AttoLispFromLisp parseLispToLisptoLispResultSuccessErrorParserFailureLispDotListListNumberStringSymbolisNullnilparse parseMaybe parseEithermkStructfromLisp typeMismatchstructlispatom fromLispExprencode ParseList parseListbase Control.MonadmzeroGHC.Basefail runParserspaceSepghc-prim GHC.TypesTrueapP Data.MaybeMaybe Data.EitherEither parseIntegralattoparsec-0.9.1.2Data.Attoparsec.NumberterminatingCharlist_ doubleQuote backslash skipLispSpacecommentlstring_unescapeStringenc_list fromNumber$fFromLispEither$fToLispEither