Safe Haskell | None |
---|---|

Language | Haskell98 |

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)

- mapTuple :: Int -> ExpQ
- mapTuple' :: Int -> ExpQ -> Q Exp
- filterTuple :: Int -> ExpQ
- filterTuple' :: Int -> ExpQ -> ExpQ
- reindexTuple :: Int -> [Int] -> Q Exp
- reverseTuple :: Int -> Q Exp
- rotateTuple :: Int -> Int -> Q Exp
- subtuples :: Int -> Int -> Q Exp
- deleteAtTuple :: Int -> Q Exp
- takeTuple :: Int -> Int -> Q Exp
- dropTuple :: Int -> Int -> Q Exp
- safeDeleteTuple :: Int -> Q Exp
- updateAtN :: Int -> Int -> Q Exp
- zipTuple :: Int -> Q Exp
- catTuples :: Int -> Int -> Q Exp
- uncatTuple :: Int -> Int -> Q Exp
- splitTupleAt :: Int -> Int -> Q Exp
- zipTupleWith :: Int -> ExpQ
- zipTupleWith' :: Int -> ExpQ -> ExpQ
- safeTupleFromList :: Int -> Q Exp
- tupleFromList :: Int -> Q Exp
- constTuple :: Int -> Q Exp
- proj :: Int -> Int -> ExpQ
- proj' :: Int -> Q Exp
- elemTuple :: Int -> Q Exp
- tupleToList :: Int -> Q Exp
- sumTuple :: Int -> Q Exp
- findSuccessiveElementsSatisfying :: Int -> Q Exp
- foldrTuple :: Int -> ExpQ
- foldrTuple' :: Int -> ExpQ -> ExpQ
- foldr1Tuple :: Int -> ExpQ
- foldr1Tuple' :: Int -> ExpQ -> Q Exp
- foldlTuple :: Int -> ExpQ
- foldlTuple' :: Int -> ExpQ -> ExpQ
- foldl1Tuple :: Int -> ExpQ
- foldl1Tuple' :: Int -> ExpQ -> Q Exp
- andTuple :: Int -> Q Exp
- orTuple :: Int -> Q Exp
- anyTuple :: Int -> Q Exp
- anyTuple' :: Int -> Q Exp -> Q Exp
- allTuple :: Int -> Q Exp
- allTuple' :: Int -> Q Exp -> Q Exp
- sequenceTuple :: Int -> Q Exp
- sequenceATuple :: Int -> Q Exp
- htuple :: Int -> TypeQ -> TypeQ

# Transformation

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

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 Source

Type of the generated expression:

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

filterTuple' :: Int -> ExpQ -> ExpQ Source

Takes the predicate as a quoted expression. See `mapTuple'`

for how this can be useful.

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

`reindexTuple n js`

=>

\(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`

.

rotateTuple :: Int -> Int -> Q Exp Source

`rotateTuple n k`

creates a function which rotates an `n`

-tuple rightwards by `k`

positions (`k`

may be negative or greater than `n-1`

).

subtuples :: Int -> Int -> Q Exp Source

Generates the function which maps a tuple `(x_1, ..., x_n)`

to the tuple of all its subtuples of the form `(x_{i_1}, ..., x_{i_k})`

, where `i_1 < i_2 < ... < i_k`

.

deleteAtTuple :: Int -> Q Exp Source

Generates a function which takes a `Num`

`i`

and a homogenous tuple of size `n`

and deletes the `i`

-th (0-based) element of the tuple.

safeDeleteTuple :: Int -> Q Exp Source

`safeDeleteTuple n`

generates a function analogous to `delete`

that takes an element and an `n`

-tuple and maybe returns an `n-1`

-tuple (if and only if the element was found).

:: Int | Length of the input tuple |

-> Int | 0-based index of the element to be modified |

-> Q Exp | (b -> c) -> (a1,a2,b,a3,a4) -> (a1,a2,c,a3,a4) |

Generates a function modifying a single element of a tuple.

# Combination

catTuples :: Int -> Int -> Q Exp Source

Type of the generated expression:

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

uncatTuple :: Int -> Int -> Q Exp Source

`uncatTuple n m = ``splitTupleAt`

(n+m) n

`uncatTuple n m`

is the inverse function of `uncurry (catTuples n m)`

.

splitTupleAt :: Int -> Int -> Q Exp Source

`splitTupleAt n i`

=> `\(x_0, ..., x_{n-1}) -> ((x_0, ..., x_{i-1}),(x_i, ..., x_{n-1})`

## ZipWith

zipTupleWith :: Int -> ExpQ Source

zipTupleWith' :: Int -> ExpQ -> ExpQ Source

Takes the zipping function as a quoted expression. See `mapTuple'`

for how this can be useful.

# Construction

safeTupleFromList :: Int -> Q Exp Source

Type of the generated expression:

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

tupleFromList :: Int -> Q Exp Source

Type of the generated expression:

[a] -> (a, ..)

The generated function is partial.

constTuple :: Int -> Q Exp Source

# Deconstruction

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

Like `proj`

, but takes the index argument as the first argument at runtime and returns a `Maybe`

.

`>>>`

$(proj' 3) :: Num a => (a1, a1, a1) -> a -> Maybe a1`:t $(proj' 3)`

tupleToList :: Int -> Q Exp Source

## Right folds

foldrTuple :: Int -> ExpQ Source

Type of the generated expression:

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

foldrTuple' :: Int -> ExpQ -> ExpQ Source

Takes the folding function (but not the seed element) as a quoted expression. See `mapTuple'`

for how this can be useful.

foldr1Tuple :: Int -> ExpQ Source

Type of the generated expression:

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

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

Takes the folding function as a quoted expression. See `mapTuple'`

for how this can be useful.

## Left folds

foldlTuple :: Int -> ExpQ Source

Type of the generated expression:

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

foldlTuple' :: Int -> ExpQ -> ExpQ Source

Takes the folding function (but not the seed element) as a quoted expression. See `mapTuple'`

for how this can be useful.

foldl1Tuple :: Int -> ExpQ Source

Type of the generated expression:

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

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

Takes the folding function as a quoted expression. See `mapTuple'`

for how this can be useful.

## Predicates

# Monadic/applicative

sequenceATuple :: Int -> Q Exp Source

Like `sequenceA`

.