{-# LANGUAGE TupleSections, DeriveGeneric, OverloadedStrings, CPP #-}
module Sugar.Types
  ( Sugar(..)
  , Wrap(..)
  , Note
  , readSugarMay
  , sugarTextMay
  , sugarMapAsIxMap
  , reservedChars
  , FromSugar(..)
  , ToSugar(..)
  ) where

import Data.Text (Text)
import Data.Map (Map)
import Data.Maybe (mapMaybe)
import Data.Text.Conversions (ToText(..), fromText, unUTF8, decodeConvertText, UTF8(..))
import Data.String (IsString(..))
import Data.Word (Word8,Word16,Word32,Word64)
import Data.Int (Int8,Int16,Int32,Int64)
import GHC.Generics (Generic)
import Safe (readMay)

import qualified Data.Map as Map
import qualified Data.Serialize as Serialize
import qualified Data.Store as Store ()
import qualified Data.ByteString as BS
import qualified Data.Text as T

---

data Sugar
  = Sugar'Unit Note
  | Sugar'Text Text Note
  | Sugar'List [Sugar] Wrap Note
  | Sugar'Map [(Sugar,Sugar)] Note
  deriving (Sugar -> Sugar -> Bool
(Sugar -> Sugar -> Bool) -> (Sugar -> Sugar -> Bool) -> Eq Sugar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sugar -> Sugar -> Bool
$c/= :: Sugar -> Sugar -> Bool
== :: Sugar -> Sugar -> Bool
$c== :: Sugar -> Sugar -> Bool
Eq, Int -> Sugar -> ShowS
[Sugar] -> ShowS
Sugar -> String
(Int -> Sugar -> ShowS)
-> (Sugar -> String) -> ([Sugar] -> ShowS) -> Show Sugar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sugar] -> ShowS
$cshowList :: [Sugar] -> ShowS
show :: Sugar -> String
$cshow :: Sugar -> String
showsPrec :: Int -> Sugar -> ShowS
$cshowsPrec :: Int -> Sugar -> ShowS
Show, (forall x. Sugar -> Rep Sugar x)
-> (forall x. Rep Sugar x -> Sugar) -> Generic Sugar
forall x. Rep Sugar x -> Sugar
forall x. Sugar -> Rep Sugar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Sugar x -> Sugar
$cfrom :: forall x. Sugar -> Rep Sugar x
Generic)

data Wrap
  = Wrap'Square
  | Wrap'Paren
  deriving (Wrap -> Wrap -> Bool
(Wrap -> Wrap -> Bool) -> (Wrap -> Wrap -> Bool) -> Eq Wrap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Wrap -> Wrap -> Bool
$c/= :: Wrap -> Wrap -> Bool
== :: Wrap -> Wrap -> Bool
$c== :: Wrap -> Wrap -> Bool
Eq, Int -> Wrap -> ShowS
[Wrap] -> ShowS
Wrap -> String
(Int -> Wrap -> ShowS)
-> (Wrap -> String) -> ([Wrap] -> ShowS) -> Show Wrap
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Wrap] -> ShowS
$cshowList :: [Wrap] -> ShowS
show :: Wrap -> String
$cshow :: Wrap -> String
showsPrec :: Int -> Wrap -> ShowS
$cshowsPrec :: Int -> Wrap -> ShowS
Show, (forall x. Wrap -> Rep Wrap x)
-> (forall x. Rep Wrap x -> Wrap) -> Generic Wrap
forall x. Rep Wrap x -> Wrap
forall x. Wrap -> Rep Wrap x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Wrap x -> Wrap
$cfrom :: forall x. Wrap -> Rep Wrap x
Generic)

type Note = Maybe [Sugar]

--

sugarTextMay :: Sugar -> Maybe Text
sugarTextMay :: Sugar -> Maybe Text
sugarTextMay (Sugar'Text Text
t Note
_) = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
t
sugarTextMay Sugar
_ = Maybe Text
forall a. Maybe a
Nothing

readSugarMay :: Read a => Sugar -> Maybe a
readSugarMay :: Sugar -> Maybe a
readSugarMay (Sugar'Text Text
t Note
_) = String -> Maybe a
forall a. Read a => String -> Maybe a
readMay (String -> Maybe a) -> String -> Maybe a
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
t
readSugarMay Sugar
_ = Maybe a
forall a. Maybe a
Nothing

sugarMapAsIxMap :: [(Sugar,Sugar)] -> Map (Int, Sugar) Sugar
sugarMapAsIxMap :: [(Sugar, Sugar)] -> Map (Int, Sugar) Sugar
sugarMapAsIxMap = [((Int, Sugar), Sugar)] -> Map (Int, Sugar) Sugar
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([((Int, Sugar), Sugar)] -> Map (Int, Sugar) Sugar)
-> ([(Sugar, Sugar)] -> [((Int, Sugar), Sugar)])
-> [(Sugar, Sugar)]
-> Map (Int, Sugar) Sugar
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> (Sugar, Sugar) -> ((Int, Sugar), Sugar))
-> [Int] -> [(Sugar, Sugar)] -> [((Int, Sugar), Sugar)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\Int
i (Sugar
k,Sugar
v) -> ((Int
i,Sugar
k),Sugar
v)) [Int
0..]

sugarShow :: Show a => a -> Sugar
sugarShow :: a -> Sugar
sugarShow a
s = Text -> Note -> Sugar
Sugar'Text (String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ a -> String
forall a. Show a => a -> String
show a
s) Note
forall a. Maybe a
Nothing

reservedChars :: [Char]
reservedChars :: String
reservedChars = [Char
'\"',Char
'[',Char
']',Char
'<',Char
'>',Char
'(',Char
')',Char
'{',Char
'}',Char
';']

--

instance Ord Sugar where
  compare :: Sugar -> Sugar -> Ordering
compare (Sugar'Unit Note
x) (Sugar'Unit Note
y) = Note -> Note -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Note
x Note
y
  compare Sugar'Unit{} Sugar
_ = Ordering
GT
  compare Sugar
_ Sugar'Unit{} = Ordering
LT
  compare (Sugar'Text Text
x0 Note
x1) (Sugar'Text Text
y0 Note
y1) = Text -> Text -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Text
x0 Text
y0 Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` Note -> Note -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Note
x1 Note
y1
  compare Sugar'Text{} Sugar
_ = Ordering
GT
  compare Sugar
_ Sugar'Text{} = Ordering
LT
  compare (Sugar'List [Sugar]
x0 Wrap
_ Note
x1) (Sugar'List [Sugar]
y0 Wrap
_ Note
y1) = [Sugar] -> [Sugar] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare [Sugar]
x0 [Sugar]
y0 Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` Note -> Note -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Note
x1 Note
y1
  compare Sugar'List{} Sugar
_ = Ordering
GT
  compare Sugar
_ Sugar'List{} = Ordering
LT
  compare (Sugar'Map [(Sugar, Sugar)]
x0 Note
x1) (Sugar'Map [(Sugar, Sugar)]
y0 Note
y1) = [(Sugar, Sugar)] -> [(Sugar, Sugar)] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare [(Sugar, Sugar)]
x0 [(Sugar, Sugar)]
y0 Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` Note -> Note -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Note
x1 Note
y1

instance Serialize.Serialize Sugar where
  get :: Get Sugar
get = do
    Word8
tag <- Get Word8
Serialize.getWord8
    Word8 -> Get Sugar
go Word8
tag
    where
      go :: Word8 -> Serialize.Get Sugar
      go :: Word8 -> Get Sugar
go Word8
0 = Note -> Sugar
Sugar'Unit (Note -> Sugar) -> Get Note -> Get Sugar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Note
forall t. Serialize t => Get t
Serialize.get
      go Word8
1 = Text -> Note -> Sugar
Sugar'Text (Text -> Note -> Sugar) -> Get Text -> Get (Note -> Sugar)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Text
getSerializedText Get (Note -> Sugar) -> Get Note -> Get Sugar
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Note
forall t. Serialize t => Get t
Serialize.get
      go Word8
2 = [Sugar] -> Wrap -> Note -> Sugar
Sugar'List ([Sugar] -> Wrap -> Note -> Sugar)
-> Get [Sugar] -> Get (Wrap -> Note -> Sugar)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get [Sugar]
forall t. Serialize t => Get t
Serialize.get Get (Wrap -> Note -> Sugar) -> Get Wrap -> Get (Note -> Sugar)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Wrap
forall t. Serialize t => Get t
Serialize.get Get (Note -> Sugar) -> Get Note -> Get Sugar
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Note
forall t. Serialize t => Get t
Serialize.get
      go Word8
3 = [(Sugar, Sugar)] -> Note -> Sugar
Sugar'Map ([(Sugar, Sugar)] -> Note -> Sugar)
-> Get [(Sugar, Sugar)] -> Get (Note -> Sugar)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get [(Sugar, Sugar)]
forall t. Serialize t => Get t
Serialize.get Get (Note -> Sugar) -> Get Note -> Get Sugar
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Note
forall t. Serialize t => Get t
Serialize.get
      go Word8
_ = String -> Get Sugar
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"No matching Sugar value"

      getSerializedText :: Serialize.Get Text
      getSerializedText :: Get Text
getSerializedText = do
        Maybe Text
txt <- (UTF8 ByteString -> Maybe Text
forall (f :: * -> *) a b. (DecodeText f a, FromText b) => a -> f b
decodeConvertText (UTF8 ByteString -> Maybe Text)
-> (ByteString -> UTF8 ByteString) -> ByteString -> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> UTF8 ByteString
forall a. a -> UTF8 a
UTF8) (ByteString -> Maybe Text) -> Get ByteString -> Get (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Get ByteString
forall t. Serialize t => Get t
Serialize.get :: Serialize.Get BS.ByteString)
        Get Text -> (Text -> Get Text) -> Maybe Text -> Get Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Get Text
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Cannot deserialize text as UTF8") Text -> Get Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Text
txt

  put :: Putter Sugar
put (Sugar'Unit Note
note) = do
    Putter Word8
forall t. Serialize t => Putter t
Serialize.put (Word8
0 :: Word8)
    Putter Note
forall t. Serialize t => Putter t
Serialize.put Note
note
  put (Sugar'Text Text
txt Note
note) = do
    Putter Word8
forall t. Serialize t => Putter t
Serialize.put (Word8
1 :: Word8)
    Putter ByteString
forall t. Serialize t => Putter t
Serialize.put (UTF8 ByteString -> ByteString
forall a. UTF8 a -> a
unUTF8 (UTF8 ByteString -> ByteString) -> UTF8 ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ Text -> UTF8 ByteString
forall a. FromText a => Text -> a
fromText Text
txt :: BS.ByteString)
    Putter Note
forall t. Serialize t => Putter t
Serialize.put Note
note
  put (Sugar'List [Sugar]
xs Wrap
w Note
note) = do
    Putter Word8
forall t. Serialize t => Putter t
Serialize.put (Word8
2 :: Word8)
    Putter [Sugar]
forall t. Serialize t => Putter t
Serialize.put [Sugar]
xs
    Putter Wrap
forall t. Serialize t => Putter t
Serialize.put Wrap
w
    Putter Note
forall t. Serialize t => Putter t
Serialize.put Note
note
  put (Sugar'Map [(Sugar, Sugar)]
m Note
note) = do
    Putter Word8
forall t. Serialize t => Putter t
Serialize.put (Word8
3 :: Word8)
    Putter [(Sugar, Sugar)]
forall t. Serialize t => Putter t
Serialize.put [(Sugar, Sugar)]
m
    Putter Note
forall t. Serialize t => Putter t
Serialize.put Note
note

instance Serialize.Serialize Wrap where

instance IsString Sugar where
  fromString :: String -> Sugar
fromString String
str = Text -> Note -> Sugar
Sugar'Text (String -> Text
forall a. ToText a => a -> Text
toText String
str) Note
forall a. Maybe a
Nothing


class FromSugar a where
  parseSugar :: Sugar -> Maybe a

instance FromSugar a => FromSugar [a] where
  parseSugar :: Sugar -> Maybe [a]
parseSugar (Sugar'List [Sugar]
xs Wrap
_ Note
_) = (Sugar -> Maybe a) -> [Sugar] -> Maybe [a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Sugar -> Maybe a
forall a. FromSugar a => Sugar -> Maybe a
parseSugar [Sugar]
xs
  parseSugar Sugar
_ = Maybe [a]
forall a. Maybe a
Nothing

instance FromSugar a => FromSugar (Maybe a) where
  parseSugar :: Sugar -> Maybe (Maybe a)
parseSugar (Sugar'Unit Note
_) = Maybe a -> Maybe (Maybe a)
forall a. a -> Maybe a
Just Maybe a
forall a. Maybe a
Nothing
  parseSugar Sugar
s = (Maybe a -> Maybe (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> Maybe (Maybe a))
-> (a -> Maybe a) -> a -> Maybe (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe a
forall a. a -> Maybe a
Just) (a -> Maybe (Maybe a)) -> Maybe a -> Maybe (Maybe a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Sugar -> Maybe a
forall a. FromSugar a => Sugar -> Maybe a
parseSugar Sugar
s

instance (FromSugar a, Ord a, FromSugar b) => FromSugar (Map a b) where
  parseSugar :: Sugar -> Maybe (Map a b)
parseSugar (Sugar'Map [(Sugar, Sugar)]
m Note
_) = Map a b -> Maybe (Map a b)
forall a. a -> Maybe a
Just (Map a b -> Maybe (Map a b)) -> Map a b -> Maybe (Map a b)
forall a b. (a -> b) -> a -> b
$ [(a, b)] -> Map a b
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(a, b)] -> Map a b) -> [(a, b)] -> Map a b
forall a b. (a -> b) -> a -> b
$
    ((Sugar, Sugar) -> Maybe (a, b)) -> [(Sugar, Sugar)] -> [(a, b)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe
      (\(Sugar
s,Sugar
v) -> (,) (a -> b -> (a, b)) -> Maybe a -> Maybe (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sugar -> Maybe a
forall a. FromSugar a => Sugar -> Maybe a
parseSugar Sugar
s Maybe (b -> (a, b)) -> Maybe b -> Maybe (a, b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sugar -> Maybe b
forall a. FromSugar a => Sugar -> Maybe a
parseSugar Sugar
v)
      [(Sugar, Sugar)]
m
  parseSugar Sugar
_ = Maybe (Map a b)
forall a. Maybe a
Nothing

instance FromSugar Text where
  parseSugar :: Sugar -> Maybe Text
parseSugar (Sugar'Text Text
t Note
_) = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
t
  parseSugar Sugar
_ = Maybe Text
forall a. Maybe a
Nothing

instance FromSugar Bool where
  parseSugar :: Sugar -> Maybe Bool
parseSugar (Sugar'Text Text
"#t" Note
_) = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
  parseSugar (Sugar'Text Text
"#f" Note
_) = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
  parseSugar Sugar
_ = Maybe Bool
forall a. Maybe a
Nothing

instance FromSugar Integer where parseSugar :: Sugar -> Maybe Integer
parseSugar = Sugar -> Maybe Integer
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Int where parseSugar :: Sugar -> Maybe Int
parseSugar = Sugar -> Maybe Int
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Int8 where parseSugar :: Sugar -> Maybe Int8
parseSugar = Sugar -> Maybe Int8
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Int16 where parseSugar :: Sugar -> Maybe Int16
parseSugar = Sugar -> Maybe Int16
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Int32 where parseSugar :: Sugar -> Maybe Int32
parseSugar = Sugar -> Maybe Int32
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Int64 where parseSugar :: Sugar -> Maybe Int64
parseSugar = Sugar -> Maybe Int64
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Word where parseSugar :: Sugar -> Maybe Word
parseSugar = Sugar -> Maybe Word
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Word8 where parseSugar :: Sugar -> Maybe Word8
parseSugar = Sugar -> Maybe Word8
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Word16 where parseSugar :: Sugar -> Maybe Word16
parseSugar = Sugar -> Maybe Word16
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Word32 where parseSugar :: Sugar -> Maybe Word32
parseSugar = Sugar -> Maybe Word32
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Word64 where parseSugar :: Sugar -> Maybe Word64
parseSugar = Sugar -> Maybe Word64
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Float where parseSugar :: Sugar -> Maybe Float
parseSugar = Sugar -> Maybe Float
forall a. Read a => Sugar -> Maybe a
readSugarMay
instance FromSugar Double where parseSugar :: Sugar -> Maybe Double
parseSugar = Sugar -> Maybe Double
forall a. Read a => Sugar -> Maybe a
readSugarMay


class ToSugar a where
  toSugar :: a -> Sugar

instance ToSugar () where
  toSugar :: () -> Sugar
toSugar () = Note -> Sugar
Sugar'Unit Note
forall a. Maybe a
Nothing

instance ToSugar Text where
  toSugar :: Text -> Sugar
toSugar Text
t = Text -> Note -> Sugar
Sugar'Text Text
t Note
forall a. Maybe a
Nothing

-- TODO: Will conflict with a String instance (aka [Char])
instance ToSugar a => ToSugar [a] where
  toSugar :: [a] -> Sugar
toSugar [a]
xs = [Sugar] -> Wrap -> Note -> Sugar
Sugar'List ((a -> Sugar) -> [a] -> [Sugar]
forall a b. (a -> b) -> [a] -> [b]
map a -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar [a]
xs) Wrap
Wrap'Square Note
forall a. Maybe a
Nothing

instance ToSugar a => ToSugar (Maybe a) where
  toSugar :: Maybe a -> Sugar
toSugar Maybe a
Nothing = Note -> Sugar
Sugar'Unit Note
forall a. Maybe a
Nothing
  toSugar (Just a
a) = a -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar a
a

instance (ToSugar a, ToSugar b) => ToSugar (Map a b) where
  toSugar :: Map a b -> Sugar
toSugar Map a b
m = [(Sugar, Sugar)] -> Note -> Sugar
Sugar'Map (((a, b) -> (Sugar, Sugar)) -> [(a, b)] -> [(Sugar, Sugar)]
forall a b. (a -> b) -> [a] -> [b]
map (\(a
k,b
v) -> (a -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar a
k, b -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar b
v)) ([(a, b)] -> [(Sugar, Sugar)]) -> [(a, b)] -> [(Sugar, Sugar)]
forall a b. (a -> b) -> a -> b
$ Map a b -> [(a, b)]
forall k a. Map k a -> [(k, a)]
Map.toList Map a b
m) Note
forall a. Maybe a
Nothing

instance (ToSugar a, ToSugar b) => ToSugar (a,b) where
  toSugar :: (a, b) -> Sugar
toSugar (a
a,b
b) = [Sugar] -> Wrap -> Note -> Sugar
Sugar'List [a -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar a
a, b -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar b
b] Wrap
Wrap'Paren Note
forall a. Maybe a
Nothing

instance (ToSugar a, ToSugar b, ToSugar c) => ToSugar (a,b,c) where
  toSugar :: (a, b, c) -> Sugar
toSugar (a
a,b
b,c
c) = [Sugar] -> Wrap -> Note -> Sugar
Sugar'List [a -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar a
a, b -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar b
b, c -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar c
c] Wrap
Wrap'Paren Note
forall a. Maybe a
Nothing

instance ToSugar Bool where
  toSugar :: Bool -> Sugar
toSugar Bool
s = Text -> Sugar
forall a. ToSugar a => a -> Sugar
toSugar (if Bool
s then Text
"#t" else Text
"#f" :: Text)

instance ToSugar Integer where toSugar :: Integer -> Sugar
toSugar = Integer -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Int where toSugar :: Int -> Sugar
toSugar = Int -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Int8 where toSugar :: Int8 -> Sugar
toSugar = Int8 -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Int16 where toSugar :: Int16 -> Sugar
toSugar = Int16 -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Int32 where toSugar :: Int32 -> Sugar
toSugar = Int32 -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Int64 where toSugar :: Int64 -> Sugar
toSugar = Int64 -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Word where toSugar :: Word -> Sugar
toSugar = Word -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Word8 where toSugar :: Word8 -> Sugar
toSugar = Word8 -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Word16 where toSugar :: Word16 -> Sugar
toSugar = Word16 -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Word32 where toSugar :: Word32 -> Sugar
toSugar = Word32 -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Word64 where toSugar :: Word64 -> Sugar
toSugar = Word64 -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Float where toSugar :: Float -> Sugar
toSugar = Float -> Sugar
forall a. Show a => a -> Sugar
sugarShow
instance ToSugar Double where toSugar :: Double -> Sugar
toSugar = Double -> Sugar
forall a. Show a => a -> Sugar
sugarShow