Haskell: a function returning the last element of a list as a Maybe Just or Nothing on empty list

I have this simple function:

myLast :: [a] -> Maybe a
myLast xs = foldr lastHelper Nothing xs

The idea is that it returns Just x on an non-empty list with the last element x. If the list is empty, Nothing is expected.

Now, I am missing the definition of lastHelper (the above myLast must remain intact (this is homework)).

I tried to solve this cipher for hours now, to no avail. How should I go about defining lastHelper?

Consider how you might solve this recursively, without foldr:

myLast [] = Nothing
myLast (x:[]) = Just x
myLast (_:xs) = myLast xs

What if, instead of having to call myLast recursively, you could assume that myLast receives the result of the recursive call as an argument?

-- No recursion possible, so ignore the "magical" second argument
myLast' [] _ = Nothing
-- The only way to return Nothing is with an empty first argument,
-- so we can assume the tail we are ignoring is empty
myLast' (x:_) Nothing = Just x
-- If we reach this case, we assume the first list has 2 or more
-- elements. x is clearly not the last one, so the last one must be
-- the last element of the tail, is given to as as the result.
myLast' (x:_) result = result

Notice that we never care about the tail of the list here; we assume that "someone" used it to give us our second argument.

foldr is that someone. We derive the helper from myLast' by receiving only the head of the list as one argument, and the presumed recursive result as the second. We no longer need the first case: foldr itself detects the empty list (which has no head) and returns our default value without using the helper. That is, the helper only gets called when myLast' would have received a non-empty first argument.

I leave the full adaptation of myLast' to the helper to the reader.

myLast xs = foldr lastHelper Nothing xs
  where lastHelper ??? ??? = ???
        lastHelper ??? ??? = ???

When all else fails, expand a few cases and figure them out by hand:

foldr lastHelper Nothing [] is Nothing by definition of foldr.

Then,

    foldr lastHelper Nothing (1::[])
--> lastHelper 1 (foldr lastHelper Nothing [])
--> lastHelper 1 Nothing [By definition of foldr]
--> We wish this to be Just 1, so decide that it is.

    foldr lastHelper Nothing (2::1::[])
--> lastHelper 2 (foldr lastHelper Nothing (1::[])
--> lastHelper 2 (Just 1) [By the previous wishful hand-expansion]    
--> Should be Just 1, as well

    foldr lastHelper Nothing (3::2::1::[])
--> lastHelper 3 (foldr lastHelper Nothing (2::1::[])
--> lastHelper 3 (Just 1) [See above]    
--> Should also be Just 1 [I sense a pattern here.]

Now you should be able to write down

lastHelper x Nothing = ???
lastHelper x ??? = ???

and fill in the blanks

foldr is a catamorphism on a list. Indeed, it foldr f z replaces (:) with f and [] with z.

This thus means that you can let f inspect the second parameter. If it is a Nothing we know that the first parameter is the last item, if it a Just we know that the first parameter is not the last item, so we propagate the last one.

The function thus will look like:

<pre><code>myLast :: [a] -&gt; Maybe a
myLast xs = foldr lastHelper Nothing xs
where lastHelper x Nothing = &hellip; -- x is the last item
lastHelper x (Just y) = &hellip; -- x is not the last item</code></pre>

where I leave filling in the <code>&hellip;</code> parts as an exercise.