fix compile errors in tiny_rope23.sml

tiny_rope23.sml

@@ -6,6 +6,31 @@ struct
   | N2 of t * int * t * int
   | N3 of t * int * t * int * t * int
 
+  fun foldl f state rope =
+    case rope of
+      Leaf str => f (str, state)
+    | N2 (l, _, r, _) => let val state = foldl f state l in foldl f state r end
+    | N3 (l, _, m, _, r, _) =>
+        let
+          val state = foldl f state l
+          val state = foldl f state m
+        in
+          foldl f state r
+        end
+
+  fun foldr f state rope =
+    case rope of
+      Leaf str => f (str, state)
+    | N2 (l, _, r, _) => let val state = foldr f state r in foldr f state l end
+    | N3 (l, _, m, _, r, _) =>
+        let
+          val state = foldr f state r
+          val state = foldr f state m
+        in
+          foldr f state l
+        end
+
+
   (* Type used for balancing ropes, used only internally. *)
   datatype treeI =
     TI of t * int
@@ -59,12 +84,11 @@ struct
             val leftString = sub1 ^ newStr
           in
             OF
-              (N2
+              ( Leaf leftString
-                 ( Leaf leftString
+              , String.size leftString
-                 , String.size leftString
+              , Leaf sub2
-                 , sub2
+              , String.size sub2
-                 , String.size sub2
+              )
-                 ))
           end
         else if
           ((String.size oldStr) - curIdx) + String.size newStr <= targetLength
@@ -73,13 +97,18 @@ struct
             val rightString = newStr ^ sub2
           in
             OF
-              (N2 (sub1, String.size sub1, rightString, String.size rightString))
+              ( Leaf sub1
+              , String.size sub1
+              , Leaf rightString
+              , String.size rightString
+              )
           end
         else
           let
-            val left = N2 (sub1, String.size sub1, newStr, String.size newStr)
+            val left =
+              N2 (Leaf sub1, String.size sub1, Leaf newStr, String.size newStr)
             val leftSize = String.size sub1 + String.size newStr
-            val right = N2 (sub2, String.size sub2, empty, 0)
+            val right = N2 (Leaf sub2, String.size sub2, empty, 0)
             val rightSize = String.size sub2
           in
             OF (left, leftSize, right, rightSize)
@@ -116,23 +145,23 @@ struct
          *)
         if curIdx < lm then
           (case ins (curIdx, newStr, l) of
-             TI (l, lm) => TI (N2 (l, lm, m, mm, r, rm))
+             TI (l, lm) => TI (N3 (l, lm, m, mm, r, rm), lm + mm + rm)
            | OF (l1, lm1, l2, lm2) =>
                OF (N2 (l1, lm1, l2, lm2), lm1 + lm2, N2 (m, mm, r, rm), mm + rm))
         else if curIdx < mm then
           (case ins (curIdx - lm, newStr, m) of
-             TI (m, mm) => TI (N3 (l, lm, m, mm, r, rm))
+             TI (m, mm) => TI (N3 (l, lm, m, mm, r, rm), lm + mm + rm)
            | OF (m1, mm1, m2, mm2) =>
                OF (N2 (l, lm, m1, mm1), lm + mm1, N2 (m2, mm2, r, rm), mm2 + rm))
         else
           (case ins (curIdx - (lm + mm), newStr, r) of
-             TI (r, rm) => TI (N3 (l, lm, m, mm, r, rm))
+             TI (r, rm) => TI (N3 (l, lm, m, mm, r, rm), lm + mm + rm)
            | OF (r1, rm1, r2, rm2) =>
-               OF (N2 (l, lm, m, mm), lm + mm, N2 (r1, rm1, r2, rm2)))
+               OF (N2 (l, lm, m, mm), lm + mm, N2 (r1, rm1, r2, rm2), rm1 + rm2))
     | Leaf oldStr => insLeaf (curIdx, newStr, oldStr)
 
-  fun insRoot (TI t) = t
+  fun insRoot (TI (t, _)) = t
-    | insRoot OF (l, lm, r, rm) = N2 (l, lm, r, rm)
+    | insRoot (OF (l, lm, r, rm)) = N2 (l, lm, r, rm)
 
   fun insert (idx, newStr, rope) =
     insRoot (ins (idx, newStr, rope))

utils.sml

@@ -1,4 +1,4 @@
-fun timeFun (title, f) =
+fun timeFun title f =
   let
     val title = String.concat ["Starting ", title, "..."]
     val _ = (print title)
@@ -19,20 +19,20 @@ fun runTxns arr =
   Vector.foldl
     (fn ((pos, delNum, insStr), rope) =>
        let
-         val rope = if delNum > 0 then TinyRope.delete (pos, delNum, rope) else rope
+         val rope = if delNum > 0 then Rope.delete (pos, delNum, rope) else rope
          val strSize = String.size insStr
          val rope =
-           if strSize > 0 then TinyRope.insert (pos, insStr, rope) else rope
+           if strSize > 0 then Rope.insert (pos, insStr, rope) else rope
        in
          rope
-       end) TinyRope.empty arr
+       end) Rope.empty arr
 
 fun runTxnsTime title arr =
   let val f = (fn () => runTxns arr)
   in timeFun title f
   end
 
-fun runToString rope = TinyRope.toString rope
+fun runToString rope = Rope.toString rope
 
 fun runToStringTime title rope =
   let val f = (fn () => runToString rope)
@@ -74,50 +74,28 @@ fun writeFile filename acc =
     ()
   end
 
-fun timeFun (title, f) = 
-  let
-    val title = String.concat ["Starting ", title, "..."]
-    val _ = (print title)
-    val startTime = Time.now ()
-    val startTime = Time.toNanoseconds startTime
-    val x = f ()
-    val endTime = Time.now ()
-    val endTime = Time.toNanoseconds endTime
-    val timeDiff = endTime - startTime
-    val timeDiff = LargeInt.toString timeDiff
-    val timeTook = String.concat ["took ", timeDiff, " nanoseconds\n"]
-    val _ = (print timeTook)
-  in
-    x
-  end
-
-fun appendMany (ctr, limit, rope) =
-  if ctr = limit then rope
-  else
-    let
-      val rope = TinyRope.append ("hello, world!", rope)
-    in
-      appendMany (ctr + 1, limit, rope)
-    end
-
-val closure = fn () =>
-   (appendMany (0, 2410, TinyRope.empty))
-
-fun closure2 rope = fn () =>
-  TinyRope.toString rope
-
-fun loop () = loop ()
-
 fun main () =
   let
-    val rope =
+    (* Timing benchmarks. *)
-      timeFun("tiny_rope append : ", closure)
+    val _ = runTxns1000Times (999, svelte_arr, startTime)
-    val str = timeFun ("tiny_rope toString: ", closure2 rope)
+    val _ = runTxns1000Times (999, rust_arr, startTime)
-    val str = String.concat str
+    val _ = runTxns1000Times (999, seph_arr, startTime)
-    val io = TextIO.openOut "hello.txt"
+    val _ = runTxns1000Times (999, automerge_arr, startTime)
-    val _ = TextIO.output (io, str)
+
+    (* Tests that line metadata is correct; will fail if incorrect. *)
+    val svelte = runTxns svelte_arr
+    val _ = Rope.verifyLines svelte
+
+    val rust = runTxns rust_arr
+    val _ = Rope.verifyLines rust
+
+    val seph = runTxns seph_arr
+    val _ = Rope.verifyLines seph
+
+    val automerge = runTxns automerge_arr
+    val _ = Rope.verifyLines automerge
   in
-     ()
+    ()
   end
 
 val _ = main ()