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
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
