module Test.FitSpec.Mutable.Tuples () where
import Test.FitSpec.Mutable
import Test.LeanCheck (productWith)
instance (Mutable a, Mutable b, Mutable c, Mutable d,
Mutable e, Mutable f, Mutable g)
=> Mutable (a,b,c,d,e,f,g) where
mutiers :: (a, b, c, d, e, f, g) -> [[(a, b, c, d, e, f, g)]]
mutiers (a
f,b
g,c
h,d
i,e
j,f
k,g
l) = (a -> (b, c, d, e, f, g) -> (a, b, c, d, e, f, g))
-> [[a]] -> [[(b, c, d, e, f, g)]] -> [[(a, b, c, d, e, f, g)]]
forall a b c. (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]
productWith (\a
f' (b
g',c
h',d
i',e
j',f
k',g
l') ->
(a
f',b
g',c
h',d
i',e
j',f
k',g
l'))
(a -> [[a]]
forall a. Mutable a => a -> [[a]]
mutiers a
f)
((b, c, d, e, f, g) -> [[(b, c, d, e, f, g)]]
forall a. Mutable a => a -> [[a]]
mutiers (b
g,c
h,d
i,e
j,f
k,g
l))
instance (Mutable a, Mutable b, Mutable c, Mutable d,
Mutable e, Mutable f, Mutable g, Mutable h)
=> Mutable (a,b,c,d,e,f,g,h) where
mutiers :: (a, b, c, d, e, f, g, h) -> [[(a, b, c, d, e, f, g, h)]]
mutiers (a
f,b
g,c
h,d
i,e
j,f
k,g
l,h
m) = (a -> (b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h))
-> [[a]]
-> [[(b, c, d, e, f, g, h)]]
-> [[(a, b, c, d, e, f, g, h)]]
forall a b c. (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]
productWith (\a
f' (b
g',c
h',d
i',e
j',f
k',g
l',h
m') ->
(a
f',b
g',c
h',d
i',e
j',f
k',g
l',h
m'))
(a -> [[a]]
forall a. Mutable a => a -> [[a]]
mutiers a
f)
((b, c, d, e, f, g, h) -> [[(b, c, d, e, f, g, h)]]
forall a. Mutable a => a -> [[a]]
mutiers (b
g,c
h,d
i,e
j,f
k,g
l,h
m))
instance (Mutable a, Mutable b, Mutable c, Mutable d, Mutable e,
Mutable f, Mutable g, Mutable h, Mutable i)
=> Mutable (a,b,c,d,e,f,g,h,i) where
mutiers :: (a, b, c, d, e, f, g, h, i) -> [[(a, b, c, d, e, f, g, h, i)]]
mutiers (a
f,b
g,c
h,d
i,e
j,f
k,g
l,h
m,i
n) =
(a -> (b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i))
-> [[a]]
-> [[(b, c, d, e, f, g, h, i)]]
-> [[(a, b, c, d, e, f, g, h, i)]]
forall a b c. (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]
productWith (\a
f' (b
g',c
h',d
i',e
j',f
k',g
l',h
m',i
n') ->
(a
f',b
g',c
h',d
i',e
j',f
k',g
l',h
m',i
n'))
(a -> [[a]]
forall a. Mutable a => a -> [[a]]
mutiers a
f)
((b, c, d, e, f, g, h, i) -> [[(b, c, d, e, f, g, h, i)]]
forall a. Mutable a => a -> [[a]]
mutiers (b
g,c
h,d
i,e
j,f
k,g
l,h
m,i
n))
instance (Mutable a, Mutable b, Mutable c, Mutable d, Mutable e,
Mutable f, Mutable g, Mutable h, Mutable i, Mutable j)
=> Mutable (a,b,c,d,e,f,g,h,i,j) where
mutiers :: (a, b, c, d, e, f, g, h, i, j)
-> [[(a, b, c, d, e, f, g, h, i, j)]]
mutiers (a
f,b
g,c
h,d
i,e
j,f
k,g
l,h
m,i
n,j
o) =
(a
-> (b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j))
-> [[a]]
-> [[(b, c, d, e, f, g, h, i, j)]]
-> [[(a, b, c, d, e, f, g, h, i, j)]]
forall a b c. (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]
productWith (\a
f' (b
g',c
h',d
i',e
j',f
k',g
l',h
m',i
n',j
o') ->
(a
f',b
g',c
h',d
i',e
j',f
k',g
l',h
m',i
n',j
o'))
(a -> [[a]]
forall a. Mutable a => a -> [[a]]
mutiers a
f)
((b, c, d, e, f, g, h, i, j) -> [[(b, c, d, e, f, g, h, i, j)]]
forall a. Mutable a => a -> [[a]]
mutiers (b
g,c
h,d
i,e
j,f
k,g
l,h
m,i
n,j
o))
instance (Mutable a, Mutable b, Mutable c, Mutable d,
Mutable e, Mutable f, Mutable g, Mutable h,
Mutable i, Mutable j, Mutable k)
=> Mutable (a,b,c,d,e,f,g,h,i,j,k) where
mutiers :: (a, b, c, d, e, f, g, h, i, j, k)
-> [[(a, b, c, d, e, f, g, h, i, j, k)]]
mutiers (a
f,b
g,c
h,d
i,e
j,f
k,g
l,h
m,i
n,j
o,k
p) =
(a
-> (b, c, d, e, f, g, h, i, j, k)
-> (a, b, c, d, e, f, g, h, i, j, k))
-> [[a]]
-> [[(b, c, d, e, f, g, h, i, j, k)]]
-> [[(a, b, c, d, e, f, g, h, i, j, k)]]
forall a b c. (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]
productWith (\a
f' (b
g',c
h',d
i',e
j',f
k',g
l',h
m',i
n',j
o',k
p') ->
(a
f',b
g',c
h',d
i',e
j',f
k',g
l',h
m',i
n',j
o',k
p'))
(a -> [[a]]
forall a. Mutable a => a -> [[a]]
mutiers a
f)
((b, c, d, e, f, g, h, i, j, k)
-> [[(b, c, d, e, f, g, h, i, j, k)]]
forall a. Mutable a => a -> [[a]]
mutiers (b
g,c
h,d
i,e
j,f
k,g
l,h
m,i
n,j
o,k
p))
instance (Mutable a, Mutable b, Mutable c, Mutable d,
Mutable e, Mutable f, Mutable g, Mutable h,
Mutable i, Mutable j, Mutable k, Mutable l)
=> Mutable (a,b,c,d,e,f,g,h,i,j,k,l) where
mutiers :: (a, b, c, d, e, f, g, h, i, j, k, l)
-> [[(a, b, c, d, e, f, g, h, i, j, k, l)]]
mutiers (a
f,b
g,c
h,d
i,e
j,f
k,g
l,h
m,i
n,j
o,k
p,l
q) =
(a
-> (b, c, d, e, f, g, h, i, j, k, l)
-> (a, b, c, d, e, f, g, h, i, j, k, l))
-> [[a]]
-> [[(b, c, d, e, f, g, h, i, j, k, l)]]
-> [[(a, b, c, d, e, f, g, h, i, j, k, l)]]
forall a b c. (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]
productWith (\a
f' (b
g',c
h',d
i',e
j',f
k',g
l',h
m',i
n',j
o',k
p',l
q') ->
(a
f',b
g',c
h',d
i',e
j',f
k',g
l',h
m',i
n',j
o',k
p',l
q'))
(a -> [[a]]
forall a. Mutable a => a -> [[a]]
mutiers a
f)
((b, c, d, e, f, g, h, i, j, k, l)
-> [[(b, c, d, e, f, g, h, i, j, k, l)]]
forall a. Mutable a => a -> [[a]]
mutiers (b
g,c
h,d
i,e
j,f
k,g
l,h
m,i
n,j
o,k
p,l
q))