[Haskell-cafe] Is this haskelly enough?

[Tillmann Rendel]

Johan Tibell wrote:
> I found myself wanting a map that looks at neighboring elements. This is
> where I used explicit recursion the most. Something like this:
> 
> f [] = []
> f ((Foo a) : (Bar b) : xs)
>   | fooBar a b = Foo a : f xs
>   | otherwise = Bar b : f xs
> 
> This is almost a map. A variation is when filtering and you want some
> look-ahead to make the filtering decision. There's probably a good way 
> to do this I'm not aware of.

If you want to map over all elements, but need to look ahead in the 
mapped function, you can map over the tails:

   map' :: ([a] -> b) -> [a] -> b
   map' f = map f . tails

f should be something like
   f (a:b:c:_) = ...


If you want to handle groups of n elements together, producing only one 
element per group, you can use unfoldr with splitAt:

   map'' :: Int -> ([a] -> b) -> [a] -> [b]
   map'' n f =
     map f . unfoldr (((not . null . fst) `guarding`) . splitAt n)

   guarding p x = guard (p x) >> return x


If you want to decide in the mapped function how many elements to 
consume, you can use unfoldr directly.

   Tillmann Rendel