将树缩减为haskell中的列表

Question

I am trying to reduce a Tree to List but I am stuck up here.. any suggestions are appreciated..

data Tree a = Leaf a | Node (Tree a) a (Tree a) deriving (Eq, Show)
treeToList :: (Ord a) => Tree a -> [a]
treeToList (Node root left right) = treeToList left ++ [root] ++   treeToList right

Expecting Result:

 ghci> treeToList (Node (Leaf 1) 2 (Node (Leaf 3) 4 (Leaf 5))) [1,2,3,4,5] 

Answer 1

You have two errors:

1. Non-exhaustive pattern (for Leaf constructor).
2. And in the pattern for Node you matching root as a left tree value ( Tree a ) and not an a .

Thus the result should look like:

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

treeToList :: (Ord a) => Tree a -> [a]
treeToList (Leaf v) = [v]
treeToList (Node left root right) = treeToList left ++ [root] ++ treeToList right

 *Main> treeToList (Node (Leaf 1) 2 (Node (Leaf 3) 4 (Leaf 5))) [1,2,3,4,5] 

Answer 2

Riffing on m0nhawk's absolutely correct answer, I'd offer the following advice. When you're writing a function that pattern matches on an algebraic data type like Tree , start by writing a template of how the function will be structured. In this case, given the type definition:

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

...and this function signature:

treeToList :: (Ord a) => Tree a -> [a]

...you can start by writing a template like this one, which is just expanding out the two alternatives of the Tree type and their components:

treeToList (Leaf value) = _
treeToList (Node left value right) = _

Read the _ (underscores) as "blanks" to fill in later. This is actually valid syntax in recent GHC versions, called a "hole" so the compiler will remind you that you need to fill it in.

By writing out a template like this and making sure you're covering all of the alternatives of the type you're working with, you greatly reduce your risk of running into problem #1 that m0nhawk pointed out.