Multiple functions applied to a single value

[Graham Klyne]

There's a possible programming idiom that I repeatedly find myself thinking 
about as I write my code.  It feels like a kind of dual of fold, except 
that it's not necessarily confined to lists.  I'm wondering if anything 
like this is discussed in the literature, or implemented in the libraries...

Scene-setting:  broadly speaking, fold takes a function and applies it to 
several values, and combines the results in some way.  What I'm thinking of 
is a combinator or suchlike that takes two or more functions, applies them 
(separately) to a single value, then combines the results of those 
combinations.

One function that I have defined and use in my code is called 'flist':

   flist :: [a->b] -> a -> [b]
   flist fs a = map ($ a) fs

(which is similar to Monad.ap, except that the 'a' parameter is not a 
list/monad).  I could imagine combining this with a fold in some cases.

A more generalized form of this that works with arbitrary monads was 
suggested by Derek Elkin:

fmonad :: Monad m => m (a->b) -> a -> m b
fmonad fm a =
     do  { f <- fm
         ; return $ f a
         }

But not all cases I encounter involve lists or monads.  A different case 
might look like this:

 >  eval :: (b->c->d) -> (a->b) -> (a->c) -> (a->d)
 >  eval f g1 g2 a = f (g1 a) (g2 a)

So, for example, a function to test of the two elements of a pair are the 
same might be:

 > pairSame = eval (==) fst snd

giving:

 > pairSame (1,2) -- false
 > pairSame (3,3) -- true

Or a function to subtract the second and subsequent elements of a list from 
the first:

 > firstDiffRest = eval (-) head (sum . tail)

 > firstDiffRest [10,4,3,2,1] -- 0

That's about as far as I've taken this, but it feels as if it might be part 
of a more general pattern.  Hence my question:  is there anything like this 
in the libraries?

#g


------------
Graham Klyne
For email:
http://www.ninebynine.org/#Contact