-- |
-- Module      : Test.FitSpec.Mutable.Tuples
-- Copyright   : (c) 2015-2017 Rudy Matela
-- License     : 3-Clause BSD  (see the file LICENSE)
-- Maintainer  : Rudy Matela <rudy@matela.com.br>
--
-- Mutable instances: septuples up to 12-tuples
--
-- This is partly a Hack that allows those instances to be hidden from Haddock.
-- Otherwise Haddock documentation will look very ugly.
-- It also makes "Test.FitSpec.ShowMutable" more readable.
--
-- This module is already exported by "Test.FitSpec",
-- so it is not needed to import this explictly.
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))