{-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}

-- ---------------------------------------------------------------------------
-- |
-- Module      : Text.Show.ByteString
-- Copyright   : (c) 2008 Dan Doel
-- Maintainer  : Dan Doel
-- Stability   : Experimental
-- Portability : Non-portable (type synonym instances)
--
-- Efficiently convert from values to lazy byte strings.

module Text.Show.ByteString ( -- * The Show class
                              Show (..)
                            , show
                              -- * Putting Chars
                            , putAscii
                            , putUTF8
                              -- * Putting Strings
                            , putAsciiStr
                            , putUTF8Str
                              -- * Putting digits
                            , unsafePutDigit
                            , putDigit
                              -- * Putting integers
                            , showpIntAtBase
                              -- * Putting floats
                            , showpGFloat
                            , showpFFloat
                            , showpEFloat
                              -- * Combining builders
                            , unlinesP
                            , unwordsP
                            , showpParen
                              -- * Printing values
                            , print
                              -- * Put
                            , Put
                            , PutM(..)
                            , runPut
                            ) where

import Prelude hiding (Show(..), print, putStrLn)
import qualified Prelude

import Data.Binary.Put
import Data.ByteString.Lazy.Char8

import Data.Int
import Data.Word
import Data.Ratio
import Data.Complex

import Data.Array

import qualified Data.Map as M
import qualified Data.Set as S

import Text.Show.ByteString.Util ( putAscii , putUTF8
                                 , putAsciiStr, putUTF8Str
                                 , unsafePutDigit
                                 )

import Text.Show.ByteString.Char
import Text.Show.ByteString.Int
import Text.Show.ByteString.Integer
import Text.Show.ByteString.Float

-- | Conversion of values to readable byte strings.
-- Minimal complete definition: 'showp' or 'showpPrec'
class Show a where
  -- | Encodes a value to an efficient byte string builder.
  -- The precedence is used to determine where to put
  -- parentheses in a shown expression involving operators.
  --
  -- Values of type Put can be efficiently combined, so the
  -- showp functions are available for showing multiple values
  -- before producing an output byte string.
  showpPrec :: Int -> a -> Put

  -- | Encodes a value to an efficient byte string builder.
  -- Values of type Put can be efficiently combined, so this
  -- is available for building strings from multiple values.
  showp     :: a -> Put

  -- | Allows for specialized display of lists of values.
  -- This is used, for example, when showing arrays of Chars.
  showpList :: [a] -> Put

  showpPrec Int
_ = a -> Put
forall a. Show a => a -> Put
showp

  showp = Int -> a -> Put
forall a. Show a => Int -> a -> Put
showpPrec Int
0

  showpList [] = Word8 -> Put
putWord8 Word8
91 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Put
putWord8 Word8
93          -- "[]"
  showpList (a
x:[a]
xs) = Word8 -> Put
putWord8 Word8
91 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp a
x Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [a] -> Put
forall a. Show a => [a] -> Put
go [a]
xs -- "[..
   where
   go :: [a] -> Put
go (a
y:[a]
ys) = Word8 -> Put
putWord8 Word8
44 Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp a
y Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [a] -> Put
go [a]
ys       -- ..,..
   go [    ] = Word8 -> Put
putWord8 Word8
93                           -- ..]"

-- | Encode a single value into a byte string
show :: Show a => a -> ByteString
show :: a -> ByteString
show = Put -> ByteString
runPut (Put -> ByteString) -> (a -> Put) -> a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Put
forall a. Show a => a -> Put
showp

-- | A utility function for surrounding output by parentheses
-- conditionally.
showpParen :: Bool -> Put -> Put
showpParen :: Bool -> Put -> Put
showpParen Bool
b Put
p | Bool
b         = Char -> Put
putAscii Char
'(' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Put
p Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
')'
               | Bool
otherwise = Put
p

-- | Print a value to the standard output
print :: Show a => a -> IO ()
print :: a -> IO ()
print = ByteString -> IO ()
putStrLn (ByteString -> IO ()) -> (a -> ByteString) -> a -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ByteString
forall a. Show a => a -> ByteString
show

-- | Merge several string builders, separating them by newlines
unlinesP :: [Put] -> Put
unlinesP :: [Put] -> Put
unlinesP [    ] = () -> Put
forall (m :: * -> *) a. Monad m => a -> m a
return ()
unlinesP (Put
p:[Put]
ps) = Put
p Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
'\n' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Put] -> Put
unlinesP [Put]
ps

-- | Merge several string builders, separating them by spaces
unwordsP :: [Put] -> Put
unwordsP :: [Put] -> Put
unwordsP [    ] = () -> Put
forall (m :: * -> *) a. Monad m => a -> m a
return ()
unwordsP [Put
p]    = Put
p
unwordsP (Put
p:[Put]
ps) = Put
p Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
' ' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Put] -> Put
unwordsP [Put]
ps

-- | Puts the digit corresponding to the Int passed in.
putDigit :: Int -> Put
putDigit :: Int -> Put
putDigit Int
i
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0     = [Char] -> Put
forall a. HasCallStack => [Char] -> a
error ([Char] -> Put) -> [Char] -> Put
forall a b. (a -> b) -> a -> b
$ [Char]
"putDigit: Negative integer: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
Prelude.show Int
i
  | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
9     = [Char] -> Put
forall a. HasCallStack => [Char] -> a
error ([Char] -> Put) -> [Char] -> Put
forall a b. (a -> b) -> a -> b
$ [Char]
"putDigit: Non-decimal digit: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
Prelude.show Int
i
  | Bool
otherwise = Int -> Put
unsafePutDigit Int
i

-- This may be a bad idea, but I'm trying it out
instance Show Put where
  showp :: Put -> Put
showp Put
p = Put
p

instance Show () where
  showp :: () -> Put
showp () = Char -> Put
putAscii Char
'(' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
')'

instance Show Char where
  showp :: Char -> Put
showp     = Char -> Put
showpChar
  showpList :: [Char] -> Put
showpList = [Char] -> Put
showpString

instance Show Bool where
  showp :: Bool -> Put
showp Bool
True  = [Char] -> Put
putAsciiStr [Char]
"True"
  showp Bool
False = [Char] -> Put
putAsciiStr [Char]
"False"

instance (Show a) => Show [a] where
  showp :: [a] -> Put
showp = [a] -> Put
forall a. Show a => [a] -> Put
showpList

instance Show Int where
  showp :: Int -> Put
showp = Int -> Put
showpInt

  showpPrec :: Int -> Int -> Put
showpPrec Int
k Int
i = Bool -> Put -> Put
showpParen (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
&& Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Int -> Put
showpInt Int
i

instance Show Int8 where
  showp :: Int8 -> Put
showp = Int8 -> Put
showpInt8

  showpPrec :: Int -> Int8 -> Put
showpPrec Int
k Int8
i = Bool -> Put -> Put
showpParen (Int8
i Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
< Int8
0 Bool -> Bool -> Bool
&& Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Int8 -> Put
showpInt8 Int8
i

instance Show Int16 where
  showp :: Int16 -> Put
showp = Int16 -> Put
showpInt16

  showpPrec :: Int -> Int16 -> Put
showpPrec Int
k Int16
i = Bool -> Put -> Put
showpParen (Int16
i Int16 -> Int16 -> Bool
forall a. Ord a => a -> a -> Bool
< Int16
0 Bool -> Bool -> Bool
&& Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Int16 -> Put
showpInt16 Int16
i

instance Show Int32 where
  showp :: Int32 -> Put
showp = Int32 -> Put
showpInt32

  showpPrec :: Int -> Int32 -> Put
showpPrec Int
k Int32
i = Bool -> Put -> Put
showpParen (Int32
i Int32 -> Int32 -> Bool
forall a. Ord a => a -> a -> Bool
< Int32
0 Bool -> Bool -> Bool
&& Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Int32 -> Put
showpInt32 Int32
i

instance Show Int64 where
  showp :: Int64 -> Put
showp = Int64 -> Put
showpInt64

  showpPrec :: Int -> Int64 -> Put
showpPrec Int
k Int64
i = Bool -> Put -> Put
showpParen (Int64
i Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
< Int64
0 Bool -> Bool -> Bool
&& Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Int64 -> Put
showpInt64 Int64
i

instance Show Word where
  showp :: Word -> Put
showp = Word -> Put
showpWord

instance Show Word8 where
  showp :: Word8 -> Put
showp = Word8 -> Put
showpWord8

instance Show Word16 where
  showp :: Word16 -> Put
showp = Word16 -> Put
showpWord16

instance Show Word32 where
  showp :: Word32 -> Put
showp = Word32 -> Put
showpWord32

instance Show Word64 where
  showp :: Word64 -> Put
showp = Word64 -> Put
showpWord64

instance Show Integer where
  showp :: Integer -> Put
showp = Integer -> Put
showpInteger

  showpPrec :: Int -> Integer -> Put
showpPrec Int
k Integer
i = Bool -> Put -> Put
showpParen (Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0 Bool -> Bool -> Bool
&& Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Integer -> Put
showpInteger Integer
i

instance Show Float where
  showp :: Float -> Put
showp = Maybe Int -> Float -> Put
forall a. RealFloat a => Maybe Int -> a -> Put
showpGFloat Maybe Int
forall a. Maybe a
Nothing

  showpPrec :: Int -> Float -> Put
showpPrec Int
k Float
f = Bool -> Put -> Put
showpParen (Float
f Float -> Float -> Bool
forall a. Ord a => a -> a -> Bool
< Float
0 Bool -> Bool -> Bool
&& Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Float -> Put
forall a. RealFloat a => Maybe Int -> a -> Put
showpGFloat Maybe Int
forall a. Maybe a
Nothing Float
f

instance Show Double where
  showp :: Double -> Put
showp = Maybe Int -> Double -> Put
forall a. RealFloat a => Maybe Int -> a -> Put
showpGFloat Maybe Int
forall a. Maybe a
Nothing

  showpPrec :: Int -> Double -> Put
showpPrec Int
k Double
f = Bool -> Put -> Put
showpParen (Double
f Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
< Double
0 Bool -> Bool -> Bool
&& Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Double -> Put
forall a. RealFloat a => Maybe Int -> a -> Put
showpGFloat Maybe Int
forall a. Maybe a
Nothing Double
f

instance (Show a, Integral a) => Show (Ratio a) where
  showpPrec :: Int -> Ratio a -> Put
showpPrec Int
k Ratio a
q = Bool -> Put -> Put
showpParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
7) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Int -> a -> Put
forall a. Show a => Int -> a -> Put
showpPrec Int
8 (Ratio a -> a
forall a. Ratio a -> a
numerator Ratio a
q) Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  Char -> Put
putAscii Char
'%' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp (Ratio a -> a
forall a. Ratio a -> a
denominator Ratio a
q)

instance (Show a, RealFloat a) => Show (Complex a) where
  showpPrec :: Int -> Complex a -> Put
showpPrec Int
k (a
a :+ a
b) = Bool -> Put -> Put
showpParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
6) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ Int -> a -> Put
forall a. Show a => Int -> a -> Put
showpPrec Int
7 a
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                         Char -> Put
putAscii Char
' ' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
':' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
'+' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
' ' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                         Int -> a -> Put
forall a. Show a => Int -> a -> Put
showpPrec Int
7 a
b

instance Show a => Show (Maybe a) where
  showpPrec :: Int -> Maybe a -> Put
showpPrec Int
_ Maybe a
Nothing  = [Char] -> Put
putAsciiStr [Char]
"Nothing"
  showpPrec Int
k (Just a
a) = Bool -> Put -> Put
showpParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ [Char] -> Put
putAsciiStr [Char]
"Just " Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> a -> Put
forall a. Show a => Int -> a -> Put
showpPrec Int
11 a
a

instance (Show a, Show b) => Show (Either a b) where
  showpPrec :: Int -> Either a b -> Put
showpPrec Int
k (Left a
a)  = Bool -> Put -> Put
showpParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ [Char] -> Put
putAsciiStr [Char]
"Left " Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> a -> Put
forall a. Show a => Int -> a -> Put
showpPrec Int
11 a
a
  showpPrec Int
k (Right b
b) = Bool -> Put -> Put
showpParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ [Char] -> Put
putAsciiStr [Char]
"Right " Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> b -> Put
forall a. Show a => Int -> a -> Put
showpPrec Int
11 b
b

instance Show Ordering where
  showp :: Ordering -> Put
showp Ordering
LT = Char -> Put
putAscii Char
'L' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
'T'
  showp Ordering
EQ = Char -> Put
putAscii Char
'E' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
'Q'
  showp Ordering
GT = Char -> Put
putAscii Char
'G' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
'T'

instance (Show a, Show b) => Show (a,b) where
  showp :: (a, b) -> Put
showp (a
a,b
b) = Char -> Put
putAscii Char
'(' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp a
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b -> Put
forall a. Show a => a -> Put
showp b
b Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
')'

instance (Show a, Show b, Show c) => Show (a,b,c) where
  showp :: (a, b, c) -> Put
showp (a
a,b
b,c
c) = Char -> Put
putAscii Char
'(' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp a
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b -> Put
forall a. Show a => a -> Put
showp b
b Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> c -> Put
forall a. Show a => a -> Put
showp c
c Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  Char -> Put
putAscii Char
')'

instance (Show a, Show b, Show c, Show d) => Show (a,b,c,d) where
  showp :: (a, b, c, d) -> Put
showp (a
a,b
b,c
c,d
d) =
    Char -> Put
putAscii Char
'(' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp a
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b -> Put
forall a. Show a => a -> Put
showp b
b Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> c -> Put
forall a. Show a => a -> Put
showp c
c Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> d -> Put
forall a. Show a => a -> Put
showp d
d Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
')'

instance (Show a, Show b, Show c, Show d, Show e) => Show (a,b,c,d,e) where
  showp :: (a, b, c, d, e) -> Put
showp (a
a,b
b,c
c,d
d,e
e) =
    Char -> Put
putAscii Char
'(' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp a
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b -> Put
forall a. Show a => a -> Put
showp b
b Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> c -> Put
forall a. Show a => a -> Put
showp c
c Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> d -> Put
forall a. Show a => a -> Put
showp d
d Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> e -> Put
forall a. Show a => a -> Put
showp e
e Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
')'

instance (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a,b,c,d,e,f) where
  showp :: (a, b, c, d, e, f) -> Put
showp (a
a,b
b,c
c,d
d,e
e,f
f) =
    Char -> Put
putAscii Char
'(' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp a
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b -> Put
forall a. Show a => a -> Put
showp b
b Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> c -> Put
forall a. Show a => a -> Put
showp c
c Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> d -> Put
forall a. Show a => a -> Put
showp d
d Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> e -> Put
forall a. Show a => a -> Put
showp e
e Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> f -> Put
forall a. Show a => a -> Put
showp f
f Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
')'

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a,b,c,d,e,f,g) where
  showp :: (a, b, c, d, e, f, g) -> Put
showp (a
a,b
b,c
c,d
d,e
e,f
f,g
g) =
    Char -> Put
putAscii Char
'(' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> Put
forall a. Show a => a -> Put
showp a
a Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b -> Put
forall a. Show a => a -> Put
showp b
b Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> c -> Put
forall a. Show a => a -> Put
showp c
c Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> d -> Put
forall a. Show a => a -> Put
showp d
d Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> e -> Put
forall a. Show a => a -> Put
showp e
e Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> f -> Put
forall a. Show a => a -> Put
showp f
f Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
',' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> g -> Put
forall a. Show a => a -> Put
showp g
g Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
    Char -> Put
putAscii Char
')'

instance (Show i, Show e, Ix i) => Show (Array i e) where
  showpPrec :: Int -> Array i e -> Put
showpPrec Int
k Array i e
a = Bool -> Put -> Put
showpParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ [Char] -> Put
putAsciiStr [Char]
"array " Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  (i, i) -> Put
forall a. Show a => a -> Put
showp (Array i e -> (i, i)
forall i e. Array i e -> (i, i)
bounds Array i e
a) Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> Put
putAscii Char
' ' Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [(i, e)] -> Put
forall a. Show a => a -> Put
showp (Array i e -> [(i, e)]
forall i e. Ix i => Array i e -> [(i, e)]
assocs Array i e
a)

instance (Show k, Show v) => Show (M.Map k v) where
  showpPrec :: Int -> Map k v -> Put
showpPrec Int
k Map k v
m = Bool -> Put -> Put
showpParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ [Char] -> Put
putAsciiStr [Char]
"fromList " Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  [(k, v)] -> Put
forall a. Show a => a -> Put
showp (Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
M.toList Map k v
m)

instance (Show e) => Show (S.Set e) where
  showpPrec :: Int -> Set e -> Put
showpPrec Int
k Set e
s = Bool -> Put -> Put
showpParen (Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (Put -> Put) -> Put -> Put
forall a b. (a -> b) -> a -> b
$ [Char] -> Put
putAsciiStr [Char]
"fromList " Put -> Put -> Put
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                  [e] -> Put
forall a. Show a => a -> Put
showp (Set e -> [e]
forall a. Set a -> [a]
S.toList Set e
s)