Ok, so having spent some further time on this. Methinks I have a solution below. The aha moment occurred when I fell upon the definition of foldr and then looked at the recursive functions. foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z []     = z foldr f z (x:xs) = f x (foldr f z xs) treeFold is implemented two ways, the first is as Brent advised, the second places the accumulator after the function and follows from foldr. I suspect the first approach is probably more practical because you can curry the accumulator away. The final check function verifies the equivalence of recursive and fold friendly functions. It was a cool exercise in all. Thanks Brent! (-:  AK module Test where data Tree a b = EmptyTree | Node a b [Tree a b]               deriving (Show, Read, Eq)  t =  Node "goal" 1.0 [         Node "a2" 0.5 [             Node "a3" 3.0 [                 Node "a4" 1.0 [                     Node "a5" 1.0 []                     ]                 ]             ],         Node "b2" 0.5 [             Node "b3.1" 2.0 [],             Node "b3.2" 2.0 [                 Node "b4" 10.0 []                 ]             ]      ] maximum0 [] = 0 maximum0 xs = maximum xs sumTree :: (Num b) => Tree a b -> b sumTree EmptyTree = 0 sumTree (Node _ value children) = value + sum (map sumTree children) count :: Tree a b -> Int count EmptyTree = 0 count (Node _ value children) = 1 + sum (map count children) depth :: Tree a b -> Int depth EmptyTree = 0 depth (Node _ value children) = 1 + maximum0 (map depth children) treeFold :: c -> (a -> b -> [c] -> c) -> Tree a b -> c treeFold acc f EmptyTree = acc treeFold acc f (Node name value children) = f name value (map (treeFold acc f) children) treeFold' :: (a -> b -> [c] -> c) -> c -> Tree a b -> c treeFold' f z EmptyTree = z treeFold' f z (Node name value children) = f name value (map (treeFold' f z) children) sumTree' :: String -> Double -> [Double] -> Double sumTree' name value xs = value + sum xs count' :: (Num c) => a -> b -> [c] -> c count' name value xs = 1 + sum xs depth' :: (Num c, Ord c) => a -> b -> [c] -> c depth' name value xs = 1 + maximum0 (xs) check = [ count t       == treeFold' count' 0 t              , sumTree t  == treeFold' sumTree' 0 t              , depth t       == treeFold' depth' 0 t              ]