Optional args

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

@@ -846,9 +846,7 @@ class ConstraintSolver extends NormalForms { self: Typer =>
             }
 
 
-          case (TupleType(fs0), TupleType(fs1)) if fs0.sizeCompare(fs1) <= 0 && fs0.sizeCompare(fs1.filter(x => !x._2.opt)) >= 0 => { // TODO[optional-fields] generalize (coerce compatible tuples)
-            println("case #1")
-
+          case (t0 @ TupleType(fs0), t1 @ TupleType(fs1)) if t0.isSubtype(t1) => {
             fs0.lazyZip(fs1).foreach { case ((ln, l), (rn, r)) =>
               ln.foreach { ln => rn.foreach { rn =>
                 if (ln =/= rn) err(

shared/src/main/scala/mlscript/TyperDatatypes.scala

@@ -274,6 +274,7 @@ abstract class TyperDatatypes extends TyperHelpers { Typer: Typer =>
       fields.map(f => s"${f._1.fold("")(_.name+": ")}${f._2},").mkString(" ")
     override def toString = s"($showInner)"
     // override def toString = s"(${fields.map(f => s"${f._1.fold("")(_+": ")}${f._2},").mkString(" ")})"
+    def isSubtype(that: TupleType): Boolean = fields.sizeCompare(that.fields) <= 0 && fields.sizeCompare(that.fields.filter(x => !x._2.opt)) >= 0
   }
 
   case class SpliceType(elems: Ls[Either[SimpleType, FieldType]])(val prov: TypeProvenance) extends ArrayBase {

shared/src/main/scala/mlscript/TyperHelpers.scala

@@ -427,10 +427,7 @@ abstract class TyperHelpers { Typer: Typer =>
       case (RecordType(fs1), RecordType(fs2)) =>
         RecordType(mergeSortedMap(fs1, fs2)(_ && _).toList)(prov)
       case (t0 @ TupleType(fs0), t1 @ TupleType(fs1)) => {
-        println("case #2")
-
-        // TODO[optional-fields] update this condition
-        if (fs0.sizeCompare(fs1) > 0 || fs0.sizeCompare(fs1.filter(x => !x._2.opt)) < 0) BotType
+        if (!t0.isSubtype(t1)) BotType
         else TupleType(tupleIntersection(fs0, fs1))(t0.prov)
       }
       case _ if !swapped => that & (this, prov, swapped = true)
@@ -491,13 +488,10 @@ abstract class TyperHelpers { Typer: Typer =>
         // case (ClassTag(ErrTypeId, _), _) | (_, ClassTag(ErrTypeId, _)) => true
         case (_: TypeTag, _: TypeTag) | (_: TV, _: TV) if this === that => true
         case (ab: ArrayBase, at: ArrayType) => ab.inner <:< at.inner
-        case (TupleType(fs1), TupleType(fs2)) => {
-          // TODO[optional-fields] generalize: handle optionality; eg: [Int] <:< [Int, Int?]
-          println(s"case #3 ${fs1} ${fs2}")
-          fs1.sizeCompare(fs2) <= 0 && fs1.sizeCompare(fs2.filter(x => !x._2.opt)) >= 0 && fs1.lazyZip(fs2).forall {
+        case (t1 @ TupleType(fs1), t2 @ TupleType(fs2)) =>
+          t1.isSubtype(t2) && fs1.lazyZip(fs2).forall {
             case ((_, ty1), (_, ty2)) => ty1 <:< ty2
           }
-        }
         case (RecordType(Nil), _) => TopType <:< that
         case (_, RecordType(Nil)) => this <:< TopType
         case (pt1 @ ClassTag(id1, ps1), pt2 @ ClassTag(id2, ps2)) => (id1 === id2) || pt1.parentsST(id2)