I understand that higher-order functions are incredibly powerful, and that you can do essentially anything you might ever want while using only 'map' and 'foldl'.
However, I have trouble believing that even experienced programmers wold find such HOF-oriented code to be more readable than Mr Akgun's solution:
foo :: (a -> a -> a) -> [a] -> [a]
foo f (x:y:rest) = f x y : foo f (y:rest)
foo f _ = []
It seems to me that 'foo', as defined here, is a direct restatement of the original program specification (the english one). Basically no translation required.
If anyone here is enough of a veteran to prefer a map/fold implementation of this spec, I would be interested to hear about the thought processes you undertake when writing such code.
Thanks.
On Thu, Apr 29, 2010 at 10:22, David Virebayre
<dav.vire+haskell@gmail.com> wrote:
On Thu, Apr 29, 2010 at 3:52 PM, jean verdier <
verdier.jean@gmail.com> wrote:
> I may have missed it in this thread, but if not, why didn't anyone
> suggest:
>
> trans [] = []
> trans [x] = [x]
> trans ('a':_:xs) = 'a' : 'A' : trans xs
> trans (x:xs) = x : trans xs
like this one, on the long run it helps trying to solve those problem
with maps, folds, filters, and zips: Eventually, you'll find the code
more readable, easier to write, and there's perhaps a better chance
that it can be optimised by ghc.
David.
--
mac