Make 'String.sub' more ergonomic

Author: ssoelvsten

lib/Hash.trp

@@ -10,15 +10,15 @@ let
      *)
     fun hashString s =
         (* String hash with fast paths for small strings *)
-        let val len = strlen s
-            val radix = 127
-            fun charCodeAt i = String.subCode (s,i)
+        let val len     = String.size s
+            val radix   = 127
+            val subCode = String.subCode s
         in case len of 0 => 0
-                     | 1 => charCodeAt 0
-                     | 2 => (radix * charCodeAt 0 + charCodeAt 1) andb Number.maxInt32
+                     | 1 => subCode 0
+                     | 2 => (radix * subCode 0 + subCode 1) andb Number.maxInt32
                      | _ => let fun go idx acc =
                                     if len <= idx then acc
-                                    else go (idx + 1) ((acc * radix + charCodeAt idx) andb Number.maxInt32)
+                                    else go (idx + 1) ((acc * radix + subCode idx) andb Number.maxInt32)
                             in go 0 0
                             end
         end

lib/README.md

@@ -27,9 +27,9 @@ target of the *makefile*.
 ## Design Principles
 
 - File names are written in `CamelCase`. This makes them conform to the Standard ML Basis Library.
-- It is more important to match the function names and signatures in the Standard ML library than to
-  improve on them. For example, `String.sub` would make more sense with the type `[Char] -> Int ->
-  Char` but to match the SML library, we will stick with `[Char] * Int -> Char`.
+- While we will try to match function names in the Standard ML library, we may take the liberty to
+  improve on the function signatures. For example, the function `String.sub` uses the same name as
+  in SML but uses the signature `[Char] -> Int -> Char` rather than `[Char] * Int -> Char`.
 - Each module exports a single *record* with the same name as the file. This (1) makes it closer to
   the SML module system and (2) allows for name resolution, e.g. `HashMap.findOpt` and
   `ListPair.findOpt` can be used in the same file.

lib/String.trp

@@ -1,9 +1,12 @@
-(* TODO: Make strings merely lists of characters, similar to Haskell? Then a lot of things can be
- *       moved out of the TCB? *)
 import Number
 import List
 
-let (** The maximum length of a string.
+(* TODO: Make strings merely lists of characters, similar to Haskell and SML? Then a lot of things
+ *       can be moved out of the TCB. *)
+
+let val __substring = substring
+
+    (** The maximum length of a string.
      *
      * ECMA-262: 6.1.4 The String Type
      *
@@ -19,15 +22,15 @@ let (** The maximum length of a string.
 
     (** Returns the `i`th character of `s`, counting from zero. If `i` is out of bounds, then "" is
      *  returned. *)
-    fun sub (s,i) = substring (s, i, i+1)
+    fun sub s i = __substring (s, i, i+1)
 
     (** The character value at the given index. If `i` is out of bounds, then 0 (NULL) is
      *  returned. *)
     (* TODO (#59): Rename to `sub'` when `'` symbols are properly supported. *)
-    fun subCode (s,i) = charCodeAtWithDefault (s, i, 0)
+    fun subCode s i = charCodeAtWithDefault (s, i, 0)
 
     (** Returns the substring of `s`. Indices beyond the end of string are silently truncated. *)
-    val substring = substring
+    fun substring s i j = __substring (s, i, j)
 
     (** The concatenation of all strings in `xs`. *)
     fun concat xs = let fun f ("",x') = x'
@@ -55,7 +58,7 @@ let (** The maximum length of a string.
 
     (** Returns the list of characters in the string `s`. *)
     fun explode s = let fun go 0 acc = acc
-                          | go i acc = go (i-1) ((sub (s,i-1))::acc)
+                          | go i acc = go (i-1) ((sub s (i-1))::acc)
                     in go (size s) [] end
 
     (** Applies `f` to each element of `f` from left to right, returning the resulting string. *)

tests/lib/String.trp

@@ -11,32 +11,32 @@ let val tests = Unit.group "String" [
             ],
             let val s = "Hello"
             in Unit.group "sub" [
-                    Unit.it "is 'H' for 0" (Unit.isEq "H" (String.sub (s, 0)))
-                  , Unit.it "is 'e' for 1" (Unit.isEq "e" (String.sub (s, 1)))
-                  , Unit.it "is 'l' for 2" (Unit.isEq "l" (String.sub (s, 2)))
-                  , Unit.it "is 'l' for 3" (Unit.isEq "l" (String.sub (s, 3)))
-                  , Unit.it "is 'o' for 4" (Unit.isEq "o" (String.sub (s, 4)))
-                  , Unit.it "is ''  for 5" (Unit.isEq ""  (String.sub (s, 5)))
-                  , Unit.it "is ''  for 6" (Unit.isEq ""  (String.sub (s, 6)))
+                    Unit.it "is 'H' for 0" (Unit.isEq "H" (String.sub s 0))
+                  , Unit.it "is 'e' for 1" (Unit.isEq "e" (String.sub s 1))
+                  , Unit.it "is 'l' for 2" (Unit.isEq "l" (String.sub s 2))
+                  , Unit.it "is 'l' for 3" (Unit.isEq "l" (String.sub s 3))
+                  , Unit.it "is 'o' for 4" (Unit.isEq "o" (String.sub s 4))
+                  , Unit.it "is ''  for 5" (Unit.isEq ""  (String.sub s 5))
+                  , Unit.it "is ''  for 6" (Unit.isEq ""  (String.sub s 6))
                 ]
             end,
             let val s = "World!"
             in Unit.group "subCode" [
-                    Unit.it "is 87 for 0"  (Unit.isEq 87  (String.subCode (s,0)))
-                  , Unit.it "is 111 for 1" (Unit.isEq 111 (String.subCode (s,1)))
-                  , Unit.it "is 114 for 2" (Unit.isEq 114 (String.subCode (s,2)))
-                  , Unit.it "is 108 for 3" (Unit.isEq 108 (String.subCode (s,3)))
-                  , Unit.it "is 100 for 4" (Unit.isEq 100 (String.subCode (s,4)))
-                  , Unit.it "is 33  for 5" (Unit.isEq 33  (String.subCode (s,5)))
-                  , Unit.it "is 0   for 6" (Unit.isEq 0   (String.subCode (s,6)))
+                    Unit.it "is 87 for 0"  (Unit.isEq 87  (String.subCode s 0))
+                  , Unit.it "is 111 for 1" (Unit.isEq 111 (String.subCode s 1))
+                  , Unit.it "is 114 for 2" (Unit.isEq 114 (String.subCode s 2))
+                  , Unit.it "is 108 for 3" (Unit.isEq 108 (String.subCode s 3))
+                  , Unit.it "is 100 for 4" (Unit.isEq 100 (String.subCode s 4))
+                  , Unit.it "is 33  for 5" (Unit.isEq 33  (String.subCode s 5))
+                  , Unit.it "is 0   for 6" (Unit.isEq 0   (String.subCode s 6))
                 ]
             end,
             let val s = "Hello Troupe!"
             in Unit.group "substring" [
-                    Unit.it "is 'Hello' for 0 5"    (Unit.isEq "Hello" (String.substring (s, 0, 5)))
-                  , Unit.it "is 'Troupe' for 6 12"  (Unit.isEq "Troupe" (String.substring (s, 6, 12)))
-                  , Unit.it "is 'Troupe!' for 6 13" (Unit.isEq "Troupe!" (String.substring (s, 6, 13)))
-                  , Unit.it "is 'Troupe!' for 6 14" (Unit.isEq "Troupe!" (String.substring (s, 6, 13)))
+                    Unit.it "is 'Hello' for 0 5"    (Unit.isEq "Hello"   (String.substring s 0 5))
+                  , Unit.it "is 'Troupe' for 6 12"  (Unit.isEq "Troupe"  (String.substring s 6 12))
+                  , Unit.it "is 'Troupe!' for 6 13" (Unit.isEq "Troupe!" (String.substring s 6 13))
+                  , Unit.it "is 'Troupe!' for 6 14" (Unit.isEq "Troupe!" (String.substring s 6 14))
                 ]
             end,
             Unit.group "concat" [

tests/rt/pos/core/string_manipulations.trp

@@ -1,9 +1,7 @@
-import String
-
-let val x = String.sub ("hello", 0)
+let val x = substring ("hello", 0, 1)
     val y = "1" ^ "2"
     val s = ("Hello" raisedTo `{alice}`)  ^ ", " ^ ("World" raisedTo `{bob}`)
     val i = 3 raisedTo `{charlie}`
     val j = 5 raisedTo `{dorothy}`
-in (x,y,s, substring (s, i, j))
-end 
+in (x, y, s, substring (s, i, j))
+end