Avoid list concat by using an accumulator

Author: Abhijit Sarkar

bintree/src/P61A.scala

@@ -10,7 +10,11 @@ import Tree.*
 
 object P61A:
   extension [A](t: Tree[A])
-    def leafList: List[A] = t match
-      case Empty                     => List.empty
-      case Node(value, Empty, Empty) => List(value)
-      case Node(_, left, right)      => left.leafList ++ right.leafList
+    def leafList: List[A] =
+      def loop(tree: Tree[A], leaves: List[A]): List[A] =
+        tree match
+          case Empty                     => leaves
+          case Node(value, Empty, Empty) => value :: leaves
+          case Node(_, left, right)      => loop(left, loop(right, leaves))
+
+      loop(t, Nil)

bintree/src/P62.scala

@@ -11,7 +11,11 @@ import Tree.*
 
 object P62:
   extension [A](t: Tree[A])
-    def internalList: List[A] = t match
-      case Empty                    => List.empty
-      case Node(_, Empty, Empty)    => List.empty
-      case Node(value, left, right) => left.internalList ++ (value :: right.internalList)
+    def internalList: List[A] =
+      def loop(tree: Tree[A], leaves: List[A]): List[A] =
+        tree match
+          case Empty                    => leaves
+          case Node(_, Empty, Empty)    => leaves
+          case Node(value, left, right) => loop(left, value :: loop(right, leaves))
+
+      loop(t, Nil)

bintree/src/P62B.scala

@@ -12,7 +12,11 @@ import Tree.*
 
 object P62B:
   extension [A](t: Tree[A])
-    def atLevel(level: Int, tree: Tree[A] = t, currLevel: Int = 1): List[A] = tree match
-      case Node(value, _, _) if currLevel == level => List(value)
-      case Node(_, left, right) => atLevel(level, left, currLevel + 1) ++ atLevel(level, right, currLevel + 1)
-      case Empty                => List.empty
+    def atLevel(level: Int): List[A] =
+      def loop(tree: Tree[A], currLevel: Int, acc: List[A]): List[A] =
+        tree match
+          case Node(value, _, _) if currLevel == level => value :: acc
+          case Node(_, left, right)                    => loop(left, currLevel + 1, loop(right, currLevel + 1, acc))
+          case Empty                                   => acc
+
+      loop(t, 1, Nil)

bintree/src/P68.scala

@@ -35,23 +35,31 @@ is yet to be processed.
 object P68:
   extension [A](t: Tree[A])
     def preorder: List[Char] =
-      t match
-        case Empty                    => Nil
-        case Node(value, left, right) => (value.toString().head :: left.preorder) ++ right.preorder
+      def loop(tree: Tree[A], acc: List[Char]): List[Char] =
+        tree match
+          case Empty                    => acc
+          case Node(value, left, right) => value.toString().head :: loop(left, loop(right, acc))
+
+      loop(t, Nil)
 
     def inorder: List[Char] =
-      t match
-        case Empty                    => Nil
-        case Node(value, left, right) => left.inorder ++ (value.toString().head :: right.inorder)
+      def loop(tree: Tree[A], acc: List[Char]): List[Char] =
+        tree match
+          case Empty                    => acc
+          case Node(value, left, right) => loop(left, value.toString().head :: loop(right, acc))
+
+      loop(t, Nil)
 
   def preInTree(pre: List[Char], in: List[Char]): Tree[Char] =
     def loop(pre: List[Char], in: List[Char]): (Tree[Char], List[Char]) =
-      pre match
-        case head :: tail if in.size == 1 => (singleton(head), tail)
-        case head :: tail if in.size > 1 =>
-          val (leftIn, rightIn) = in.span(_ != head)
-          val (left, xs)        = loop(tail, leftIn)
-          val (right, ys)       = loop(xs, rightIn.tail)
+      (pre, in) match
+        case (head :: tail, _ :: Nil)    => (singleton(head), tail)
+        case (head :: tail, _ :: _ :: _) =>
+          // unchecked needed since the pattern match in val is not exhaustive and may fail.
+          // "pattern's type is more specialized than the right hand side expression's type"
+          val (leftIn, (_ :: rightIn)) = (in.span(_ != head): @unchecked)
+          val (left, xs)               = loop(tail, leftIn)
+          val (right, ys)              = loop(xs, rightIn)
           (Node(head, left, right), ys)
         case _ => (Empty, pre)
 

bintree/src/P69.scala

@@ -19,12 +19,12 @@ import Tree.*
 object P69:
   extension [A](t: Tree[A])
     def toDotstring: String =
-      def loop(tree: Tree[A]): DList[Char] =
+      def loop(tree: Tree[A], acc: List[Char]): List[Char] =
         tree match
-          case Empty                    => DList.singleton('.')
-          case Node(value, left, right) => DList.singleton(value.toString().head) ++ loop(left) ++ loop(right)
+          case Empty                    => '.' :: acc
+          case Node(value, left, right) => value.toString().head :: loop(left, loop(right, acc))
 
-      loop(t).toList.mkString
+      loop(t, Nil).mkString
 
   def fromDotstring(s: String): Tree[Char] =
     def loop(t: String): (Tree[Char], String) =