Rename WrappedMap to MutMap and use functions rather than methods

Author: LPTK

hkmc2/shared/src/test/mlscript-compile/MutMap.mls

@@ -0,0 +1,47 @@
+import "./Option.mls"
+import "./Predef.mls"
+
+open Predef
+open Option { Some, None }
+
+
+module MutMap with ...
+
+class MutMap(val underlying) with
+  
+  set this.(Symbol.iterator) =
+    () => underlying.(Symbol.iterator)()
+
+fun get(key)(m) =
+  if m.underlying.has(key)
+  then Some of m.underlying.get(key)
+  else None
+
+fun insert(key, value)(m) =
+  m.underlying.set(key, value)
+  ()
+
+fun updateWith(key)(op)(m) =
+  if op(m |> get(key)) is
+    Some(value) then m.underlying.set(key, value)
+    None then m.underlying.delete(key)
+
+fun keysIterator(m) = m.underlying.keys()
+
+fun valuesIterator(m) = m.underlying.values()
+
+fun values(m) = Array.from of m.underlying.values()
+
+fun toMap(entries) =
+  let
+    m = empty
+    i = 0
+    length = entries.length
+  while i < length do
+    m |> insert of ...entries.at(i)
+    set i += 1
+  m
+
+fun empty = new MutMap(new Map())
+
+

hkmc2/shared/src/test/mlscript-compile/Predef.mjs

@@ -35,38 +35,49 @@ let Predef1;
   static pipeFrom(f2, x3) {
     return runtime.safeCall(f2(x3))
   } 
-  static tap(x4, f3) {
+  static pipeIntoHi(x4, f3) {
+    return runtime.safeCall(f3(x4))
+  } 
+  static pipeFromHi(f4, x5) {
+    return runtime.safeCall(f4(x5))
+  } 
+  static tap(x6, f5) {
     let tmp;
-    tmp = runtime.safeCall(f3(x4));
-    return (tmp , x4)
+    tmp = runtime.safeCall(f5(x6));
+    return (tmp , x6)
   } 
-  static pat(f4, x5) {
+  static pat(f6, x7) {
     let tmp;
-    tmp = runtime.safeCall(f4(x5));
-    return (tmp , x5)
+    tmp = runtime.safeCall(f6(x7));
+    return (tmp , x7)
   } 
-  static andThen(f5, g) {
-    return (x6) => {
+  static andThen(f7, g) {
+    return (x8) => {
       let tmp;
-      tmp = runtime.safeCall(f5(x6));
+      tmp = runtime.safeCall(f7(x8));
       return runtime.safeCall(g(tmp))
     }
   } 
-  static compose(f6, g1) {
-    return (x6) => {
+  static compose(f8, g1) {
+    return (x8) => {
       let tmp;
-      tmp = runtime.safeCall(g1(x6));
-      return runtime.safeCall(f6(tmp))
+      tmp = runtime.safeCall(g1(x8));
+      return runtime.safeCall(f8(tmp))
+    }
+  } 
+  static passTo(receiver, f9) {
+    return (...args1) => {
+      return runtime.safeCall(f9(receiver, ...args1))
     }
   } 
-  static passTo(receiver, f7) {
+  static passToLo(receiver1, f10) {
     return (...args1) => {
-      return runtime.safeCall(f7(receiver, ...args1))
+      return runtime.safeCall(f10(receiver1, ...args1))
     }
   } 
-  static call(receiver1, f8) {
+  static call(receiver2, f11) {
     return (...args1) => {
-      return f8.call(receiver1, ...args1)
+      return f11.call(receiver2, ...args1)
     }
   } 
   static print(...xs) {
@@ -93,7 +104,7 @@ let Predef1;
   static tuple(...xs1) {
     return xs1
   } 
-  static foldr(f9) {
+  static foldr(f12) {
     return (first, ...rest) => {
       let len, i, init, scrut, scrut1, tmp, tmp1, tmp2, tmp3, tmp4, tmp5;
       len = rest.length;
@@ -111,7 +122,7 @@ let Predef1;
             tmp2 = i - 1;
             i = tmp2;
             tmp3 = runtime.safeCall(rest.at(i));
-            tmp4 = runtime.safeCall(f9(tmp3, init));
+            tmp4 = runtime.safeCall(f12(tmp3, init));
             init = tmp4;
             tmp5 = runtime.Unit;
             continue tmp6;
@@ -120,21 +131,21 @@ let Predef1;
           }
           break;
         }
-        return runtime.safeCall(f9(first, init))
+        return runtime.safeCall(f12(first, init))
       }
     }
   } 
   static mkStr(...xs2) {
     let tmp, tmp1, lambda;
-    lambda = (undefined, function (acc, x6) {
+    lambda = (undefined, function (acc, x8) {
       let tmp2, tmp3, tmp4;
-      if (typeof x6 === 'string') {
+      if (typeof x8 === 'string') {
         tmp2 = true;
       } else {
         tmp2 = false;
       }
       tmp3 = runtime.safeCall(Predef.assert(tmp2));
-      tmp4 = acc + x6;
+      tmp4 = acc + x8;
       return (tmp3 , tmp4)
     });
     tmp = lambda;

hkmc2/shared/src/test/mlscript-compile/Predef.mls

@@ -14,14 +14,23 @@ fun (@) apply(f, ...args) = f(...args)
 fun (|>) pipeInto(x, f) = f(x)
 fun (<|) pipeFrom(f, x) = f(x)
 
+// Same as above but with high precedence
+fun (.>) pipeIntoHi(x, f) = f(x)
+fun (<.) pipeFromHi(f, x) = f(x)
+
 fun (!>) tap(x, f) = f(x); x
 fun (<!) pat(f, x) = f(x); x
 
 fun (>>) andThen(f, g)(x) = g(f(x))
 fun (<<) compose(f, g)(x) = f(g(x))
 
+// x . foo(a, b, c) == foo(x, a, b, c)
 fun (.) passTo(receiver, f)(...args) = f(receiver, ...args)
 
+// Same as above but with low precedence
+fun (|.) passToLo(receiver, f)(...args) = f(receiver, ...args)
+
+// x . foo(a, b, c) == foo.call(x, a, b, c)
 fun (|>.) call(receiver, f)(...args) = f.call(receiver, ...args)
 
 val pass1 = Rendering.pass1

hkmc2/shared/src/test/mlscript-compile/WrappedMap.mls

@@ -1,10 +1,12 @@
-import "../../WrappedMap.mls"
+import "../../MutMap.mls"
+import "../../Predef.mls"
 
+open Predef
 module Examples with...
 
-val examples = WrappedMap.empty
+val examples = Map.empty
 
-examples.insert of
+examples |> Map.insert of
   "hanoi"
   name: "Hanoi from Caml Light"
   source: """let spaces n = make_string n " ";;
@@ -33,7 +35,7 @@ let rec join_lines l1 l2 l3 =
   | _ -> failwith "join_lines";;
 """
 
-examples.insert of
+examples |> Map.insert of
   "extensible"
   name: "Extensible Syntax"
   source: """#newKeyword ("hello", Some 3, Some 3)

hkmc2/shared/src/test/mlscript-compile/apps/parsing-web-demo/Examples.mls

@@ -7,10 +7,11 @@ import "../../Stack.mls"
 import "../../Option.mls"
 import "../../Predef.mls"
 import "../../Iter.mls"
+import "../../MutMap.mls"
 
+open Predef
 open Stack
 open Option { Some, None }
-open Predef { print, tuple }
 open Token { LiteralKind }
 open ParseRule { Choice }
 
@@ -39,10 +40,10 @@ fun extendKeyword(tree: TreeT) =
 // * Add an empty parse rule to the map associated with the given name.
 fun newCategory(tree: TreeT) =
   if tree is Tree.Literal(Token.LiteralKind.String, name) and
-    Rules.syntaxKinds.get(name) is
+    Rules.syntaxKinds |> MutMap.get(name) is
       Some(rule) then print of "Category already exists: " + rule.display
       None then
-        Rules.syntaxKinds.insert(name, ParseRule.ParseRule(name, Nil))
+        Rules.syntaxKinds |> MutMap.insert(name, ParseRule.ParseRule(name, Nil))
         Rules.extendedKinds.add(name)
   else
     print of "expect a string literal but found " + tree
@@ -52,14 +53,14 @@ pattern ClosedCategory = "ident" | "typevar"
 
 fun extendCategory(choiceBodyTree: TreeT) =
   if parseChoiceTree(choiceBodyTree) is
-    Some([kindName, choice]) and Rules.syntaxKinds.get(kindName) is
+    Some([kindName, choice]) and Rules.syntaxKinds |> MutMap.get(kindName) is
       Some(rule) and kindName is
         // If the `kindName` is built-in and extensible, we check if the choice
         // refers to another category in the beginning. If so, we inline the
         // referenced category's choices into the current choice.
         OpenCategory and choice is
           Choice.Ref(refKindName, process, outerPrec, innerPrec, rest) and
-            Rules.syntaxKinds.get(refKindName) is Some(refRule) then
+            Rules.syntaxKinds |> MutMap.get(refKindName) is Some(refRule) then
               // TODO: The `process` function should be applied to the referenced rule.
               // TODO: How to handle `outerPrec` and `innerPrec`?
               rule.extendChoices of refRule.andThen(rest, process).choices
@@ -79,7 +80,7 @@ fun parseChoiceTree(tree: TreeT) =
   fun go(trees: StackT[TreeT]): Choice.Choice = 
     let res = if trees is
       Tree.App(Tree.Ident("keyword", _), Tree.Literal(LiteralKind.String, name)) :: rest and
-        Keywords.all.get(name) is Some(keyword) then
+        Keywords.all |> MutMap.get(name) is Some(keyword) then
           Choice.keyword(keyword)(go(rest))
       Tree.Literal(LiteralKind.String, name) :: rest then
         Choice.reference(name)(process: Cons, name: "unnamed", choices: tuple of go(rest))

hkmc2/shared/src/test/mlscript-compile/apps/parsing/Extension.mls

@@ -1,30 +1,30 @@
 import "../../Option.mls"
 import "../../Iter.mls"
 import "../../Predef.mls"
-import "../../WrappedMap.mls"
+import "../../MutMap.mls"
 import "./Keyword.mls"
 
+open Predef
 open Option { Some, None }
-open Predef { tuple }
 open Keyword { INT_MIN, INT_MAX }
 
 module Keywords with ...
 
 fun makePrecMap(startPrec: Int, ...ops) =
   let
-    m = WrappedMap.empty
+    m = MutMap.empty
     i = 0
   while i < ops.length do
     ops.at(i).split(" ").forEach of (op, _, _) =>
       if op.length > 0 do
-        m.insert of op, i + startPrec
+        m |> MutMap.insert of op, i + startPrec
     set i += 1
   m
 
-val all = WrappedMap.empty
+val all = MutMap.empty
 fun keyword(name, leftPrec, rightPrec) =
   let result = Keyword.Keyword(name, leftPrec, rightPrec)
-  all.insert(name, result)
+  all |> MutMap.insert(name, result)
   result
 let prec = 0 
 fun currPrec = Some(prec)
@@ -89,12 +89,12 @@ let precMap = makePrecMap of
   "+ -"
   "* %"
   "~"
-  "" // perfix operators
+  "" // prefix operators
   "" // applications
   "."
 
 // The largest precedence value of all operators.
-val periodPrec = precMap.get(".") Option.unsafe.get()
+val periodPrec = precMap |> MutMap.get(".") |> Option.unsafe.get
 
 val _period = keyword of ".", Some(periodPrec), Some(periodPrec)
 
@@ -103,9 +103,9 @@ val appPrec = maxOperatorPrec - 1
 val prefixPrec = appPrec - 1
 
 // Get the precedence of a single character operator.
-fun charPrec(op) = precMap.get(op) Option.unsafe.get()
+fun charPrec(op) = precMap |> MutMap.get(op) |> Option.unsafe.get
 
-fun charPrecOpt(op) = precMap.get(op)
+fun charPrecOpt(op) = precMap |> MutMap.get(op)
 
 val _asterisk = keyword of "*", charPrecOpt("*"), charPrecOpt("*")
 val _equalequal = keyword of "==", charPrecOpt("="), charPrecOpt("=")
@@ -121,11 +121,11 @@ val _rightCurly = keyword of "}", basePrec, None
 val _begin = keyword of "begin", bracketPrec, basePrec
 val _end = keyword of "end", basePrec, None
 
-let builtinKeywords = new Set(all.keysIterator)
+let builtinKeywords = new Set(all |> MutMap.keysIterator)
 fun extended = all
   Iter.filtering of case [k, _] then builtinKeywords.has(k) is false
   Iter.toArray()
-  WrappedMap.toMap()
+  MutMap.toMap()
 
 pattern Letter = "a" ..= "z" | "A" ..= "Z"
 

hkmc2/shared/src/test/mlscript-compile/apps/parsing/Keywords.mls

@@ -1,4 +1,4 @@
-import "../../WrappedMap.mls"
+import "../../MutMap.mls"
 import "../../Iter.mls"
 import "../../Option.mls"
 import "../../Stack.mls"
@@ -216,7 +216,7 @@ data class ParseRule[A](name: Str, choices: StackT[ChoiceT[A]]) with
       else []
     Iter.flattening()
     Iter.toArray()
-    WrappedMap.toMap()
+    MutMap.toMap()
 
   // Collect all keyword choices in this rule.
   fun keywordChoices = _keywordChoices.get()