{-# LANGUAGE AllowAmbiguousTypes    #-}
{-# LANGUAGE CPP                    #-}
{-# LANGUAGE ConstraintKinds        #-}
{-# LANGUAGE FlexibleInstances      #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE GADTs                  #-}
{-# LANGUAGE ScopedTypeVariables    #-}
{-# LANGUAGE TupleSections          #-}
{-# LANGUAGE TypeApplications       #-}
{-# LANGUAGE TypeFamilies           #-}
{-# LANGUAGE TypeInType             #-}
{-# LANGUAGE TypeOperators          #-}
{-# LANGUAGE UndecidableInstances   #-}

#if __GLASGOW_HASKELL__ == 802
{-# OPTIONS_GHC -fno-solve-constant-dicts #-}
#endif


-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Generics.Product.Internal.HList
-- Copyright   :  (C) 2019 Csongor Kiss
-- License     :  BSD3
-- Maintainer  :  Csongor Kiss <kiss.csongor.kiss@gmail.com>
-- Stability   :  experimental
-- Portability :  non-portable
--
-- Derive an isomorphism between a product type and a flat HList.
--
-----------------------------------------------------------------------------

module Data.Generics.Product.Internal.HList
  ( GIsList(..)
  , IndexList (..)
  , HList (..)
  , type (++)
  , Elem
  , ListTuple (..)
  , TupleToList
  ) where

#if __GLASGOW_HASKELL__ < 804
import Data.Semigroup
#endif
import GHC.TypeLits

import Data.Kind    (Type)
import GHC.Generics
import Data.Profunctor
import Data.Generics.Internal.Profunctor.Lens
import Data.Generics.Internal.Profunctor.Iso

data HList (as :: [Type]) where
  Nil :: HList '[]
  (:>) :: a -> HList as -> HList (a ': as)

infixr 5 :>

type family ((as :: [k]) ++ (bs :: [k])) :: [k] where
  '[]       ++ bs = bs
  (a ': as) ++ bs = a ': as ++ bs

instance Semigroup (HList '[]) where
  _ <> :: HList '[] -> HList '[] -> HList '[]
<> _ = HList '[]
Nil

instance Monoid (HList '[]) where
  mempty :: HList '[]
mempty  = HList '[]
Nil
  mappend :: HList '[] -> HList '[] -> HList '[]
mappend _ _ = HList '[]
Nil

instance (Semigroup a, Semigroup (HList as)) => Semigroup (HList (a ': as)) where
  (x :: a
x :> xs :: HList as
xs) <> :: HList (a : as) -> HList (a : as) -> HList (a : as)
<> (y :: a
y :> ys :: HList as
ys) = (a
x a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
a
y) a -> HList as -> HList (a : as)
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> (HList as
xs HList as -> HList as -> HList as
forall a. Semigroup a => a -> a -> a
<> HList as
HList as
ys)

instance (Monoid a, Monoid (HList as)) => Monoid (HList (a ': as)) where
  mempty :: HList (a : as)
mempty = a
forall a. Monoid a => a
mempty a -> HList as -> HList (a : as)
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList as
forall a. Monoid a => a
mempty
  mappend :: HList (a : as) -> HList (a : as) -> HList (a : as)
mappend (x :: a
x :> xs :: HList as
xs) (y :: a
y :> ys :: HList as
ys) = a -> a -> a
forall a. Monoid a => a -> a -> a
mappend a
x a
a
y a -> HList as -> HList (a : as)
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList as -> HList as -> HList as
forall a. Monoid a => a -> a -> a
mappend HList as
xs HList as
HList as
ys

class Elem (as :: [(k, Type)]) (key :: k) (i :: Nat) a | as key -> i a
instance {-# OVERLAPPING #-} pos ~ 0 => Elem (a ': xs) key pos a
instance (Elem xs key i a, pos ~ (i + 1)) => Elem (x ': xs) key pos a

class GIsList
  (f :: Type -> Type)
  (g :: Type -> Type)
  (as :: [Type])
  (bs :: [Type]) | f -> as, g -> bs, bs f -> g, as g -> f where

  glist :: Iso (f x) (g x) (HList as) (HList bs)

  -- We define this reversed version, otherwise uses of `fromIso glist` are not
  -- properly inlined by GHC 8.0.2.
  -- This is not actually used.
  glistR :: Iso (HList bs) (HList as) (g x) (f x)
  glistR = Iso (f x) (g x) (HList as) (HList bs)
-> Iso (HList bs) (HList as) (g x) (f x)
forall s t a b. Iso s t a b -> Iso b a t s
fromIso forall (f :: * -> *) (g :: * -> *) (as :: [*]) (bs :: [*]) x.
GIsList f g as bs =>
Iso (f x) (g x) (HList as) (HList bs)
Iso (f x) (g x) (HList as) (HList bs)
glist

instance
  ( GIsList l l' as as'
  , GIsList r r' bs bs'
  , Appending as bs cs as' bs' cs'
  , cs ~ (as ++ bs)
  , cs' ~ (as' ++ bs')
  ) => GIsList (l :*: r) (l' :*: r') cs cs' where

  glist :: p (HList cs) (HList cs') -> p ((:*:) l r x) ((:*:) l' r' x)
glist = p (l x, r x) (l' x, r' x) -> p ((:*:) l r x) ((:*:) l' r' x)
forall (a :: * -> *) (b :: * -> *) x (a' :: * -> *) (b' :: * -> *).
Iso ((:*:) a b x) ((:*:) a' b' x) (a x, b x) (a' x, b' x)
prodIso (p (l x, r x) (l' x, r' x) -> p ((:*:) l r x) ((:*:) l' r' x))
-> (p (HList cs) (HList cs') -> p (l x, r x) (l' x, r' x))
-> p (HList cs) (HList cs')
-> p ((:*:) l r x) ((:*:) l' r' x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Iso (l x) (l' x) (HList as) (HList as')
-> Iso (r x) (r' x) (HList bs) (HList bs')
-> Iso
     (l x, r x) (l' x, r' x) (HList as, HList bs) (HList as', HList bs')
forall s t a b s' t' a' b'.
Iso s t a b
-> Iso s' t' a' b' -> Iso (s, s') (t, t') (a, a') (b, b')
pairing forall (f :: * -> *) (g :: * -> *) (as :: [*]) (bs :: [*]) x.
GIsList f g as bs =>
Iso (f x) (g x) (HList as) (HList bs)
Iso (l x) (l' x) (HList as) (HList as')
glist forall (f :: * -> *) (g :: * -> *) (as :: [*]) (bs :: [*]) x.
GIsList f g as bs =>
Iso (f x) (g x) (HList as) (HList bs)
Iso (r x) (r' x) (HList bs) (HList bs')
glist (p (HList as, HList bs) (HList as', HList bs')
 -> p (l x, r x) (l' x, r' x))
-> (p (HList cs) (HList cs')
    -> p (HList as, HList bs) (HList as', HList bs'))
-> p (HList cs) (HList cs')
-> p (l x, r x) (l' x, r' x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p (HList cs) (HList cs')
-> p (HList as, HList bs) (HList as', HList bs')
forall (as :: [*]) (bs :: [*]) (cs :: [*]) (as' :: [*])
       (bs' :: [*]) (cs' :: [*]).
Appending as bs cs as' bs' cs' =>
Iso
  (HList as, HList bs) (HList as', HList bs') (HList cs) (HList cs')
appending
  {-# INLINE glist #-}

instance GIsList f g as bs => GIsList (M1 t meta f) (M1 t meta g) as bs where
  glist :: p (HList as) (HList bs) -> p (M1 t meta f x) (M1 t meta g x)
glist = p (f x) (g x) -> p (M1 t meta f x) (M1 t meta g x)
forall i (c :: Meta) (f :: * -> *) p (g :: * -> *).
Iso (M1 i c f p) (M1 i c g p) (f p) (g p)
mIso (p (f x) (g x) -> p (M1 t meta f x) (M1 t meta g x))
-> (p (HList as) (HList bs) -> p (f x) (g x))
-> p (HList as) (HList bs)
-> p (M1 t meta f x) (M1 t meta g x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p (HList as) (HList bs) -> p (f x) (g x)
forall (f :: * -> *) (g :: * -> *) (as :: [*]) (bs :: [*]) x.
GIsList f g as bs =>
Iso (f x) (g x) (HList as) (HList bs)
glist
  {-# INLINE glist #-}

instance GIsList (Rec0 a) (Rec0 b) '[a] '[b] where
  glist :: p (HList '[a]) (HList '[b]) -> p (Rec0 a x) (Rec0 b x)
glist = p a b -> p (Rec0 a x) (Rec0 b x)
forall r a p b. Iso (K1 r a p) (K1 r b p) a b
kIso (p a b -> p (Rec0 a x) (Rec0 b x))
-> (p (HList '[a]) (HList '[b]) -> p a b)
-> p (HList '[a]) (HList '[b])
-> p (Rec0 a x) (Rec0 b x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p (HList '[a]) (HList '[b]) -> p a b
forall a b. Iso a b (HList '[a]) (HList '[b])
singleton
  {-# INLINE glist #-}

instance GIsList U1 U1 '[] '[] where
  glist :: p (HList '[]) (HList '[]) -> p (U1 x) (U1 x)
glist = (U1 x -> HList '[])
-> (HList '[] -> U1 x) -> Iso (U1 x) (U1 x) (HList '[]) (HList '[])
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (HList '[] -> U1 x -> HList '[]
forall a b. a -> b -> a
const HList '[]
Nil) (U1 x -> HList '[] -> U1 x
forall a b. a -> b -> a
const U1 x
forall k (p :: k). U1 p
U1)
  {-# INLINE glist #-}

--------------------------------------------------------------------------------
-- | as ++ bs === cs
class Appending as bs cs as' bs' cs'
  | as bs cs cs'   -> as' bs'
  , as' bs' cs cs' -> as bs
  , as bs          -> cs
  , as' bs'        -> cs'
  where
  appending :: Iso (HList as, HList bs) (HList as', HList bs') (HList cs) (HList cs')

-- | [] ++ bs === bs
instance Appending '[] bs bs '[] bs' bs' where
  appending :: p (HList bs) (HList bs')
-> p (HList '[], HList bs) (HList '[], HList bs')
appending = ((HList '[], HList bs) -> HList bs)
-> (HList bs' -> (HList '[], HList bs'))
-> Iso
     (HList '[], HList bs) (HList '[], HList bs') (HList bs) (HList bs')
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (HList '[], HList bs) -> HList bs
forall a b. (a, b) -> b
snd (HList '[]
Nil,)

-- | (a : as) ++ bs === (a : cs)
instance
  Appending as bs cs as' bs' cs' -- as ++ bs == cs
  => Appending (a ': as) bs (a ': cs) (a' ': as') bs' (a' ': cs') where
  appending :: p (HList (a : cs)) (HList (a' : cs'))
-> p (HList (a : as), HList bs) (HList (a' : as'), HList bs')
appending
    = Iso
  (HList (a : as)) (HList (a' : as')) (a, HList as) (a', HList as')
-> Iso (HList bs) (HList bs') (HList bs) (HList bs')
-> Iso
     (HList (a : as), HList bs)
     (HList (a' : as'), HList bs')
     ((a, HList as), HList bs)
     ((a', HList as'), HList bs')
forall s t a b s' t' a' b'.
Iso s t a b
-> Iso s' t' a' b' -> Iso (s, s') (t, t') (a, a') (b, b')
pairing (Iso
  (a', HList as') (a, HList as) (HList (a' : as')) (HList (a : as))
-> Iso
     (HList (a : as)) (HList (a' : as')) (a, HList as) (a', HList as')
forall s t a b. Iso s t a b -> Iso b a t s
fromIso forall a (as :: [*]) b (bs :: [*]).
Iso (a, HList as) (b, HList bs) (HList (a : as)) (HList (b : bs))
Iso
  (a', HList as') (a, HList as) (HList (a' : as')) (HList (a : as))
consing) forall a. a -> a
Iso (HList bs) (HList bs') (HList bs) (HList bs')
id -- ((a, as), bs)
    (p ((a, HList as), HList bs) ((a', HList as'), HList bs')
 -> p (HList (a : as), HList bs) (HList (a' : as'), HList bs'))
-> (p (HList (a : cs)) (HList (a' : cs'))
    -> p ((a, HList as), HList bs) ((a', HList as'), HList bs'))
-> p (HList (a : cs)) (HList (a' : cs'))
-> p (HList (a : as), HList bs) (HList (a' : as'), HList bs')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p (a, (HList as, HList bs)) (a', (HList as', HList bs'))
-> p ((a, HList as), HList bs) ((a', HList as'), HList bs')
forall a b c a' b' c'.
Iso ((a, b), c) ((a', b'), c') (a, (b, c)) (a', (b', c'))
assoc3                       -- (a, (as, bs))
    (p (a, (HList as, HList bs)) (a', (HList as', HList bs'))
 -> p ((a, HList as), HList bs) ((a', HList as'), HList bs'))
-> (p (HList (a : cs)) (HList (a' : cs'))
    -> p (a, (HList as, HList bs)) (a', (HList as', HList bs')))
-> p (HList (a : cs)) (HList (a' : cs'))
-> p ((a, HList as), HList bs) ((a', HList as'), HList bs')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Iso a a' a a'
-> Iso
     (HList as, HList bs) (HList as', HList bs') (HList cs) (HList cs')
-> Iso
     (a, (HList as, HList bs))
     (a', (HList as', HList bs'))
     (a, HList cs)
     (a', HList cs')
forall s t a b s' t' a' b'.
Iso s t a b
-> Iso s' t' a' b' -> Iso (s, s') (t, t') (a, a') (b, b')
pairing forall a. a -> a
Iso a a' a a'
id forall (as :: [*]) (bs :: [*]) (cs :: [*]) (as' :: [*])
       (bs' :: [*]) (cs' :: [*]).
Appending as bs cs as' bs' cs' =>
Iso
  (HList as, HList bs) (HList as', HList bs') (HList cs) (HList cs')
Iso
  (HList as, HList bs) (HList as', HList bs') (HList cs) (HList cs')
appending         -- (a, cs)
    (p (a, HList cs) (a', HList cs')
 -> p (a, (HList as, HList bs)) (a', (HList as', HList bs')))
-> (p (HList (a : cs)) (HList (a' : cs'))
    -> p (a, HList cs) (a', HList cs'))
-> p (HList (a : cs)) (HList (a' : cs'))
-> p (a, (HList as, HList bs)) (a', (HList as', HList bs'))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p (HList (a : cs)) (HList (a' : cs'))
-> p (a, HList cs) (a', HList cs')
forall a (as :: [*]) b (bs :: [*]).
Iso (a, HList as) (b, HList bs) (HList (a : as)) (HList (b : bs))
consing                      -- (a : cs)

singleton :: Iso a b (HList '[a]) (HList '[ b])
singleton :: p (HList '[a]) (HList '[b]) -> p a b
singleton = (a -> HList '[a])
-> (HList '[b] -> b) -> Iso a b (HList '[a]) (HList '[b])
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (a -> HList '[] -> HList '[a]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil) (\(x :: a
x :> _) -> b
a
x)

consing :: Iso (a, HList as) (b, HList bs) (HList (a ': as)) (HList (b ': bs))
consing :: p (HList (a : as)) (HList (b : bs))
-> p (a, HList as) (b, HList bs)
consing = ((a, HList as) -> HList (a : as))
-> (HList (b : bs) -> (b, HList bs))
-> Iso
     (a, HList as) (b, HList bs) (HList (a : as)) (HList (b : bs))
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso (\(x :: a
x, xs :: HList as
xs) -> a
x a -> HList as -> HList (a : as)
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList as
xs) (\(x :: a
x :> xs :: HList as
xs) -> (a
x, HList as
xs))

--------------------------------------------------------------------------------
class IndexList (i :: Nat) as bs a b | i as -> a, i bs -> b, i as b -> bs, i bs a -> as where
  point :: Lens (HList as) (HList bs) a b

instance {-# OVERLAPPING #-}
  ( as ~ (a ': as')
  , bs ~ (b ': as')
  ) => IndexList 0 as bs a b where
  point :: p a b -> p (HList as) (HList bs)
point = (HList as -> (HList as', a))
-> ((HList as', b) -> HList (b : as'))
-> Lens (HList as) (HList (b : as')) a b
forall s c a b t. (s -> (c, a)) -> ((c, b) -> t) -> Lens s t a b
lens (\(x :: a
x :> xs :: HList as
xs) -> (HList as'
HList as
xs, a
a
x)) (\(xs :: HList as'
xs, x' :: b
x') -> b
x' b -> HList as' -> HList (b : as')
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList as'
xs)
  {-# INLINE point #-}

instance
  ( IndexList (n - 1) as' bs' a b
  , as ~ (x ': as')
  , bs ~ (x ': bs')
  ) => IndexList n as bs a b where
  point :: p a b -> p (HList as) (HList bs)
point = Iso (x, HList bs') (x, HList as') (HList bs) (HList as)
-> Iso (HList as) (HList bs) (x, HList as') (x, HList bs')
forall s t a b. Iso s t a b -> Iso b a t s
fromIso forall a (as :: [*]) b (bs :: [*]).
Iso (a, HList as) (b, HList bs) (HList (a : as)) (HList (b : bs))
Iso (x, HList bs') (x, HList as') (HList bs) (HList as)
consing (p (x, HList as') (x, HList bs') -> p (HList as) (HList bs))
-> (p a b -> p (x, HList as') (x, HList bs'))
-> p a b
-> p (HList as) (HList bs)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LensLike (Alongside p (HList as') (HList bs')) x x x x
-> LensLike (Alongside p x x) (HList as') (HList bs') a b
-> LensLike p (x, HList as') (x, HList bs') (x, a) (x, b)
forall (p :: * -> * -> *) s' t' s t a b a' b'.
Profunctor p =>
LensLike (Alongside p s' t') s t a b
-> LensLike (Alongside p a b) s' t' a' b'
-> LensLike p (s, s') (t, t') (a, a') (b, b')
alongside LensLike (Alongside p (HList as') (HList bs')) x x x x
forall a. a -> a
id (forall (as :: [*]) (bs :: [*]) a b.
IndexList (n - 1) as bs a b =>
Lens (HList as) (HList bs) a b
forall (i :: Nat) (as :: [*]) (bs :: [*]) a b.
IndexList i as bs a b =>
Lens (HList as) (HList bs) a b
point @(n-1)) LensLike p (x, HList as') (x, HList bs') (x, a) (x, b)
-> (p a b -> p (x, a) (x, b))
-> p a b
-> p (x, HList as') (x, HList bs')
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p a b -> p (x, a) (x, b)
forall (p :: * -> * -> *) a b c.
Strong p =>
p a b -> p (c, a) (c, b)
second'
  {-# INLINE point #-}

--------------------------------------------------------------------------------
-- * Convert tuples to/from HLists

class ListTuple (tuple :: Type) (as :: [Type]) | as -> tuple where
  type ListToTuple as :: Type
  tupled :: Iso' (HList as) tuple
  tupled = (HList as -> tuple)
-> (tuple -> HList as) -> Iso (HList as) (HList as) tuple tuple
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso HList as -> tuple
forall tuple (as :: [*]). ListTuple tuple as => HList as -> tuple
listToTuple tuple -> HList as
forall tuple (as :: [*]). ListTuple tuple as => tuple -> HList as
tupleToList

  tupleToList :: tuple -> HList as
  listToTuple :: HList as -> tuple

instance ListTuple () '[] where
  type ListToTuple '[] = ()
  tupleToList :: () -> HList '[]
tupleToList _ = HList '[]
Nil
  listToTuple :: HList '[] -> ()
listToTuple _ = ()

instance ListTuple a '[a] where
  type ListToTuple '[a] = a
  tupleToList :: a -> HList '[a]
tupleToList a :: a
a
    = a
a a -> HList '[] -> HList '[a]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a] -> a
listToTuple (a :: a
a :> Nil)
    = a
a
a

instance ListTuple (a, b) '[a, b] where
  type ListToTuple '[a, b] = (a, b)
  tupleToList :: (a, b) -> HList '[a, b]
tupleToList (a :: a
a, b :: b
b)
    = a
a a -> HList '[b] -> HList '[a, b]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b -> HList '[] -> HList '[b]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b] -> (a, b)
listToTuple (a :: a
a :> b :: a
b :> Nil)
    = (a
a
a, b
a
b)

instance ListTuple (a, b, c) '[a, b, c] where
  type ListToTuple '[a, b, c] = (a, b, c)
  tupleToList :: (a, b, c) -> HList '[a, b, c]
tupleToList (a :: a
a, b :: b
b, c :: c
c)
    = a
a a -> HList '[b, c] -> HList '[a, b, c]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b -> HList '[c] -> HList '[b, c]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c -> HList '[] -> HList '[c]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c] -> (a, b, c)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> Nil)
    = (a
a
a, b
a
b, c
a
c)

instance ListTuple (a, b, c, d) '[a, b, c, d] where
  type ListToTuple '[a, b, c, d] = (a, b, c, d)
  tupleToList :: (a, b, c, d) -> HList '[a, b, c, d]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d)
    = a
a a -> HList '[b, c, d] -> HList '[a, b, c, d]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b -> HList '[c, d] -> HList '[b, c, d]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c -> HList '[d] -> HList '[c, d]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd -> HList '[] -> HList '[d]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d] -> (a, b, c, d)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d)

instance ListTuple (a, b, c, d, e) '[a, b, c, d, e] where
  type ListToTuple '[a, b, c, d, e] = (a, b, c, d, e)
  tupleToList :: (a, b, c, d, e) -> HList '[a, b, c, d, e]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e)
    = a
a a -> HList '[b, c, d, e] -> HList '[a, b, c, d, e]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b -> HList '[c, d, e] -> HList '[b, c, d, e]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c -> HList '[d, e] -> HList '[c, d, e]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd -> HList '[e] -> HList '[d, e]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e -> HList '[] -> HList '[e]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e] -> (a, b, c, d, e)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e)

instance ListTuple (a, b, c, d, e, f) '[a, b, c, d, e, f] where
  type ListToTuple '[a, b, c, d, e, f] = (a, b, c, d, e, f)
  tupleToList :: (a, b, c, d, e, f) -> HList '[a, b, c, d, e, f]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f)
    = a
a a -> HList '[b, c, d, e, f] -> HList '[a, b, c, d, e, f]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b -> HList '[c, d, e, f] -> HList '[b, c, d, e, f]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c -> HList '[d, e, f] -> HList '[c, d, e, f]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd -> HList '[e, f] -> HList '[d, e, f]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e -> HList '[f] -> HList '[e, f]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f -> HList '[] -> HList '[f]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f] -> (a, b, c, d, e, f)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f)

instance ListTuple (a, b, c, d, e, f, g) '[a, b, c, d, e, f, g] where
  type ListToTuple '[a, b, c, d, e, f, g] = (a, b, c, d, e, f, g)
  tupleToList :: (a, b, c, d, e, f, g) -> HList '[a, b, c, d, e, f, g]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g)
    = a
a a -> HList '[b, c, d, e, f, g] -> HList '[a, b, c, d, e, f, g]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b -> HList '[c, d, e, f, g] -> HList '[b, c, d, e, f, g]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c -> HList '[d, e, f, g] -> HList '[c, d, e, f, g]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd -> HList '[e, f, g] -> HList '[d, e, f, g]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e -> HList '[f, g] -> HList '[e, f, g]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f -> HList '[g] -> HList '[f, g]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g -> HList '[] -> HList '[g]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g] -> (a, b, c, d, e, f, g)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g)

instance ListTuple (a, b, c, d, e, f, g, h) '[a, b, c, d, e, f, g, h] where
  type ListToTuple '[a, b, c, d, e, f, g, h] = (a, b, c, d, e, f, g, h)
  tupleToList :: (a, b, c, d, e, f, g, h) -> HList '[a, b, c, d, e, f, g, h]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h)
    = a
a a
-> HList '[b, c, d, e, f, g, h] -> HList '[a, b, c, d, e, f, g, h]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b -> HList '[c, d, e, f, g, h] -> HList '[b, c, d, e, f, g, h]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c -> HList '[d, e, f, g, h] -> HList '[c, d, e, f, g, h]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd -> HList '[e, f, g, h] -> HList '[d, e, f, g, h]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e -> HList '[f, g, h] -> HList '[e, f, g, h]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f -> HList '[g, h] -> HList '[f, g, h]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g -> HList '[h] -> HList '[g, h]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h -> HList '[] -> HList '[h]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h] -> (a, b, c, d, e, f, g, h)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h)

instance ListTuple (a, b, c, d, e, f, g, h, j) '[a, b, c, d, e, f, g, h, j] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j] = (a, b, c, d, e, f, g, h, j)
  tupleToList :: (a, b, c, d, e, f, g, h, j) -> HList '[a, b, c, d, e, f, g, h, j]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j]
-> HList '[a, b, c, d, e, f, g, h, j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j] -> HList '[b, c, d, e, f, g, h, j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c -> HList '[d, e, f, g, h, j] -> HList '[c, d, e, f, g, h, j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd -> HList '[e, f, g, h, j] -> HList '[d, e, f, g, h, j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e -> HList '[f, g, h, j] -> HList '[e, f, g, h, j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f -> HList '[g, h, j] -> HList '[f, g, h, j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g -> HList '[h, j] -> HList '[g, h, j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h -> HList '[j] -> HList '[h, j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j -> HList '[] -> HList '[j]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j] -> (a, b, c, d, e, f, g, h, j)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j)

instance ListTuple (a, b, c, d, e, f, g, h, j, k) '[a, b, c, d, e, f, g, h, j, k] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k] = (a, b, c, d, e, f, g, h, j, k)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k)
-> HList '[a, b, c, d, e, f, g, h, j, k]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k]
-> HList '[a, b, c, d, e, f, g, h, j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k]
-> HList '[b, c, d, e, f, g, h, j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k] -> HList '[c, d, e, f, g, h, j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd -> HList '[e, f, g, h, j, k] -> HList '[d, e, f, g, h, j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e -> HList '[f, g, h, j, k] -> HList '[e, f, g, h, j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f -> HList '[g, h, j, k] -> HList '[f, g, h, j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g -> HList '[h, j, k] -> HList '[g, h, j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h -> HList '[j, k] -> HList '[h, j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j -> HList '[k] -> HList '[j, k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k -> HList '[] -> HList '[k]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k]
-> (a, b, c, d, e, f, g, h, j, k)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k)

instance ListTuple (a, b, c, d, e, f, g, h, j, k, l) '[a, b, c, d, e, f, g, h, j, k, l] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k, l] = (a, b, c, d, e, f, g, h, j, k, l)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k, l)
-> HList '[a, b, c, d, e, f, g, h, j, k, l]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k, l :: l
l)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k, l]
-> HList '[a, b, c, d, e, f, g, h, j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k, l]
-> HList '[b, c, d, e, f, g, h, j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k, l]
-> HList '[c, d, e, f, g, h, j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd
-> HList '[e, f, g, h, j, k, l] -> HList '[d, e, f, g, h, j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e -> HList '[f, g, h, j, k, l] -> HList '[e, f, g, h, j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f -> HList '[g, h, j, k, l] -> HList '[f, g, h, j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g -> HList '[h, j, k, l] -> HList '[g, h, j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h -> HList '[j, k, l] -> HList '[h, j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j -> HList '[k, l] -> HList '[j, k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k -> HList '[l] -> HList '[k, l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> l
l l -> HList '[] -> HList '[l]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k, l]
-> (a, b, c, d, e, f, g, h, j, k, l)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> l :: a
l :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k, l
a
l)

instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m) '[a, b, c, d, e, f, g, h, j, k, l, m] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k, l, m] = (a, b, c, d, e, f, g, h, j, k, l, m)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k, l, m)
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k, l :: l
l, m :: m
m)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k, l, m]
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k, l, m]
-> HList '[b, c, d, e, f, g, h, j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k, l, m]
-> HList '[c, d, e, f, g, h, j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd
-> HList '[e, f, g, h, j, k, l, m]
-> HList '[d, e, f, g, h, j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e
-> HList '[f, g, h, j, k, l, m] -> HList '[e, f, g, h, j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f -> HList '[g, h, j, k, l, m] -> HList '[f, g, h, j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g -> HList '[h, j, k, l, m] -> HList '[g, h, j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h -> HList '[j, k, l, m] -> HList '[h, j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j -> HList '[k, l, m] -> HList '[j, k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k -> HList '[l, m] -> HList '[k, l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> l
l l -> HList '[m] -> HList '[l, m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> m
m m -> HList '[] -> HList '[m]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k, l, m]
-> (a, b, c, d, e, f, g, h, j, k, l, m)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> l :: a
l :> m :: a
m :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k, l
a
l, m
a
m)

instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n) '[a, b, c, d, e, f, g, h, j, k, l, m, n] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k, l, m, n] = (a, b, c, d, e, f, g, h, j, k, l, m, n)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k, l, m, n)
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k, l :: l
l, m :: m
m, n :: n
n)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n]
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k, l, m, n]
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k, l, m, n]
-> HList '[c, d, e, f, g, h, j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd
-> HList '[e, f, g, h, j, k, l, m, n]
-> HList '[d, e, f, g, h, j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e
-> HList '[f, g, h, j, k, l, m, n]
-> HList '[e, f, g, h, j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f
-> HList '[g, h, j, k, l, m, n] -> HList '[f, g, h, j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g -> HList '[h, j, k, l, m, n] -> HList '[g, h, j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h -> HList '[j, k, l, m, n] -> HList '[h, j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j -> HList '[k, l, m, n] -> HList '[j, k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k -> HList '[l, m, n] -> HList '[k, l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> l
l l -> HList '[m, n] -> HList '[l, m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> m
m m -> HList '[n] -> HList '[m, n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> n
n n -> HList '[] -> HList '[n]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k, l, m, n]
-> (a, b, c, d, e, f, g, h, j, k, l, m, n)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> l :: a
l :> m :: a
m :> n :: a
n :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k, l
a
l, m
a
m, n
a
n)

instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o) '[a, b, c, d, e, f, g, h, j, k, l, m, n, o] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k, l, m, n, o] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k, l, m, n, o)
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k, l :: l
l, m :: m
m, n :: n
n, o :: o
o)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o]
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o]
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k, l, m, n, o]
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd
-> HList '[e, f, g, h, j, k, l, m, n, o]
-> HList '[d, e, f, g, h, j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e
-> HList '[f, g, h, j, k, l, m, n, o]
-> HList '[e, f, g, h, j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f
-> HList '[g, h, j, k, l, m, n, o]
-> HList '[f, g, h, j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g
-> HList '[h, j, k, l, m, n, o] -> HList '[g, h, j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h -> HList '[j, k, l, m, n, o] -> HList '[h, j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j -> HList '[k, l, m, n, o] -> HList '[j, k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k -> HList '[l, m, n, o] -> HList '[k, l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> l
l l -> HList '[m, n, o] -> HList '[l, m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> m
m m -> HList '[n, o] -> HList '[m, n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> n
n n -> HList '[o] -> HList '[n, o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> o
o o -> HList '[] -> HList '[o]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o]
-> (a, b, c, d, e, f, g, h, j, k, l, m, n, o)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> l :: a
l :> m :: a
m :> n :: a
n :> o :: a
o :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k, l
a
l, m
a
m, n
a
n, o
a
o)

instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p) '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p)
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k, l :: l
l, m :: m
m, n :: n
n, o :: o
o, p :: p
p)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o, p]
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o, p]
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k, l, m, n, o, p]
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd
-> HList '[e, f, g, h, j, k, l, m, n, o, p]
-> HList '[d, e, f, g, h, j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e
-> HList '[f, g, h, j, k, l, m, n, o, p]
-> HList '[e, f, g, h, j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f
-> HList '[g, h, j, k, l, m, n, o, p]
-> HList '[f, g, h, j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g
-> HList '[h, j, k, l, m, n, o, p]
-> HList '[g, h, j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h
-> HList '[j, k, l, m, n, o, p] -> HList '[h, j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j -> HList '[k, l, m, n, o, p] -> HList '[j, k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k -> HList '[l, m, n, o, p] -> HList '[k, l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> l
l l -> HList '[m, n, o, p] -> HList '[l, m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> m
m m -> HList '[n, o, p] -> HList '[m, n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> n
n n -> HList '[o, p] -> HList '[n, o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> o
o o -> HList '[p] -> HList '[o, p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> p
p p -> HList '[] -> HList '[p]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p]
-> (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> l :: a
l :> m :: a
m :> n :: a
n :> o :: a
o :> p :: a
p :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k, l
a
l, m
a
m, n
a
n, o
a
o, p
a
p)

instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q) '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q)
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k, l :: l
l, m :: m
m, n :: n
n, o :: o
o, p :: p
p, q :: q
q)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o, p, q]
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o, p, q]
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k, l, m, n, o, p, q]
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd
-> HList '[e, f, g, h, j, k, l, m, n, o, p, q]
-> HList '[d, e, f, g, h, j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e
-> HList '[f, g, h, j, k, l, m, n, o, p, q]
-> HList '[e, f, g, h, j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f
-> HList '[g, h, j, k, l, m, n, o, p, q]
-> HList '[f, g, h, j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g
-> HList '[h, j, k, l, m, n, o, p, q]
-> HList '[g, h, j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h
-> HList '[j, k, l, m, n, o, p, q]
-> HList '[h, j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j
-> HList '[k, l, m, n, o, p, q] -> HList '[j, k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k -> HList '[l, m, n, o, p, q] -> HList '[k, l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> l
l l -> HList '[m, n, o, p, q] -> HList '[l, m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> m
m m -> HList '[n, o, p, q] -> HList '[m, n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> n
n n -> HList '[o, p, q] -> HList '[n, o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> o
o o -> HList '[p, q] -> HList '[o, p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> p
p p -> HList '[q] -> HList '[p, q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> q
q q -> HList '[] -> HList '[q]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q]
-> (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> l :: a
l :> m :: a
m :> n :: a
n :> o :: a
o :> p :: a
p :> q :: a
q :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k, l
a
l, m
a
m, n
a
n, o
a
o, p
a
p, q
a
q)

instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r) '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r)
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k, l :: l
l, m :: m
m, n :: n
n, o :: o
o, p :: p
p, q :: q
q, r :: r
r)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r]
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o, p, q, r]
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k, l, m, n, o, p, q, r]
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd
-> HList '[e, f, g, h, j, k, l, m, n, o, p, q, r]
-> HList '[d, e, f, g, h, j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e
-> HList '[f, g, h, j, k, l, m, n, o, p, q, r]
-> HList '[e, f, g, h, j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f
-> HList '[g, h, j, k, l, m, n, o, p, q, r]
-> HList '[f, g, h, j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g
-> HList '[h, j, k, l, m, n, o, p, q, r]
-> HList '[g, h, j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h
-> HList '[j, k, l, m, n, o, p, q, r]
-> HList '[h, j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j
-> HList '[k, l, m, n, o, p, q, r]
-> HList '[j, k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k
-> HList '[l, m, n, o, p, q, r] -> HList '[k, l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> l
l l -> HList '[m, n, o, p, q, r] -> HList '[l, m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> m
m m -> HList '[n, o, p, q, r] -> HList '[m, n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> n
n n -> HList '[o, p, q, r] -> HList '[n, o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> o
o o -> HList '[p, q, r] -> HList '[o, p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> p
p p -> HList '[q, r] -> HList '[p, q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> q
q q -> HList '[r] -> HList '[q, r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> r
r r -> HList '[] -> HList '[r]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r]
-> (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> l :: a
l :> m :: a
m :> n :: a
n :> o :: a
o :> p :: a
p :> q :: a
q :> r :: a
r :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k, l
a
l, m
a
m, n
a
n, o
a
o, p
a
p, q
a
q, r
a
r)

instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s) '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s] where
  type ListToTuple '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s)
  tupleToList :: (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s)
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
tupleToList (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e, f :: f
f, g :: g
g, h :: h
h, j :: j
j, k :: k
k, l :: l
l, m :: m
m, n :: n
n, o :: o
o, p :: p
p, q :: q
q, r :: r
r, s :: s
s)
    = a
a a
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
-> HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> b
b b
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
-> HList '[b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> c
c c
-> HList '[d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
-> HList '[c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> d
dd
-> HList '[e, f, g, h, j, k, l, m, n, o, p, q, r, s]
-> HList '[d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> e
e e
-> HList '[f, g, h, j, k, l, m, n, o, p, q, r, s]
-> HList '[e, f, g, h, j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> f
f f
-> HList '[g, h, j, k, l, m, n, o, p, q, r, s]
-> HList '[f, g, h, j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> g
g g
-> HList '[h, j, k, l, m, n, o, p, q, r, s]
-> HList '[g, h, j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> h
h h
-> HList '[j, k, l, m, n, o, p, q, r, s]
-> HList '[h, j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> j
j j
-> HList '[k, l, m, n, o, p, q, r, s]
-> HList '[j, k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> k
k k
-> HList '[l, m, n, o, p, q, r, s]
-> HList '[k, l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> l
l l
-> HList '[m, n, o, p, q, r, s] -> HList '[l, m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> m
m m -> HList '[n, o, p, q, r, s] -> HList '[m, n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> n
n n -> HList '[o, p, q, r, s] -> HList '[n, o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> o
o o -> HList '[p, q, r, s] -> HList '[o, p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> p
p p -> HList '[q, r, s] -> HList '[p, q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> q
q q -> HList '[r, s] -> HList '[q, r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> r
r r -> HList '[s] -> HList '[r, s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> s
s s -> HList '[] -> HList '[s]
forall a (as :: [*]). a -> HList as -> HList (a : as)
:> HList '[]
Nil
  listToTuple :: HList '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
-> (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s)
listToTuple (a :: a
a :> b :: a
b :> c :: a
c :> d :: a
d :> e :: a
e :> f :: a
f :> g :: a
g :> h :: a
h :> j :: a
j :> k :: a
k :> l :: a
l :> m :: a
m :> n :: a
n :> o :: a
o :> p :: a
p :> q :: a
q :> r :: a
r :> s :: a
s :> Nil)
    = (a
a
a, b
a
b, c
a
c, d
a
d, e
a
e, f
a
f, g
a
g, h
a
h, j
a
j, k
a
k, l
a
l, m
a
m, n
a
n, o
a
o, p
a
p, q
a
q, r
a
r, s
a
s)

type family TupleToList a where
  TupleToList () = '[]
  TupleToList (a, b) = '[a, b]
  TupleToList (a, b, c) = '[a, b, c]
  TupleToList (a, b, c, d) = '[a, b, c, d]
  TupleToList (a, b, c, d, e) = '[a, b, c, d, e]
  TupleToList (a, b, c, d, e, f) = '[a, b, c, d, e, f]
  TupleToList (a, b, c, d, e, f, g) = '[a, b, c, d, e, f, g]
  TupleToList (a, b, c, d, e, f, g, h) = '[a, b, c, d, e, f, g, h]
  TupleToList (a, b, c, d, e, f, g, h, j) = '[a, b, c, d, e, f, g, h, j]
  TupleToList (a, b, c, d, e, f, g, h, j, k) = '[a, b, c, d, e, f, g, h, j, k]
  TupleToList (a, b, c, d, e, f, g, h, j, k, l) = '[a, b, c, d, e, f, g, h, j, k, l]
  TupleToList (a, b, c, d, e, f, g, h, j, k, l, m) = '[a, b, c, d, e, f, g, h, j, k, l, m]
  TupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n) = '[a, b, c, d, e, f, g, h, j, k, l, m, n]
  TupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o) = '[a, b, c, d, e, f, g, h, j, k, l, m, n, o]
  TupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p) = '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p]
  TupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q) = '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q]
  TupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r) = '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r]
  TupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s) = '[a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s]
  TupleToList a = '[a]