@@ -0,0 +1,356 @@
1+{-# LANGUAGE AllowAmbiguousTypes #-}
2+{-# LANGUAGE CPP #-}
3+{-# LANGUAGE ConstraintKinds #-}
4+{-# LANGUAGE FlexibleInstances #-}
5+{-# LANGUAGE FunctionalDependencies #-}
6+{-# LANGUAGE GADTs #-}
7+{-# LANGUAGE ScopedTypeVariables #-}
8+{-# LANGUAGE TupleSections #-}
9+{-# LANGUAGE TypeApplications #-}
10+{-# LANGUAGE TypeFamilies #-}
11+{-# LANGUAGE TypeInType #-}
12+{-# LANGUAGE TypeOperators #-}
13+{-# LANGUAGE UndecidableInstances #-}
14+
15+#if __GLASGOW_HASKELL__ == 802
16+{-# OPTIONS_GHC -fno-solve-constant-dicts #-}
17+#endif
18+
19+
20+-----------------------------------------------------------------------------
21+-- |
22+-- Module : Data.Generics.Product.Internal.List
23+-- Copyright : (C) 2017 Csongor Kiss
24+-- License : BSD3
25+-- Maintainer : Csongor Kiss <kiss.csongor.kiss@gmail.com>
26+-- Stability : experimental
27+-- Portability : non-portable
28+--
29+-- Derive an isomorphism between a product type and a flat HList.
30+--
31+-----------------------------------------------------------------------------
32+
33+module Data.Generics.Product.Internal.List
34+ ( GIsList (..)
35+ , IndexList (..)
36+ , List (..)
37+ , type (++)
38+ , Elem
39+ , ListTuple (..)
40+ , TupleToList
41+ ) where
42+
43+import GHC.TypeLits
44+import Data.Semigroup
45+
46+import Data.Kind (Type)
47+import GHC.Generics
48+import Data.Profunctor
49+import Data.Generics.Internal.Profunctor.Lens
50+import Data.Generics.Internal.Profunctor.Iso
51+
52+data List (as :: [(m, Type)]) where
53+ Nil :: List '[]
54+ (:>) :: a -> List as -> List ('(s, a) ': as)
55+
56+infixr 5 :>
57+
58+type family ((as :: [k]) ++ (bs :: [k])) :: [k] where
59+ '[] ++ bs = bs
60+ (a ': as) ++ bs = a ': as ++ bs
61+
62+instance Semigroup (List '[]) where
63+ _ <> _ = Nil
64+
65+instance Monoid (List '[]) where
66+ mempty = Nil
67+ mappend _ _ = Nil
68+
69+instance (Semigroup a, Semigroup (List as)) => Semigroup (List ('(k, a) ': as)) where
70+ (x :> xs) <> (y :> ys) = (x <> y) :> (xs <> ys)
71+
72+instance (Monoid a, Monoid (List as)) => Monoid (List ('(k, a) ': as)) where
73+ mempty = mempty :> mempty
74+ mappend (x :> xs) (y :> ys) = mappend x y :> mappend xs ys
75+
76+class Elem (as :: [(k, Type)]) (key :: k) (i :: Nat) a | as key -> i a
77+instance {-# OVERLAPPING #-} pos ~ 0 => Elem ('(key, a) ': xs) key pos a
78+instance (Elem xs key i a, pos ~ (i + 1)) => Elem (x ': xs) key pos a
79+
80+class GIsList
81+ (m :: Type)
82+ (f :: Type -> Type)
83+ (g :: Type -> Type)
84+ (as :: [(m, Type)])
85+ (bs :: [(m, Type)]) | m f -> as, m g -> bs, bs f -> g, as g -> f where
86+
87+ glist :: Iso (f x) (g x) (List as) (List bs)
88+
89+ glistL :: Lens (f x) (g x) (List as) (List bs)
90+ glistL = glist @m
91+
92+ glistR :: Lens (List bs) (List as) (g x) (f x)
93+ glistR = fromIso (glist @m)
94+
95+instance
96+ ( GIsList m l l' as as'
97+ , GIsList m r r' bs bs'
98+ , Appending List as bs cs as' bs' cs'
99+ , cs ~ (as ++ bs)
100+ , cs' ~ (as' ++ bs')
101+ ) => GIsList m (l :*: r) (l' :*: r') cs cs' where
102+
103+ glist = prodIso . pairing (glist @m) (glist @m) . appending
104+ {-# INLINE glist #-}
105+
106+instance GIsList m f g as bs => GIsList m (M1 t meta f) (M1 t meta g) as bs where
107+ glist = mIso . glist @m
108+ {-# INLINE glist #-}
109+
110+instance {-# OVERLAPS #-}
111+ GIsList Symbol
112+ (S1 ('MetaSel ('Just field) u s i) (Rec0 a))
113+ (S1 ('MetaSel ('Just field) u s i) (Rec0 b))
114+ '[ '(field, a)] '[ '(field, b)] where
115+ glist = mIso . kIso . singleton
116+ {-# INLINE glist #-}
117+
118+instance GIsList Type (Rec0 a) (Rec0 a) '[ '(a, a)] '[ '(a, a)] where
119+ glist = kIso . singleton
120+ {-# INLINE glist #-}
121+
122+instance GIsList () (Rec0 a) (Rec0 b) '[ '( '(), a)] '[ '( '(), b)] where
123+ glist = kIso . singleton
124+ {-# INLINE glist #-}
125+
126+instance GIsList m U1 U1 '[] '[] where
127+ glist = iso (const Nil) (const U1)
128+ {-# INLINE glist #-}
129+
130+--------------------------------------------------------------------------------
131+-- as ++ bs == cs
132+-- as' + == cs'
133+class Appending f (as :: [k]) bs cs (as' :: [k]) bs' cs' | as bs cs cs' -> as' bs', as' bs' cs cs' -> as bs, as bs -> cs, as' bs' -> cs' where
134+ appending :: Iso (f as, f bs) (f as', f bs') (f cs) (f cs')
135+
136+instance Appending List '[] bs bs '[] bs' bs' where
137+ appending = iso (\(_, b) -> b) (Nil,)
138+
139+instance Appending List as bs cs as' bs' cs'
140+ => Appending List ('(f, a) ': as) bs ('(f, a) ': cs) ('(f, a') ': as') bs' ('(f, a') ': cs') where
141+ appending = pairing (fromIso consing) id . assoc3 . pairing id appending . consing
142+
143+singleton :: Iso a b (List '[ '(field, a)]) (List '[ '(field, b)])
144+singleton = iso (:> Nil) (\(x :> _) -> x)
145+
146+consing :: Iso (a, List as) (b, List bs) (List ('(f, a) ': as)) (List ('(f, b) ': bs))
147+consing = iso (\(x, xs) -> x :> xs) (\(x :> xs) -> (x, xs))
148+
149+--------------------------------------------------------------------------------
150+
151+-- This ended up not being used now... still cool to have
152+flipping :: Iso' (List (a1 ': a2 ': as)) (List (a2 ': a1 ': as))
153+flipping = iso
154+ (\(a1 :> a2 :> as) -> a2 :> a1 :> as)
155+ (\(a2 :> a1 :> as) -> a1 :> a2 :> as)
156+
157+class Inserting f a as bs | bs a -> as where
158+ inserting :: Iso' (f (a ': as)) (f bs)
159+
160+instance Inserting f a as (a ': as) where
161+ inserting = id
162+
163+instance Inserting List a as bs => Inserting List a ('(fb, b) ': as) ('(fb, b) ': bs) where
164+ inserting = flipping . fromIso consing . pairing id (inserting @_ @a) . consing
165+
166+class Permuting f as bs where
167+ permuting :: Iso' (f as) (f bs)
168+
169+instance Permuting List '[] '[] where
170+ permuting = id
171+
172+instance (Permuting List as as', Inserting List '(fa, a) as' bs')
173+ => Permuting List ('(fa, a) ': as) bs' where
174+ permuting = fromIso consing . pairing id permuting . consing . inserting @_ @'(fa, _)
175+
176+--------------------------------------------------------------------------------
177+class IndexList (i :: Nat) as bs a b | i as -> a, i bs -> b, i as b -> bs, i bs a -> as where
178+ point :: Lens (List as) (List bs) a b
179+
180+instance {-# OVERLAPPING #-}
181+ ( as ~ ('(f, a) ': as')
182+ , bs ~ ('(f, b) ': as')
183+ ) => IndexList 0 as bs a b where
184+ point = lens (\(x :> xs) -> (xs, x)) (\(xs, x') -> x' :> xs)
185+ {-# INLINE point #-}
186+
187+instance
188+ ( IndexList (n - 1) as' bs' a b
189+ , as ~ ('(f, x) ': as')
190+ , bs ~ ('(f, x) ': bs')
191+ ) => IndexList n as bs a b where
192+ point = fromIso consing . alongside id (point @(n-1)) . second'
193+ {-# INLINE point #-}
194+
195+--------------------------------------------------------------------------------
196+-- * Convert tuples to/from HLists
197+
198+class ListTuple (tuple :: Type) (as :: [(k, Type)]) | as -> tuple where
199+ type ListToTuple as :: Type
200+ tupled :: Iso' (List as) tuple
201+ tupled = iso listToTuple tupleToList
202+
203+ tupleToList :: tuple -> List as
204+ listToTuple :: List as -> tuple
205+
206+instance ListTuple () '[] where
207+ type ListToTuple '[] = ()
208+ tupleToList _ = Nil
209+ listToTuple _ = ()
210+
211+instance ListTuple a '[ '(fa, a)] where
212+ type ListToTuple '[ '(fa, a)] = a
213+ tupleToList a
214+ = a :> Nil
215+ listToTuple (a :> Nil)
216+ = a
217+
218+instance ListTuple (a, b) '[ '(fa, a), '(fb, b)] where
219+ type ListToTuple '[ '(fa, a), '(fb, b)] = (a, b)
220+ tupleToList (a, b)
221+ = a :> b :> Nil
222+ listToTuple (a :> b :> Nil)
223+ = (a, b)
224+
225+instance ListTuple (a, b, c) '[ '(fa, a), '(fb, b), '(fc, c)] where
226+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c)] = (a, b, c)
227+ tupleToList (a, b, c)
228+ = a :> b :> c :> Nil
229+ listToTuple (a :> b :> c :> Nil)
230+ = (a, b, c)
231+
232+instance ListTuple (a, b, c, d) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d)] where
233+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d)] = (a, b, c, d)
234+ tupleToList (a, b, c, d)
235+ = a :> b :> c :> d:> Nil
236+ listToTuple (a :> b :> c :> d :> Nil)
237+ = (a, b, c, d)
238+
239+instance ListTuple (a, b, c, d, e) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e)] where
240+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e)] = (a, b, c, d, e)
241+ tupleToList (a, b, c, d, e)
242+ = a :> b :> c :> d:> e :> Nil
243+ listToTuple (a :> b :> c :> d :> e :> Nil)
244+ = (a, b, c, d, e)
245+
246+instance ListTuple (a, b, c, d, e, f) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f)] where
247+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f)] = (a, b, c, d, e, f)
248+ tupleToList (a, b, c, d, e, f)
249+ = a :> b :> c :> d:> e :> f :> Nil
250+ listToTuple (a :> b :> c :> d :> e :> f :> Nil)
251+ = (a, b, c, d, e, f)
252+
253+instance ListTuple (a, b, c, d, e, f, g) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g)] where
254+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g)] = (a, b, c, d, e, f, g)
255+ tupleToList (a, b, c, d, e, f, g)
256+ = a :> b :> c :> d:> e :> f :> g :> Nil
257+ listToTuple (a :> b :> c :> d :> e :> f :> g :> Nil)
258+ = (a, b, c, d, e, f, g)
259+
260+instance ListTuple (a, b, c, d, e, f, g, h) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h)] where
261+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h)] = (a, b, c, d, e, f, g, h)
262+ tupleToList (a, b, c, d, e, f, g, h)
263+ = a :> b :> c :> d:> e :> f :> g :> h :> Nil
264+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> Nil)
265+ = (a, b, c, d, e, f, g, h)
266+
267+instance ListTuple (a, b, c, d, e, f, g, h, j) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j)] where
268+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j)] = (a, b, c, d, e, f, g, h, j)
269+ tupleToList (a, b, c, d, e, f, g, h, j)
270+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> Nil
271+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> Nil)
272+ = (a, b, c, d, e, f, g, h, j)
273+
274+instance ListTuple (a, b, c, d, e, f, g, h, j, k) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k)] where
275+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k)] = (a, b, c, d, e, f, g, h, j, k)
276+ tupleToList (a, b, c, d, e, f, g, h, j, k)
277+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> Nil
278+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> Nil)
279+ = (a, b, c, d, e, f, g, h, j, k)
280+
281+instance ListTuple (a, b, c, d, e, f, g, h, j, k, l) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l)] where
282+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l)] = (a, b, c, d, e, f, g, h, j, k, l)
283+ tupleToList (a, b, c, d, e, f, g, h, j, k, l)
284+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> l :> Nil
285+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> l :> Nil)
286+ = (a, b, c, d, e, f, g, h, j, k, l)
287+
288+instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m)] where
289+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m)] = (a, b, c, d, e, f, g, h, j, k, l, m)
290+ tupleToList (a, b, c, d, e, f, g, h, j, k, l, m)
291+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> l :> m :> Nil
292+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> l :> m :> Nil)
293+ = (a, b, c, d, e, f, g, h, j, k, l, m)
294+
295+instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n)] where
296+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n)] = (a, b, c, d, e, f, g, h, j, k, l, m, n)
297+ tupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n)
298+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> l :> m :> n :> Nil
299+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> l :> m :> n :> Nil)
300+ = (a, b, c, d, e, f, g, h, j, k, l, m, n)
301+
302+instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o)] where
303+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o)] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o)
304+ tupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o)
305+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> Nil
306+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> Nil)
307+ = (a, b, c, d, e, f, g, h, j, k, l, m, n, o)
308+
309+instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o), '(fp, p)] where
310+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o), '(fp, p)] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p)
311+ tupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p)
312+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> p :> Nil
313+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> p :> Nil)
314+ = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p)
315+
316+instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o), '(fp, p), '(fq, q)] where
317+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o), '(fp, p), '(fq, q)] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q)
318+ tupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q)
319+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> p :> q :> Nil
320+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> p :> q :> Nil)
321+ = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q)
322+
323+instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o), '(fp, p), '(fq, q), '(fr, r)] where
324+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o), '(fp, p), '(fq, q), '(fr, r)] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r)
325+ tupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r)
326+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> p :> q :> r :> Nil
327+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> p :> q :> r :> Nil)
328+ = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r)
329+
330+instance ListTuple (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s) '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o), '(fp, p), '(fq, q), '(fr, r), '(fs, s)] where
331+ type ListToTuple '[ '(fa, a), '(fb, b), '(fc, c), '(fd, d), '(fe, e), '(ff, f), '(fg, g), '(fh, h), '(fj, j), '(fk, k), '(fl, l), '(fm, m), '(fn, n), '(fo, o), '(fp, p), '(fq, q), '(fr, r), '(fs, s)] = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s)
332+ tupleToList (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s)
333+ = a :> b :> c :> d:> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> p :> q :> r :> s :> Nil
334+ listToTuple (a :> b :> c :> d :> e :> f :> g :> h :> j :> k :> l :> m :> n :> o :> p :> q :> r :> s :> Nil)
335+ = (a, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s)
336+
337+type family TupleToList a where
338+ TupleToList () = '[]
339+ TupleToList (a, b) = '[ '( '(), a), '( '(), b)]
340+ TupleToList (a, b, c) = '[ '( '(), a), '( '(), b), '( '(), c)]
341+ TupleToList (a, b, c, d) = '[ '( '(), a), '( '(), b), '( '(), c), '( '(), d)]
342+ TupleToList (a, b, c, d, e) = '[ '( '(), a), '( '(), b), '( '(), c), '( '(), d), '( '(), e)]
343+ TupleToList (a, b, c, d, e, f) = '[ '( '(), a), '( '(), b), '( '(), c), '( '(), d), '( '(), e), '( '(), f)]
344+ TupleToList (a, b, c, d, e, f, g) = '[ '( '(), a), '( '(), b), '( '(), c), '( '(), d), '( '(), e), '( '(), f), '( '(), g)]
345+ TupleToList (a, b, c, d, e, f, g, h) = '[ '( '(), a), '( '(), b), '( '(), c), '( '(), d), '( '(), e), '( '(), f), '( '(), g), '( '(), h)]
346+ TupleToList (a, b, c, d, e, f, g, h, j) = '[ '( '(), a), '( '(), b), '( '(), c), '( '(), d), '( '(), e), '( '(), f), '( '(), g), '( '(), h), '( '(), j)]
347+ TupleToList (a, b, c, d, e, f, g, h, j, k) = '[ '( '(), a), '( '(), b), '( '(), c), '( '(), d), '( '(), e), '( '(), f), '( '(), g), '( '(), h), '( '(), j), '( '(), k)]
348+ TupleToList (a, b, c, d, e, f, g, h, j, k, l) = '[ '( '(), a), '( '(), b), '( '(), c), '( '(), d), '( '(), e), '( '(), f), '( '(), g), '( '(), h), '( '(), j), '( '(), k), '( '(), l)]
349+ 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)]
350+ 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)]
351+ 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)]
352+ 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)]
353+ 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)]
354+ 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)]
355+ 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)]
356+ TupleToList a = '[ '( '(), a)]