Haskell 二叉树递归

Question

I am a beginner in haskell and I need to display the value in a tree based on directions specified in a List (Path). I have liste below the Data structures , I want to understand why my recursive feature that i have implemented is wrong

import Data.List

 data Step = L | R
 deriving(Eq,Show)

type Path = [Step]  

 data Tree a = Node a (Tree a) (Tree a)
             | End
        deriving (Eq,Show)

      leaf :: a -> Tree a
      leaf x = Node x End End

     ex :: Tree Int


     ex = Node 4 (Node 3 (leaf 2) End)
               (Node 7 (Node 5 End (leaf 6))
                     (leaf 8))



        valueAt :: Path -> Tree a -> Maybe a
        valueAt (p:ps) (Node a l r)  
                               | p == L = valueAt ps l 
                               | p == R = valueAt ps r
                               | ps == [] = Just           
                               | otherwise = Nothing

// When i execute this it says non exhaustive function at valueAt. So im guessing my recursive idea was implemented wrong. Can anyone explain why .

Answer 1

You did not handle the case valueAt [] someTree . The line valueAt (p:ps) ... only matches a non empty list starting with p and continuing with ps . ps might be empty, but p:ps never is.

If you compile with the flag -Wall , GHC should warn about this at compile time. I would strongly recommend this.

As a style suggestion, avoid guards such as p == ... since they do not perform any pattern match. Try instead something like

valueAt :: Path -> Tree a -> Maybe a
valueAt []     (Node a _ _) = Just a    -- note the "a" !
valueAt (L:ps) (Node _ l _) = valueAt ps l
valueAt (R:ps) (Node _ _ r) = valueAt ps r
valueAt _      End          = Nothing   -- in all the other cases

Answer 2

Your pattern match for valueAt does not cover [] , because (p:ps) will fail on an empty list. However, it is not necessary that it do so. Guards are evaluated in the order they are written, which means that your p == L and p == R guards are evaluated before your ps == [] case. In other words, you have put your edge case after your recursion cases, resulting in an invalid pattern match. This code should fix that.

valueAt (p:ps) (Node a l r)  
                           | ps == [] = Just    
                           | p == L = valueAt ps l 
                           | p == R = valueAt ps r       
                           | otherwise = Nothing

However, your code has another problem. The function has the type description valueAt :: Path -> Tree a -> Maybe a , but in your edge case ( ps == [] ), Just has type a -> Maybe a ; Just is applied to too few arguments . Try this instead.

                           | ps == [] = Just a

Now that your errors are fixed, I would also suggest moving from guards and == to pattern matches. It will be simpler, faster, and less error prone.

valueAt :: Path -> Tree a -> Maybe a
valueAt []     (Node a _ _) = Just a
valueAt (L:ps) (Node _ l _) = valueAt ps l
valueAt (R:ps) (Node _ _ r) = valueAt ps r
valueAt _      _            = Nothing