Safe Haskell	None
Language	Haskell2010

Haskus.Utils.Tuple

Description

Tuple helpers

Synopsis

uncurry3 :: (a -> b -> c -> r) -> (a, b, c) -> r
uncurry4 :: (a -> b -> c -> d -> r) -> (a, b, c, d) -> r
uncurry5 :: (a -> b -> c -> d -> e -> r) -> (a, b, c, d, e) -> r
uncurry6 :: (a -> b -> c -> d -> e -> f -> r) -> (a, b, c, d, e, f) -> r
uncurry7 :: (a -> b -> c -> d -> e -> f -> g -> r) -> (a, b, c, d, e, f, g) -> r
take4 :: [a] -> (a, a, a, a)
fromTuple4 :: (a, a, a, a) -> [a]
module Data.Tuple
type Solo = Unit
pattern Solo :: a -> Solo a
type family Tuple xs = t | t -> xs where ...
type family Tuple# xs = t | t -> xs where ...
type family TypeReps xs where ...
class ExtractTuple (n :: Nat) xs where
- tupleN :: Tuple xs -> Index n xs
class TupleCon xs where
- tupleCon :: TupleFun (Tuple xs) xs
tupleHead :: forall xs. ExtractTuple 0 xs => Tuple xs -> Index 0 xs
class TupleTail ts ts' | ts -> ts' where
- tupleTail :: ts -> ts'
class TupleCons t ts ts' | t ts -> ts' where
- tupleCons :: t -> ts -> ts'
class ReorderTuple t1 t2 where
- tupleReorder :: t1 -> t2

Documentation

uncurry3 :: (a -> b -> c -> r) -> (a, b, c) -> r Source #

Uncurry3

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

Uncurry4

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

Uncurry5

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

Uncurry6

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

Uncurry7

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

Take specialised for quadruple

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

toList for quadruple

module Data.Tuple

type Solo = Unit Source #

pattern Solo :: a -> Solo a Source #

type family Tuple xs = t | t -> xs where ... Source #

Boxed tuple

TODO: put this family into GHC

Equations

Tuple '[] = ()
Tuple '[a] = Solo a
Tuple '[a, b] = (a, b)
Tuple '[a, b, c] = (a, b, c)
Tuple '[a, b, c, d] = (a, b, c, d)
Tuple '[a, b, c, d, e] = (a, b, c, d, e)
Tuple '[a, b, c, d, e, f] = (a, b, c, d, e, f)
Tuple '[a, b, c, d, e, f, g] = (a, b, c, d, e, f, g)
Tuple '[a, b, c, d, e, f, g, h] = (a, b, c, d, e, f, g, h)
Tuple '[a, b, c, d, e, f, g, h, i] = (a, b, c, d, e, f, g, h, i)
Tuple '[a, b, c, d, e, f, g, h, i, j] = (a, b, c, d, e, f, g, h, i, j)
Tuple '[a, b, c, d, e, f, g, h, i, j, k] = (a, b, c, d, e, f, g, h, i, j, k)
Tuple '[a, b, c, d, e, f, g, h, i, j, k, l] = (a, b, c, d, e, f, g, h, i, j, k, l)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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)
Tuple '[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 Tuple# xs = t | t -> xs where ... Source #

Unboxed tuple

TODO: put this family into GHC

Equations

Tuple# '[] = (# #)
Tuple# '[a] = (# a #)
Tuple# '[a, b] = (# a, b #)
Tuple# '[a, b, c] = (# a, b, c #)
Tuple# '[a, b, c, d] = (# a, b, c, d #)
Tuple# '[a, b, c, d, e] = (# a, b, c, d, e #)
Tuple# '[a, b, c, d, e, f] = (# a, b, c, d, e, f #)
Tuple# '[a, b, c, d, e, f, g] = (# a, b, c, d, e, f, g #)
Tuple# '[a, b, c, d, e, f, g, h] = (# a, b, c, d, e, f, g, h #)
Tuple# '[a, b, c, d, e, f, g, h, i] = (# a, b, c, d, e, f, g, h, i #)

type family TypeReps xs where ... Source #

Equations

TypeReps '[] = '[]
TypeReps ((a :: TYPE k) ': as) = k ': TypeReps as

class ExtractTuple (n :: Nat) xs where Source #

Extract a tuple value statically

Methods

tupleN :: Tuple xs -> Index n xs Source #

Extract a tuple value by type-level index

Instances

Instances details

ExtractTuple 0 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6, e7] -> Index 0 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
ExtractTuple 0 '[e0, e1, e2, e3, e4, e5, e6] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6] -> Index 0 '[e0, e1, e2, e3, e4, e5, e6] Source #
ExtractTuple 0 '[e0, e1, e2, e3, e4, e5] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5] -> Index 0 '[e0, e1, e2, e3, e4, e5] Source #
ExtractTuple 0 '[e0, e1, e2, e3, e4] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4] -> Index 0 '[e0, e1, e2, e3, e4] Source #
ExtractTuple 0 '[e0, e1, e2, e3] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3] -> Index 0 '[e0, e1, e2, e3] Source #
ExtractTuple 0 '[e0, e1, e2] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2] -> Index 0 '[e0, e1, e2] Source #
ExtractTuple 0 '[e0, e1] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1] -> Index 0 '[e0, e1] Source #
ExtractTuple 0 '[a] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[a] -> Index 0 '[a] Source #
ExtractTuple 1 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6, e7] -> Index 1 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
ExtractTuple 1 '[e0, e1, e2, e3, e4, e5, e6] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6] -> Index 1 '[e0, e1, e2, e3, e4, e5, e6] Source #
ExtractTuple 1 '[e0, e1, e2, e3, e4, e5] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5] -> Index 1 '[e0, e1, e2, e3, e4, e5] Source #
ExtractTuple 1 '[e0, e1, e2, e3, e4] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4] -> Index 1 '[e0, e1, e2, e3, e4] Source #
ExtractTuple 1 '[e0, e1, e2, e3] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3] -> Index 1 '[e0, e1, e2, e3] Source #
ExtractTuple 1 '[e0, e1, e2] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2] -> Index 1 '[e0, e1, e2] Source #
ExtractTuple 1 '[e0, e1] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1] -> Index 1 '[e0, e1] Source #
ExtractTuple 2 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6, e7] -> Index 2 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
ExtractTuple 2 '[e0, e1, e2, e3, e4, e5, e6] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6] -> Index 2 '[e0, e1, e2, e3, e4, e5, e6] Source #
ExtractTuple 2 '[e0, e1, e2, e3, e4, e5] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5] -> Index 2 '[e0, e1, e2, e3, e4, e5] Source #
ExtractTuple 2 '[e0, e1, e2, e3, e4] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4] -> Index 2 '[e0, e1, e2, e3, e4] Source #
ExtractTuple 2 '[e0, e1, e2, e3] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3] -> Index 2 '[e0, e1, e2, e3] Source #
ExtractTuple 2 '[e0, e1, e2] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2] -> Index 2 '[e0, e1, e2] Source #
ExtractTuple 3 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6, e7] -> Index 3 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
ExtractTuple 3 '[e0, e1, e2, e3, e4, e5, e6] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6] -> Index 3 '[e0, e1, e2, e3, e4, e5, e6] Source #
ExtractTuple 3 '[e0, e1, e2, e3, e4, e5] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5] -> Index 3 '[e0, e1, e2, e3, e4, e5] Source #
ExtractTuple 3 '[e0, e1, e2, e3, e4] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4] -> Index 3 '[e0, e1, e2, e3, e4] Source #
ExtractTuple 3 '[e0, e1, e2, e3] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3] -> Index 3 '[e0, e1, e2, e3] Source #
ExtractTuple 4 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6, e7] -> Index 4 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
ExtractTuple 4 '[e0, e1, e2, e3, e4, e5, e6] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6] -> Index 4 '[e0, e1, e2, e3, e4, e5, e6] Source #
ExtractTuple 4 '[e0, e1, e2, e3, e4, e5] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5] -> Index 4 '[e0, e1, e2, e3, e4, e5] Source #
ExtractTuple 4 '[e0, e1, e2, e3, e4] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4] -> Index 4 '[e0, e1, e2, e3, e4] Source #
ExtractTuple 5 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6, e7] -> Index 5 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
ExtractTuple 5 '[e0, e1, e2, e3, e4, e5, e6] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6] -> Index 5 '[e0, e1, e2, e3, e4, e5, e6] Source #
ExtractTuple 5 '[e0, e1, e2, e3, e4, e5] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5] -> Index 5 '[e0, e1, e2, e3, e4, e5] Source #
ExtractTuple 6 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6, e7] -> Index 6 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
ExtractTuple 6 '[e0, e1, e2, e3, e4, e5, e6] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6] -> Index 6 '[e0, e1, e2, e3, e4, e5, e6] Source #
ExtractTuple 7 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleN :: Tuple '[e0, e1, e2, e3, e4, e5, e6, e7] -> Index 7 '[e0, e1, e2, e3, e4, e5, e6, e7] Source #

class TupleCon xs where Source #

Create a Tuple

Methods

tupleCon :: TupleFun (Tuple xs) xs Source #

Create a Tuple

Instances

Instances details

TupleCon ('[] :: [Type]) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCon :: TupleFun (Tuple '[]) '[] Source #
TupleCon '[a, b, c, d, e, f] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCon :: TupleFun (Tuple '[a, b, c, d, e, f]) '[a, b, c, d, e, f] Source #
TupleCon '[a, b, c, d, e] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCon :: TupleFun (Tuple '[a, b, c, d, e]) '[a, b, c, d, e] Source #
TupleCon '[a, b, c, d] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCon :: TupleFun (Tuple '[a, b, c, d]) '[a, b, c, d] Source #
TupleCon '[a, b, c] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCon :: TupleFun (Tuple '[a, b, c]) '[a, b, c] Source #
TupleCon '[a, b] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCon :: TupleFun (Tuple '[a, b]) '[a, b] Source #
TupleCon '[a] Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCon :: TupleFun (Tuple '[a]) '[a] Source #

tupleHead :: forall xs. ExtractTuple 0 xs => Tuple xs -> Index 0 xs Source #

Get first element of the tuple

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

Methods

tupleTail :: ts -> ts' Source #

Instances

Instances details

TupleTail (a, b) (Solo b) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleTail :: (a, b) -> Solo b Source #
TupleTail (a, b, c) (b, c) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleTail :: (a, b, c) -> (b, c) Source #
TupleTail (a, b, c, d) (b, c, d) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleTail :: (a, b, c, d) -> (b, c, d) Source #
TupleTail (a, b, c, d, e) (b, c, d, e) Source #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple Methods tupleTail :: (a, b, c, d, e, f) -> (b, c, d, e, f) Source #

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

Methods

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

Instances

Instances details

TupleCons a (Solo b) (a, b) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCons :: a -> Solo b -> (a, b) Source #
TupleCons a (b, c) (a, b, c) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCons :: a -> (b, c) -> (a, b, c) Source #
TupleCons a (b, c, d) (a, b, c, d) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCons :: a -> (b, c, d) -> (a, b, c, d) Source #
TupleCons a (b, c, d, e) (a, b, c, d, e) Source #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple Methods tupleCons :: a -> (b, c, d, e, f) -> (a, b, c, d, e, f) Source #

class ReorderTuple t1 t2 where Source #

Reorder tuple elements

Methods

tupleReorder :: t1 -> t2 Source #

Reorder tuple elements

Instances

Instances details

ReorderTuple (Solo a) (Solo a) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: Solo a -> Solo a Source #
ReorderTuple (a, b) (b, a) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b) -> (b, a) Source #
ReorderTuple (a, b) (a, b) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b) -> (a, b) Source #
ReorderTuple (a, b, c) (c, b, a) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b, c) -> (c, b, a) Source #
ReorderTuple (a, b, c) (c, a, b) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b, c) -> (c, a, b) Source #
ReorderTuple (a, b, c) (b, c, a) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b, c) -> (b, c, a) Source #
ReorderTuple (a, b, c) (b, a, c) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b, c) -> (b, a, c) Source #
ReorderTuple (a, b, c) (a, c, b) Source #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b, c) -> (a, c, b) Source #
ReorderTuple (a, b, c) (a, b, c) Source #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b, c, d) -> (a, x, y, z) Source #
ReorderTuple (a, b, c, d) (a, b, c, d) Source #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple 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 #
Instance details Defined in Haskus.Utils.Tuple Methods tupleReorder :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) Source #