haskus-system-0.6.0.0: Haskus system programming framework

Safe HaskellSafe
LanguageHaskell2010

Haskus.Utils.Tuple

Description

Tuple helpers

Synopsis

Documentation

uncurry4 :: (a -> b -> c -> d -> e) -> (a, b, c, d) -> e Source #

Uncurry specialised for quadruple

take4 :: [a] -> (a, a, a, a) Source #

Take specialised for quadruple

fromTuple4 :: (a, a, a, a) -> [a] Source #

toList for quadruple

module Data.Tuple

newtype Single a Source #

Singleton type

Constructors

Single a 

Instances

ExtractTuple 0 (Single t) t Source # 

Methods

tupleN :: Single t -> t Source #

TupleCons a (Single b) (a, b) Source # 

Methods

tupleCons :: a -> Single b -> (a, b) Source #

Eq a => Eq (Single a) Source # 

Methods

(==) :: Single a -> Single a -> Bool #

(/=) :: Single a -> Single a -> Bool #

Show a => Show (Single a) Source # 

Methods

showsPrec :: Int -> Single a -> ShowS #

show :: Single a -> String #

showList :: [Single a] -> ShowS #

TupleHead (Single a) a Source # 

Methods

tupleHead :: Single a -> a Source #

ReorderTuple (Single a) (Single a) Source # 

Methods

tupleReorder :: Single a -> Single a Source #

TupleTail (a, b) (Single b) Source # 

Methods

tupleTail :: (a, b) -> Single b Source #

HTuple' ((:) * a ([] *)) (Single a) Source # 

Methods

hToTuple' :: HList ((* ': a) [*]) -> Single a Source #

hFromTuple' :: Single a -> HList ((* ': a) [*]) Source #

type family TupleToList t where ... Source #

Equations

TupleToList (Single a) = '[a] 
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, i) = '[a, b, c, d, e, f, g, h, i] 
TupleToList (a, b, c, d, e, f, g, h, i, j) = '[a, b, c, d, e, f, g, h, i, j] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k) = '[a, b, c, d, e, f, g, h, i, j, k] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l) = '[a, b, c, d, e, f, g, h, i, j, k, l] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m) = '[a, b, c, d, e, f, g, h, i, j, k, l, m] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y] 
TupleToList (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) = '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z] 

type family ListToTuple t where ... Source #

Equations

ListToTuple '[a] = Single a 
ListToTuple '[a, b] = (a, b) 
ListToTuple '[a, b, c] = (a, b, c) 
ListToTuple '[a, b, c, d] = (a, b, c, d) 
ListToTuple '[a, b, c, d, e] = (a, b, c, d, e) 
ListToTuple '[a, b, c, d, e, f] = (a, b, c, d, e, f) 
ListToTuple '[a, b, c, d, e, f, g] = (a, b, c, d, e, f, g) 
ListToTuple '[a, b, c, d, e, f, g, h] = (a, b, c, d, e, f, g, h) 
ListToTuple '[a, b, c, d, e, f, g, h, i] = (a, b, c, d, e, f, g, h, i) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j] = (a, b, c, d, e, f, g, h, i, j) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k] = (a, b, c, d, e, f, g, h, i, j, k) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l] = (a, b, c, d, e, f, g, h, i, j, k, l) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m] = (a, b, c, d, e, f, g, h, i, j, k, l, m) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) 
ListToTuple '[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z] = (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) 

class ExtractTuple n t x | n t -> x where Source #

Extract a tuple value statically

Minimal complete definition

tupleN

Methods

tupleN :: t -> x Source #

Extract a tuple value by type-level index

Instances

ExtractTuple 0 (Single t) t Source # 

Methods

tupleN :: Single t -> t Source #

ExtractTuple 0 (e0, e1) e0 Source # 

Methods

tupleN :: (e0, e1) -> e0 Source #

ExtractTuple 1 (e0, e1) e1 Source # 

Methods

tupleN :: (e0, e1) -> e1 Source #

ExtractTuple 0 (e0, e1, e2) e0 Source # 

Methods

tupleN :: (e0, e1, e2) -> e0 Source #

ExtractTuple 1 (e0, e1, e2) e1 Source # 

Methods

tupleN :: (e0, e1, e2) -> e1 Source #

ExtractTuple 2 (e0, e1, e2) e2 Source # 

Methods

tupleN :: (e0, e1, e2) -> e2 Source #

ExtractTuple 0 (e0, e1, e2, e3) e0 Source # 

Methods

tupleN :: (e0, e1, e2, e3) -> e0 Source #

ExtractTuple 1 (e0, e1, e2, e3) e1 Source # 

Methods

tupleN :: (e0, e1, e2, e3) -> e1 Source #

ExtractTuple 2 (e0, e1, e2, e3) e2 Source # 

Methods

tupleN :: (e0, e1, e2, e3) -> e2 Source #

ExtractTuple 3 (e0, e1, e2, e3) e3 Source # 

Methods

tupleN :: (e0, e1, e2, e3) -> e3 Source #

ExtractTuple 0 (e0, e1, e2, e3, e4) e0 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4) -> e0 Source #

ExtractTuple 1 (e0, e1, e2, e3, e4) e1 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4) -> e1 Source #

ExtractTuple 2 (e0, e1, e2, e3, e4) e2 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4) -> e2 Source #

ExtractTuple 3 (e0, e1, e2, e3, e4) e3 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4) -> e3 Source #

ExtractTuple 4 (e0, e1, e2, e3, e4) e4 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4) -> e4 Source #

ExtractTuple 0 (e0, e1, e2, e3, e4, e5) e0 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5) -> e0 Source #

ExtractTuple 1 (e0, e1, e2, e3, e4, e5) e1 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5) -> e1 Source #

ExtractTuple 2 (e0, e1, e2, e3, e4, e5) e2 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5) -> e2 Source #

ExtractTuple 3 (e0, e1, e2, e3, e4, e5) e3 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5) -> e3 Source #

ExtractTuple 4 (e0, e1, e2, e3, e4, e5) e4 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5) -> e4 Source #

ExtractTuple 5 (e0, e1, e2, e3, e4, e5) e5 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5) -> e5 Source #

ExtractTuple 0 (e0, e1, e2, e3, e4, e5, e6) e0 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6) -> e0 Source #

ExtractTuple 1 (e0, e1, e2, e3, e4, e5, e6) e1 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6) -> e1 Source #

ExtractTuple 2 (e0, e1, e2, e3, e4, e5, e6) e2 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6) -> e2 Source #

ExtractTuple 3 (e0, e1, e2, e3, e4, e5, e6) e3 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6) -> e3 Source #

ExtractTuple 4 (e0, e1, e2, e3, e4, e5, e6) e4 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6) -> e4 Source #

ExtractTuple 5 (e0, e1, e2, e3, e4, e5, e6) e5 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6) -> e5 Source #

ExtractTuple 6 (e0, e1, e2, e3, e4, e5, e6) e6 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6) -> e6 Source #

ExtractTuple 0 (e0, e1, e2, e3, e4, e5, e6, e7) e0 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6, e7) -> e0 Source #

ExtractTuple 1 (e0, e1, e2, e3, e4, e5, e6, e7) e1 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6, e7) -> e1 Source #

ExtractTuple 2 (e0, e1, e2, e3, e4, e5, e6, e7) e2 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6, e7) -> e2 Source #

ExtractTuple 3 (e0, e1, e2, e3, e4, e5, e6, e7) e3 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6, e7) -> e3 Source #

ExtractTuple 4 (e0, e1, e2, e3, e4, e5, e6, e7) e4 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6, e7) -> e4 Source #

ExtractTuple 5 (e0, e1, e2, e3, e4, e5, e6, e7) e5 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6, e7) -> e5 Source #

ExtractTuple 6 (e0, e1, e2, e3, e4, e5, e6, e7) e6 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6, e7) -> e6 Source #

ExtractTuple 7 (e0, e1, e2, e3, e4, e5, e6, e7) e7 Source # 

Methods

tupleN :: (e0, e1, e2, e3, e4, e5, e6, e7) -> e7 Source #

class TupleHead ts ts' | ts -> ts' where Source #

Minimal complete definition

tupleHead

Methods

tupleHead :: ts -> ts' Source #

Instances

TupleHead (Single a) a Source # 

Methods

tupleHead :: Single a -> a Source #

TupleHead (a, b) a Source # 

Methods

tupleHead :: (a, b) -> a Source #

TupleHead (a, b, c) a Source # 

Methods

tupleHead :: (a, b, c) -> a Source #

TupleHead (a, b, c, d) a Source # 

Methods

tupleHead :: (a, b, c, d) -> a Source #

TupleHead (a, b, c, d, e) a Source # 

Methods

tupleHead :: (a, b, c, d, e) -> a Source #

TupleHead (a, b, c, d, e, f) a Source # 

Methods

tupleHead :: (a, b, c, d, e, f) -> a Source #

class TupleTail ts ts' | ts -> ts' where Source #

Minimal complete definition

tupleTail

Methods

tupleTail :: ts -> ts' Source #

Instances

TupleTail (a, b) (Single b) Source # 

Methods

tupleTail :: (a, b) -> Single b Source #

TupleTail (a, b, c) (b, c) Source # 

Methods

tupleTail :: (a, b, c) -> (b, c) Source #

TupleTail (a, b, c, d) (b, c, d) Source # 

Methods

tupleTail :: (a, b, c, d) -> (b, c, d) Source #

TupleTail (a, b, c, d, e) (b, c, d, e) Source # 

Methods

tupleTail :: (a, b, c, d, e) -> (b, c, d, e) Source #

TupleTail (a, b, c, d, e, f) (b, c, d, e, f) Source # 

Methods

tupleTail :: (a, b, c, d, e, f) -> (b, c, d, e, f) Source #

class TupleCons t ts ts' | t ts -> ts' where Source #

Minimal complete definition

tupleCons

Methods

tupleCons :: t -> ts -> ts' Source #

Instances

TupleCons a (Single b) (a, b) Source # 

Methods

tupleCons :: a -> Single b -> (a, b) Source #

TupleCons a (b, c) (a, b, c) Source # 

Methods

tupleCons :: a -> (b, c) -> (a, b, c) Source #

TupleCons a (b, c, d) (a, b, c, d) Source # 

Methods

tupleCons :: a -> (b, c, d) -> (a, b, c, d) Source #

TupleCons a (b, c, d, e) (a, b, c, d, e) Source # 

Methods

tupleCons :: a -> (b, c, d, e) -> (a, b, c, d, e) Source #

TupleCons a (b, c, d, e, f) (a, b, c, d, e, f) Source # 

Methods

tupleCons :: a -> (b, c, d, e, f) -> (a, b, c, d, e, f) Source #

class ReorderTuple t1 t2 where Source #

Reorder tuple elements

Minimal complete definition

tupleReorder

Methods

tupleReorder :: t1 -> t2 Source #

Reorder tuple elements

Instances

ReorderTuple (Single a) (Single a) Source # 

Methods

tupleReorder :: Single a -> Single a Source #

ReorderTuple (a, b) (b, a) Source # 

Methods

tupleReorder :: (a, b) -> (b, a) Source #

ReorderTuple (a, b) (a, b) Source # 

Methods

tupleReorder :: (a, b) -> (a, b) Source #

ReorderTuple (a, b, c) (c, b, a) Source # 

Methods

tupleReorder :: (a, b, c) -> (c, b, a) Source #

ReorderTuple (a, b, c) (c, a, b) Source # 

Methods

tupleReorder :: (a, b, c) -> (c, a, b) Source #

ReorderTuple (a, b, c) (b, c, a) Source # 

Methods

tupleReorder :: (a, b, c) -> (b, c, a) Source #

ReorderTuple (a, b, c) (b, a, c) Source # 

Methods

tupleReorder :: (a, b, c) -> (b, a, c) Source #

ReorderTuple (a, b, c) (a, c, b) Source # 

Methods

tupleReorder :: (a, b, c) -> (a, c, b) Source #

ReorderTuple (a, b, c) (a, b, c) Source # 

Methods

tupleReorder :: (a, b, c) -> (a, b, c) Source #

ReorderTuple (a, b, c) (x, y, z) => ReorderTuple (a, b, c, d) (x, y, z, d) Source # 

Methods

tupleReorder :: (a, b, c, d) -> (x, y, z, d) Source #

ReorderTuple (a, b, d) (x, y, z) => ReorderTuple (a, b, c, d) (x, y, c, z) Source # 

Methods

tupleReorder :: (a, b, c, d) -> (x, y, c, z) Source #

ReorderTuple (a, c, d) (x, y, z) => ReorderTuple (a, b, c, d) (x, b, y, z) Source # 

Methods

tupleReorder :: (a, b, c, d) -> (x, b, y, z) Source #

ReorderTuple (b, c, d) (x, y, z) => ReorderTuple (a, b, c, d) (a, x, y, z) Source # 

Methods

tupleReorder :: (a, b, c, d) -> (a, x, y, z) Source #

ReorderTuple (a, b, c, d) (a, b, c, d) Source # 

Methods

tupleReorder :: (a, b, c, d) -> (a, b, c, d) Source #

ReorderTuple (a, b, c, d) (x, y, z, w) => ReorderTuple (a, b, c, d, e) (x, y, z, w, e) Source # 

Methods

tupleReorder :: (a, b, c, d, e) -> (x, y, z, w, e) Source #

ReorderTuple (a, b, c, e) (x, y, z, w) => ReorderTuple (a, b, c, d, e) (x, y, z, d, w) Source # 

Methods

tupleReorder :: (a, b, c, d, e) -> (x, y, z, d, w) Source #

ReorderTuple (a, b, d, e) (x, y, z, w) => ReorderTuple (a, b, c, d, e) (x, y, c, z, w) Source # 

Methods

tupleReorder :: (a, b, c, d, e) -> (x, y, c, z, w) Source #

ReorderTuple (a, c, d, e) (x, y, z, w) => ReorderTuple (a, b, c, d, e) (x, b, y, z, w) Source # 

Methods

tupleReorder :: (a, b, c, d, e) -> (x, b, y, z, w) Source #

ReorderTuple (b, c, d, e) (x, y, z, w) => ReorderTuple (a, b, c, d, e) (a, x, y, z, w) Source # 

Methods

tupleReorder :: (a, b, c, d, e) -> (a, x, y, z, w) Source #

ReorderTuple (a, b, c, d, e) (a, b, c, d, e) Source # 

Methods

tupleReorder :: (a, b, c, d, e) -> (a, b, c, d, e) Source #

ReorderTuple (a, b, c, d, e) (x, y, z, w, v) => ReorderTuple (a, b, c, d, e, f) (x, y, z, w, v, f) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f) -> (x, y, z, w, v, f) Source #

ReorderTuple (a, b, c, d, f) (x, y, z, w, v) => ReorderTuple (a, b, c, d, e, f) (x, y, z, w, e, v) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f) -> (x, y, z, w, e, v) Source #

ReorderTuple (a, b, c, e, f) (x, y, z, w, v) => ReorderTuple (a, b, c, d, e, f) (x, y, z, d, w, v) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f) -> (x, y, z, d, w, v) Source #

ReorderTuple (a, b, d, e, f) (x, y, z, w, v) => ReorderTuple (a, b, c, d, e, f) (x, y, c, z, w, v) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f) -> (x, y, c, z, w, v) Source #

ReorderTuple (a, c, d, e, f) (x, y, z, w, v) => ReorderTuple (a, b, c, d, e, f) (x, b, y, z, w, v) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f) -> (x, b, y, z, w, v) Source #

ReorderTuple (b, c, d, e, f) (x, y, z, w, v) => ReorderTuple (a, b, c, d, e, f) (a, x, y, z, w, v) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f) -> (a, x, y, z, w, v) Source #

ReorderTuple (a, b, c, d, e, f) (a, b, c, d, e, f) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) Source #

ReorderTuple (a, b, c, d, e, f) (x, y, z, w, v, u) => ReorderTuple (a, b, c, d, e, f, g) (x, y, z, w, v, u, g) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g) -> (x, y, z, w, v, u, g) Source #

ReorderTuple (a, b, c, d, e, g) (x, y, z, w, v, u) => ReorderTuple (a, b, c, d, e, f, g) (x, y, z, w, v, f, u) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g) -> (x, y, z, w, v, f, u) Source #

ReorderTuple (a, b, c, d, f, g) (x, y, z, w, v, u) => ReorderTuple (a, b, c, d, e, f, g) (x, y, z, w, e, v, u) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g) -> (x, y, z, w, e, v, u) Source #

ReorderTuple (a, b, c, e, f, g) (x, y, z, w, v, u) => ReorderTuple (a, b, c, d, e, f, g) (x, y, z, d, w, v, u) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g) -> (x, y, z, d, w, v, u) Source #

ReorderTuple (a, b, d, e, f, g) (x, y, z, w, v, u) => ReorderTuple (a, b, c, d, e, f, g) (x, y, c, z, w, v, u) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g) -> (x, y, c, z, w, v, u) Source #

ReorderTuple (a, c, d, e, f, g) (x, y, z, w, v, u) => ReorderTuple (a, b, c, d, e, f, g) (x, b, y, z, w, v, u) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g) -> (x, b, y, z, w, v, u) Source #

ReorderTuple (b, c, d, e, f, g) (x, y, z, w, v, u) => ReorderTuple (a, b, c, d, e, f, g) (a, x, y, z, w, v, u) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g) -> (a, x, y, z, w, v, u) Source #

ReorderTuple (a, b, c, d, e, f, g) (a, b, c, d, e, f, g) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) Source #

ReorderTuple (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) Source #

ReorderTuple (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) Source #

ReorderTuple (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i, j) Source # 

Methods

tupleReorder :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) Source #