minor changes

Author: auht

shared/src/main/scala/mlscript/ConstraintSolver.scala

@@ -825,12 +825,13 @@ class ConstraintSolver extends NormalForms { self: Typer =>
             val newBound = (cctx._1 ::: cctx._2.reverse).foldRight(rhs)((c, ty) =>
               if (c.prov is noProv) ty else mkProxy(ty, c.prov))
             lhs.upperBounds ::= newBound // update the bound
-            lhs.tsc.toList.flatMap { case (k,v)=>v.map((k,_)) }.foreach {
-              case (tsc, i) =>
+            lhs.tsc.foreachEntry { (tsc, v) =>
+              v.foreach { i =>
                 if (!tsc.tvs(i)._1) {
                   tsc.updateOn(i, rhs)
                   if (tsc.constraints.isEmpty) reportError()
                 }
+              }
             }
             val u = lhs.tsc.filter(_._1.constraints.sizeCompare(1) === 0)
             u.foreachEntry { case (k, _) => lhs.tsc.remove(k) }
@@ -846,12 +847,13 @@ class ConstraintSolver extends NormalForms { self: Typer =>
             val newBound = (cctx._1 ::: cctx._2.reverse).foldLeft(lhs)((ty, c) =>
               if (c.prov is noProv) ty else mkProxy(ty, c.prov))
             rhs.lowerBounds ::= newBound // update the bound
-            rhs.tsc.toList.flatMap { case (k,v)=>v.map((k,_)) }.foreach {
-              case (tsc, i) =>
+            rhs.tsc.foreachEntry { (tsc, v) =>
+              v.foreach { i =>
                 if(tsc.tvs(i)._1) {
                   tsc.updateOn(i, lhs)
                   if (tsc.constraints.isEmpty) reportError()
                 }
+              }
             }
             val u = rhs.tsc.filter(_._1.constraints.sizeCompare(1) === 0)
             u.foreachEntry { case (k, _) => rhs.tsc.remove(k) }

shared/src/main/scala/mlscript/Typer.scala

@@ -113,11 +113,14 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
               if (p) (b, tv) else (tv, b) }
           }.toList, innerTy)
 
-        val ambiguous: Bool = innerTy.getVars.toList.flatMap(_.tsc)
+        val ambiguous = innerTy.getVars.toList.flatMap(_.tsc)
           .flatMap(_._1.tvs).distinct
           .groupBy(_._2)
-          .exists { case (v,pvs) => pvs.sizeIs > 1 }
-        if (ambiguous) raise(ErrorReport(Ls(fromStr("ambiguous") -> N), true))
+          .filter { case (v,pvs) => pvs.sizeIs > 1 }
+        if (ambiguous.nonEmpty) raise(ErrorReport(
+          msg"ambiguous" -> N ::
+          ambiguous.map { case (v,_) => msg"cannot determine satisfiability of type ${v.expPos}" -> v.prov.loco }.toList
+          , true))
 
         println(s"Inferred poly constr: $cty  —— where ${cty.showBounds}")
 

shared/src/test/diff/nu/HeungTung.mls

@@ -423,7 +423,9 @@ fun r: Int -> Int & Bool -> Bool
 :e
 x => r(r(x))
 //│ ╔══[ERROR] ambiguous
-//│ ╙──
+//│ ╟── cannot determine satisfiability of type ?a
+//│ ║  l.424: 	x => r(r(x))
+//│ ╙──       	       ^^^^
 //│ forall 'a 'b. 'a -> 'b
 //│   where
 //│     [+'c, -'b] in {[Int, Int], [Bool, Bool]}
@@ -468,7 +470,9 @@ fun s: Str -> Str & AA -> AA
 :e
 let g = x => s(r(x))
 //│ ╔══[ERROR] ambiguous
-//│ ╙──
+//│ ╟── cannot determine satisfiability of type ?a
+//│ ║  l.471: 	let g = x => s(r(x))
+//│ ╙──       	               ^^^^
 //│ let g: forall 'a 'b. 'a -> 'b
 //│   where
 //│     [+'c, -'b] in {[Str, Str], [AA, AA]}
@@ -480,13 +484,13 @@ let g = x => s(r(x))
 :e
 g(0)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.481: 	g(0)
+//│ ║  l.485: 	g(0)
 //│ ║         	^^^^
 //│ ╟── integer literal of type `Int` does not match type `?a`
-//│ ║  l.481: 	g(0)
+//│ ║  l.485: 	g(0)
 //│ ║         	  ^
 //│ ╟── Note: constraint arises from application:
-//│ ║  l.469: 	let g = x => s(r(x))
+//│ ║  l.471: 	let g = x => s(r(x))
 //│ ╙──       	               ^^^^
 //│ error
 //│ res
@@ -514,18 +518,31 @@ fun app2: ('a -> 'a -> 'a) -> 'a -> 'a
 fun snd: A -> Int -> Int & Str -> Str -> Str
 //│ fun snd: A -> Int -> Int & Str -> Str -> Str
 
+
 :e
 x => app2(snd)(x):Int
 //│ ╔══[ERROR] Type mismatch in type ascription:
-//│ ║  l.518: 	x => app2(snd)(x):Int
+//│ ║  l.523: 	x => app2(snd)(x):Int
 //│ ║         	     ^^^^^^^^^^^^
 //│ ╟── application of type `'a` does not match type `nothing`
 //│ ╟── Note: constraint arises from type reference:
-//│ ║  l.518: 	x => app2(snd)(x):Int
+//│ ║  l.523: 	x => app2(snd)(x):Int
 //│ ╙──       	                  ^^^
 //│ ╔══[ERROR] ambiguous
-//│ ╙──
+//│ ╙── cannot determine satisfiability of type 'a
 //│ nothing -> Int
 //│ res
 //│     = <no result>
 //│       app2 is not implemented
+
+fun app2_ (f:'a -> 'a -> 'a)(x) = f(x)(x)
+//│ fun app2_: forall 'a. (f: 'a -> 'a -> 'a) -> 'a -> 'a
+
+app2_(snd)
+//│ 'a -> 'b
+//│   where
+//│     'a <: 'b
+//│     [+'a, -'a, -'b] in {[A & Int, Int, Int], [Str, Str, Str]}
+//│ res
+//│     = <no result>
+//│       snd is not implemented