TupleTH

Note: One-tuples are currently understood as just the original type by Template Haskell (though this could be an undefined case which is not guaranteed to work this way?), so for example, we get

 $(catTuples 1 2) = \x (y,z) -> (x,y,z)

Types

htuple :: Int -> TypeQ -> TypeQ

Makes a homogenous tuple type of the given size and element type

 $(htuple 2) [t| Char |] = (Char,Char)

Transformation

mapTuple :: Int -> ExpQ

Type of the generated expression:

 (a -> b) -> (a, ..) -> (b, ..)

mapTuple' :: Int -> ExpQ -> Q Exp

Takes the mapping as a quoted expression. This can sometimes produce an expression that typechecks when the analogous expression using filterTuple does not, e.g.:

 $(mapTuple 2) Just        ((),"foo") -- Type error 
 $(mapTuple' 2 [| Just |]) ((),"foo") -- OK

filterTuple :: Int -> ExpQ

Type of the generated expression:

 (a -> Bool) -> (a, ..) -> [a]

filterTuple' :: Int -> ExpQ -> ExpQ

Takes the predicate as a quoted expression. See mapTuple' for how this can be useful.

reindexTuple :: Int -> [Int] -> Q Exp

reindexTuple n js creates the function

 \(x_0, ..., x_{n-1}) -> (x_{js !! 0}, x_{js !! 1}, .. x_{last js})

For example,

 $(reindexTuple 3 [1,1,0,0]) ('a','b','c') == ('b','b','a','a')

Each element of js must be nonnegative and less than n.

reverseTuple :: Int -> Q Exp

Like reverse.

rotateTuple :: Int -> Int -> Q Exp

rotateTuple n k creates a function which rotates an n-tuple rightwards by k positions (k may be negative or greater than n-1).

Combination

zipTuple :: Int -> Q Exp

Like zip.

Type of the generated expression:

 (a1, a2, ..) -> (b1, b2, ..) -> ((a1,b1), (a2,b2), ..)

catTuples :: Int -> Int -> Q Exp

Type of the generated expression:

 (a1, ..) -> (b1, ..) -> (a1, .., b1, ..)

uncatTuple :: Int -> Int -> Q Exp

uncatTuple n m is the inverse function of uncurry (catTuples n m).

ZipWith

zipTupleWith :: Int -> ExpQ

Like zipWith.

Type of the generated expression:

 (a -> b -> c) -> (a, ..) -> (b, ..) -> (c, ..)

zipTupleWith' :: Int -> ExpQ -> ExpQ

Takes the zipping function as a quoted expression. See mapTuple' for how this can be useful.

Construction

safeTupleFromList :: Int -> Q Exp

Type of the generated expression:

 [a] -> Maybe (a, ..)

tupleFromList :: Int -> Q Exp

Type of the generated expression:

 [a] -> (a, ..)

The generated function is partial.

constTuple :: Int -> Q Exp

Deconstruction

proj

Arguments

:: Int

Size of tuple

-> Int

0-based index of component to retrieve

-> ExpQ

 Generate a projection (like 'fst' and 'snd').

elemTuple :: Int -> Q Exp

Like elem.

Type of generated expression:

 Eq a => a -> (a, ..) -> Bool

tupleToList :: Int -> Q Exp

sumTuple :: Int -> Q Exp

Right folds

foldrTuple :: Int -> ExpQ

Type of the generated expression:

 (a -> r -> r) -> r -> (a, ..) -> r

foldrTuple' :: Int -> ExpQ -> ExpQ

Takes the folding function (but not the seed element) as a quoted expression. See mapTuple' for how this can be useful.

foldr1Tuple :: Int -> ExpQ

Type of the generated expression:

 (a -> a -> a) -> (a, ..) -> a

foldr1Tuple' :: Int -> ExpQ -> Q Exp

Takes the folding function as a quoted expression. See mapTuple' for how this can be useful.

Left folds

foldlTuple :: Int -> ExpQ

Type of the generated expression:

 (r -> a -> r) -> r -> (a, ..) -> r

foldlTuple' :: Int -> ExpQ -> ExpQ

Takes the folding function (but not the seed element) as a quoted expression. See mapTuple' for how this can be useful.

foldl1Tuple :: Int -> ExpQ

Type of the generated expression:

 (a -> a -> a) -> (a, ..) -> a

foldl1Tuple' :: Int -> ExpQ -> Q Exp

Takes the folding function as a quoted expression. See mapTuple' for how this can be useful.

Predicates

andTuple :: Int -> Q Exp

Like and.

orTuple :: Int -> Q Exp

Like or.

anyTuple :: Int -> Q Exp

Like any.

anyTuple' :: Int -> Q Exp -> Q Exp

allTuple :: Int -> Q Exp

Like all.

allTuple' :: Int -> Q Exp -> Q Exp

Monadic/applicative

sequenceTuple :: Int -> Q Exp

Like sequence.

sequenceATuple :: Int -> Q Exp

Like sequenceA.