{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Data.SExpresso.Language.SchemeR5RS (
SExprType(..),
SchemeToken(..),
tokenParser,
sexpr,
Datum(..),
sexpr2Datum,
whitespace,
comment,
interTokenSpace,
interTokenSpace1,
identifier,
boolean,
character,
stringParser,
quote,
quasiquote,
comma,
commaAt,
dot,
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
data SchemeToken =
TBoolean Bool
| TNumber SchemeNumber
| TChar Char
| TString T.Text
| TIdentifier T.Text
| TQuote
| TQuasiquote
| TComma
| TCommaAt
| 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)
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
<|>
(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
<|>
(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
<|>
(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
data SExprType =
STList
| 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)
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)
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)
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 :: (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 ())
comment :: (MonadParsec e s m, Token s ~ Char) => m ()
= 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
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 ()
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 :: 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
"...")
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 :: 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
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
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)
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)
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)
type Pounds = Integer
data UInteger =
UInteger Integer
| UIntPounds Integer Pounds
| 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
data Precision =
PDefault |
PShort |
PSingle |
PDouble |
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)
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)
data SReal =
SInteger Sign UInteger
| SRational Sign UInteger UInteger
| 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
data Complex =
CReal SReal
| CAngle SReal SReal
| 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
data = 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)
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
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)))
complex' :: Sign -> m Complex
complex' Sign
sr = do
SReal
n1 <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> Sign -> m SReal
ureal Radix
r Sign
sr
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
Maybe Char
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SReal -> Complex
CReal SReal
n1
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
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
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
UInteger
u1 <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Radix -> m UInteger
uinteger Radix
r
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
Maybe Char
Nothing -> UInteger -> m SReal
plainInteger UInteger
u1
Just Char
'/' -> UInteger -> m SReal
rational UInteger
u1
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
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
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
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
'\''
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
'`'
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
','
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
",@"
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
'.'