tree.clj

dev> (defrecord Tree [left right])
dev.Tree
dev> (defn ->list [tree]
       (letfn [(rec [acc {:keys [left right] :as t}]
                 (if (instance? Tree t)
                   (if (instance? Tree left)
                     (recur acc (->Tree (:left left) (->Tree (:right left) right)))
                     (recur (cons left acc) right))
                   (cons t acc)))]
         (reverse (rec [] tree))))
#'dev/->list
dev> (->list 3)
(3)
dev> (->list (->Tree 3 4))
(3 4)
dev> (->list (->Tree (->Tree (->Tree 2 3) 4) 5))
(2 3 4 5)

tree.hs

> data Tree a = Leaf a | Branch (Tree a) (Tree a) deriving Show
data Tree a = Leaf a | Branch (Tree a) (Tree a)
[Prelude]
> :{
Prelude| toList :: Tree a -> [a]
Prelude| toList = reverse . rec []
Prelude|   where
Prelude|     rec acc (Leaf v) = v : acc
Prelude|     rec acc (Branch (Leaf v) right) = rec (v : acc) right
Prelude|     rec acc (Branch (Branch left right) right') = rec acc (Branch left (Branch right right'))
Prelude| :}
toList :: Tree a -> [a]
[Prelude]
> toList $ Leaf 3
[3]
it :: Num a => [a]
[Prelude]
> toList $ Branch (Leaf 3) (Leaf 4)
[3,4]
it :: Num a => [a]
[Prelude]
> toList $ Branch (Branch (Branch (Leaf 2) (Leaf 3)) (Leaf 4)) (Leaf 5)
[2,3,4,5]
it :: Num a => [a]

tree2.clj

dev> (defn ->list' [tree]
       (letfn [(rec [acc {{:keys [left right]
                           :as left'} :left
                          right' :right
                          :as t}]
                 (if left
                   (recur acc (->Tree left (->Tree right right')))
                   (if left'
                     (recur (cons left' acc) right')
                     (cons t acc))))]
         (reverse (rec [] tree))))
#'dev/->list'
dev> (->list' 3)
(3)
dev> (->list' (->Tree 3 4))
(3 4)
dev> (->list' (->Tree (->Tree (->Tree 2 3) 4) 5))
(2 3 4 5)