replace @immut/list with @list

myfreess · myfreess · commit 37894783425a · 2025-07-16T10:53:04.000+08:00
diff --git a/src/falsify/driver.mbt b/src/falsify/driver.mbt
@@ -51,7 +51,7 @@ fn[T] append_success(
   {
     ..acc,
     rng,
-    success: Cons(success, acc.success),
+    success: acc.success.add(success),
     todo: acc.todo - 1,
     discarded: 0,
   }
@@ -61,7 +61,7 @@ fn[T] append_success(
 pub fn[T] init_state(opt : Config) -> DriverState[T] {
   {
     rng: opt.replay.unwrap_or(@quickcheck/splitmix.new()),
-    success: Nil,
+    success: @list.empty(),
     todo: opt.tests,
     discarded: 0,
     total_discard: 0,
@@ -101,7 +101,7 @@ pub fn[T, E] falsify(
           let success : Success[T] = { result: x, seed: now.clone(), run }
           if run.deterministic {
             match (acc.success, acc.total_discard) {
-              (Nil, 0) => (Cons(success, Nil), 0, None)
+              (Empty, 0) => (@list.singleton(success), 0, None)
               _ => abort("impossible")
             }
           } else {
diff --git a/src/falsify/falsify.mbti b/src/falsify/falsify.mbti
@@ -1,7 +1,7 @@
 package "moonbitlang/quickcheck/falsify"
 
 import(
-  "moonbitlang/core/immut/list"
+  "moonbitlang/core/list"
   "moonbitlang/core/quickcheck/splitmix"
 )
 
diff --git a/src/falsify/property.mbt b/src/falsify/property.mbt
@@ -1,5 +1,5 @@
 ///|
-pub typealias @immut/list.T as List
+pub typealias @list.T as List
 
 ///|
 struct TestRun {
@@ -10,7 +10,7 @@ struct TestRun {
 
 ///|
 pub fn init_test_run() -> TestRun {
-  { log: Nil, deterministic: true, labels: @immut/hashmap.new() }
+  { log: @list.empty(), deterministic: true, labels: @immut/hashmap.new() }
 }
 
 ///|
@@ -55,7 +55,7 @@ pub fn[T, E] discard() -> Property[T, E] {
 ///|
 pub fn info(msg : String) -> Property[Unit, String] {
   mk_property(fn(run) {
-    pure((TestPassed(()), { ..run, log: Cons(msg, run.log) }))
+    pure((TestPassed(()), { ..run, log: run.log.add(msg) }))
   })
 }
 
@@ -87,7 +87,7 @@ pub fn[T, E] gen(f : (T) -> String?, g : Gen[T]) -> Property[T, E] {
     fn(x) {
       match f(x) {
         None => (TestPassed(x), { ..run, deterministic: false })
-        Some(msg) => (TestPassed(x), { ..run, log: Cons(msg, run.log) })
+        Some(msg) => (TestPassed(x), { ..run, log: run.log.add(msg) })
       }
     }
   }
diff --git a/src/feat/enumerable.mbt b/src/feat/enumerable.mbt
@@ -37,11 +37,11 @@ pub impl Enumerable for UInt64 with enumerate() {
 }
 
 ///|
-pub impl[E : Enumerable] Enumerable for @immut/list.T[E] with enumerate() {
+pub impl[E : Enumerable] Enumerable for @list.T[E] with enumerate() {
   consts(
-    @immut/list.of([
-      singleton(Nil),
-      unary(@utils.pair_function(@immut/list.Cons(_, _))),
+    @list.of([
+      singleton(@list.empty()),
+      unary(@utils.pair_function(fn(e : E, lst : @list.T[E]) { lst.add(e) })),
     ]),
   )
 }
diff --git a/src/feat/enumerate.mbt b/src/feat/enumerate.mbt
@@ -75,7 +75,7 @@ pub fn[T, U] app(f : Enumerate[(T) -> U], e : Enumerate[T]) -> Enumerate[U] {
 }
 
 ///|
-pub fn[T] consts(ls : @immut/list.T[Enumerate[T]]) -> Enumerate[T] {
+pub fn[T] consts(ls : @list.T[Enumerate[T]]) -> Enumerate[T] {
   pay(fn() { ls.fold(union, init=empty()) })
 }
 
diff --git a/src/feat/feat.mbti b/src/feat/feat.mbti
@@ -2,7 +2,7 @@ package "moonbitlang/quickcheck/feat"
 
 import(
   "moonbitlang/core/bigint"
-  "moonbitlang/core/immut/list"
+  "moonbitlang/core/list"
   "moonbitlang/quickcheck/lazy"
 )
 
diff --git a/src/feat/finite.mbt b/src/feat/finite.mbt
@@ -107,12 +107,12 @@ pub fn[M] fin_mconcat(val : LazyList[Finite[M]]) -> Finite[M] {
 }
 
 ///|
-pub fn[T] to_array(self : Finite[T]) -> (BigInt, @immut/list.T[T]) {
+pub fn[T] to_array(self : Finite[T]) -> (BigInt, @list.T[T]) {
   (
     self.fCard,
-    loop (self.fCard, @immut/list.Nil) {
+    loop (self.fCard, @list.empty()) {
       (0, acc) => acc
-      (n, acc) => continue (n - 1, Cons((self.fIndex)(n), acc))
+      (n, acc) => continue (n - 1, acc.add((self.fIndex)(n)))
     },
   )
 }
diff --git a/src/gen.mbt b/src/gen.mbt
@@ -268,7 +268,7 @@ pub fn[T] frequency(arr : Array[(Int, Gen[T])]) -> Gen[T] {
 
 ///| Chooses one of the given generators, with a weighted random distribution.
 /// @alert unsafe "Panics if the list is empty or total weight is less than one"
-pub fn[T] frequency_list(lst : @immut/list.T[(Int, T)]) -> Gen[T] {
+pub fn[T] frequency_list(lst : @list.T[(Int, T)]) -> Gen[T] {
   lst
   .to_array()
   .map(fn(x) {
@@ -279,10 +279,10 @@ pub fn[T] frequency_list(lst : @immut/list.T[(Int, T)]) -> Gen[T] {
 }
 
 ///| Generate a list of elements from individual generators
-pub fn[T] flatten_list(lst : @immut/list.T[Gen[T]]) -> Gen[@immut/list.T[T]] {
+pub fn[T] flatten_list(lst : @list.T[Gen[T]]) -> Gen[@list.T[T]] {
   match lst {
-    Nil => pure(Nil)
-    Cons(x, xs) => liftA2(@immut/list.T::Cons(_, _), x, flatten_list(xs))
+    Empty => pure(@list.empty())
+    More(x, tail=xs) => liftA2(@list.T::add, flatten_list(xs), x)
   }
 }
 
@@ -315,7 +315,7 @@ pub fn[T] one_of(arr : Array[Gen[T]]) -> Gen[T] {
 
 ///| Randomly uses one of the given generators in list
 /// @alert unsafe "Panics if the list is empty"
-pub fn[T] one_of_list(lst : @immut/list.T[T]) -> Gen[T] {
+pub fn[T] one_of_list(lst : @list.T[T]) -> Gen[T] {
   int_bound(lst.length()).fmap(fn(x) { lst.unsafe_nth(x) })
 }
 
@@ -400,23 +400,20 @@ pub fn char_range(lo : Char, hi : Char) -> Gen[Char] {
 }
 
 ///|
-pub fn[T] list_with_size(size : Int, gen : Gen[T]) -> Gen[@immut/list.T[T]] {
-  loop (size, pure(@immut/list.Nil)) {
+pub fn[T] list_with_size(size : Int, gen : Gen[T]) -> Gen[@list.T[T]] {
+  loop (size, pure(@list.empty())) {
     (n, acc) =>
       if n <= 0 {
         break acc
       } else {
-        continue (n - 1, liftA2(@immut/list.T::Cons(_, _), gen, acc))
+        continue (n - 1, liftA2(@list.T::add, acc, gen))
       }
   }
 }
 
 ///|
-pub fn[T : Compare] sorted_list(
-  size : Int,
-  gen : Gen[T]
-) -> Gen[@immut/list.T[T]] {
-  list_with_size(size, gen).fmap(@immut/list.T::sort)
+pub fn[T : Compare] sorted_list(size : Int, gen : Gen[T]) -> Gen[@list.T[T]] {
+  list_with_size(size, gen).fmap(@list.T::sort)
 }
 
 ///|
diff --git a/src/internal_shrinking/internal_shrinking.mbti b/src/internal_shrinking/internal_shrinking.mbti
@@ -1,7 +1,7 @@
 package "moonbitlang/quickcheck/internal_shrinking"
 
 import(
-  "moonbitlang/core/immut/list"
+  "moonbitlang/core/list"
 )
 
 // Values
diff --git a/src/internal_shrinking/shrink_tree.mbt b/src/internal_shrinking/shrink_tree.mbt
@@ -10,34 +10,32 @@ pub impl[T : Show] Show for ShrinkTree[T] with output(self, logger) {
 }
 
 ///|
-pub fn[T : Show] draw(
-  self : ShrinkTree[T],
-  depth : Int
-) -> @immut/list.T[String] {
+pub fn[T : Show] draw(self : ShrinkTree[T], depth : Int) -> @list.T[String] {
   if depth == 0 {
-    return Cons("limit reach", Nil)
+    return @list.singleton("limit reach")
   }
-  fn shift(first : String, other : String, x : @immut/list.T[String]) {
+  fn shift(first : String, other : String, x : @list.T[String]) {
     @lazy.zip_lazy_normal(
       String::op_add,
       @lazy.Cons(first, @lazy.LazyRef::from_value(@lazy.repeat(other))),
       x,
     )
   }
 
-  fn draw_sub(l : @immut/list.T[ShrinkTree[T]]) {
+  fn draw_sub(l : @list.T[ShrinkTree[T]]) {
     match l {
-      @immut/list.Nil => @immut/list.Nil
-      Cons(t, Nil) => Cons("│", shift("└─ ", "   ", t.draw(depth - 1)))
-      Cons(t, ts) =>
-        @immut/list.T::concat(
-          Cons("│", shift("├─ ", "│  ", t.draw(depth - 1))),
+      Empty => @list.empty()
+      More(t, tail=Empty) =>
+        shift("└─ ", "   ", t.draw(depth - 1)).add("│")
+      More(t, tail=ts) =>
+        @list.T::concat(
+          shift("├─ ", "│  ", t.draw(depth - 1)).add("│"),
           draw_sub(ts),
         )
     }
   }
 
-  Cons(self.leaf.to_string(), draw_sub(@immut/list.from_iter(self.branch)))
+  draw_sub(@list.from_iter(self.branch)).add(self.leaf.to_string())
 }
 
 ///|
diff --git a/src/lazy/lazy.mbti b/src/lazy/lazy.mbti
@@ -1,7 +1,7 @@
 package "moonbitlang/quickcheck/lazy"
 
 import(
-  "moonbitlang/core/immut/list"
+  "moonbitlang/core/list"
 )
 
 // Values
diff --git a/src/lazy/lazy_list.mbt b/src/lazy/lazy_list.mbt
@@ -39,10 +39,10 @@ pub fn[T] index(self : LazyList[T], i : Int) -> T {
 }
 
 ///|
-pub fn[T] to_lazy(ls : @immut/list.T[T]) -> LazyList[T] {
+pub fn[T] to_lazy(ls : @list.T[T]) -> LazyList[T] {
   match ls {
-    Nil => Nil
-    Cons(x, xs) => Cons(x, LazyRef::from_value(to_lazy(xs)))
+    Empty => Nil
+    More(x, tail=xs) => Cons(x, LazyRef::from_value(to_lazy(xs)))
   }
 }
 
@@ -220,12 +220,12 @@ pub fn[X : Add] infinite_stream(start : X, step : X) -> LazyList[X] {
 pub fn[A, B, C] zip_lazy_normal(
   f : (A, B) -> C,
   xs : LazyList[A],
-  ys : @immut/list.T[B]
-) -> @immut/list.T[C] {
+  ys : @list.T[B]
+) -> @list.T[C] {
   match (xs, ys) {
-    (Cons(x, xs), Cons(y, ys)) =>
-      Cons(f(x, y), zip_lazy_normal(f, xs.force(), ys))
-    (_, _) => Nil
+    (Cons(x, xs), More(y, tail=ys)) =>
+      zip_lazy_normal(f, xs.force(), ys).add(f(x, y))
+    (_, _) => @list.empty()
   }
 }
 
@@ -257,9 +257,9 @@ pub fn[T] unfold(
 }
 
 ///|
-pub fn[T] from_list(ls : @immut/list.T[T]) -> LazyList[T] {
+pub fn[T] from_list(ls : @list.T[T]) -> LazyList[T] {
   match ls {
-    Nil => Nil
-    Cons(x, xs) => Cons(x, LazyRef::from_value(from_list(xs)))
+    Empty => Nil
+    More(x, tail=xs) => Cons(x, LazyRef::from_value(from_list(xs)))
   }
 }
diff --git a/src/quickcheck.mbti b/src/quickcheck.mbti
@@ -3,7 +3,7 @@ package "moonbitlang/quickcheck"
 import(
   "moonbitlang/core/bigint"
   "moonbitlang/core/buffer"
-  "moonbitlang/core/immut/list"
+  "moonbitlang/core/list"
   "moonbitlang/core/quickcheck/splitmix"
   "moonbitlang/quickcheck/feat"
   "moonbitlang/quickcheck/rose"
diff --git a/src/result.mbt b/src/result.mbt
@@ -76,11 +76,11 @@ impl Default for SingleResult with default() {
     maybe_discarded_ratio: None,
     maybe_max_shrinks: None,
     maybe_max_test_size: None,
-    labels: Nil,
-    classes: Nil,
-    tables: Nil,
-    test_case: Nil,
+    labels: @list.empty(),
+    classes: @list.empty(),
+    tables: @list.empty(),
+    test_case: @list.empty(),
     error: InternalError("none"),
-    callbacks: Nil,
+    callbacks: @list.empty(),
   }
 }
diff --git a/src/shrink.mbt b/src/shrink.mbt
@@ -241,15 +241,15 @@ test "shrink 6-tuple" {
 }
 
 ///|
-pub impl[T : Shrink] Shrink for @immut/list.T[T] with shrink(xs) {
+pub impl[T : Shrink] Shrink for @list.T[T] with shrink(xs) {
   let n = xs.length()
-  fn shr_sub_terms(lst : @immut/list.T[T]) {
+  fn shr_sub_terms(lst : @list.T[T]) {
     match lst {
-      Nil => Iter::empty()
-      Cons(x, xs) =>
+      Empty => Iter::empty()
+      More(x, tail=xs) =>
         T::shrink(x)
-        .map(fn(x_) { @immut/list.Cons(x_, xs) })
-        .concat(shr_sub_terms(xs).map(fn(xs_) { Cons(x, xs_) }))
+        .map(fn(x_) { xs.add(x_) })
+        .concat(shr_sub_terms(xs).map(fn(xs_) { xs_.add(x) }))
     }
   }
 
@@ -262,7 +262,7 @@ pub impl[T : Shrink] Shrink for @immut/list.T[T] with shrink(xs) {
 
 ///|
 test "shrink int list" {
-  let il : @immut/list.T[Int] = @immut/list.of([1, 2, 3, 4, 5, 6])
+  let il : @list.T[Int] = @list.of([1, 2, 3, 4, 5, 6])
   let s = Shrink::shrink(il)
   inspect(
     s,
diff --git a/src/state.mbt b/src/state.mbt
@@ -1,5 +1,5 @@
 ///|
-typealias @immut/list.T as List
+typealias @list.T as List
 
 ///|
 struct Printer {
@@ -224,17 +224,17 @@ priv type ListCompare[T] List[T] derive(Eq, Show)
 ///|
 impl[T : Compare] Compare for ListCompare[T] with compare(self, other) {
   match (self.inner(), other.inner()) {
-    (Cons(x, xs), Cons(y, ys)) => {
+    (More(x, tail=xs), More(y, tail=ys)) => {
       let res = T::compare(x, y)
       if res == 0 {
         Compare::compare(ListCompare(xs), ListCompare(ys))
       } else {
         res
       }
     }
-    (Cons(_), Nil) => 1
-    (Nil, Cons(_)) => -1
-    (Nil, Nil) => 0
+    (More(_), Empty) => 1
+    (Empty, More(_)) => -1
+    (Empty, Empty) => 0
   }
 }
 
diff --git a/src/testable.mbt b/src/testable.mbt
diff --git a/src/testing/axiom.mbt b/src/testing/axiom.mbt
diff --git a/src/testing/driver.mbt b/src/testing/driver.mbt
diff --git a/src/testing/gen.mbt b/src/testing/gen.mbt
diff --git a/src/utils/common.mbt b/src/utils/common.mbt
diff --git a/src/utils/utils.mbti b/src/utils/utils.mbti

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`package "moonbitlang/quickcheck/falsify"`
`2`	`2`
`3`	`3`	`import(`
`4`		`- "moonbitlang/core/immut/list"`
	`4`	`+ "moonbitlang/core/list"`
`5`	`5`	`"moonbitlang/core/quickcheck/splitmix"`
`6`	`6`	`)`
`7`	`7`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`///\|`
`2`		`-pub typealias @immut/list.T as List`
	`2`	`+pub typealias @list.T as List`
`3`	`3`
`4`	`4`	`///\|`
`5`	`5`	`struct TestRun {`
`@@ -10,7 +10,7 @@ struct TestRun {`
`10`	`10`
`11`	`11`	`///\|`
`12`	`12`	`pub fn init_test_run() -> TestRun {`
`13`		`- { log: Nil, deterministic: true, labels: @immut/hashmap.new() }`
	`13`	`+ { log: @list.empty(), deterministic: true, labels: @immut/hashmap.new() }`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`///\|`
`@@ -55,7 +55,7 @@ pub fn[T, E] discard() -> Property[T, E] {`
`55`	`55`	`///\|`
`56`	`56`	`pub fn info(msg : String) -> Property[Unit, String] {`
`57`	`57`	`mk_property(fn(run) {`
`58`		`- pure((TestPassed(()), { ..run, log: Cons(msg, run.log) }))`
	`58`	`+ pure((TestPassed(()), { ..run, log: run.log.add(msg) }))`
`59`	`59`	`})`
`60`	`60`	`}`
`61`	`61`
`@@ -87,7 +87,7 @@ pub fn[T, E] gen(f : (T) -> String?, g : Gen[T]) -> Property[T, E] {`
`87`	`87`	`fn(x) {`
`88`	`88`	`match f(x) {`
`89`	`89`	`None => (TestPassed(x), { ..run, deterministic: false })`
`90`		`- Some(msg) => (TestPassed(x), { ..run, log: Cons(msg, run.log) })`
	`90`	`+ Some(msg) => (TestPassed(x), { ..run, log: run.log.add(msg) })`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,11 +37,11 @@ pub impl Enumerable for UInt64 with enumerate() {`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`///\|`
`40`		`-pub impl[E : Enumerable] Enumerable for @immut/list.T[E] with enumerate() {`
	`40`	`+pub impl[E : Enumerable] Enumerable for @list.T[E] with enumerate() {`
`41`	`41`	`consts(`
`42`		`- @immut/list.of([`
`43`		`- singleton(Nil),`
`44`		`- unary(@utils.pair_function(@immut/list.Cons(_, _))),`
	`42`	`+ @list.of([`
	`43`	`+ singleton(@list.empty()),`
	`44`	`+ unary(@utils.pair_function(fn(e : E, lst : @list.T[E]) { lst.add(e) })),`
`45`	`45`	`]),`
`46`	`46`	`)`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ pub fn[T, U] app(f : Enumerate[(T) -> U], e : Enumerate[T]) -> Enumerate[U] {`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`///\|`
`78`		`-pub fn[T] consts(ls : @immut/list.T[Enumerate[T]]) -> Enumerate[T] {`
	`78`	`+pub fn[T] consts(ls : @list.T[Enumerate[T]]) -> Enumerate[T] {`
`79`	`79`	`pay(fn() { ls.fold(union, init=empty()) })`
`80`	`80`	`}`
`81`	`81`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ package "moonbitlang/quickcheck/feat"`
`2`	`2`
`3`	`3`	`import(`
`4`	`4`	`"moonbitlang/core/bigint"`
`5`		`- "moonbitlang/core/immut/list"`
	`5`	`+ "moonbitlang/core/list"`
`6`	`6`	`"moonbitlang/quickcheck/lazy"`
`7`	`7`	`)`
`8`	`8`
Original file line number	Diff line number	Diff line change
`@@ -107,12 +107,12 @@ pub fn[M] fin_mconcat(val : LazyList[Finite[M]]) -> Finite[M] {`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`///\|`
`110`		`-pub fn[T] to_array(self : Finite[T]) -> (BigInt, @immut/list.T[T]) {`
	`110`	`+pub fn[T] to_array(self : Finite[T]) -> (BigInt, @list.T[T]) {`
`111`	`111`	`(`
`112`	`112`	`self.fCard,`
`113`		`- loop (self.fCard, @immut/list.Nil) {`
	`113`	`+ loop (self.fCard, @list.empty()) {`
`114`	`114`	`(0, acc) => acc`
`115`		`- (n, acc) => continue (n - 1, Cons((self.fIndex)(n), acc))`
	`115`	`+ (n, acc) => continue (n - 1, acc.add((self.fIndex)(n)))`
`116`	`116`	`},`
`117`	`117`	`)`
`118`	`118`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`package "moonbitlang/quickcheck/internal_shrinking"`
`2`	`2`
`3`	`3`	`import(`
`4`		`- "moonbitlang/core/immut/list"`
	`4`	`+ "moonbitlang/core/list"`
`5`	`5`	`)`
`6`	`6`
`7`	`7`	`// Values`
Original file line number	Diff line number	Diff line change
`@@ -10,34 +10,32 @@ pub impl[T : Show] Show for ShrinkTree[T] with output(self, logger) {`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`///\|`
`13`		`-pub fn[T : Show] draw(`
`14`		`- self : ShrinkTree[T],`
`15`		`- depth : Int`
`16`		`-) -> @immut/list.T[String] {`
	`13`	`+pub fn[T : Show] draw(self : ShrinkTree[T], depth : Int) -> @list.T[String] {`
`17`	`14`	`if depth == 0 {`
`18`		`- return Cons("limit reach", Nil)`
	`15`	`+ return @list.singleton("limit reach")`
`19`	`16`	`}`
`20`		`- fn shift(first : String, other : String, x : @immut/list.T[String]) {`
	`17`	`+ fn shift(first : String, other : String, x : @list.T[String]) {`
`21`	`18`	`@lazy.zip_lazy_normal(`
`22`	`19`	`String::op_add,`
`23`	`20`	`@lazy.Cons(first, @lazy.LazyRef::from_value(@lazy.repeat(other))),`
`24`	`21`	`x,`
`25`	`22`	`)`
`26`	`23`	`}`
`27`	`24`
`28`		`- fn draw_sub(l : @immut/list.T[ShrinkTree[T]]) {`
	`25`	`+ fn draw_sub(l : @list.T[ShrinkTree[T]]) {`
`29`	`26`	`match l {`
`30`		`- @immut/list.Nil => @immut/list.Nil`
`31`		`- Cons(t, Nil) => Cons("│", shift("└─ ", " ", t.draw(depth - 1)))`
`32`		`- Cons(t, ts) =>`
`33`		`- @immut/list.T::concat(`
`34`		`- Cons("│", shift("├─ ", "│ ", t.draw(depth - 1))),`
	`27`	`+ Empty => @list.empty()`
	`28`	`+ More(t, tail=Empty) =>`
	`29`	`+ shift("└─ ", " ", t.draw(depth - 1)).add("│")`
	`30`	`+ More(t, tail=ts) =>`
	`31`	`+ @list.T::concat(`
	`32`	`+ shift("├─ ", "│ ", t.draw(depth - 1)).add("│"),`
`35`	`33`	`draw_sub(ts),`
`36`	`34`	`)`
`37`	`35`	`}`
`38`	`36`	`}`
`39`	`37`
`40`		`- Cons(self.leaf.to_string(), draw_sub(@immut/list.from_iter(self.branch)))`
	`38`	`+ draw_sub(@list.from_iter(self.branch)).add(self.leaf.to_string())`
`41`	`39`	`}`
`42`	`40`
`43`	`41`	`///\|`