where keyword for pattern guards

Author: Chronarak

hkmc2/shared/src/main/scala/hkmc2/semantics/ucs/Desugarer.scala

@@ -7,11 +7,12 @@ import mlscript.utils.*, shorthands.*
 import Message.MessageContext
 import utils.TraceLogger
 import syntax.Literal
-import Keyword.{as, and, `do`, `else`, is, let, `then`}
+import Keyword.{as, and, `do`, `else`, is, let, `then`, where}
 import collection.mutable.{HashMap, SortedSet}
 import Elaborator.{ctx, Ctxl}
 import scala.annotation.targetName
 import hkmc2.semantics.ClassDef.Parameterized
+import hkmc2.codegen.Case.Lit
 
 object Desugarer:
   extension (op: Keyword.Infix)
@@ -608,6 +609,11 @@ class Desugarer(val elaborator: Elaborator)
       case pattern and consequent => fallback => ctx =>
         val innerSplit = termSplit(consequent, identity)(Split.End)
         expandMatch(scrutSymbol, pattern, innerSplit)(fallback)(ctx)
+      case pattern where condition => fallback => ctx =>
+        val sym = TempSymbol(N, "conditionTemp")
+        val newSequel = expandMatch(sym, Tree.BoolLit(true), sequel)(fallback)
+        val newNewSequel = (ctx: Ctx) => Split.Let(sym, term(condition)(using ctx), newSequel(ctx))
+        expandMatch(scrutSymbol, pattern, newNewSequel)(fallback)(ctx)
       case Jux(Ident(".."), Ident(_)) => fallback => _ =>
         raise(ErrorReport(msg"Illegal rest pattern." -> pattern.toLoc :: Nil))
         fallback

hkmc2/shared/src/main/scala/hkmc2/syntax/Keyword.scala

@@ -103,7 +103,7 @@ object Keyword:
   val `object` = Keyword("object", N, curPrec)
   val `open` = Keyword("open", N, curPrec)
   val `type` = Keyword("type", N, N)
-  val `where` = Keyword("where", N, N)
+  val `where` = Keyword("where", curPrec, curPrec)
   val `forall` = Keyword("forall", N, N)
   val `exists` = Keyword("exists", N, N)
   val `null` = Keyword("null", N, N)
@@ -139,7 +139,7 @@ object Keyword:
     `abstract`, mut, virtual, `override`, declare, public, `private`)
 
   type Infix = `and`.type | `or`.type | `then`.type | `else`.type | `is`.type | `:`.type | `->`.type |
-    `=>`.type | `extends`.type | `restricts`.type | `as`.type | `do`.type
+    `=>`.type | `extends`.type | `restricts`.type | `as`.type | `do`.type | `where`.type
 
   type Ellipsis = `...`.type | `..`.type
 

hkmc2/shared/src/main/scala/hkmc2/syntax/ParseRule.scala

@@ -396,6 +396,7 @@ class ParseRules(using State):
     genInfixRule(`extends`, (rhs, _: Unit) => lhs => InfixApp(lhs, `extends`, rhs)),
     genInfixRule(`restricts`, (rhs, _: Unit) => lhs => InfixApp(lhs, `restricts`, rhs)),
     genInfixRule(`do`, (rhs, _: Unit) => lhs => InfixApp(lhs, `do`, rhs)),
+    genInfixRule(`where`, (rhs, _: Unit) => lhs => InfixApp(lhs, `where`, rhs)),
   )
 
 end ParseRules

hkmc2/shared/src/test/mlscript/ucs/patterns/where.mls

@@ -0,0 +1,36 @@
+:js
+
+data class Pair[A, B](fst: A, snd: B)
+
+
+fun orderedPair(p) = p is
+    Pair(a, b) where a <= b
+
+orderedPair(Pair(4, 5))
+//│ = true
+
+orderedPair(4)
+//│ = false
+
+orderedPair(Pair(1, 1))
+//│ = true
+
+orderedPair(Pair(2, 1))
+//│ = false
+
+fun foo(p) = p is
+    Pair(a, b) where
+        let c = a
+        a == 0
+
+foo(Pair(5, 5))
+//│ = false
+
+foo(Pair(0, 0))
+//│ = true
+
+foo(Pair(0, 4))
+//│ = true
+
+foo(Pair(4, 0))
+//│ = false

hkmc2/shared/src/test/mlscript/ucs/syntax/PlainConditionals.mls

@@ -53,13 +53,7 @@ fun foo(x) = x is
 
 fun foo(x) = x is Pair(a, b) | Int
 
-:todo
 fun foo(x) = x is (Pair(a, b) where a > b) | Int
-//│ ╔══[PARSE ERROR] Unexpected 'where' keyword here
-//│ ║  l.57: 	fun foo(x) = x is (Pair(a, b) where a > b) | Int
-//│ ╙──      	                              ^^^^^
-
-
 
 data class A[T](arg: T)