-- |
-- Module      :  Data.SExpresso.Language.SchemeR5RS
-- Copyright   :  © 2019 Vincent Archambault
-- License     :  0BSD
--
-- Maintainer  :  Vincent Archambault <archambault.v@gmail.com>
-- Stability   :  experimental
--
-- Module for parsing the Scheme R5RS language.
--
-- Scheme R5RS s-expressions are parsed as @'SExpr' 'SExprType'
-- 'SchemeToken'@.  Such s-expressions can be converted into a Scheme
-- R5RS datum (see 'Datum') by the function 'sexpr2Datum'.


{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ScopedTypeVariables #-}

-- Parsing library for some parts of the Scheme R5RS language
-- as defined in section 7 of the report
-- The library does parse tab and \r\n and whitespace
module Data.SExpresso.Language.SchemeR5RS (
  -- * SchemeToken and Datum related data types and functions
  SExprType(..),
  SchemeToken(..),
  tokenParser,
  sexpr,

  Datum(..),
  sexpr2Datum,

  -- * Scheme R5RS whitespace parsers
  whitespace,
  comment,
  interTokenSpace,
  interTokenSpace1,

  -- * Individual parser for each of the constructors of SchemeToken
  identifier,
  boolean,
  character,
  stringParser,
  quote,
  quasiquote,
  comma,
  commaAt,
  dot,

  -- ** Scheme Number
  --
  -- | Scheme R5RS numbers are quite exotic. They can have exactness
  -- prefix, radix prefix and the pound sign (#) can replace a
  -- digit. On top of that, you can define integer, rational, decimal
  -- and complex numbers of arbitrary precision. Decimal numbers can
  -- also have a suffix indicating the machine precision.
  --
  -- Since Haskell does not have native types to express this
  -- complexity, this module defines the 'SchemeNumber' data type to
  -- encode the parsed number. User of this module can then convert a
  -- 'SchemeNumber' object to a more appropriate data type according
  -- to their needs.
  SchemeNumber(..),
  Exactness(..),
  Complex(..),
  SReal(..),
  Sign(..),
  UInteger(..),
  Pounds,
  Precision(..),
  Suffix(..),
  number,


  ) where

import Control.Monad (mzero)
import Data.Data
import Data.Maybe
import Data.Proxy
import Data.List
import qualified Data.Char as C
import qualified Data.Text as T
import qualified Data.Text.Lazy as L
import qualified Data.Text.Lazy.Builder as B
import Data.Foldable
import Text.Megaparsec
import Text.Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer as ML
import Data.SExpresso.SExpr
import Data.SExpresso.Parse

-- | The 'SchemeToken' data type defines the atoms of an Scheme R5RS
-- s-expression. An @'SExpr' 'SExprType' 'SchemeToken'@ object
-- containning the atoms 'TQuote', 'TQuasiquote', 'TComma', 'TCommaAt'
-- and 'TDot' need futher processing in order to get what the R5RS
-- report calls a datum. See also 'Datum'.
data SchemeToken =
  -- | A boolean.
  TBoolean Bool
  -- | A number. See 'SchemeNumber'.
  | TNumber SchemeNumber
  -- | A unicode character.
  | TChar Char
  -- | A string.
  | TString T.Text
  -- | A valid R5RS identifier.
  | TIdentifier T.Text
  -- | The quote (') symbol.
  | TQuote
  -- | The quasiquote (`) symbol.
  | TQuasiquote
  -- | The comma (,) symbol.
  | TComma
  -- | The comma at (,\@) symbol.
  | TCommaAt
  -- | The dot (.) symbol.
  | TDot
  deriving (SchemeToken -> SchemeToken -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SchemeToken -> SchemeToken -> Bool
$c/= :: SchemeToken -> SchemeToken -> Bool
== :: SchemeToken -> SchemeToken -> Bool
$c== :: SchemeToken -> SchemeToken -> Bool
Eq, Int -> SchemeToken -> ShowS
[SchemeToken] -> ShowS
SchemeToken -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [SchemeToken] -> ShowS
$cshowList :: [SchemeToken] -> ShowS
show :: SchemeToken -> [Char]
$cshow :: SchemeToken -> [Char]
showsPrec :: Int -> SchemeToken -> ShowS
$cshowsPrec :: Int -> SchemeToken -> ShowS
Show, Typeable SchemeToken
SchemeToken -> DataType
SchemeToken -> Constr
(forall b. Data b => b -> b) -> SchemeToken -> SchemeToken
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SchemeToken -> u
forall u. (forall d. Data d => d -> u) -> SchemeToken -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeToken -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeToken -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemeToken -> m SchemeToken
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeToken -> m SchemeToken
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemeToken
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemeToken -> c SchemeToken
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemeToken)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemeToken)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeToken -> m SchemeToken
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeToken -> m SchemeToken
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeToken -> m SchemeToken
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeToken -> m SchemeToken
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemeToken -> m SchemeToken
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemeToken -> m SchemeToken
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemeToken -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemeToken -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SchemeToken -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemeToken -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeToken -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeToken -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeToken -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeToken -> r
gmapT :: (forall b. Data b => b -> b) -> SchemeToken -> SchemeToken
$cgmapT :: (forall b. Data b => b -> b) -> SchemeToken -> SchemeToken
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemeToken)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemeToken)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemeToken)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemeToken)
dataTypeOf :: SchemeToken -> DataType
$cdataTypeOf :: SchemeToken -> DataType
toConstr :: SchemeToken -> Constr
$ctoConstr :: SchemeToken -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemeToken
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemeToken
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemeToken -> c SchemeToken
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemeToken -> c SchemeToken
Data)

-- | The 'tokenParser' parses a 'SchemeToken'
tokenParser :: (MonadParsec e s m, Token s ~ Char) => m SchemeToken
tokenParser :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m SchemeToken
tokenParser = (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Bool
boolean forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> SchemeToken
TBoolean) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              -- character must come before number
              (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
character forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> SchemeToken
TChar) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Text
stringParser forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> SchemeToken
TString) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              -- We must try number because it can conflict with
              -- the dot ex : .2 and (a . b)
              -- and identifier ex : - and -1
              (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m SchemeNumber
number forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. SchemeNumber -> SchemeToken
TNumber) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Text
identifier forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> SchemeToken
TIdentifier) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
quote forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SchemeToken
TQuote) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
quasiquote forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SchemeToken
TQuasiquote) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              -- commaAt must come before comma
              (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Text
commaAt forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SchemeToken
TCommaAt) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
comma forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SchemeToken
TComma) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
              (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
dot forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SchemeToken
TDot)


spacingRule :: SchemeToken -> SpacingRule
spacingRule :: SchemeToken -> SpacingRule
spacingRule (TString Text
_) = SpacingRule
SOptional
spacingRule SchemeToken
TQuote = SpacingRule
SOptional
spacingRule SchemeToken
TQuasiquote  = SpacingRule
SOptional
spacingRule SchemeToken
TComma = SpacingRule
SOptional
spacingRule SchemeToken
TCommaAt = SpacingRule
SOptional
spacingRule SchemeToken
_ = SpacingRule
SMandatory

-- | Scheme R5RS defines two types of s-expressions. Standard list
-- beginning with '(' and vector beginning with '#('. The 'SExprType'
-- data type indicates which one was parsed.
data SExprType =
  -- | A standard list
  STList
  -- | A vector
  | STVector
  deriving (SExprType -> SExprType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SExprType -> SExprType -> Bool
$c/= :: SExprType -> SExprType -> Bool
== :: SExprType -> SExprType -> Bool
$c== :: SExprType -> SExprType -> Bool
Eq, Int -> SExprType -> ShowS
[SExprType] -> ShowS
SExprType -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [SExprType] -> ShowS
$cshowList :: [SExprType] -> ShowS
show :: SExprType -> [Char]
$cshow :: SExprType -> [Char]
showsPrec :: Int -> SExprType -> ShowS
$cshowsPrec :: Int -> SExprType -> ShowS
Show, Typeable SExprType
SExprType -> DataType
SExprType -> Constr
(forall b. Data b => b -> b) -> SExprType -> SExprType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SExprType -> u
forall u. (forall d. Data d => d -> u) -> SExprType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SExprType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SExprType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SExprType -> m SExprType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SExprType -> m SExprType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SExprType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SExprType -> c SExprType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SExprType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SExprType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SExprType -> m SExprType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SExprType -> m SExprType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SExprType -> m SExprType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SExprType -> m SExprType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SExprType -> m SExprType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SExprType -> m SExprType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SExprType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SExprType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SExprType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SExprType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SExprType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SExprType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SExprType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SExprType -> r
gmapT :: (forall b. Data b => b -> b) -> SExprType -> SExprType
$cgmapT :: (forall b. Data b => b -> b) -> SExprType -> SExprType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SExprType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SExprType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SExprType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SExprType)
dataTypeOf :: SExprType -> DataType
$cdataTypeOf :: SExprType -> DataType
toConstr :: SExprType -> Constr
$ctoConstr :: SExprType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SExprType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SExprType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SExprType -> c SExprType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SExprType -> c SExprType
Data)

-- | The 'sexpr' defines a 'SExprParser' to parse a Scheme R5RS
-- s-expression as an @'SExpr' 'SExprType' 'SchemeToken'@. If you also
-- want source position see the 'withLocation' function.
--
-- Space is optional before and after the following tokens:
--
-- * 'TString'
-- * 'TQuote'
-- * 'TQuasiquote'
-- * 'TComma'
-- * 'TCommaAt'
sexpr :: forall e s m . (MonadParsec e s m, Token s ~ Char) => SExprParser m SExprType SchemeToken
sexpr :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
SExprParser m SExprType SchemeToken
sexpr =
  let sTag :: m SExprType
sTag = (forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
'(' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SExprType
STList) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#(") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return SExprType
STVector)
      eTag :: b -> m b
eTag = \b
t -> forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
')' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return b
t
  in forall (m :: * -> *) b a c.
m c
-> (c -> m b)
-> m a
-> m ()
-> (a -> a -> SpacingRule)
-> SExprParser m b a
SExprParser m SExprType
sTag forall {b}. b -> m b
eTag forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m SchemeToken
tokenParser forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
interTokenSpace1 (forall a. (a -> SpacingRule) -> a -> a -> SpacingRule
mkSpacingRule SchemeToken -> SpacingRule
spacingRule)

-- | The 'Datum' data type implements the Scheme R5RS definition of a Datum. See also 'sexpr2Datum'.
data Datum = DBoolean Bool
           | DNumber SchemeNumber
           | DChar Char
           | DString T.Text
           | DIdentifier T.Text
           | DList [Datum]
           | DDotList [Datum] Datum
           | DQuote Datum
           | DQuasiquote Datum
           | DComma Datum
           | DCommaAt Datum
           | DVector [Datum]
           deriving (Datum -> Datum -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Datum -> Datum -> Bool
$c/= :: Datum -> Datum -> Bool
== :: Datum -> Datum -> Bool
$c== :: Datum -> Datum -> Bool
Eq, Int -> Datum -> ShowS
[Datum] -> ShowS
Datum -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Datum] -> ShowS
$cshowList :: [Datum] -> ShowS
show :: Datum -> [Char]
$cshow :: Datum -> [Char]
showsPrec :: Int -> Datum -> ShowS
$cshowsPrec :: Int -> Datum -> ShowS
Show, Typeable Datum
Datum -> DataType
Datum -> Constr
(forall b. Data b => b -> b) -> Datum -> Datum
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Datum -> u
forall u. (forall d. Data d => d -> u) -> Datum -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Datum -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Datum -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Datum -> m Datum
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Datum -> m Datum
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Datum
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Datum -> c Datum
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Datum)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Datum)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Datum -> m Datum
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Datum -> m Datum
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Datum -> m Datum
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Datum -> m Datum
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Datum -> m Datum
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Datum -> m Datum
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Datum -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Datum -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Datum -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Datum -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Datum -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Datum -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Datum -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Datum -> r
gmapT :: (forall b. Data b => b -> b) -> Datum -> Datum
$cgmapT :: (forall b. Data b => b -> b) -> Datum -> Datum
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Datum)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Datum)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Datum)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Datum)
dataTypeOf :: Datum -> DataType
$cdataTypeOf :: Datum -> DataType
toConstr :: Datum -> Constr
$ctoConstr :: Datum -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Datum
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Datum
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Datum -> c Datum
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Datum -> c Datum
Data)

-- | The 'sexpr2Datum' function takes a list of 'SchemeToken' and
-- returns a list of 'Datum'. In case of failure it will report an
-- error, hence the 'Either' data type in the signature.
--
-- As defined in the Scheme R5RS report, the 'TQuote', 'TQuasiquote',
-- 'TComma', 'TCommaAt' and 'TDot' tokens must be followed by another
-- token.
sexpr2Datum :: [SExpr SExprType SchemeToken] -> Either String [Datum]
sexpr2Datum :: [SExpr SExprType SchemeToken] -> Either [Char] [Datum]
sexpr2Datum = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> b -> m b) -> b -> t a -> m b
foldrM SExpr SExprType SchemeToken -> [Datum] -> Either [Char] [Datum]
vectorFold []
  where vectorFold :: SExpr SExprType SchemeToken -> [Datum] -> Either String [Datum]
        vectorFold :: SExpr SExprType SchemeToken -> [Datum] -> Either [Char] [Datum]
vectorFold (SAtom SchemeToken
TQuote) [] = forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ [Char]
"Expecting a datum after a quote"
        vectorFold (SAtom SchemeToken
TQuote) (Datum
x : [Datum]
xs) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Datum -> Datum
DQuote Datum
x forall a. a -> [a] -> [a]
: [Datum]
xs
        vectorFold (SAtom SchemeToken
TQuasiquote) [] = forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ [Char]
"Expecting a datum after a quasiquote"
        vectorFold (SAtom SchemeToken
TQuasiquote) (Datum
x : [Datum]
xs) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Datum -> Datum
DQuasiquote Datum
x forall a. a -> [a] -> [a]
: [Datum]
xs
        vectorFold (SAtom SchemeToken
TComma) [] = forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ [Char]
"Expecting a datum after a comma"
        vectorFold (SAtom SchemeToken
TComma) (Datum
x : [Datum]
xs) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Datum -> Datum
DComma Datum
x forall a. a -> [a] -> [a]
: [Datum]
xs
        vectorFold (SAtom SchemeToken
TCommaAt) [] = forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ [Char]
"Expecting a datum after a commaAt"
        vectorFold (SAtom SchemeToken
TCommaAt) (Datum
x : [Datum]
xs) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Datum -> Datum
DCommaAt Datum
x forall a. a -> [a] -> [a]
: [Datum]
xs
        vectorFold (SAtom SchemeToken
TDot) [Datum]
_ = forall a b. a -> Either a b
Left [Char]
"Unexpected dot"
        vectorFold (SList SExprType
STVector [SExpr SExprType SchemeToken]
xs) [Datum]
acc = ((:) forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Datum] -> Datum
DVector) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [SExpr SExprType SchemeToken] -> Either [Char] [Datum]
sexpr2Datum [SExpr SExprType SchemeToken]
xs forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure [Datum]
acc
        vectorFold (SList SExprType
STList [SExpr SExprType SchemeToken]
xs) [Datum]
acc =
          let chooseConstructor :: (Bool, [Datum]) -> [Datum] -> [Datum]
chooseConstructor (Bool
isDotList, [Datum]
ls) = (:) (if Bool
isDotList
                                                       then [Datum] -> Datum -> Datum
DDotList (forall a. [a] -> [a]
init [Datum]
ls) (forall a. [a] -> a
last [Datum]
ls)
                                                       else [Datum] -> Datum
DList [Datum]
ls)
          in (Bool, [Datum]) -> [Datum] -> [Datum]
chooseConstructor forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> b -> m b) -> b -> t a -> m b
foldrM SExpr SExprType SchemeToken
-> (Bool, [Datum]) -> Either [Char] (Bool, [Datum])
listFold (Bool
False, []) [SExpr SExprType SchemeToken]
xs) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure [Datum]
acc
        vectorFold (SAtom SchemeToken
x) [Datum]
acc = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ SchemeToken -> Datum
simpleToken SchemeToken
x forall a. a -> [a] -> [a]
: [Datum]
acc

        simpleToken :: SchemeToken -> Datum
        simpleToken :: SchemeToken -> Datum
simpleToken (TBoolean Bool
x) = Bool -> Datum
DBoolean Bool
x
        simpleToken (TNumber SchemeNumber
x) = SchemeNumber -> Datum
DNumber SchemeNumber
x
        simpleToken (TChar Char
x) = Char -> Datum
DChar Char
x
        simpleToken (TString Text
x) = Text -> Datum
DString Text
x
        simpleToken (TIdentifier Text
x) = Text -> Datum
DIdentifier Text
x
        simpleToken SchemeToken
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"simpleToken only handles a subset of SchemeToken constructors"

        listFold :: SExpr SExprType SchemeToken -> (Bool, [Datum]) -> Either String (Bool, [Datum])
        listFold :: SExpr SExprType SchemeToken
-> (Bool, [Datum]) -> Either [Char] (Bool, [Datum])
listFold (SAtom SchemeToken
TDot) (Bool
_, [Datum
x]) = forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool
True, [Datum
x])
        listFold SExpr SExprType SchemeToken
x (Bool
d, [Datum]
acc) = (,) Bool
d forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SExpr SExprType SchemeToken -> [Datum] -> Either [Char] [Datum]
vectorFold SExpr SExprType SchemeToken
x [Datum]
acc

------------------------- Whitespace and comments -------------------------
-- | The 'whitespace' parser  parses one space, tab or end of line (\\n and \\r\\n).
whitespace :: (MonadParsec e s m, Token s ~ Char) => m ()
whitespace :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
whitespace = (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
' ' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
             (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'\t' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
             (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Tokens s)
eol forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ())

-- | The 'comment' parser parses a semi-colon (;) character and
-- everything until the end of line included.
comment :: (MonadParsec e s m, Token s ~ Char) => m ()
comment :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
comment = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
';' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
          forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing (\Token s
c -> Token s
c forall a. Eq a => a -> a -> Bool
/= Char
'\n' Bool -> Bool -> Bool
&& Token s
c forall a. Eq a => a -> a -> Bool
/= Char
'\r') forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
          ((forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Tokens s)
eol forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *). MonadParsec e s m => m ()
eof)

atmosphere :: (MonadParsec e s m, Token s ~ Char) => m ()
atmosphere :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
atmosphere = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
whitespace forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
comment

-- | The 'interTokenSpace' parser parses zero or more whitespace or comment.
interTokenSpace :: (MonadParsec e s m, Token s ~ Char) => m ()
interTokenSpace :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
interTokenSpace = forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
atmosphere forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | The 'interTokenSpace1' parser parses one or more whitespace or comment.
interTokenSpace1 :: (MonadParsec e s m, Token s ~ Char) => m ()
interTokenSpace1 :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
interTokenSpace1 = forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
atmosphere forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()

------------------------- Identifier -------------------------

-- | The 'identifier' parser parses a Scheme R5RS identifier.
identifier :: forall e s m . (MonadParsec e s m, Token s ~ Char) => m T.Text
identifier :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Text
identifier = m Text
standardIdentifier forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Text
peculiarIdentifier
  where standardIdentifier :: m Text
standardIdentifier = do
          Char
i <- forall (f :: * -> *) e s (m :: * -> *).
(Foldable f, MonadParsec e s m) =>
f (Token s) -> m (Token s)
oneOf [Char]
initialList
          Tokens s
is <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing (\Token s
c -> Token s
c forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char]
subsequentList)
          forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Char] -> Text
T.pack forall a b. (a -> b) -> a -> b
$ (Char
i forall a. a -> [a] -> [a]
: forall s. Stream s => Proxy s -> Tokens s -> [Token s]
chunkToTokens (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) Tokens s
is)

initialList :: String
initialList :: [Char]
initialList = [Char
'a'..Char
'z'] forall a. [a] -> [a] -> [a]
++ [Char
'A'..Char
'Z'] forall a. [a] -> [a] -> [a]
++ [Char]
"!$%&*/:<=>?^_~"

subsequentList :: String
subsequentList :: [Char]
subsequentList = [Char]
initialList forall a. [a] -> [a] -> [a]
++ [Char
'0'..Char
'9'] forall a. [a] -> [a] -> [a]
++ [Char]
"+-.@"

peculiarIdentifier :: forall e s m . (MonadParsec e s m, Token s ~ Char) => m T.Text
peculiarIdentifier :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Text
peculiarIdentifier = (forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
'+' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Text
"+") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
                     (forall e s (m :: * -> *).
MonadParsec e s m =>
Token s -> m (Token s)
single Char
'-' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Text
"-") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
                     (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"...") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Text
"...")

------------------------- Booleans -------------------------
-- | The 'boolean' parser parses a Scheme R5RS boolean (\#t or \#f).
boolean :: forall e s m . (MonadParsec e s m, Token s ~ Char) => m Bool
boolean :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Bool
boolean = (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#t") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#f") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False)


------------------------- Character -------------------------
-- | The 'character' parser parses a Scheme R5RS character.
character :: forall e s m . (MonadParsec e s m, Token s ~ Char) => m Char
character :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
character = do
  Tokens s
_ <- forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#\\")
  (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"newline") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\n') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
   (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"space") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
' ') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
   forall e s (m :: * -> *). MonadParsec e s m => m (Token s)
anySingle

------------------------- String -------------------------
-- | The 'stringParser' parser parses a Scheme R5RS character.
stringParser :: forall e s m . (MonadParsec e s m, Token s ~ Char) => m T.Text
stringParser :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Text
stringParser = do
  Token s
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'"'
  Builder
xs <- (MonadParsec e s m, Token s ~ Char) => m Builder
consume
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Text
L.toStrict forall a b. (a -> b) -> a -> b
$ Builder -> Text
B.toLazyText Builder
xs

  where consume :: (MonadParsec e s m, Token s ~ Char) => m B.Builder
        consume :: (MonadParsec e s m, Token s ~ Char) => m Builder
consume = do
          Tokens s
x <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing (\Token s
c -> Token s
c forall a. Eq a => a -> a -> Bool
/= Char
'\\' Bool -> Bool -> Bool
&& Token s
c forall a. Eq a => a -> a -> Bool
/= Char
'"')
          Char
c <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'\\' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'"'
          let xB :: Builder
xB = [Char] -> Builder
B.fromString forall a b. (a -> b) -> a -> b
$ forall s. Stream s => Proxy s -> Tokens s -> [Token s]
chunkToTokens (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) Tokens s
x
          case Char
c of
            Char
'"' -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Builder
xB
            Char
_ -> do
               Char
c1 <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'\\' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'"'
               Builder
x2 <- (MonadParsec e s m, Token s ~ Char) => m Builder
consume
               forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Builder
xB forall a. Semigroup a => a -> a -> a
<> [Char] -> Builder
B.fromString [Char
c1] forall a. Semigroup a => a -> a -> a
<> Builder
x2


------------------------- Numbers -------------------------
data Radix = R2 | R8 | R10 | R16
           deriving (Radix -> Radix -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Radix -> Radix -> Bool
$c/= :: Radix -> Radix -> Bool
== :: Radix -> Radix -> Bool
$c== :: Radix -> Radix -> Bool
Eq, Int -> Radix -> ShowS
[Radix] -> ShowS
Radix -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Radix] -> ShowS
$cshowList :: [Radix] -> ShowS
show :: Radix -> [Char]
$cshow :: Radix -> [Char]
showsPrec :: Int -> Radix -> ShowS
$cshowsPrec :: Int -> Radix -> ShowS
Show, Typeable Radix
Radix -> DataType
Radix -> Constr
(forall b. Data b => b -> b) -> Radix -> Radix
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Radix -> u
forall u. (forall d. Data d => d -> u) -> Radix -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Radix -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Radix -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Radix -> m Radix
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Radix -> m Radix
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Radix
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Radix -> c Radix
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Radix)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Radix)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Radix -> m Radix
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Radix -> m Radix
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Radix -> m Radix
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Radix -> m Radix
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Radix -> m Radix
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Radix -> m Radix
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Radix -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Radix -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Radix -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Radix -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Radix -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Radix -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Radix -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Radix -> r
gmapT :: (forall b. Data b => b -> b) -> Radix -> Radix
$cgmapT :: (forall b. Data b => b -> b) -> Radix -> Radix
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Radix)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Radix)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Radix)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Radix)
dataTypeOf :: Radix -> DataType
$cdataTypeOf :: Radix -> DataType
toConstr :: Radix -> Constr
$ctoConstr :: Radix -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Radix
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Radix
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Radix -> c Radix
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Radix -> c Radix
Data)

-- | A Scheme R5RS number is either exact or inexact. The paragraph
-- 6.4.2 from the R5RS report should clarify the meaning of exact and
-- inexact :
--
-- \"\"\"A numerical constant may be specified to be either
-- exact or inexact by a prefix.  The prefixes are \#e for exact, and \#i
-- for inexact.  An exactness prefix may appear before or after any
-- radix prefix that is used.  If the written representation of a
-- number has no exactness prefix, the constant may be either inexact
-- or exact.  It is inexact if it contains a decimal point, an
-- exponent, or a \“#\” character in the place of a digit, otherwise it
-- is exact.\"\"\"
data Exactness = Exact | Inexact
               deriving (Exactness -> Exactness -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Exactness -> Exactness -> Bool
$c/= :: Exactness -> Exactness -> Bool
== :: Exactness -> Exactness -> Bool
$c== :: Exactness -> Exactness -> Bool
Eq, Int -> Exactness -> ShowS
[Exactness] -> ShowS
Exactness -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Exactness] -> ShowS
$cshowList :: [Exactness] -> ShowS
show :: Exactness -> [Char]
$cshow :: Exactness -> [Char]
showsPrec :: Int -> Exactness -> ShowS
$cshowsPrec :: Int -> Exactness -> ShowS
Show, Typeable Exactness
Exactness -> DataType
Exactness -> Constr
(forall b. Data b => b -> b) -> Exactness -> Exactness
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Exactness -> u
forall u. (forall d. Data d => d -> u) -> Exactness -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Exactness -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Exactness -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exactness -> m Exactness
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exactness -> m Exactness
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exactness
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exactness -> c Exactness
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exactness)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exactness)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exactness -> m Exactness
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exactness -> m Exactness
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exactness -> m Exactness
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exactness -> m Exactness
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exactness -> m Exactness
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exactness -> m Exactness
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exactness -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exactness -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Exactness -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Exactness -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Exactness -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Exactness -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Exactness -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Exactness -> r
gmapT :: (forall b. Data b => b -> b) -> Exactness -> Exactness
$cgmapT :: (forall b. Data b => b -> b) -> Exactness -> Exactness
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exactness)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exactness)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exactness)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exactness)
dataTypeOf :: Exactness -> DataType
$cdataTypeOf :: Exactness -> DataType
toConstr :: Exactness -> Constr
$ctoConstr :: Exactness -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exactness
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exactness
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exactness -> c Exactness
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exactness -> c Exactness
Data)

-- | The 'Sign' datatype indicates if a number is positive ('Plus') or negative ('Minus')
data Sign = Plus | Minus
          deriving (Sign -> Sign -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sign -> Sign -> Bool
$c/= :: Sign -> Sign -> Bool
== :: Sign -> Sign -> Bool
$c== :: Sign -> Sign -> Bool
Eq, Int -> Sign -> ShowS
[Sign] -> ShowS
Sign -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Sign] -> ShowS
$cshowList :: [Sign] -> ShowS
show :: Sign -> [Char]
$cshow :: Sign -> [Char]
showsPrec :: Int -> Sign -> ShowS
$cshowsPrec :: Int -> Sign -> ShowS
Show, Typeable Sign
Sign -> DataType
Sign -> Constr
(forall b. Data b => b -> b) -> Sign -> Sign
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
forall u. (forall d. Data d => d -> u) -> Sign -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Sign -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Sign -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
$cgmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
dataTypeOf :: Sign -> DataType
$cdataTypeOf :: Sign -> DataType
toConstr :: Sign -> Constr
$ctoConstr :: Sign -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
Data)

-- | A Scheme R5RS number can have many # signs at the end. This type alias
-- indicates the number of # signs parsed.
type Pounds = Integer

-- | A Scheme R5RS unsigned integer can be written in three ways.
--
-- * With digits only
-- * With digits and # signs
-- * With only # signs in some special context.
data UInteger =
  -- | Integer made only of digits
  UInteger Integer
  -- | Integer made of digits and #. The first argument is the number
  -- that was parsed and the second the number of # signs. For
  -- example, 123## is represented as @UIntPounds 123 2@. Do not take
  -- the first argument as a good approximation of the number. It
  -- needs to be shifted by the number of pounds.
  | UIntPounds Integer Pounds
  -- | Integer made only of #. It can only appear as the third argument in numbers of the form @'SDecimal' _ _ _ _@.
  | UPounds Pounds
  deriving (UInteger -> UInteger -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UInteger -> UInteger -> Bool
$c/= :: UInteger -> UInteger -> Bool
== :: UInteger -> UInteger -> Bool
$c== :: UInteger -> UInteger -> Bool
Eq, Int -> UInteger -> ShowS
[UInteger] -> ShowS
UInteger -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [UInteger] -> ShowS
$cshowList :: [UInteger] -> ShowS
show :: UInteger -> [Char]
$cshow :: UInteger -> [Char]
showsPrec :: Int -> UInteger -> ShowS
$cshowsPrec :: Int -> UInteger -> ShowS
Show, Typeable UInteger
UInteger -> DataType
UInteger -> Constr
(forall b. Data b => b -> b) -> UInteger -> UInteger
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UInteger -> u
forall u. (forall d. Data d => d -> u) -> UInteger -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UInteger -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UInteger -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UInteger -> m UInteger
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UInteger -> m UInteger
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UInteger
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UInteger -> c UInteger
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UInteger)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UInteger)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UInteger -> m UInteger
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UInteger -> m UInteger
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UInteger -> m UInteger
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UInteger -> m UInteger
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UInteger -> m UInteger
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UInteger -> m UInteger
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UInteger -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UInteger -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> UInteger -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UInteger -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UInteger -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UInteger -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UInteger -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UInteger -> r
gmapT :: (forall b. Data b => b -> b) -> UInteger -> UInteger
$cgmapT :: (forall b. Data b => b -> b) -> UInteger -> UInteger
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UInteger)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UInteger)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UInteger)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UInteger)
dataTypeOf :: UInteger -> DataType
$cdataTypeOf :: UInteger -> DataType
toConstr :: UInteger -> Constr
$ctoConstr :: UInteger -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UInteger
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UInteger
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UInteger -> c UInteger
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UInteger -> c UInteger
Data)

hasPounds :: UInteger -> Bool
hasPounds :: UInteger -> Bool
hasPounds (UInteger Integer
_) = Bool
False
hasPounds UInteger
_ = Bool
True

isInexactI :: UInteger -> Bool
isInexactI :: UInteger -> Bool
isInexactI = UInteger -> Bool
hasPounds

-- | Scheme R5RS defines 5 types of machine precision for a decimal
-- number. The machine precision is specified in the suffix (see
-- 'Suffix').
data Precision =
  -- | Suffix starting with e.
  PDefault |
  -- | Suffix starting with s.
  PShort |
  -- | Suffix starting with f.
  PSingle |
  -- | Suffix starting with d.
  PDouble |
  -- | Suffix starting with l.
  PLong
  deriving (Precision -> Precision -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Precision -> Precision -> Bool
$c/= :: Precision -> Precision -> Bool
== :: Precision -> Precision -> Bool
$c== :: Precision -> Precision -> Bool
Eq, Int -> Precision -> ShowS
[Precision] -> ShowS
Precision -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Precision] -> ShowS
$cshowList :: [Precision] -> ShowS
show :: Precision -> [Char]
$cshow :: Precision -> [Char]
showsPrec :: Int -> Precision -> ShowS
$cshowsPrec :: Int -> Precision -> ShowS
Show, Typeable Precision
Precision -> DataType
Precision -> Constr
(forall b. Data b => b -> b) -> Precision -> Precision
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Precision -> u
forall u. (forall d. Data d => d -> u) -> Precision -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Precision -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Precision -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Precision -> m Precision
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Precision -> m Precision
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Precision
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Precision -> c Precision
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Precision)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Precision)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Precision -> m Precision
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Precision -> m Precision
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Precision -> m Precision
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Precision -> m Precision
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Precision -> m Precision
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Precision -> m Precision
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Precision -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Precision -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Precision -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Precision -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Precision -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Precision -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Precision -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Precision -> r
gmapT :: (forall b. Data b => b -> b) -> Precision -> Precision
$cgmapT :: (forall b. Data b => b -> b) -> Precision -> Precision
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Precision)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Precision)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Precision)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Precision)
dataTypeOf :: Precision -> DataType
$cdataTypeOf :: Precision -> DataType
toConstr :: Precision -> Constr
$ctoConstr :: Precision -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Precision
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Precision
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Precision -> c Precision
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Precision -> c Precision
Data)

-- | The 'Suffix' data type represents the suffix for a Scheme R5RS
-- decimal number. It is a based 10 exponent.
data Suffix = Suffix Precision Sign Integer
            deriving (Suffix -> Suffix -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Suffix -> Suffix -> Bool
$c/= :: Suffix -> Suffix -> Bool
== :: Suffix -> Suffix -> Bool
$c== :: Suffix -> Suffix -> Bool
Eq, Int -> Suffix -> ShowS
[Suffix] -> ShowS
Suffix -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Suffix] -> ShowS
$cshowList :: [Suffix] -> ShowS
show :: Suffix -> [Char]
$cshow :: Suffix -> [Char]
showsPrec :: Int -> Suffix -> ShowS
$cshowsPrec :: Int -> Suffix -> ShowS
Show, Typeable Suffix
Suffix -> DataType
Suffix -> Constr
(forall b. Data b => b -> b) -> Suffix -> Suffix
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Suffix -> u
forall u. (forall d. Data d => d -> u) -> Suffix -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Suffix -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Suffix -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Suffix -> m Suffix
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Suffix -> m Suffix
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Suffix
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Suffix -> c Suffix
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Suffix)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Suffix)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Suffix -> m Suffix
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Suffix -> m Suffix
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Suffix -> m Suffix
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Suffix -> m Suffix
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Suffix -> m Suffix
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Suffix -> m Suffix
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Suffix -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Suffix -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Suffix -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Suffix -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Suffix -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Suffix -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Suffix -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Suffix -> r
gmapT :: (forall b. Data b => b -> b) -> Suffix -> Suffix
$cgmapT :: (forall b. Data b => b -> b) -> Suffix -> Suffix
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Suffix)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Suffix)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Suffix)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Suffix)
dataTypeOf :: Suffix -> DataType
$cdataTypeOf :: Suffix -> DataType
toConstr :: Suffix -> Constr
$ctoConstr :: Suffix -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Suffix
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Suffix
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Suffix -> c Suffix
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Suffix -> c Suffix
Data)

-- | The 'SReal' data type represents a Scheme R5RS real number.
data SReal =
  -- | A signed integer.
  SInteger Sign UInteger
  -- | A signed rational. The first number is the numerator and the
  -- second one the denominator.
  | SRational Sign UInteger UInteger
  -- | A signed decimal number. The first number appears before the
  -- dot, the second one after the dot.
  | SDecimal Sign UInteger UInteger (Maybe Suffix)
  deriving (SReal -> SReal -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SReal -> SReal -> Bool
$c/= :: SReal -> SReal -> Bool
== :: SReal -> SReal -> Bool
$c== :: SReal -> SReal -> Bool
Eq, Int -> SReal -> ShowS
[SReal] -> ShowS
SReal -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [SReal] -> ShowS
$cshowList :: [SReal] -> ShowS
show :: SReal -> [Char]
$cshow :: SReal -> [Char]
showsPrec :: Int -> SReal -> ShowS
$cshowsPrec :: Int -> SReal -> ShowS
Show, Typeable SReal
SReal -> DataType
SReal -> Constr
(forall b. Data b => b -> b) -> SReal -> SReal
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SReal -> u
forall u. (forall d. Data d => d -> u) -> SReal -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SReal -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SReal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SReal -> m SReal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SReal -> m SReal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SReal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SReal -> c SReal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SReal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SReal)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SReal -> m SReal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SReal -> m SReal
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SReal -> m SReal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SReal -> m SReal
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SReal -> m SReal
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SReal -> m SReal
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SReal -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SReal -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SReal -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SReal -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SReal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SReal -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SReal -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SReal -> r
gmapT :: (forall b. Data b => b -> b) -> SReal -> SReal
$cgmapT :: (forall b. Data b => b -> b) -> SReal -> SReal
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SReal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SReal)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SReal)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SReal)
dataTypeOf :: SReal -> DataType
$cdataTypeOf :: SReal -> DataType
toConstr :: SReal -> Constr
$ctoConstr :: SReal -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SReal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SReal
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SReal -> c SReal
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SReal -> c SReal
Data)

isInexactR :: SReal -> Bool
isInexactR :: SReal -> Bool
isInexactR (SInteger Sign
_ UInteger
i) = UInteger -> Bool
isInexactI UInteger
i
isInexactR (SRational Sign
_ UInteger
i1 UInteger
i2) = UInteger -> Bool
isInexactI UInteger
i1 Bool -> Bool -> Bool
|| UInteger -> Bool
isInexactI UInteger
i2
isInexactR (SDecimal Sign
_ UInteger
_ UInteger
_ Maybe Suffix
_) = Bool
True

-- | The 'Complex' data type represents a Scheme R5RS complex number.
data Complex =
  -- | A real number.
  CReal SReal
  -- | A complex number in angular notation.
  | CAngle SReal SReal
  -- | A complex number in absolute notation.
  | CAbsolute SReal SReal
  deriving (Complex -> Complex -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Complex -> Complex -> Bool
$c/= :: Complex -> Complex -> Bool
== :: Complex -> Complex -> Bool
$c== :: Complex -> Complex -> Bool
Eq, Int -> Complex -> ShowS
[Complex] -> ShowS
Complex -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Complex] -> ShowS
$cshowList :: [Complex] -> ShowS
show :: Complex -> [Char]
$cshow :: Complex -> [Char]
showsPrec :: Int -> Complex -> ShowS
$cshowsPrec :: Int -> Complex -> ShowS
Show, Typeable Complex
Complex -> DataType
Complex -> Constr
(forall b. Data b => b -> b) -> Complex -> Complex
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Complex -> u
forall u. (forall d. Data d => d -> u) -> Complex -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Complex -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Complex -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Complex -> m Complex
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Complex -> m Complex
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Complex
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Complex -> c Complex
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Complex)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Complex)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Complex -> m Complex
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Complex -> m Complex
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Complex -> m Complex
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Complex -> m Complex
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Complex -> m Complex
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Complex -> m Complex
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Complex -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Complex -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Complex -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Complex -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Complex -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Complex -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Complex -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Complex -> r
gmapT :: (forall b. Data b => b -> b) -> Complex -> Complex
$cgmapT :: (forall b. Data b => b -> b) -> Complex -> Complex
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Complex)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Complex)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Complex)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Complex)
dataTypeOf :: Complex -> DataType
$cdataTypeOf :: Complex -> DataType
toConstr :: Complex -> Constr
$ctoConstr :: Complex -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Complex
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Complex
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Complex -> c Complex
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Complex -> c Complex
Data)

isInexact :: Complex -> Bool
isInexact :: Complex -> Bool
isInexact (CReal SReal
s) = SReal -> Bool
isInexactR SReal
s
isInexact (CAngle SReal
s1 SReal
s2) = SReal -> Bool
isInexactR SReal
s1 Bool -> Bool -> Bool
|| SReal -> Bool
isInexactR SReal
s2
isInexact (CAbsolute SReal
s1 SReal
s2) = SReal -> Bool
isInexactR SReal
s1 Bool -> Bool -> Bool
|| SReal -> Bool
isInexactR SReal
s2

-- | A Scheme R5RS number is an exact or inexact complex number.
data SchemeNumber = SchemeNumber Exactness Complex
                  deriving (SchemeNumber -> SchemeNumber -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SchemeNumber -> SchemeNumber -> Bool
$c/= :: SchemeNumber -> SchemeNumber -> Bool
== :: SchemeNumber -> SchemeNumber -> Bool
$c== :: SchemeNumber -> SchemeNumber -> Bool
Eq, Int -> SchemeNumber -> ShowS
[SchemeNumber] -> ShowS
SchemeNumber -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [SchemeNumber] -> ShowS
$cshowList :: [SchemeNumber] -> ShowS
show :: SchemeNumber -> [Char]
$cshow :: SchemeNumber -> [Char]
showsPrec :: Int -> SchemeNumber -> ShowS
$cshowsPrec :: Int -> SchemeNumber -> ShowS
Show, Typeable SchemeNumber
SchemeNumber -> DataType
SchemeNumber -> Constr
(forall b. Data b => b -> b) -> SchemeNumber -> SchemeNumber
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SchemeNumber -> u
forall u. (forall d. Data d => d -> u) -> SchemeNumber -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeNumber -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeNumber -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemeNumber -> m SchemeNumber
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeNumber -> m SchemeNumber
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemeNumber
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemeNumber -> c SchemeNumber
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemeNumber)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemeNumber)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeNumber -> m SchemeNumber
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeNumber -> m SchemeNumber
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeNumber -> m SchemeNumber
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemeNumber -> m SchemeNumber
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemeNumber -> m SchemeNumber
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemeNumber -> m SchemeNumber
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemeNumber -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemeNumber -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SchemeNumber -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemeNumber -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeNumber -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeNumber -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeNumber -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemeNumber -> r
gmapT :: (forall b. Data b => b -> b) -> SchemeNumber -> SchemeNumber
$cgmapT :: (forall b. Data b => b -> b) -> SchemeNumber -> SchemeNumber
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemeNumber)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemeNumber)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemeNumber)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemeNumber)
dataTypeOf :: SchemeNumber -> DataType
$cdataTypeOf :: SchemeNumber -> DataType
toConstr :: SchemeNumber -> Constr
$ctoConstr :: SchemeNumber -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemeNumber
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemeNumber
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemeNumber -> c SchemeNumber
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemeNumber -> c SchemeNumber
Data)

-- | The 'number' parser parses a Scheme R5RS number.
number :: (MonadParsec e s m, Token s ~ Char) => m SchemeNumber
number :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m SchemeNumber
number = do
  (Maybe Radix
r, Maybe Exactness
e) <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Maybe Radix, Maybe Exactness)
prefix
  Complex
c <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m Complex
complex (forall a. a -> Maybe a -> a
fromMaybe Radix
R10 Maybe Radix
r)
  let e' :: Exactness
e' = forall a. a -> Maybe a -> a
fromMaybe (if Complex -> Bool
isInexact Complex
c then Exactness
Inexact else Exactness
Exact) Maybe Exactness
e
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Exactness -> Complex -> SchemeNumber
SchemeNumber Exactness
e'  Complex
c

complex :: forall e s m . (MonadParsec e s m, Token s ~ Char) => Radix -> m Complex
complex :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m Complex
complex Radix
r = do
  Maybe Sign
ms <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Sign
sign
  case Maybe Sign
ms of
    Maybe Sign
Nothing -> Sign -> m Complex
complex' Sign
Plus
    Just Sign
s -> forall {s} {m :: * -> *} {e}.
(Token s ~ Char, MonadParsec e s m) =>
Sign -> m Complex
i Sign
s forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Sign -> m Complex
complex' Sign
s

  where
    -- Parser for +i and -i
    i :: Sign -> m Complex
i Sign
s = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'i' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SReal -> SReal -> Complex
CAbsolute (Sign -> UInteger -> SReal
SInteger Sign
Plus (Integer -> UInteger
UInteger Integer
0)) (Sign -> UInteger -> SReal
SInteger Sign
s (Integer -> UInteger
UInteger Integer
1)))

    -- Parser for complex except +i and -i
    complex' :: Sign -> m Complex
complex' Sign
sr = do
      -- First parse a number
      SReal
n1 <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> Sign -> m SReal
ureal Radix
r Sign
sr
      -- Check if the number is followed by any of these characters
      Maybe Char
c <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'@' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'+' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'-' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'i')
      case Maybe Char
c of
          -- Plain real number
          Maybe Char
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SReal -> Complex
CReal SReal
n1
          -- Complex angular number
          Just Char
'@' -> do
            SReal
n2 <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m SReal
real Radix
r
            forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SReal -> SReal -> Complex
CAngle SReal
n1 SReal
n2
          -- Pure imaginary number
          Just Char
'i' -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SReal -> SReal -> Complex
CAbsolute (Sign -> UInteger -> SReal
SInteger Sign
Plus (Integer -> UInteger
UInteger Integer
0)) SReal
n1
          -- Real +/- Imaginary number
          Just Char
'+' -> SReal -> Sign -> m Complex
imaginaryPart SReal
n1 Sign
Plus
          Just Char
_ -> SReal -> Sign -> m Complex
imaginaryPart SReal
n1 Sign
Minus

    imaginaryPart :: SReal -> Sign -> m Complex
imaginaryPart SReal
realN Sign
si = do
      Maybe SReal
u <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> Sign -> m SReal
ureal Radix
r Sign
si)
      Token s
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'i'
      case Maybe SReal
u of
        Maybe SReal
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SReal -> SReal -> Complex
CAbsolute SReal
realN (Sign -> UInteger -> SReal
SInteger Sign
si (Integer -> UInteger
UInteger Integer
1))
        Just SReal
n2 -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SReal -> SReal -> Complex
CAbsolute SReal
realN SReal
n2

real :: (MonadParsec e s m, Token s ~ Char) => Radix -> m SReal
real :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m SReal
real Radix
r = do
  Sign
s <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Sign
Plus forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Sign
sign
  forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> Sign -> m SReal
ureal Radix
r Sign
s

ureal :: forall e s m . (MonadParsec e s m, Token s ~ Char) => Radix -> Sign -> m SReal
ureal :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> Sign -> m SReal
ureal Radix
r Sign
s = m SReal
dotN forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m SReal
ureal'

  where dotN :: m SReal
dotN =  do
          Token s
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.'
          if Radix
r forall a. Eq a => a -> a -> Bool
/= Radix
R10
          then forall e s (m :: * -> *) a.
MonadParsec e s m =>
[Char] -> m a -> m a
label [Char]
"Numbers containing decimal point must be in decimal radix" forall (m :: * -> *) a. MonadPlus m => m a
mzero
          else do
             UInteger
n <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m UInteger
uinteger Radix
R10
             Maybe Suffix
sf <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Suffix
suffix
             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Sign -> UInteger -> UInteger -> Maybe Suffix -> SReal
SDecimal Sign
s (Integer -> UInteger
UInteger Integer
0) UInteger
n Maybe Suffix
sf

        ureal' :: m SReal
ureal' = do
          -- First parse an integer
          UInteger
u1 <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m UInteger
uinteger Radix
r
          -- Check if the integer is followed by these characters
          Maybe Char
mc <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'/' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.')
          case Maybe Char
mc of
            -- Integer with or without suffix
            Maybe Char
Nothing -> UInteger -> m SReal
plainInteger UInteger
u1
            -- Rational
            Just Char
'/' -> UInteger -> m SReal
rational UInteger
u1
            -- Decimal
            Just Char
_ -> UInteger -> m SReal
decimal UInteger
u1

        plainInteger :: UInteger -> m SReal
plainInteger UInteger
u1 = do
            Maybe Suffix
sf <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Suffix
suffix
            case Maybe Suffix
sf of
              Just Suffix
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Sign -> UInteger -> UInteger -> Maybe Suffix -> SReal
SDecimal Sign
s UInteger
u1 (Integer -> UInteger
UInteger Integer
0) Maybe Suffix
sf
              Maybe Suffix
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Sign -> UInteger -> SReal
SInteger Sign
s UInteger
u1

        rational :: UInteger -> m SReal
rational UInteger
u1 = do
          UInteger
u2 <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m UInteger
uinteger Radix
r
          forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Sign -> UInteger -> UInteger -> SReal
SRational Sign
s UInteger
u1 UInteger
u2

        decimal :: UInteger -> m SReal
decimal UInteger
u1 = do
          if Radix
r forall a. Eq a => a -> a -> Bool
/= Radix
R10
          then forall e s (m :: * -> *) a.
MonadParsec e s m =>
[Char] -> m a -> m a
label [Char]
"Numbers containing decimal point must be in decimal radix" forall (m :: * -> *) a. MonadPlus m => m a
mzero
          else do
             -- If u1 has # character, only other # are
             -- allowed. Otherwise a number may be present
             Maybe Integer
n <- if UInteger -> Bool
hasPounds UInteger
u1 then forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing else forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Integral a) =>
Radix -> m a
udigit Radix
R10) :: m (Maybe Integer)
             Tokens s
pounds <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing (forall a. Eq a => a -> a -> Bool
== Char
'#')
             Maybe Suffix
sf <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Suffix
suffix
             let nbPounds :: Integer
nbPounds = forall a. Integral a => a -> Integer
toInteger forall a b. (a -> b) -> a -> b
$ forall s. Stream s => Proxy s -> Tokens s -> Int
chunkLength (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) Tokens s
pounds
             let u2 :: UInteger
u2 = case (UInteger -> Bool
hasPounds UInteger
u1, Integer
nbPounds, Maybe Integer
n) of
                         (Bool
True, Integer
p, Maybe Integer
_) -> Integer -> UInteger
UPounds Integer
p
                         (Bool
False, Integer
0, Maybe Integer
Nothing) -> Integer -> UInteger
UInteger Integer
0
                         (Bool
False, Integer
0, (Just Integer
x)) -> Integer -> UInteger
UInteger Integer
x
                         (Bool
False, Integer
p, Maybe Integer
Nothing) -> Integer -> UInteger
UPounds Integer
p
                         (Bool
False, Integer
p, (Just Integer
x)) -> Integer -> Integer -> UInteger
UIntPounds Integer
x Integer
p
             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Sign -> UInteger -> UInteger -> Maybe Suffix -> SReal
SDecimal Sign
s UInteger
u1 UInteger
u2 Maybe Suffix
sf

uinteger :: forall e s m . (MonadParsec e s m, Token s ~ Char) => Radix -> m UInteger
uinteger :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m UInteger
uinteger Radix
r = do
  Integer
n <- forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Integral a) =>
Radix -> m a
udigit Radix
r
  Tokens s
pounds <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing (forall a. Eq a => a -> a -> Bool
== Char
'#')
  let nbPounds :: Integer
nbPounds = forall a. Integral a => a -> Integer
toInteger forall a b. (a -> b) -> a -> b
$ forall s. Stream s => Proxy s -> Tokens s -> Int
chunkLength (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) Tokens s
pounds
  if Integer
nbPounds forall a. Ord a => a -> a -> Bool
<= Integer
0
  then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Integer -> UInteger
UInteger Integer
n
  else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Integer -> Integer -> UInteger
UIntPounds Integer
n Integer
nbPounds


prefix :: (MonadParsec e s m, Token s ~ Char) => m (Maybe Radix, Maybe Exactness)
prefix :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Maybe Radix, Maybe Exactness)
prefix = do
  Maybe (Token s)
x <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'#'
  case Maybe (Token s)
x of
    Maybe (Token s)
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Maybe a
Nothing, forall a. Maybe a
Nothing)
    Maybe (Token s)
_ -> do
      Char
c <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'i' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'e' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'b' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
           forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'o' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'd' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'x'
      case Char
c of
        Char
'i' -> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Radix
radix forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Radix
r -> forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Radix
r, forall a. a -> Maybe a
Just Exactness
Inexact)
        Char
'e' -> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Radix
radix forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Radix
r -> forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Radix
r, forall a. a -> Maybe a
Just Exactness
Exact)
        Char
'b' -> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Exactness
exactness forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Exactness
e -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just Radix
R2, Maybe Exactness
e)
        Char
'o' -> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Exactness
exactness forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Exactness
e -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just Radix
R8, Maybe Exactness
e)
        Char
'd' -> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Exactness
exactness forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Exactness
e -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just Radix
R10, Maybe Exactness
e)
        Char
_ -> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Exactness
exactness forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Exactness
e -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just Radix
R16, Maybe Exactness
e)

exactness :: forall e s m . (MonadParsec e s m, Token s ~ Char) => m Exactness
exactness :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Exactness
exactness = (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#e") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Exactness
Exact) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
            (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#i") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Exactness
Inexact)

radix :: forall e s m . (MonadParsec e s m, Token s ~ Char) => m  Radix
radix :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Radix
radix =
  (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#b") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Radix
R2) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#o") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Radix
R8) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#d") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Radix
R10) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
"#x") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Radix
R16)

udigit :: forall e s m a . (MonadParsec e s m, Token s ~ Char, Integral a) => Radix -> m a
udigit :: forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Integral a) =>
Radix -> m a
udigit Radix
r = do
  case Radix
r of
    Radix
R2 -> forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
ML.binary
    Radix
R8 -> forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
ML.octal
    Radix
R10 -> forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
ML.decimal
    Radix
R16 -> m a
hexadecimal -- ML.hexadecimal also parses uppercase "ABCDEF"
  where hexadecimal :: m a
hexadecimal = Tokens s -> a
mkNum
                      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe [Char] -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P forall a. Maybe a
Nothing (\Token s
c -> Token s
c forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Char]
"0123456789abcdef" :: String))
                      forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"hexadecimal integer"

        mkNum :: Tokens s -> a
mkNum    = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' forall {a}. Num a => a -> Char -> a
step a
0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s. Stream s => Proxy s -> Tokens s -> [Token s]
chunkToTokens (forall {k} (t :: k). Proxy t
Proxy :: Proxy s)
        step :: a -> Char -> a
step a
a Char
c = a
a forall a. Num a => a -> a -> a
* a
16 forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (Char -> Int
C.digitToInt Char
c)

sign :: (MonadParsec e s m, Token s ~ Char) => m  Sign
sign :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Sign
sign = (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'-' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Sign
Minus) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'+' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Sign
Plus)

suffix :: (MonadParsec e s m, Token s ~ Char) => m Suffix
suffix :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Suffix
suffix = do
  Precision
p <- (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'e' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Precision
PDefault)  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
       (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
's' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Precision
PShort)  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
       (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'f' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Precision
PSingle) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
       (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'd' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Precision
PDouble) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
       (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'l' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Precision
PLong)
  Sign
s <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Sign
Plus forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Sign
sign
  Integer
n <- forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Integral a) =>
Radix -> m a
udigit Radix
R10
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Precision -> Sign -> Integer -> Suffix
Suffix Precision
p Sign
s Integer
n

------------------------- Other tokens -------------------------
-- | The 'quote' parser parses a quote character (').
quote :: (MonadParsec e s m, Token s ~ Char) => m Char
quote :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
quote = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'\''

-- | The 'quasiquote' parser parses a quasiquote character (`).
quasiquote :: (MonadParsec e s m, Token s ~ Char) => m Char
quasiquote :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
quasiquote = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'`'

-- | The 'comma' parser parses a comma (,).
comma :: (MonadParsec e s m, Token s ~ Char) => m Char
comma :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
comma = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
','

-- | The 'commaAt' parser parses a comma followed by \@ (,\@).
commaAt :: forall e s m . (MonadParsec e s m, Token s ~ Char) => m T.Text
commaAt :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Text
commaAt = forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
chunk (forall s. Stream s => Proxy s -> [Token s] -> Tokens s
tokensToChunk (forall {k} (t :: k). Proxy t
Proxy :: Proxy s) [Char]
",@") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Text
",@"

-- | The 'dot' parser parses a single dot character (.).
dot :: (MonadParsec e s m, Token s ~ Char) => m Char
dot :: forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m Char
dot = forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'.'