I understand the theory but i loose it on the implementation.
Lets take the better variant.
last5 :: [a] -> Maybe a last5 = foldr acc Nothing where acc x Nothing = Just x acc _ j = j
Let's say we have [1,2,3]
Do I understand that acc = Nothing. and x = 3 ?
Not, acc is not Nothing. acc is a function of type (a -> Maybe a -> Maybe a). Nothing is a value of type Maybe a. The two cannot possibly be the same. foldr takes care of feeding the proper arguments to `acc`.
and after acc x Nothing = Just x acc get's the value 3
The result of calling `acc` with arguments 3 and Nothing is `Just 3`. But that's NOT the value of `acc`. acc is still a function. Note that there is no such thing as in-place mutation in Haskell, so you cannot just change the value of `acc`. But the RESULT of calling acc 3 Nothing is `Just 3`. This result is taken by foldr and passed again to `acc` together with the next item in the list. This continues until the list is exhausted and foldr returns the last result it got from calling `acc`.
But how does x get's the value 3 or does foldr takes care of that ?
foldr takes care of all that. foldr calls `acc` with the proper arguments and does all the bookkeeping internally. There is actually not much to bookkeep. Here's an implementation of foldr foldr :: (a -> b -> b) -> b -> [a] -> b foldr _ b [] = b foldr f b (a:as) = foldr f (f a b) as So, no great bookkeeping, just plain recursion. Stefan