S.D.Mechveliani writes:
> As Haskell has the standard functions fst, snd to decompose (a,b),
> maybe, it worths to provide also
> tuple31, tuple31, tuple31,
> ...
> tuple51, tuple52, tuple53, tuple54, tuple55
>
> for the tuples of n = 3,4,5 ?
I've found some of these useful, except I named them differently:
> fst3 :: (a,b,c) -> a
> fst3 (x,_,_) = x
> snd3 :: (a,b,c) -> b
> snd3 (_,x,_) = x
> thd3 :: (a,b,c) -> c
> thd3 (_,_,x) = x
.... never got around to quadruples etc.
I also defined (some of these may be untested):
> tripl :: a -> (a,a,a)
> tripl x = (x,x,x)
> curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d
> curry3 f x y z = f (x, y, z)
> uncurry3 :: (a -> b -> c -> d) -> ((a, b, c) -> d)
> uncurry3 f t = f (fst3 t) (snd3 t) (thd3 t)
> applyTriple :: (a -> b, a -> c, a -> d) -> a -> (b,c,d)
> applyTriple (f,g,h) x = (f x, g x, h x)
> cross3 :: (a -> b, c -> d, e -> f) -> (a,c,e) -> (b,d,f)
> cross3 (f,g,h) (x,y,z) = (f x, g y, h z)
> mapTriple :: (a -> b) -> (a, a, a) -> (b, b, b)
> mapTriple = cross3 . tripl
> applyFst3 :: (a -> b) -> (a, c, d) -> (b, c, d)
> applyFst3 f = applyTriple (f . fst3, snd3, thd3)
> applySnd3 :: (a -> b) -> (c, a, d) -> (c, b, d)
> applySnd3 f = applyTriple (fst3, f . snd3, thd3)
> applyThd3 :: (a -> b) -> (c, d, a) -> (c, d, b)
> applyThd3 f = applyTriple (fst3, snd3, f . thd3)
> applyArgs3 :: (a -> b) -> (c -> d) -> (e -> f) -> (b -> d -> f -> g) -> (a -> c -> e -> g)
> applyArgs3 af1 af2 af3 f = \x y z -> f (af1 x) (af2 y) (af3 z)
> rotl :: (a -> b -> c -> d) -> (b -> c -> a -> d)
> rotl f y z x = f x y z
> rotr :: (a -> b -> c -> d) -> (c -> a -> b -> d)
> rotr f z x y = f x y z
> rotl4 :: (a -> b -> c -> d -> e) -> (b -> c -> d -> a -> e)
> rotl4 f y z t x = f x y z t
> rotr4 :: (a -> b -> c -> d -> e) -> (d -> a -> b -> c -> e)
> rotr4 f t x y z = f x y z t
Some more combinators (only for pairs so far):
> twin :: a -> (a,a)
> twin x = (x,x)
> swap :: (a,b) -> (b,a)
> swap (x,y) = (y,x)
-- apply a pair of functions to one argument
> applyPair :: (a -> b, a -> c) -> a -> (b, c)
> applyPair (f, g) x = (f x, g x)
-- apply a pair of functions to a pair
> cross :: (a -> b, c -> d) -> (a, c) -> (b, d)
> cross (f, g) = applyPair (f . fst, g . snd)
-- compose a pair of functions onto one function
> dotPair :: (a -> b, a -> c) -> (d -> a) -> (d -> b, d -> c)
> dotPair (f, g) h = (f . h, g . h)
-- compose a pair of functions onto a pair of functions
> dotCross :: (a -> b, c -> d) -> (e -> a, f -> c) -> (e -> b, f -> d)
> dotCross (f, g) (h, i) = (f . h, g . i)
> mapPair :: (a -> b) -> (a, a) -> (b, b)
> mapPair = cross . twin
> applyFst :: (a -> b) -> (a, c) -> (b, c)
> applyFst f = applyPair (f . fst, snd)
> applySnd :: (a -> b) -> (c, a) -> (c, b)
> applySnd f = applyPair (fst, f . snd)
> applyArgs :: (a -> b) -> (c -> d) -> (b -> d -> e) -> (a -> c -> e)
> applyArgs af1 af2 f = \x y -> f (af1 x) (af2 y)
> betweenFst :: (a -> b -> c) -> (a, d) -> (b, e) -> c
> betweenFst = applyArgs fst fst
> betweenSnd :: (a -> b -> c) -> (d, a) -> (e, b) -> c
> betweenSnd = applyArgs snd snd
I find these combinators useful, and probably other people have their own
versions - it would be nice to get them standardised, so we all speak the same
language. By standardised, I mean a prominent version that will be adopted by
users, not necessarily a committee process.
Tim
