Write a function that counts the number of elements in a rosetree - haskell

Question

Write a function
that counts the number of elements in a rosetree.
I tried counts the number of elements in a rosetree.
data RoseTree a = RoseNode a [RoseTree a]
deriving Show
things :: RoseTree String
things =
RoseNode "thing" [
RoseNode "animal" [
RoseNode "cat" [], RoseNode "dog" []
],
RoseNode "metal" [
RoseNode "alloy" [
RoseNode "steel" [], RoseNode "bronze" []
],
RoseNode "element" [
RoseNode "gold" [], RoseNode "tin" [], RoseNode "iron" []
]
],
RoseNode "fruit" [
RoseNode "apple" [
RoseNode "Granny Smith" [], RoseNode "Pink Lady" []
],
RoseNode "banana" [],
RoseNode "orange" []
],
RoseNode "astronomical object" [
RoseNode "Planet" [
RoseNode "Earth" [], RoseNode "Mars" []
],
RoseNode "Star" [
RoseNode "The Sun" [], RoseNode "Sirius" []
],
RoseNode "Galaxy" [
RoseNode "Milky Way" []
]
]
]
It should be 27, however, it returns 4.
EDIT: Here is my attempt:
roseSize x = case x of
RoseNode a [] -> 0
RoseNode a (x:xs) -> 1 + roseSize (RoseNode a xs)

Answer 1

It should be 27, however, it returns 4.
roseSize x = case x of
RoseNode a [] -> 0
RoseNode a (x:xs) -> 1 + roseSize (RoseNode a xs)
So you're not counting the sub-trees recursively. Try instead (fixed: base case to 1),
roseSize (RoseNode _ []) = 1
roseSize (RoseNode a (t:ts)) = roseSize t + roseSize (RoseNode a ts)
The missing part is roseSize t.
Otherwise you're only making recursive calls for the first layer of the tree.
If you evaluate your function by hand this becomes apparent,
roseSize things
~> roseSize (RoseNode "thing" [ animals, metals, fruits, astronomical_objects ]
~> 1 + roseSize (RoseNode "thing" [ metals, fruits, astronomical_objects ])
~> 1 + 1 + roseSize (RoseNode "thing" [ fruits, astronomical_objects ])
~> 1 + 1 + 1 + roseSize (RoseNode "thing" [ astronomical_objects ])
~> 1 + 1 + 1 + 1 + roseSize (RoseNode "thing" [])
~> 1 + 1 + 1 + 1 + 0
whereas with roseSize t in the function body the evaluation becomes
roseSize things
~> roseSize (RoseNode "thing" [ animals, metals, fruits, astronomical_objects ]
~> roseSize animals
+ roseSize (RoseNode "thing" [ metals, fruits, astronomical_objects ])
~> roseSize (RoseNode "animal" [ cat, dog ])
+ roseSize (RoseNode "thing" [ metals, fruits, astronomical_objects ])
~> roseSize cat
+ roseSize (RoseNode "animal" [ dog ])
+ roseSize (RoseNode "thing" [ metals, fruits, astronomical_objects ])
~> 1 -- given the base case of 1 instead of 0
+ roseSize (RoseNode "animal" [ dog ])
+ roseSize (RoseNode "thing" [ metals, fruits, astronomical_objects ])
~> ...
As an exercise, making this function explicitly recursive is fine.
But you may want to consider a more general approach, either using higher-order functions like PF. Castro does it, or an existing data structure like Data.Tree of containers:
import qualified Data.Tree as T
import Data.Tree (Tree(..))
things :: Tree String
things = Node "thing" [ animals, metals, fruits, astronomical_objects ]
where
animals = Node "animal" (map pure [ "cat", "dog" ])
metals = Node "metal" [ alloys, elements ]
alloys = Node "alloy" (map pure [ "steel", "bronze" ])
elements = Node "element" (map pure [ "gold", "tin", "iron" ])
fruits = ...
astronomical_objects = ...
Since a Data.Tree is Foldable, you can use length on it.
So it's not necessary to define a custom roseSize function.
At this point you're counting the nodes in a tree, and not the leaves of a tree, with leaves being the actual objects rather than the categories to which they belong. So you may actually be interested in counting the leaves.
You could do that by creating a function that finds the leaves:
leaves :: Tree a -> [a]
leaves (Node x []) = ... -- x is a leaf
leaves (Node _x ts) = ... -- _x isn't a leaf
With this template you can't easily use explicit recursion, i.e. matching on Node x (t:ts) and calling leaves on ts, since then the non-leaf case eventually ends in the base case, making the exhausted category appear as a leaf. But you can use higher-order functions to abstract out the recursion, e.g. concat, map, or concatMap of Prelude.
Using a library rose tree gives you other advantages, too, for example a bunch of other type class instances (Applicative giving you pure "foo" to construct a singleton tree / leaf) and a pretty-printing function:
> putStrLn $ T.drawTree things
thing
|
+- animal
| |
| +- cat
| |
| `- dog
|
`- metal
|
+- alloy
| |
| +- steel
| |
| `- bronze
|
...

Answer 2

You should use map and fold with RoseTrees, e.g.:
size (RoseNode x xs) = 1 + (sum (map size xs))
where sum is just:
sum = foldl (+) 0