{-# 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
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