September 2017 Update

Task/Tree-traversal/APL/tree-traversal-1.apl

@@ -0,0 +1,4 @@
+preorder ← {l r←⍺ ⍵⍵ ⍵ ⋄ (⊃r)∇⍨⍣(×≢r)⊢(⊃l)∇⍨⍣(×≢l)⊢⍺ ⍺⍺ ⍵}
+inorder  ← {l r←⍺ ⍵⍵ ⍵ ⋄ (⊃r)∇⍨⍣(×≢r)⊢⍵ ⍺⍺⍨(⊃l)∇⍨⍣(×≢l)⊢⍺}
+postorder← {l r←⍺ ⍵⍵ ⍵ ⋄ ⍵ ⍺⍺⍨(⊃r)∇⍨⍣(×≢r)⊢(⊃l)∇⍨⍣(×≢l)⊢⍺}
+lvlorder ← {0=⍴⍵:⍺ ⋄ (⊃⍺⍺⍨/(⌽⍵),⊂⍺)∇⊃∘(,/)⍣2⊢⍺∘⍵⍵¨⍵}

Task/Tree-traversal/APL/tree-traversal-2.apl

@@ -0,0 +1,3 @@
+tree←1(2(4(7⍬⍬)⍬)(5⍬⍬))(3(6(8⍬⍬)(9⍬⍬))⍬)
+visit←{⍺,(×≢⍵)⍴⊃⍵}
+children←{⊂¨@(×∘≢¨)1↓⍵}

Task/Tree-traversal/AppleScript/tree-traversal-1.applescript

@@ -1,88 +0,0 @@
-on run
-    set tree to {1, {2, {4, {7}, {}}, {5}}, {3, {6, {8}, {9}}, {}}}
-
-    return {|pre-order|:¬
-        traverse("pre-order", tree), |in-order|:¬
-        traverse("in-order", tree), |post-order|:¬
-        traverse("post-order", tree), |level-order|:¬
-        traverse("level-order", tree)}
-
-end run
-
--- traverse :: String -> Tree -> [Int]
-on traverse(strOrderName, tree)
-    if strOrderName does not start with "level" then
-        set {v, l, r} to nodeParts(tree)
-
-        if l is {} then
-            set lstLeft to []
-        else
-            set lstLeft to traverse(strOrderName, l)
-        end if
-
-        if r is {} then
-            set lstRight to []
-        else
-            set lstRight to traverse(strOrderName, r)
-        end if
-
-        -- PRE-ORDER
-        if strOrderName begins with "pre" then
-            v & lstLeft & lstRight
-
-            -- IN-ORDER
-        else if strOrderName begins with "in" then
-            lstLeft & v & lstRight
-
-            -- POST-ORDER
-        else if strOrderName begins with "post" then
-            lstLeft & lstRight & v
-
-        end if
-    else
-        -- LEVEL-ORDER
-        levelOrder({tree})
-    end if
-end traverse
-
-
--- levelOrder :: [Tree] -> [Int]
-on levelOrder(lstTree)
-    if length of lstTree > 0 then
-        set {head, tail} to uncons(lstTree)
-
-        -- Take any value found in the head node
-        -- deferring any child nodes to the end of the tail
-        -- before recursing
-
-        if head is not {} then
-            set {v, l, r} to nodeParts(head)
-            v & levelOrder(tail & {l, r})
-        else
-            levelOrder(tail)
-        end if
-    else
-        {}
-    end if
-end levelOrder
-
--- nodeParts :: Tree -> (Int, Tree, Tree)
-on nodeParts(tree)
-    if class of tree is list and length of tree = 3 then
-        tree
-    else
-        {tree} & {{}, {}}
-    end if
-end nodeParts
-
-
--- GENERIC
-
--- uncons :: [a] -> Maybe (a, [a])
-on uncons(xs)
-    if length of xs > 0 then
-        {item 1 of xs, rest of xs}
-    else
-        missing value
-    end if
-end uncons

Task/Tree-traversal/AppleScript/tree-traversal-2.applescript

@@ -1,4 +0,0 @@
-{|pre-order|:{1, 2, 4, 7, 5, 3, 6, 8, 9},
-|in-order|:{7, 4, 2, 5, 1, 8, 6, 9, 3},
-|post-order|:{7, 4, 5, 2, 8, 9, 6, 3, 1},
-|level-order|:{1, 2, 3, 4, 5, 6, 7, 8, 9}}

Task/Tree-traversal/AppleScript/tree-traversal.applescript

@@ -0,0 +1,215 @@
+on run
+    set tree to {1, {2, {4, {7}, {}}, {5}}, {3, {6, {8}, {9}}, {}}}
+
+    -- asciiTree :: String
+    set asciiTree to ¬
+        unlines({¬
+            "         1", ¬
+            "        / \\", ¬
+            "       /   \\", ¬
+            "      /     \\", ¬
+            "     2       3", ¬
+            "    / \\     /", ¬
+            "   4   5   6", ¬
+            "  /       / \\", ¬
+            " 7       8   9"})
+
+    script tabulate
+        on |λ|(s, xs)
+            justifyLeft(14, space, s & ":") & unwords(xs)
+        end |λ|
+    end script
+
+    set strResult to asciiTree & linefeed & linefeed & ¬
+        unlines(zipWith(tabulate, ¬
+            ["preorder", "inorder", "postorder", "level-order"], ¬
+            ap([preorder, inorder, postorder, levelOrder], [tree])))
+
+    set the clipboard to strResult
+    return strResult
+end run
+
+-- TRAVERSAL FUNCTIONS --------------------------------------------------------
+
+-- preorder :: Tree Int -> [Int]
+on preorder(tree)
+    set {v, l, r} to nodeParts(tree)
+    if l is {} then
+        set lstLeft to []
+    else
+        set lstLeft to preorder(l)
+    end if
+
+    if r is {} then
+        set lstRight to []
+    else
+        set lstRight to preorder(r)
+    end if
+    v & lstLeft & lstRight
+end preorder
+
+-- inorder :: Tree Int -> [Int]
+on inorder(tree)
+    set {v, l, r} to nodeParts(tree)
+    if l is {} then
+        set lstLeft to []
+    else
+        set lstLeft to inorder(l)
+    end if
+
+    if r is {} then
+        set lstRight to []
+    else
+        set lstRight to inorder(r)
+    end if
+
+    lstLeft & v & lstRight
+end inorder
+
+-- postorder :: Tree Int -> [Int]
+on postorder(tree)
+    set {v, l, r} to nodeParts(tree)
+    if l is {} then
+        set lstLeft to []
+    else
+        set lstLeft to postorder(l)
+    end if
+
+    if r is {} then
+        set lstRight to []
+    else
+        set lstRight to postorder(r)
+    end if
+    lstLeft & lstRight & v
+end postorder
+
+-- levelOrder :: Tree Int -> [Int]
+on levelOrder(tree)
+    if length of tree > 0 then
+        set {head, tail} to uncons(tree)
+
+        -- Take any value found in the head node
+        -- deferring any child nodes to the end of the tail
+        -- before recursing
+
+        if head is not {} then
+            set {v, l, r} to nodeParts(head)
+            v & levelOrder(tail & {l, r})
+        else
+            levelOrder(tail)
+        end if
+    else
+        {}
+    end if
+end levelOrder
+
+-- nodeParts :: Tree -> (Int, Tree, Tree)
+on nodeParts(tree)
+    if class of tree is list and length of tree = 3 then
+        tree
+    else
+        {tree} & {{}, {}}
+    end if
+end nodeParts
+
+
+-- GENERIC FUNCTIONS ----------------------------------------------------------
+
+-- A list of functions applied to a list of arguments
+-- (<*> | ap) :: [(a -> b)] -> [a] -> [b]
+on ap(fs, xs)
+    set lngFs to length of fs
+    set lngXs to length of xs
+    set lst to {}
+    repeat with i from 1 to lngFs
+        tell mReturn(contents of item i of fs)
+            repeat with j from 1 to lngXs
+                set end of lst to |λ|(contents of (item j of xs))
+            end repeat
+        end tell
+    end repeat
+    return lst
+end ap
+
+-- intercalate :: Text -> [Text] -> Text
+on intercalate(strText, lstText)
+    set {dlm, my text item delimiters} to {my text item delimiters, strText}
+    set strJoined to lstText as text
+    set my text item delimiters to dlm
+    return strJoined
+end intercalate
+
+-- justifyLeft :: Int -> Char -> Text -> Text
+on justifyLeft(n, cFiller, strText)
+    if n > length of strText then
+        text 1 thru n of (strText & replicate(n, cFiller))
+    else
+        strText
+    end if
+end justifyLeft
+
+-- min :: Ord a => a -> a -> a
+on min(x, y)
+    if y < x then
+        y
+    else
+        x
+    end if
+end min
+
+-- Lift 2nd class handler function into 1st class script wrapper
+-- mReturn :: Handler -> Script
+on mReturn(f)
+    if class of f is script then
+        f
+    else
+        script
+            property |λ| : f
+        end script
+    end if
+end mReturn
+
+-- replicate :: Int -> a -> [a]
+on replicate(n, a)
+    set out to {}
+    if n < 1 then return out
+    set dbl to {a}
+
+    repeat while (n > 1)
+        if (n mod 2) > 0 then set out to out & dbl
+        set n to (n div 2)
+        set dbl to (dbl & dbl)
+    end repeat
+    return out & dbl
+end replicate
+
+-- uncons :: [a] -> Maybe (a, [a])
+on uncons(xs)
+    if length of xs > 0 then
+        {item 1 of xs, rest of xs}
+    else
+        missing value
+    end if
+end uncons
+
+-- unlines :: [String] -> String
+on unlines(xs)
+    intercalate(linefeed, xs)
+end unlines
+
+-- unwords :: [String] -> String
+on unwords(xs)
+    intercalate(space, xs)
+end unwords
+
+-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+on zipWith(f, xs, ys)
+    set lng to min(length of xs, length of ys)
+    set lst to {}
+    tell mReturn(f)
+        repeat with i from 1 to lng
+            set end of lst to |λ|(item i of xs, item i of ys)
+        end repeat
+        return lst
+    end tell
+end zipWith

Task/Tree-traversal/Coq/tree-traversal.coq

@@ -0,0 +1,51 @@
+Require Import Utf8.
+Require Import List.
+
+Unset Elimination Schemes.
+
+(* Rose tree, with numbers on nodes *)
+Inductive tree := Tree { value : nat ; children : list tree }.
+
+Fixpoint height (t: tree) : nat :=
+  1 + fold_left (λ n t, max n (height t)) (children t) 0.
+
+Example leaf n : tree := {| value := n ; children := nil |}.
+
+Example t2 : tree := {| value := 2 ; children := {| value := 4 ; children := leaf 7 :: nil |} :: leaf 5 :: nil |}.
+
+Example t3 : tree := {| value := 3 ; children := {| value := 6 ; children := leaf 8 :: leaf 9 :: nil |} :: nil |}.
+
+Example t9 : tree := {| value := 1 ; children := t2 :: t3 :: nil |}.
+
+Fixpoint preorder (t: tree) : list nat :=
+  let '{| value := n ; children := c |} := t in
+  n :: flat_map preorder c.
+
+Fixpoint inorder (t: tree) : list nat :=
+  let '{| value := n ; children := c |} := t in
+  match c with
+  | nil => n :: nil
+  | ℓ :: r => inorder ℓ ++ n :: flat_map inorder r
+  end.
+
+Fixpoint postorder (t: tree) : list nat :=
+  let '{| value := n ; children := c |} := t in
+  flat_map postorder c ++ n :: nil.
+
+(* Auxiliary function for levelorder, which operates on forests *)
+(* Since the recursion is tricky, it relies on a fuel parameter which obviously decreases. *)
+Fixpoint levelorder_forest (fuel: nat) (f: list tree) : list nat:=
+  match fuel with
+  | O => nil
+  | S fuel' =>
+    let '(p, f) := fold_right (λ t r, let '(x, f) := r in (value t :: x, children t ++ f) ) (nil, nil) f in
+    p ++ levelorder_forest fuel' f
+  end.
+
+Definition levelorder (t: tree) : list nat :=
+  levelorder_forest (height t) (t :: nil).
+
+Compute preorder t9.
+Compute inorder t9.
+Compute postorder t9.
+Compute levelorder t9.

Task/Tree-traversal/Haskell/tree-traversal.hs

@@ -1,45 +1,55 @@
-data Tree a = Empty
-            | Node { value :: a,
-                     left  :: Tree a,
-                     right :: Tree a }
+data Tree a
+  = Empty
+  | Node { value :: a
+         , left :: Tree a
+         , right :: Tree a}
 
 preorder, inorder, postorder, levelorder :: Tree a -> [a]
+preorder Empty = []
+preorder (Node v l r) = v : preorder l ++ preorder r
 
-preorder Empty        = []
-preorder (Node v l r) =    [v]
-                        ++ preorder l
-                        ++ preorder r
+inorder Empty = []
+inorder (Node v l r) = inorder l ++ (v : inorder r)
 
-inorder Empty        = []
-inorder (Node v l r) =    inorder l
-                       ++ [v]
-                       ++ inorder r
-
-postorder Empty        = []
-postorder (Node v l r) =    postorder l
-                         ++ postorder r
-                         ++ [v]
+postorder Empty = []
+postorder (Node v l r) = postorder l ++ postorder r ++ [v]
 
 levelorder x = loop [x]
-    where loop []                = []
-          loop (Empty      : xs) = loop xs
-          loop (Node v l r : xs) = v : loop (xs ++ [l,r])
+  where
+    loop [] = []
+    loop (Empty:xs) = loop xs
+    loop (Node v l r:xs) = v : loop (xs ++ [l, r])
 
+-- TEST --------------------------------------------------------------
 tree :: Tree Int
-tree = Node 1
-            (Node 2
-                  (Node 4
-                        (Node 7 Empty Empty)
-                        Empty)
-                  (Node 5 Empty Empty))
-            (Node 3
-                  (Node 6
-                        (Node 8 Empty Empty)
-                        (Node 9 Empty Empty))
-                  Empty)
+tree =
+  Node
+    1
+    (Node 2 (Node 4 (Node 7 Empty Empty) Empty) (Node 5 Empty Empty))
+    (Node 3 (Node 6 (Node 8 Empty Empty) (Node 9 Empty Empty)) Empty)
 
+asciiTree :: String
+asciiTree =
+  unlines
+    [ "         1"
+    , "        / \\"
+    , "       /   \\"
+    , "      /     \\"
+    , "     2       3"
+    , "    / \\     /"
+    , "   4   5   6"
+    , "  /       / \\"
+    , " 7       8   9"
+    ]
+
+-- OUTPUT --------------------------------------------------------------
 main :: IO ()
-main = do print $ preorder tree
-          print $ inorder tree
-          print $ postorder tree
-          print $ levelorder tree
+main = do
+  putStrLn asciiTree
+  mapM_ putStrLn $
+    zipWith
+      (\s xs -> justifyLeft 14 ' ' (s ++ ":") ++ unwords (show <$> xs))
+      ["preorder", "inorder", "postorder", "level-order"]
+      ([preorder, inorder, postorder, levelorder] <*> [tree])
+  where
+    justifyLeft n c s = take n (s ++ replicate n c)

Task/Tree-traversal/Java/tree-traversal.java

@@ -1,105 +1,87 @@
-import java.util.Queue;
-import java.util.LinkedList;
-public class TreeTraverse
-{
- private static class Node<T>
- {
-  public Node<T> left;
-  public Node<T> right;
-  public T data;
-  public Node(T data)
-  {
-   this.data = data;
-  }
-  public Node<T> getLeft()
-  {
-   return this.left;
-  }
-  public void setLeft(Node<T> left)
-  {
-   this.left = left;
-  }
-  public Node<T> getRight()
-  {
-   return this.right;
-  }
-  public void setRight(Node<T> right)
-  {
-   this.right = right;
-  }
- }
- public static void preorder(Node<?> n)
- {
-  if (n != null)
-  {
-   System.out.print(n.data + " ");
-   preorder(n.getLeft());
-   preorder(n.getRight());
-  }
- }
- public static void inorder(Node<?> n)
- {
-  if (n != null)
-  {
-   inorder(n.getLeft());
-   System.out.print(n.data + " ");
-   inorder(n.getRight());
-  }
- }
- public static void postorder(Node<?> n)
- {
-  if (n != null)
-  {
-   postorder(n.getLeft());
-   postorder(n.getRight());
-   System.out.print(n.data + " ");
-  }
- }
- public static void levelorder(Node<?> n)
- {
-  Queue<Node<?>> nodequeue = new LinkedList<Node<?>>();
-  if (n != null)
-   nodequeue.add(n);
-  while (!nodequeue.isEmpty())
-  {
-   Node<?> next = nodequeue.remove();
-   System.out.print(next.data + " ");
-   if (next.getLeft() != null)
-   {
-    nodequeue.add(next.getLeft());
-   }
-   if (next.getRight() != null)
-   {
-    nodequeue.add(next.getRight());
-   }
-  }
- }
- public static void main(final String[] args)
- {
-  Node<Integer> one = new Node<Integer>(1);
-  Node<Integer> two = new Node<Integer>(2);
-  Node<Integer> three = new Node<Integer>(3);
-  Node<Integer> four = new Node<Integer>(4);
-  Node<Integer> five = new Node<Integer>(5);
-  Node<Integer> six = new Node<Integer>(6);
-  Node<Integer> seven = new Node<Integer>(7);
-  Node<Integer> eight = new Node<Integer>(8);
-  Node<Integer> nine = new Node<Integer>(9);
-  one.setLeft(two);
-  one.setRight(three);
-  two.setLeft(four);
-  two.setRight(five);
-  three.setLeft(six);
-  four.setLeft(seven);
-  six.setLeft(eight);
-  six.setRight(nine);
-  preorder(one);
-  System.out.println();
-  inorder(one);
-  System.out.println();
-  postorder(one);
-  System.out.println();
-  levelorder(one);
-  System.out.println();
- }
+import java.util.*;
+
+public class TreeTraversal {
+
+        static class Node<T> {
+		T value;
+		Node<T> left;
+		Node<T> right;
+
+		Node(T value) {
+			this.value = value;
+		}
+
+		void visit() {
+			System.out.print(this.value + " ");
+		}
+	}
+
+	static enum ORDER {
+		PREORDER, INORDER, POSTORDER, LEVEL
+	}
+
+	static void traverse(Node<?> node, ORDER order) {
+		if (node == null) {
+			return;
+		}
+		switch (order) {
+		case PREORDER:
+			node.visit();
+			traverse(node.left, order);
+			traverse(node.right, order);
+			break;
+		case INORDER:
+			traverse(node.left, order);
+			node.visit();
+			traverse(node.right, order);
+			break;
+		case POSTORDER:
+			traverse(node.left, order);
+			traverse(node.right, order);
+			node.visit();
+			break;
+		case LEVEL:
+			Queue<Node<?>> queue = new LinkedList<>();
+			queue.add(node);
+			while(!queue.isEmpty()){
+				Node<?> next = queue.remove();
+				next.visit();
+				if(next.left!=null)
+					queue.add(next.left);
+				if(next.right!=null)
+					queue.add(next.right);
+			}
+		}
+	}	
+
+	public static void main(String[] args) {
+
+		Node<Integer> one = new Node<Integer>(1);
+		Node<Integer> two = new Node<Integer>(2);
+		Node<Integer> three = new Node<Integer>(3);
+		Node<Integer> four = new Node<Integer>(4);
+		Node<Integer> five = new Node<Integer>(5);
+		Node<Integer> six = new Node<Integer>(6);
+		Node<Integer> seven = new Node<Integer>(7);
+		Node<Integer> eight = new Node<Integer>(8);
+		Node<Integer> nine = new Node<Integer>(9);
+		
+		one.left = two;
+		one.right = three;
+		two.left = four;
+		two.right = five;
+		three.left = six;
+		four.left = seven;
+		six.left = eight;
+		six.right = nine;
+
+		traverse(one, ORDER.PREORDER);
+		System.out.println();
+		traverse(one, ORDER.INORDER);
+		System.out.println();
+		traverse(one, ORDER.POSTORDER);
+		System.out.println();
+		traverse(one, ORDER.LEVEL);
+		
+	}
 }

Task/Tree-traversal/JavaScript/tree-traversal-6.js

@@ -0,0 +1,99 @@
+(() => {
+    // TRAVERSALS -------------------------------------------------------------
+
+    // preorder Tree a -> [a]
+    const preorder = a => [a[v]]
+        .concat(a[l] ? preorder(a[l]) : [])
+        .concat(a[r] ? preorder(a[r]) : []);
+
+    // inorder Tree a -> [a]
+    const inorder = a =>
+        (a[l] ? inorder(a[l]) : [])
+        .concat(a[v])
+        .concat(a[r] ? inorder(a[r]) : []);
+
+    // postorder Tree a -> [a]
+    const postorder = a =>
+        (a[l] ? postorder(a[l]) : [])
+        .concat(a[r] ? postorder(a[r]) : [])
+        .concat(a[v]);
+
+    // levelorder Tree a -> [a]
+    const levelorder = a => (function go(x) {
+        return x.length ? (
+            x[0] ? (
+                [x[0][v]].concat(
+                    go(x.slice(1)
+                        .concat([x[0][l], x[0][r]])
+                    )
+                )
+            ) : go(x.slice(1))
+        ) : [];
+    })([a]);
+
+
+    // GENERIC FUNCTIONS  -----------------------------------------------------
+
+    // A list of functions applied to a list of arguments
+    // <*> :: [(a -> b)] -> [a] -> [b]
+    const ap = (fs, xs) => //
+        [].concat.apply([], fs.map(f => //
+            [].concat.apply([], xs.map(x => [f(x)]))));
+
+    // intercalate :: String -> [a] -> String
+    const intercalate = (s, xs) => xs.join(s);
+
+    // justifyLeft :: Int -> Char -> Text -> Text
+    const justifyLeft = (n, cFiller, strText) =>
+        n > strText.length ? (
+            (strText + cFiller.repeat(n))
+            .substr(0, n)
+        ) : strText;
+
+    // unlines :: [String] -> String
+    const unlines = xs => xs.join('\n');
+
+    // unwords :: [String] -> String
+    const unwords = xs => xs.join(' ');
+
+    // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+    const zipWith = (f, xs, ys) =>
+        Array.from({
+            length: Math.min(xs.length, ys.length)
+        }, (_, i) => f(xs[i], ys[i]));
+
+    // TEST -------------------------------------------------------------------
+    // asciiTree :: String
+    const asciiTree = unlines([
+        '         1',
+        '        / \\',
+        '       /   \\',
+        '      /     \\',
+        '     2       3',
+        '    / \\     /',
+        '   4   5   6',
+        '  /       / \\',
+        ' 7       8   9'
+    ]);
+
+    const [v, l, r] = [0, 1, 2],
+    tree = [1, [2, [4, [7]],
+                [5]
+            ],
+            [3, [6, [8],
+                [9]
+            ]]
+        ],
+
+        // fs :: [(Tree a -> [a])]
+        fs = [preorder, inorder, postorder, levelorder];
+
+    return asciiTree + '\n\n' +
+        intercalate('\n',
+            zipWith(
+                (f, xs) => justifyLeft(12, ' ', f.name + ':') + unwords(xs),
+                fs,
+                ap(fs, [tree])
+            )
+        );
+})();

Task/Tree-traversal/JavaScript/tree-traversal-7.js

@@ -0,0 +1,14 @@
+         1
+        / \
+       /   \
+      /     \
+     2       3
+    / \     /
+   4   5   6
+  /       / \
+ 7       8   9
+
+preorder:   1 2 4 7 5 3 6 8 9
+inorder:    7 4 2 5 1 8 6 9 3
+postorder:  7 4 5 2 8 9 6 3 1
+levelorder: 1 2 3 4 5 6 7 8 9

Task/Tree-traversal/Kotlin/tree-traversal-2.kotlin

@@ -1,27 +1,27 @@
-data class Node(val v: Int, var left: Node? = null, var right: Node? = null) {
-    override fun toString() = " $v"
-
-    fun preOrder()  { print(this); left?.preOrder(); right?.preOrder() }
-    fun inorder()   { left?.inorder(); print(this); right?.inorder() }
-    fun postOrder() { left?.postOrder(); right?.postOrder(); print(this) }
-
-    fun levelOrder() = with(mutableListOf(this)) {
-        do {
-            val node = removeAt(0)
-            print(node)
-            node.left?.let { add(it) }
-            node.right?.let { add(it) }
-        } while (any())
-    }
-
-    inline fun exec(name: String, f: (Node) -> Unit) {
-        print(name)
-        f(this)
-        println()
-    }
-}
-
 fun main(args: Array<String>) {
+    data class Node(val v: Int, var left: Node? = null, var right: Node? = null) {
+        override fun toString() = " $v"
+
+        fun preOrder()  { print(this); left?.preOrder(); right?.preOrder() }
+        fun inorder()   { left?.inorder(); print(this); right?.inorder() }
+        fun postOrder() { left?.postOrder(); right?.postOrder(); print(this) }
+
+        fun levelOrder() = with(mutableListOf(this)) {
+            do {
+                val node = removeAt(0)
+                print(node)
+                node.left?.let { add(it) }
+                node.right?.let { add(it) }
+            } while (any())
+        }
+
+        inline fun exec(name: String, f: (Node) -> Unit) {
+            print(name)
+            f(this)
+            println()
+        }
+    }
+
     val nodes = Array(10) { Node(it) }
 
     nodes[1].left = nodes[2]

Task/Tree-traversal/OoRexx/tree-traversal.rexx

@@ -0,0 +1,83 @@
+  one = .Node~new(1);
+  two = .Node~new(2);
+  three = .Node~new(3);
+  four = .Node~new(4);
+  five = .Node~new(5);
+  six = .Node~new(6);
+  seven = .Node~new(7);
+  eight = .Node~new(8);
+  nine = .Node~new(9);
+
+  one~left = two
+  one~right = three
+  two~left = four
+  two~right = five
+  three~left = six
+  four~left = seven
+  six~left = eight
+  six~right = nine
+
+  out = .array~new
+  .treetraverser~preorder(one, out);
+  say "Preorder:  " out~toString("l", ", ")
+  out~empty
+  .treetraverser~inorder(one, out);
+  say "Inorder:   " out~toString("l", ", ")
+  out~empty
+  .treetraverser~postorder(one, out);
+  say "Postorder: " out~toString("l", ", ")
+  out~empty
+  .treetraverser~levelorder(one, out);
+  say "Levelorder:" out~toString("l", ", ")
+
+
+::class node
+::method init
+  expose left right data
+  use strict arg data
+  left = .nil
+  right = .nil
+
+::attribute left
+::attribute right
+::attribute data
+
+::class treeTraverser
+::method preorder class
+  use arg node, out
+  if node \== .nil then do
+      out~append(node~data)
+      self~preorder(node~left, out)
+      self~preorder(node~right, out)
+  end
+
+::method inorder class
+  use arg node, out
+  if node \== .nil then do
+      self~inorder(node~left, out)
+      out~append(node~data)
+      self~inorder(node~right, out)
+  end
+
+::method postorder class
+  use arg node, out
+  if node \== .nil then do
+      self~postorder(node~left, out)
+      self~postorder(node~right, out)
+      out~append(node~data)
+  end
+
+::method levelorder class
+  use arg node, out
+
+  if node == .nil then return
+  nodequeue = .queue~new
+  nodequeue~queue(node)
+  loop while \nodequeue~isEmpty
+      next = nodequeue~pull
+      out~append(next~data)
+      if next~left \= .nil then
+          nodequeue~queue(next~left)
+      if next~right \= .nil then
+          nodequeue~queue(next~right)
+  end

Task/Tree-traversal/SequenceL/tree-traversal.sequencel

@@ -0,0 +1,42 @@
+main(args(2)) :=
+    "preorder: " ++ toString(preOrder(testTree)) ++
+    "\ninoder: " ++ toString(inOrder(testTree)) ++
+    "\npostorder: " ++ toString(postOrder(testTree)) ++
+    "\nlevel-order: " ++ toString(levelOrder(testTree));
+
+Node ::= (value : int, left : Node, right : Node);
+
+preOrder(n) := [n.value] ++
+               (preOrder(n.left) when isDefined(n, left) else []) ++
+               (preOrder(n.right) when isDefined(n, right) else []);
+
+inOrder(n) :=  (inOrder(n.left) when isDefined(n, left) else []) ++
+               [n.value] ++
+               (inOrder(n.right) when isDefined(n, right) else []);
+
+postOrder(n) := (postOrder(n.left) when isDefined(n, left) else []) ++
+                (postOrder(n.right) when isDefined(n, right) else []) ++
+                [n.value];
+
+levelOrder(n) := levelOrderHelper([n]);
+levelOrderHelper(ns(1)) :=
+    let
+        n := head(ns);
+    in
+        [] when size(ns) = 0 else
+        [n.value] ++ levelOrderHelper(tail(ns) ++
+        ([n.left] when isDefined(n, left) else []) ++
+        ([n.right] when isDefined(n, right) else []));
+
+testTree :=
+    (value : 1,
+     left : (value : 2,
+             left : (value : 4,
+                     left : (value : 7)),
+                     right : (value : 5)),
+             right : (value : 3,
+                      left : (value : 6,
+                              left : (value : 8),
+                              right : (value : 9))
+             )
+    );

Task/Tree-traversal/Zkl/tree-traversal-1.zkl

@@ -0,0 +1,31 @@
+class Node{ var [mixin=Node]left,right; var v;
+   fcn init(val,[Node]l=Void,[Node]r=Void) { v,left,right=vm.arglist }
+}
+
+class BTree{ var [mixin=Node] root;
+   fcn init(r){ root=r }
+   const VISIT=Void, LEFT="left", RIGHT="right";
+   fcn preOrder  { traverse(VISIT,LEFT, RIGHT) }
+   fcn inOrder   { traverse(LEFT, VISIT,RIGHT) }
+   fcn postOrder { traverse(LEFT, RIGHT,VISIT) }
+   fcn [private] traverse(order){  //--> list of Nodes
+      sink:=List();
+      fcn(sink,[Node]n,order){
+         if(n){ foreach o in (order){
+	    if(VISIT==o) sink.write(n);
+	    else self.fcn(sink,n.setVar(o),order);  // actually get var, eg n.left
+	 }}
+      }(sink,root,vm.arglist);
+      sink
+   }
+   fcn levelOrder{  // breadth first
+      sink:=List(); q:=List(root);
+      while(q){
+         n:=q.pop(0); l:=n.left; r:=n.right;
+	 sink.write(n);
+	 if(l) q.append(l);
+	 if(r) q.append(r);
+      }
+      sink
+   }
+}

Task/Tree-traversal/Zkl/tree-traversal-2.zkl

@@ -0,0 +1,11 @@
+t:=BTree(Node(1,
+	   Node(2,
+	      Node(4,Node(7)),
+	      Node(5)),
+	   Node(3,
+	      Node(6, Node(8),Node(9)))));
+
+t.preOrder()  .apply("v").println("  preorder");
+t.inOrder()   .apply("v").println("  inorder");
+t.postOrder() .apply("v").println("  postorder");
+t.levelOrder().apply("v").println("  level-order");