{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}

module Simplex.Messaging.Encoding
  ( Encoding (..),
    Tail (..),
    Large (..),
    _smpP,
    smpEncodeList,
    smpListP,
    lenEncode,
  )
where

import Data.Attoparsec.ByteString.Char8 (Parser)
import qualified Data.Attoparsec.ByteString.Char8 as A
import Data.Bits (shiftL, shiftR, (.|.))
import Data.ByteString.Char8 (ByteString)
import qualified Data.ByteString.Char8 as B
import Data.ByteString.Internal (c2w, w2c)
import Data.Text (Text)
import Data.Text.Encoding (decodeUtf8', encodeUtf8)
import Data.Int (Int64)
import qualified Data.List.NonEmpty as L
import Data.Time.Clock.System (SystemTime (..))
import Data.Word (Word16, Word32)
import Network.Transport.Internal (decodeWord16, decodeWord32, encodeWord16, encodeWord32)
import Simplex.Messaging.Parsers (parseAll)
import Simplex.Messaging.Util ((<$?>))

-- | SMP protocol encoding
class Encoding a where
  {-# MINIMAL smpEncode, (smpDecode | smpP) #-}

  -- | protocol encoding of type (default implementation uses protocol ByteString encoding)
  smpEncode :: a -> ByteString

  -- | decoding of type (default implementation uses parser)
  smpDecode :: ByteString -> Either String a
  smpDecode = Parser a -> ByteString -> Either String a
forall a. Parser a -> ByteString -> Either String a
parseAll Parser a
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpDecode #-}

  -- | protocol parser of type (default implementation parses protocol ByteString encoding)
  smpP :: Parser a
  smpP = ByteString -> Either String a
forall a. Encoding a => ByteString -> Either String a
smpDecode (ByteString -> Either String a)
-> Parser ByteString ByteString -> Parser a
forall (m :: * -> *) a b.
MonadFail m =>
(a -> Either String b) -> m a -> m b
<$?> Parser ByteString ByteString
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance Encoding Char where
  smpEncode :: Char -> ByteString
smpEncode = Char -> ByteString
B.singleton
  {-# INLINE smpEncode #-}
  smpP :: Parser Char
smpP = Parser Char
A.anyChar
  {-# INLINE smpP #-}

instance Encoding Bool where
  smpEncode :: Bool -> ByteString
smpEncode = \case
    Bool
True -> ByteString
"T"
    Bool
False -> ByteString
"F"
  {-# INLINE smpEncode #-}
  smpP :: Parser Bool
smpP =
    Parser Char
forall a. Encoding a => Parser a
smpP Parser Char -> (Char -> Parser Bool) -> Parser Bool
forall a b.
Parser ByteString a
-> (a -> Parser ByteString b) -> Parser ByteString b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Char
'T' -> Bool -> Parser Bool
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
      Char
'F' -> Bool -> Parser Bool
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
      Char
_ -> String -> Parser Bool
forall a. String -> Parser ByteString a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid Bool"
  {-# INLINE smpP #-}

instance Encoding Word16 where
  smpEncode :: Word16 -> ByteString
smpEncode = Word16 -> ByteString
encodeWord16
  {-# INLINE smpEncode #-}
  smpP :: Parser Word16
smpP = ByteString -> Word16
decodeWord16 (ByteString -> Word16)
-> Parser ByteString ByteString -> Parser Word16
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser ByteString ByteString
A.take Int
2
  {-# INLINE smpP #-}

instance Encoding Word32 where
  smpEncode :: Word32 -> ByteString
smpEncode = Word32 -> ByteString
encodeWord32
  {-# INLINE smpEncode #-}
  smpP :: Parser Word32
smpP = ByteString -> Word32
decodeWord32 (ByteString -> Word32)
-> Parser ByteString ByteString -> Parser Word32
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser ByteString ByteString
A.take Int
4
  {-# INLINE smpP #-}

instance Encoding Int64 where
  smpEncode :: Int64 -> ByteString
smpEncode Int64
i = Int64 -> ByteString
w32 (Int64
i Int64 -> Int -> Int64
forall a. Bits a => a -> Int -> a
`shiftR` Int
32) ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> Int64 -> ByteString
w32 Int64
i
  {-# INLINE smpEncode #-}
  smpP :: Parser Int64
smpP = do
    Int64
l <- Parser Int64
w32P
    Int64
r <- Parser Int64
w32P
    Int64 -> Parser Int64
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int64 -> Parser Int64) -> Int64 -> Parser Int64
forall a b. (a -> b) -> a -> b
$ (Int64
l Int64 -> Int -> Int64
forall a. Bits a => a -> Int -> a
`shiftL` Int
32) Int64 -> Int64 -> Int64
forall a. Bits a => a -> a -> a
.|. Int64
r
  {-# INLINE smpP #-}

w32 :: Int64 -> ByteString
w32 :: Int64 -> ByteString
w32 = forall a. Encoding a => a -> ByteString
smpEncode @Word32 (Word32 -> ByteString) -> (Int64 -> Word32) -> Int64 -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral
{-# INLINE w32 #-}

w32P :: Parser Int64
w32P :: Parser Int64
w32P = Word32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Int64) -> Parser Word32 -> Parser Int64
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Encoding a => Parser a
smpP @Word32
{-# INLINE w32P #-}

-- ByteStrings are assumed no longer than 255 bytes
instance Encoding ByteString where
  smpEncode :: ByteString -> ByteString
smpEncode ByteString
s = Char -> ByteString -> ByteString
B.cons (Int -> Char
lenEncode (Int -> Char) -> Int -> Char
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
s) ByteString
s
  {-# INLINE smpEncode #-}
  smpP :: Parser ByteString ByteString
smpP = Int -> Parser ByteString ByteString
A.take (Int -> Parser ByteString ByteString)
-> Parser ByteString Int -> Parser ByteString ByteString
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Parser ByteString Int
lenP
  {-# INLINE smpP #-}

lenEncode :: Int -> Char
lenEncode :: Int -> Char
lenEncode = Word8 -> Char
w2c (Word8 -> Char) -> (Int -> Word8) -> Int -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral
{-# INLINE lenEncode #-}

lenP :: Parser Int
lenP :: Parser ByteString Int
lenP = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Int) -> (Char -> Word8) -> Char -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Word8
c2w (Char -> Int) -> Parser Char -> Parser ByteString Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Char
A.anyChar
{-# INLINE lenP #-}

instance Encoding a => Encoding (Maybe a) where
  smpEncode :: Maybe a -> ByteString
smpEncode = ByteString -> (a -> ByteString) -> Maybe a -> ByteString
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ByteString
"0" ((Char
'1' Char -> ByteString -> ByteString
`B.cons`) (ByteString -> ByteString) -> (a -> ByteString) -> a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode)
  {-# INLINE smpEncode #-}
  smpP :: Parser (Maybe a)
smpP =
    Parser Char
forall a. Encoding a => Parser a
smpP Parser Char -> (Char -> Parser (Maybe a)) -> Parser (Maybe a)
forall a b.
Parser ByteString a
-> (a -> Parser ByteString b) -> Parser ByteString b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Char
'0' -> Maybe a -> Parser (Maybe a)
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing
      Char
'1' -> a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> Parser ByteString a -> Parser (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString a
forall a. Encoding a => Parser a
smpP
      Char
_ -> String -> Parser (Maybe a)
forall a. String -> Parser ByteString a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid Maybe tag"
  {-# INLINE smpP #-}

newtype Tail = Tail {Tail -> ByteString
unTail :: ByteString}

instance Encoding Tail where
  smpEncode :: Tail -> ByteString
smpEncode = Tail -> ByteString
unTail
  {-# INLINE smpEncode #-}
  smpP :: Parser Tail
smpP = ByteString -> Tail
Tail (ByteString -> Tail) -> Parser ByteString ByteString -> Parser Tail
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString ByteString
A.takeByteString
  {-# INLINE smpP #-}

-- newtype for encoding/decoding ByteStrings over 255 bytes with 2-bytes length prefix
newtype Large = Large {Large -> ByteString
unLarge :: ByteString}

instance Encoding Large where
  smpEncode :: Large -> ByteString
smpEncode (Large ByteString
s) = forall a. Encoding a => a -> ByteString
smpEncode @Word16 (Int -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word16) -> Int -> Word16
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
s) ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
s
  {-# INLINE smpEncode #-}
  smpP :: Parser Large
smpP = do
    Int
len <- Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Int) -> Parser Word16 -> Parser ByteString Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Encoding a => Parser a
smpP @Word16
    ByteString -> Large
Large (ByteString -> Large)
-> Parser ByteString ByteString -> Parser Large
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser ByteString ByteString
A.take Int
len
  {-# INLINE smpP #-}

instance Encoding SystemTime where
  smpEncode :: SystemTime -> ByteString
smpEncode = Int64 -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode (Int64 -> ByteString)
-> (SystemTime -> Int64) -> SystemTime -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SystemTime -> Int64
systemSeconds
  {-# INLINE smpEncode #-}
  smpP :: Parser SystemTime
smpP = (Int64 -> Word32 -> SystemTime
`MkSystemTime` Word32
0) (Int64 -> SystemTime) -> Parser Int64 -> Parser SystemTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Int64
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

_smpP :: Encoding a => Parser a
_smpP :: forall a. Encoding a => Parser a
_smpP = Parser Char
A.space Parser Char -> Parser ByteString a -> Parser ByteString a
forall a b.
Parser ByteString a -> Parser ByteString b -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ByteString a
forall a. Encoding a => Parser a
smpP

-- lists encode/parse as a sequence of items prefixed with list length (as 1 byte)
smpEncodeList :: Encoding a => [a] -> ByteString
smpEncodeList :: forall a. Encoding a => [a] -> ByteString
smpEncodeList [a]
xs = Char -> ByteString -> ByteString
B.cons (Int -> Char
lenEncode (Int -> Char) -> Int -> Char
forall a b. (a -> b) -> a -> b
$ [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs) (ByteString -> ByteString)
-> ([ByteString] -> ByteString) -> [ByteString] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ByteString] -> ByteString
B.concat ([ByteString] -> ByteString) -> [ByteString] -> ByteString
forall a b. (a -> b) -> a -> b
$ (a -> ByteString) -> [a] -> [ByteString]
forall a b. (a -> b) -> [a] -> [b]
map a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode [a]
xs

smpListP :: Encoding a => Parser [a]
smpListP :: forall a. Encoding a => Parser [a]
smpListP = (Int -> Parser ByteString a -> Parser ByteString [a]
forall (m :: * -> *) a. Monad m => Int -> m a -> m [a]
`A.count` Parser ByteString a
forall a. Encoding a => Parser a
smpP) (Int -> Parser ByteString [a])
-> Parser ByteString Int -> Parser ByteString [a]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Parser ByteString Int
lenP

instance Encoding Text where
  smpEncode :: Text -> ByteString
smpEncode = ByteString -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode (ByteString -> ByteString)
-> (Text -> ByteString) -> Text -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
encodeUtf8
  {-# INLINE smpEncode #-}
  smpP :: Parser Text
smpP = (UnicodeException -> Parser Text)
-> (Text -> Parser Text)
-> Either UnicodeException Text
-> Parser Text
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Parser Text
forall a. String -> Parser ByteString a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Text)
-> (UnicodeException -> String) -> UnicodeException -> Parser Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnicodeException -> String
forall a. Show a => a -> String
show) Text -> Parser Text
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either UnicodeException Text -> Parser Text)
-> (ByteString -> Either UnicodeException Text)
-> ByteString
-> Parser Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either UnicodeException Text
decodeUtf8' (ByteString -> Parser Text)
-> Parser ByteString ByteString -> Parser Text
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Parser ByteString ByteString
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance Encoding String where
  smpEncode :: String -> ByteString
smpEncode = ByteString -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode (ByteString -> ByteString)
-> (String -> ByteString) -> String -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
B.pack
  {-# INLINE smpEncode #-}
  smpP :: Parser String
smpP = ByteString -> String
B.unpack (ByteString -> String)
-> Parser ByteString ByteString -> Parser String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString ByteString
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance Encoding a => Encoding (L.NonEmpty a) where
  smpEncode :: NonEmpty a -> ByteString
smpEncode = [a] -> ByteString
forall a. Encoding a => [a] -> ByteString
smpEncodeList ([a] -> ByteString)
-> (NonEmpty a -> [a]) -> NonEmpty a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
L.toList
  smpP :: Parser (NonEmpty a)
smpP =
    Parser ByteString Int
lenP Parser ByteString Int
-> (Int -> Parser (NonEmpty a)) -> Parser (NonEmpty a)
forall a b.
Parser ByteString a
-> (a -> Parser ByteString b) -> Parser ByteString b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Int
0 -> String -> Parser (NonEmpty a)
forall a. String -> Parser ByteString a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"empty list"
      Int
n -> [a] -> NonEmpty a
forall a. HasCallStack => [a] -> NonEmpty a
L.fromList ([a] -> NonEmpty a) -> Parser ByteString [a] -> Parser (NonEmpty a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser ByteString a -> Parser ByteString [a]
forall (m :: * -> *) a. Monad m => Int -> m a -> m [a]
A.count Int
n Parser ByteString a
forall a. Encoding a => Parser a
smpP

instance (Encoding a, Encoding b) => Encoding (a, b) where
  smpEncode :: (a, b) -> ByteString
smpEncode (a
a, b
b) = a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode a
a ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> b -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode b
b
  {-# INLINE smpEncode #-}
  smpP :: Parser (a, b)
smpP = (,) (a -> b -> (a, b))
-> Parser ByteString a -> Parser ByteString (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString a
forall a. Encoding a => Parser a
smpP Parser ByteString (b -> (a, b))
-> Parser ByteString b -> Parser (a, b)
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString b
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance (Encoding a, Encoding b, Encoding c) => Encoding (a, b, c) where
  smpEncode :: (a, b, c) -> ByteString
smpEncode (a
a, b
b, c
c) = [ByteString] -> ByteString
B.concat [a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode a
a, b -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode b
b, c -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode c
c]
  {-# INLINE smpEncode #-}
  smpP :: Parser (a, b, c)
smpP = (,,) (a -> b -> c -> (a, b, c))
-> Parser ByteString a -> Parser ByteString (b -> c -> (a, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString a
forall a. Encoding a => Parser a
smpP Parser ByteString (b -> c -> (a, b, c))
-> Parser ByteString b -> Parser ByteString (c -> (a, b, c))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString b
forall a. Encoding a => Parser a
smpP Parser ByteString (c -> (a, b, c))
-> Parser ByteString c -> Parser (a, b, c)
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString c
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance (Encoding a, Encoding b, Encoding c, Encoding d) => Encoding (a, b, c, d) where
  smpEncode :: (a, b, c, d) -> ByteString
smpEncode (a
a, b
b, c
c, d
d) = [ByteString] -> ByteString
B.concat [a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode a
a, b -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode b
b, c -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode c
c, d -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode d
d]
  {-# INLINE smpEncode #-}
  smpP :: Parser (a, b, c, d)
smpP = (,,,) (a -> b -> c -> d -> (a, b, c, d))
-> Parser ByteString a
-> Parser ByteString (b -> c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString a
forall a. Encoding a => Parser a
smpP Parser ByteString (b -> c -> d -> (a, b, c, d))
-> Parser ByteString b
-> Parser ByteString (c -> d -> (a, b, c, d))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString b
forall a. Encoding a => Parser a
smpP Parser ByteString (c -> d -> (a, b, c, d))
-> Parser ByteString c -> Parser ByteString (d -> (a, b, c, d))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString c
forall a. Encoding a => Parser a
smpP Parser ByteString (d -> (a, b, c, d))
-> Parser ByteString d -> Parser (a, b, c, d)
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString d
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance (Encoding a, Encoding b, Encoding c, Encoding d, Encoding e) => Encoding (a, b, c, d, e) where
  smpEncode :: (a, b, c, d, e) -> ByteString
smpEncode (a
a, b
b, c
c, d
d, e
e) = [ByteString] -> ByteString
B.concat [a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode a
a, b -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode b
b, c -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode c
c, d -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode d
d, e -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode e
e]
  {-# INLINE smpEncode #-}
  smpP :: Parser (a, b, c, d, e)
smpP = (,,,,) (a -> b -> c -> d -> e -> (a, b, c, d, e))
-> Parser ByteString a
-> Parser ByteString (b -> c -> d -> e -> (a, b, c, d, e))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString a
forall a. Encoding a => Parser a
smpP Parser ByteString (b -> c -> d -> e -> (a, b, c, d, e))
-> Parser ByteString b
-> Parser ByteString (c -> d -> e -> (a, b, c, d, e))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString b
forall a. Encoding a => Parser a
smpP Parser ByteString (c -> d -> e -> (a, b, c, d, e))
-> Parser ByteString c
-> Parser ByteString (d -> e -> (a, b, c, d, e))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString c
forall a. Encoding a => Parser a
smpP Parser ByteString (d -> e -> (a, b, c, d, e))
-> Parser ByteString d -> Parser ByteString (e -> (a, b, c, d, e))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString d
forall a. Encoding a => Parser a
smpP Parser ByteString (e -> (a, b, c, d, e))
-> Parser ByteString e -> Parser (a, b, c, d, e)
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString e
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance (Encoding a, Encoding b, Encoding c, Encoding d, Encoding e, Encoding f) => Encoding (a, b, c, d, e, f) where
  smpEncode :: (a, b, c, d, e, f) -> ByteString
smpEncode (a
a, b
b, c
c, d
d, e
e, f
f) = [ByteString] -> ByteString
B.concat [a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode a
a, b -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode b
b, c -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode c
c, d -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode d
d, e -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode e
e, f -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode f
f]
  {-# INLINE smpEncode #-}
  smpP :: Parser (a, b, c, d, e, f)
smpP = (,,,,,) (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> Parser ByteString a
-> Parser ByteString (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString a
forall a. Encoding a => Parser a
smpP Parser ByteString (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> Parser ByteString b
-> Parser ByteString (c -> d -> e -> f -> (a, b, c, d, e, f))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString b
forall a. Encoding a => Parser a
smpP Parser ByteString (c -> d -> e -> f -> (a, b, c, d, e, f))
-> Parser ByteString c
-> Parser ByteString (d -> e -> f -> (a, b, c, d, e, f))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString c
forall a. Encoding a => Parser a
smpP Parser ByteString (d -> e -> f -> (a, b, c, d, e, f))
-> Parser ByteString d
-> Parser ByteString (e -> f -> (a, b, c, d, e, f))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString d
forall a. Encoding a => Parser a
smpP Parser ByteString (e -> f -> (a, b, c, d, e, f))
-> Parser ByteString e
-> Parser ByteString (f -> (a, b, c, d, e, f))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString e
forall a. Encoding a => Parser a
smpP Parser ByteString (f -> (a, b, c, d, e, f))
-> Parser ByteString f -> Parser (a, b, c, d, e, f)
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString f
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance (Encoding a, Encoding b, Encoding c, Encoding d, Encoding e, Encoding f, Encoding g) => Encoding (a, b, c, d, e, f, g) where
  smpEncode :: (a, b, c, d, e, f, g) -> ByteString
smpEncode (a
a, b
b, c
c, d
d, e
e, f
f, g
g) = [ByteString] -> ByteString
B.concat [a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode a
a, b -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode b
b, c -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode c
c, d -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode d
d, e -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode e
e, f -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode f
f, g -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode g
g]
  {-# INLINE smpEncode #-}
  smpP :: Parser (a, b, c, d, e, f, g)
smpP = (,,,,,,) (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Parser ByteString a
-> Parser
     ByteString (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString a
forall a. Encoding a => Parser a
smpP Parser
  ByteString (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Parser ByteString b
-> Parser
     ByteString (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString b
forall a. Encoding a => Parser a
smpP Parser ByteString (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Parser ByteString c
-> Parser ByteString (d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString c
forall a. Encoding a => Parser a
smpP Parser ByteString (d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Parser ByteString d
-> Parser ByteString (e -> f -> g -> (a, b, c, d, e, f, g))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString d
forall a. Encoding a => Parser a
smpP Parser ByteString (e -> f -> g -> (a, b, c, d, e, f, g))
-> Parser ByteString e
-> Parser ByteString (f -> g -> (a, b, c, d, e, f, g))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString e
forall a. Encoding a => Parser a
smpP Parser ByteString (f -> g -> (a, b, c, d, e, f, g))
-> Parser ByteString f
-> Parser ByteString (g -> (a, b, c, d, e, f, g))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString f
forall a. Encoding a => Parser a
smpP Parser ByteString (g -> (a, b, c, d, e, f, g))
-> Parser ByteString g -> Parser (a, b, c, d, e, f, g)
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString g
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}

instance (Encoding a, Encoding b, Encoding c, Encoding d, Encoding e, Encoding f, Encoding g, Encoding h) => Encoding (a, b, c, d, e, f, g, h) where
  smpEncode :: (a, b, c, d, e, f, g, h) -> ByteString
smpEncode (a
a, b
b, c
c, d
d, e
e, f
f, g
g, h
h) = [ByteString] -> ByteString
B.concat [a -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode a
a, b -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode b
b, c -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode c
c, d -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode d
d, e -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode e
e, f -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode f
f, g -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode g
g, h -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode h
h]
  {-# INLINE smpEncode #-}
  smpP :: Parser (a, b, c, d, e, f, g, h)
smpP = (,,,,,,,) (a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Parser ByteString a
-> Parser
     ByteString
     (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString a
forall a. Encoding a => Parser a
smpP Parser
  ByteString
  (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Parser ByteString b
-> Parser
     ByteString (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString b
forall a. Encoding a => Parser a
smpP Parser
  ByteString (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Parser ByteString c
-> Parser
     ByteString (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString c
forall a. Encoding a => Parser a
smpP Parser
  ByteString (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Parser ByteString d
-> Parser ByteString (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString d
forall a. Encoding a => Parser a
smpP Parser ByteString (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Parser ByteString e
-> Parser ByteString (f -> g -> h -> (a, b, c, d, e, f, g, h))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString e
forall a. Encoding a => Parser a
smpP Parser ByteString (f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Parser ByteString f
-> Parser ByteString (g -> h -> (a, b, c, d, e, f, g, h))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString f
forall a. Encoding a => Parser a
smpP Parser ByteString (g -> h -> (a, b, c, d, e, f, g, h))
-> Parser ByteString g
-> Parser ByteString (h -> (a, b, c, d, e, f, g, h))
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString g
forall a. Encoding a => Parser a
smpP Parser ByteString (h -> (a, b, c, d, e, f, g, h))
-> Parser ByteString h -> Parser (a, b, c, d, e, f, g, h)
forall a b.
Parser ByteString (a -> b)
-> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByteString h
forall a. Encoding a => Parser a
smpP
  {-# INLINE smpP #-}