Safe Haskell | Safe-Inferred |
---|---|

Language | Haskell98 |

## Synopsis

- mapPair :: (a -> c, b -> d) -> (a, b) -> (c, d)
- mapFst :: (a -> c) -> (a, b) -> (c, b)
- mapSnd :: (b -> c) -> (a, b) -> (a, c)
- zipPair :: (a, b) -> (c, d) -> ((a, c), (b, d))
- zipWithPair :: (a -> c -> e, b -> d -> f) -> (a, b) -> (c, d) -> (e, f)
- swap :: (a, b) -> (b, a)
- forcePair :: (a, b) -> (a, b)
- mapTriple :: (a -> d, b -> e, c -> f) -> (a, b, c) -> (d, e, f)
- mapFst3 :: (a -> d) -> (a, b, c) -> (d, b, c)
- mapSnd3 :: (b -> d) -> (a, b, c) -> (a, d, c)
- mapThd3 :: (c -> d) -> (a, b, c) -> (a, b, d)
- zipWithTriple :: (a -> d -> g, b -> e -> h, c -> f -> i) -> (a, b, c) -> (d, e, f) -> (g, h, i)
- uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d

# Pair

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

Cf. `(***)`

.

Apply two functions on corresponding values in a pair,
where the pattern match on the pair constructor is lazy.
This is crucial in recursions such as the one of `partition`

.
One the other hand there are applications
where strict application is crucial,
e.g. `mapSnd f ab`

where the left pair member is a large lazy list.
With the lazy `mapSnd`

we make the application of `f`

depend on the whole pair `ab`

.
See Data.Tuple.Example for two examples
where one variant is definitely better than the other one.

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

# Triple

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