Haskell convert "case of" statement to tail recursive code

Question

I need help. I have a function of that form

myFunction = case myFunction of
    (Nothing) -> (Just)
    (Just) -> (Just)

I want to make it tail recursive. How would one do it ? I understand that the fact we have a different statement according to the return of the recursive call makes it difficult (reason I need help ^^). I can give the original function, but I'm rather looking for a more general solution. Thanks in advance

Edit: Actual code:

myFunction :: MyTree x -> (x, Maybe(MyTree x))
myFunction = (x, Nothing)
myFunction (MyNode left right) = case myFunction left of
                                      (x, Nothing)    -> (x, Just right)
                                      (x, Just left2) -> (x, Just (Node left2 right))

That code doesn't make sense. I have pasted it into your question and reformatted it. Please edit the question so that it contains your actual code. — dave4420, Nov 21 '12 at 23:09

score 1 · Answer 1 · edited May 23 '17 at 10:27

I'll assume you defined

data MyTree x = MyLeaf x | MyNode (MyTree x) (MyTree x)

and meant

myFunction :: MyTree x -> (x, Maybe(MyTree x))
myFunction (MyLeaf x) = (x, Nothing)
myFunction (MyNode left right) = case myFunction left of
                                      (x, Nothing)    -> (x, Just right)
                                      (x, Just left2) -> (x, Just (MyNode left2 right))

Which is a function that pulls out the leftmost leaf and sews the corresponding right branch in where it was.

You ask how to make this tail recursive. Why is that? In some (strict) languages, tail recursive code is more efficient, but Haskell uses lazy evaluation, which means it doesn't matter how late the recursive calls happen, but rather how early they produce output. In this case, the head recursive case myFunction left of zooms right down the tree until it finds that leftmost leaf, you can't get to it any quicker. However, on the way back up, it does pass the x around a bit rather than returning immediately, but it also sews all the right branches back on at the appropriate plave without any bookkeeping, which is the joy of using recursion on a recursive data structure.

See this question about why tail recursion isn't the most important thing for efficiency in Haskell.

Three classic things to do to a binary tree with data at the nodes are: 1. pre-order traversal (visit the current node first then the left subtree then right) - doubly tail recursive 2. in-order traversal (visit left subtree, then current node, then right) - head and tail recursive 3. post-order traversal (visit left and right subtrees before the current node) - doubly head recursive.

Post order sounds worryingly head recursive to someone not used to lazy evaluation, but it's an efficient way to sum the values in your tree, for example, particularly if you make sure the compiler knows it's strict.

As always, the best algorithms give the fastest results, and you should compile with -O2 if you want optimisations turned on.

score 0 · Answer 2 · answered Nov 21 '12 at 23:28

These have to match.

myFunction = ...
myFunction (MyNode left right) = ...

They don't match. You can't use them together. Why? One of them takes zero arguments, the other one takes one argument. They must take the same number of arguments. If you need to ignore an argument, use _. Note that the version that uses _ has to be after the version that doesn't use _.

myFunction :: MyTree x -> Maybe (MyTree x)
myFunction (MyNode left right) =
  case myFunction left of
    Nothing -> Just right
    Just left2 -> Just (MyNode left2 right)
myFunction _ = Nothing

I don't know what x is supposed to be in the body of your function. It's not bound to anything.

This isn't tail recursive. Not all functions can be made into tail recursive functions.

Hint

Maybe if you described what the function was supposed to do, we could help you do that.

Haskell convert "case of" statement to tail recursive code

2 Answers2

Hint