Data.Generics.Product.Internal.HList

Derive an isomorphism between a product type and a flat HList.

Documentation

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

Methods

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

Instances

GIsList (U1 :: Type -> Type) (U1 :: Type -> Type) ('[] :: [Type]) ('[] :: [Type])

Defined in Data.Generics.Product.Internal.HList

Methods

glist :: Iso (U1 x) (U1 x) (HList '[]) (HList '[])

GIsList (Rec0 a) (Rec0 b) '[a] '[b]

Defined in Data.Generics.Product.Internal.HList

Methods

glist :: Iso (Rec0 a x) (Rec0 b x) (HList '[a]) (HList '[b])

(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'

Defined in Data.Generics.Product.Internal.HList

Methods

glist :: Iso ((l :*: r) x) ((l' :*: r') x) (HList cs) (HList cs')

GIsList f g as bs => GIsList (M1 t meta f) (M1 t meta g) as bs

Defined in Data.Generics.Product.Internal.HList

Methods

glist :: Iso (M1 t meta f x) (M1 t meta g x) (HList as) (HList bs)

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

Methods

point :: Lens (HList as) (HList bs) a b

Instances

(IndexList (n - 1) as' bs' a b, as ~ (x ': as'), bs ~ (x ': bs')) => IndexList n as bs a b

Defined in Data.Generics.Product.Internal.HList

Methods

point :: Lens (HList as) (HList bs) a b

(as ~ (a ': as'), bs ~ (b ': as')) => IndexList 0 as bs a b

Defined in Data.Generics.Product.Internal.HList

Methods

point :: Lens (HList as) (HList bs) a b

data HList (as :: [Type]) where

Constructors

Nil :: HList '[]

(:>) :: a -> HList as -> HList (a ': as) infixr 5

Instances

(Semigroup a, Semigroup (HList as)) => Semigroup (HList (a ': as))

Defined in Data.Generics.Product.Internal.HList

Methods

(<>) :: HList (a ': as) -> HList (a ': as) -> HList (a ': as)

sconcat :: NonEmpty (HList (a ': as)) -> HList (a ': as)

stimes :: Integral b => b -> HList (a ': as) -> HList (a ': as)

Semigroup (HList ('[] :: [Type]))

Defined in Data.Generics.Product.Internal.HList

Methods

(<>) :: HList '[] -> HList '[] -> HList '[]

sconcat :: NonEmpty (HList '[]) -> HList '[]

stimes :: Integral b => b -> HList '[] -> HList '[]

(Monoid a, Monoid (HList as)) => Monoid (HList (a ': as))

Defined in Data.Generics.Product.Internal.HList

Methods

mempty :: HList (a ': as)

mappend :: HList (a ': as) -> HList (a ': as) -> HList (a ': as)

mconcat :: [HList (a ': as)] -> HList (a ': as)

Monoid (HList ('[] :: [Type]))

Defined in Data.Generics.Product.Internal.HList

Methods

mempty :: HList '[]

mappend :: HList '[] -> HList '[] -> HList '[]

mconcat :: [HList '[]] -> HList '[]

type family (as :: [k]) ++ (bs :: [k]) :: [k] where ...

Equations

'[] ++ bs = bs

(a ': as) ++ bs = a ': (as ++ bs)

class Elem (as :: [(k, Type)]) (key :: k) (i :: Nat) a | as key -> i a

Instances

(Elem xs key i a, pos ~ (i + 1)) => Elem (x ': xs :: [(k1, Type)]) (key :: k1) pos (a :: k2)

Defined in Data.Generics.Product.Internal.HList

pos ~ 0 => Elem (a ': xs :: [(k, Type)]) (key :: k) pos (a :: (k, Type))

Defined in Data.Generics.Product.Internal.HList

class ListTuple (tuple :: Type) (tuple' :: Type) (as :: [Type]) (bs :: [Type]) | as -> tuple, bs -> tuple' where

Minimal complete definition

tupleToList, listToTuple

Methods

tupled :: Iso (HList as) (HList bs) tuple tuple'

tupleToList :: tuple' -> HList bs

listToTuple :: HList as -> tuple

Instances

ListTuple () () ('[] :: [Type]) ('[] :: [Type])

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[]) (HList '[]) () ()

tupleToList :: () -> HList '[]

listToTuple :: HList '[] -> ()

ListTuple a a' '[a] '[a']

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a]) (HList '[a']) a a'

tupleToList :: a' -> HList '[a']

listToTuple :: HList '[a] -> a

ListTuple (a1, b1) (a2, b2) '[a1, b1] '[a2, b2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1]) (HList '[a2, b2]) (a1, b1) (a2, b2)

tupleToList :: (a2, b2) -> HList '[a2, b2]

listToTuple :: HList '[a1, b1] -> (a1, b1)

ListTuple (a1, b1, c1) (a2, b2, c2) '[a1, b1, c1] '[a2, b2, c2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1]) (HList '[a2, b2, c2]) (a1, b1, c1) (a2, b2, c2)

tupleToList :: (a2, b2, c2) -> HList '[a2, b2, c2]

listToTuple :: HList '[a1, b1, c1] -> (a1, b1, c1)

ListTuple (a1, b1, c1, d1) (a2, b2, c2, d2) '[a1, b1, c1, d1] '[a2, b2, c2, d2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1]) (HList '[a2, b2, c2, d2]) (a1, b1, c1, d1) (a2, b2, c2, d2)

tupleToList :: (a2, b2, c2, d2) -> HList '[a2, b2, c2, d2]

listToTuple :: HList '[a1, b1, c1, d1] -> (a1, b1, c1, d1)

ListTuple (a1, b1, c1, d1, e1) (a2, b2, c2, d2, e2) '[a1, b1, c1, d1, e1] '[a2, b2, c2, d2, e2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1]) (HList '[a2, b2, c2, d2, e2]) (a1, b1, c1, d1, e1) (a2, b2, c2, d2, e2)

tupleToList :: (a2, b2, c2, d2, e2) -> HList '[a2, b2, c2, d2, e2]

listToTuple :: HList '[a1, b1, c1, d1, e1] -> (a1, b1, c1, d1, e1)

ListTuple (a1, b1, c1, d1, e1, f1) (a2, b2, c2, d2, e2, f2) '[a1, b1, c1, d1, e1, f1] '[a2, b2, c2, d2, e2, f2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1]) (HList '[a2, b2, c2, d2, e2, f2]) (a1, b1, c1, d1, e1, f1) (a2, b2, c2, d2, e2, f2)

tupleToList :: (a2, b2, c2, d2, e2, f2) -> HList '[a2, b2, c2, d2, e2, f2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1] -> (a1, b1, c1, d1, e1, f1)

ListTuple (a1, b1, c1, d1, e1, f1, g1) (a2, b2, c2, d2, e2, f2, g2) '[a1, b1, c1, d1, e1, f1, g1] '[a2, b2, c2, d2, e2, f2, g2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1]) (HList '[a2, b2, c2, d2, e2, f2, g2]) (a1, b1, c1, d1, e1, f1, g1) (a2, b2, c2, d2, e2, f2, g2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2) -> HList '[a2, b2, c2, d2, e2, f2, g2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1] -> (a1, b1, c1, d1, e1, f1, g1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1) (a2, b2, c2, d2, e2, f2, g2, h2) '[a1, b1, c1, d1, e1, f1, g1, h1] '[a2, b2, c2, d2, e2, f2, g2, h2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2]) (a1, b1, c1, d1, e1, f1, g1, h1) (a2, b2, c2, d2, e2, f2, g2, h2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1] -> (a1, b1, c1, d1, e1, f1, g1, h1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1) (a2, b2, c2, d2, e2, f2, g2, h2, j2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1) (a2, b2, c2, d2, e2, f2, g2, h2, j2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1)

ListTuple (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1, s1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2) '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1, s1] '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2]

Defined in Data.Generics.Product.Internal.HList

Methods

tupled :: Iso (HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1, s1]) (HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2]) (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1, s1) (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2)

tupleToList :: (a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2) -> HList '[a2, b2, c2, d2, e2, f2, g2, h2, j2, k2, l2, m2, n2, o2, p2, q2, r2, s2]

listToTuple :: HList '[a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1, s1] -> (a1, b1, c1, d1, e1, f1, g1, h1, j1, k1, l1, m1, n1, o1, p1, q1, r1, s1)

type family TupleToList a where ...

Equations

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]