Type checker

examples/morphir-elm-projects/evaluator-tests/morphir-hashes.json

@@ -2,7 +2,7 @@
     "src/Morphir/Examples/App/ConstructorTests.elm": "56fdf0bd81a5d4b51e8e94cf16d01c05",
     "src/Morphir/Examples/App/CurrentTest.elm": "7217989153ede6e82dfe1edb324e8aa5",
     "src/Morphir/Examples/App/DestructureTests.elm": "130b60a9f5c1f62b9e1394b2b1b74339",
-    "src/Morphir/Examples/App/DictionaryTests.elm": "8405796239dd9d7f7794fb119dd54124",
+    "src/Morphir/Examples/App/DictionaryTests.elm": "df2a17d866f6e6ee78672ecbb8ca219c",
     "src/Morphir/Examples/App/EllieStuff.elm": "f9259184f634d714dabcd8ec90f07e7a",
     "src/Morphir/Examples/App/EnumTest.elm": "1bdb50499357960926f3ffe7984a83c0",
     "src/Morphir/Examples/App/ExampleModule.elm": "e90c60dd8d4756d55d91efd7923a8cca",
@@ -19,8 +19,10 @@
     "src/Morphir/Examples/App/OptionTests.elm": "7be9a6971b4cd70e2f622664ebaf8a16",
     "src/Morphir/Examples/App/PatternMatchTests.elm": "2d597bd3d8d6353fe4fc5f4d9b739fca",
     "src/Morphir/Examples/App/RecordTests.elm": "bf6e25596923414d93d9bc532f35293e",
+    "src/Morphir/Examples/App/SetTests.elm": "72a2dcc13ebc592e3f63c9733e064443",
     "src/Morphir/Examples/App/SimpleTests.elm": "f7794a1165f7fe3e5df89b84d0bdbcd8",
     "src/Morphir/Examples/App/SkdBasicTests.elm": "930eb32abe511d003720cfaffcc114b0",
     "src/Morphir/Examples/App/TupleTests.elm": "2c80092fe40ef7666906ee42214376ac",
+    "src/Morphir/Examples/App/TypeCheckerTests.elm": "6da55ef4bc0d30651b1119c3b84206d2",
     "src/Morphir/Examples/App/UserDefinedReferenceTests.elm": "9bf29afa60bad03b200d08ac8f099b99"
 }

examples/morphir-elm-projects/evaluator-tests/src/Morphir/Examples/App/TypeCheckerTests.elm

@@ -1,5 +1,10 @@
 module Morphir.Examples.App.TypeCheckerTests exposing (..)
 
+intToInt : Int -> Int
+intToInt x = x
+
+tupleUp : t -> t -> (t, t)
+tupleUp x y = (x, y)
 
 withParam : (List a) -> a
 withParam l = case l of
@@ -9,4 +14,7 @@ withParam l = case l of
 withInt : (List Int) -> Int
 withInt l = case l of
     head :: _ -> head
-    _ -> withParam l
+    _ -> withParam l
+
+twoArgEntry : Int -> String -> (Int, String)
+twoArgEntry i s = (i, s)

morphir/runtime/jvm/src/org/finos/morphir/runtime/EvaluationLibraryPlatformSpecific.scala

@@ -52,4 +52,11 @@ trait EvaluationLibraryPlatformSpecific {
         .mapError(MorphirIRDecodingError(_))
     } yield morphirIRFile.distribution
 
+  def loadValueFromFileZIO(fileName: String): Task[TypedValue] =
+    for {
+      fileContents <- ZIO.readFile(fileName)
+      value <- ZIO.fromEither(fileContents.fromJson[TypedValue])
+        .mapError(MorphirIRDecodingError(_))
+    } yield value
+
 }

morphir/runtime/src/org/finos/morphir/runtime/Distributions.scala

@@ -0,0 +1,104 @@
+package org.finos.morphir.runtime
+
+import org.finos.morphir.naming._
+import org.finos.morphir.naming._
+import org.finos.morphir.ir.{Type as T, Value as V}
+import org.finos.morphir.ir.Value.{
+  Value,
+  Pattern,
+  TypedValue,
+  USpecification => UValueSpec,
+  TypedDefinition => TypedValueDef
+}
+import org.finos.morphir.ir.Type.{Type, UType, USpecification => UTypeSpec}
+import org.finos.morphir.ir.Module.{Specification => ModSpec, Definition => ModDef}
+import org.finos.morphir.ir.sdk
+import org.finos.morphir.ir.sdk.Basics
+import org.finos.morphir.ir.Field
+import org.finos.morphir.runtime.exports.*
+import org.finos.morphir.ir.distribution.Distribution
+import org.finos.morphir.ir.distribution.Distribution.Library
+import zio.Chunk
+
+//TODO: Error hierarchy and code should reflect possibility of specification lookup
+sealed abstract class LookupError(msg: String) extends Exception(msg) {
+  def getMsg: String = msg
+}
+case class MissingPackage(pkgName: PackageName) extends LookupError(s"Package ${pkgName.toString} not found")
+case class MissingModule(pkgName: PackageName, modName: ModuleName)
+    extends LookupError(s"Package ${pkgName.toString} does not contain module ${modName.toString}")
+case class MissingType(pkgName: PackageName, modName: ModuleName, typeName: Name)
+    extends LookupError(s"Module ${pkgName.toString}:${modName.toString} has no type named ${typeName.toTitleCase}")
+case class MissingDefinition(pkgName: PackageName, modName: ModuleName, defName: Name) extends LookupError(
+      s"Module ${pkgName.toString}:${modName.toString} has no definition named ${defName.toCamelCase}"
+    )
+case class MissingConstructor(pkgName: PackageName, modName: ModuleName, ctorName: Name) extends LookupError(
+      s"Module ${pkgName.toString}:${modName.toString} has no constructor named ${ctorName.toTitleCase}"
+    )
+
+class Distributions(dists: Map[PackageName, Distribution]) {
+  def lookupModuleSpecification(pkgName: PackageName, modName: ModuleName): Either[LookupError, ModSpec.Raw] =
+    dists.get(pkgName) match {
+      case Some(Library(_, _, packageDef)) =>
+        packageDef.toSpecification.modules.get(modName) match {
+          case Some(module) => Right(module)
+          case None         => Left(new MissingModule(pkgName, modName))
+        }
+      case None => Left(new MissingPackage(pkgName))
+    }
+
+  def lookupModuleDefinition(pkgName: PackageName, modName: ModuleName): Either[LookupError, ModDef[Unit, UType]] =
+    dists.get(pkgName) match {
+      case Some(Library(_, _, packageDef)) =>
+        packageDef.modules.get(modName) match {
+          case Some(module) => Right(module.value)
+          case None         => Left(new MissingModule(pkgName, modName))
+        }
+      case None => Left(new MissingPackage(pkgName))
+    }
+
+  def lookupTypeSpecification(
+      pkgName: PackageName,
+      modName: ModuleName,
+      localName: Name
+  ): Either[LookupError, UTypeSpec] =
+    lookupModuleSpecification(pkgName, modName).flatMap(_.lookupTypeSpecification(localName) match {
+      case Some(tpe) => Right(tpe)
+      case None      => Left(new MissingType(pkgName, modName, localName))
+    })
+
+  def lookupTypeSpecification(fqn: FQName): Either[LookupError, UTypeSpec] =
+    lookupTypeSpecification(fqn.packagePath, fqn.modulePath, fqn.localName)
+
+  def lookupValueSpecification(
+      pkgName: PackageName,
+      modName: ModuleName,
+      localName: Name
+  ): Either[LookupError, UValueSpec] =
+    lookupModuleSpecification(pkgName, modName).flatMap(_.lookupValueSpecification(localName) match {
+      case Some(tpe) => Right(tpe)
+      case None      => Left(new MissingDefinition(pkgName, modName, localName))
+    })
+
+  def lookupValueSpecification(fqn: FQName): Either[LookupError, UValueSpec] =
+    lookupValueSpecification(fqn.packagePath, fqn.modulePath, fqn.localName)
+
+  def lookupValueDefinition(
+      pkgName: PackageName,
+      modName: ModuleName,
+      localName: Name
+  ): Either[LookupError, TypedValueDef] =
+    lookupModuleDefinition(pkgName, modName).flatMap(_.lookupValueDefinition(localName) match {
+      case Some(tpe) => Right(tpe)
+      case None      => Left(new MissingDefinition(pkgName, modName, localName))
+    })
+
+  def lookupValueDefinition(fqn: FQName): Either[LookupError, TypedValueDef] =
+    lookupValueDefinition(fqn.packagePath, fqn.modulePath, fqn.localName)
+  def getDists: Map[PackageName, Distribution] = dists
+}
+
+object Distributions {
+  def apply(dists: Distribution*): Distributions =
+    new Distributions(dists.map { case (lib: Library) => lib.packageName -> lib }.toMap)
+}

morphir/runtime/src/org/finos/morphir/runtime/Extractors.scala

@@ -0,0 +1,213 @@
+package org.finos.morphir.runtime
+
+import org.finos.morphir.naming._
+import org.finos.morphir.ir.{Type as T, Value as V}
+import org.finos.morphir.ir.Value.{Value, Pattern, TypedValue, USpecification => UValueSpec}
+import org.finos.morphir.ir.Type.{Type, UType, USpecification => UTypeSpec}
+import org.finos.morphir.ir.sdk
+import org.finos.morphir.ir.sdk.Basics
+import org.finos.morphir.ir.Field
+import org.finos.morphir.runtime.exports.*
+import zio.Chunk
+import Extractors.Types
+
+object Extractors {
+
+  object FQString {
+    def unapply(fqName: FQName): Option[String] = Some(fqName.toString())
+  }
+  object Types {
+    object ListRef {
+      def unapply(tpe: UType): Option[UType] =
+        tpe match {
+          // TODO: The SDK specification should make these names available, without requiring a type argument
+          case Type.Reference(_, FQString("Morphir.SDK:List:list"), Chunk(elementType)) =>
+            Some(elementType)
+          case _ => None
+        }
+    }
+
+    object SetRef {
+      def unapply(tpe: UType): Option[UType] =
+        tpe match {
+          case Type.Reference(_, FQString("Morphir.SDK:Set:set"), Chunk(elementType)) =>
+            Some(elementType)
+          case _ => None
+        }
+    }
+    object MaybeRef {
+      def unapply(tpe: UType): Option[UType] =
+        tpe match {
+          case Type.Reference(_, FQString("Morphir.SDK:Maybe:maybe"), Chunk(elementType)) =>
+            Some(elementType)
+          case _ => None
+        }
+    }
+
+    object ResultRef {
+      def unapply(tpe: UType): Option[(UType, UType)] =
+        tpe match {
+          case Type.Reference(_, FQString("Morphir.SDK:Result:result"), Chunk(keyType, valType)) =>
+            Some((keyType, valType))
+          case _ => None
+        }
+    }
+    object DictRef {
+      def unapply(tpe: UType): Option[(UType, UType)] =
+        tpe match {
+          case Type.Reference(_, FQString("Morphir.SDK:Dict:dict"), Chunk(keyType, valType)) =>
+            Some((keyType, valType))
+          case _ => None
+        }
+    }
+    trait CommonReference {
+      val tpe: UType
+      // TODO: Consider exposing more at the SDK level, so that these type names may be looked up w/o the "asInstanceOf"
+      def ref = tpe.asInstanceOf[Type.Reference[Unit]]
+      def unapply(argTpe: UType): Boolean =
+        argTpe match {
+          case Type.Reference(_, fqName, Chunk()) if fqName == ref.typeName => true
+          case _                                                            => false
+        }
+    }
+    object IntRef extends CommonReference {
+      final val tpe = Basics.intType
+    }
+    object Int16Ref extends CommonReference {
+      final val tpe = sdk.Int.int16Type
+    }
+    object Int32Ref extends CommonReference {
+      final val tpe = sdk.Int.int32Type
+    }
+    object Int64Ref extends CommonReference {
+      final val tpe = sdk.Int.int64Type
+    }
+    object BoolRef extends CommonReference {
+      final val tpe = Basics.boolType
+    }
+    object FloatRef extends CommonReference {
+      final val tpe = Basics.floatType
+    }
+    object DecimalRef extends CommonReference {
+      final val tpe = sdk.Decimal.decimalType
+    }
+    object StringRef extends CommonReference {
+      final val tpe = sdk.String.stringType
+    }
+    object CharRef extends CommonReference {
+      final val tpe = sdk.Char.charType
+    }
+    object LocalDateRef extends CommonReference {
+      final val tpe = sdk.LocalDate.localDateType
+    }
+    object LocalTimeRef extends CommonReference {
+      final val tpe = sdk.LocalTime.localTimeType
+    }
+    // Matches anything w/o nested subtypes
+    object LeafType {
+      def unapply(tpe: UType): Boolean =
+        tpe match {
+          case Type.Reference(_, _, Chunk()) => true
+          case Type.Unit(_)                  => true
+          case _                             => false
+        }
+    }
+    // Matches any reference that does not come from the morphir SDK
+    object NonNativeRef {
+      def unapply(tpe: UType): Option[(FQName, Chunk[UType])] =
+        tpe match {
+          case Type.Reference(_, name, args)
+              if (!Utils.isNative(name)) =>
+            Some((name, args))
+          case _ => None
+        }
+    }
+    // Matches any reference that does come from the DK
+    object NativeRef {
+      def unapply(tpe: UType): Option[(FQName, Chunk[UType])] =
+        tpe match {
+          case Type.Reference(_, name, args)
+              if (Utils.isNative(name)) =>
+            Some((name, args))
+          case _ => None
+        }
+    }
+    // Extractor object that unwraps a single layer of aliasing, applying any bindings that were discovered in the process
+    class Dealiased(dists: Distributions) {
+      def unapply(tpe: UType): Option[UType] = // If it's aliased we may need to grab bindings
+        tpe match {
+          case NativeRef(_, _) => None
+          case Type.Reference(_, typeName, typeArgs) =>
+            val lookedUp = dists.lookupTypeSpecification(typeName.packagePath, typeName.modulePath, typeName.localName)
+            lookedUp match {
+              case Right(T.Specification.TypeAliasSpecification(typeParams, expr)) =>
+                val newBindings = typeParams.zip(typeArgs).toMap
+                Some(Utils.applyBindings(expr, newBindings))
+              case _ => None // Missing name, but failing extractors cause problems
+            }
+          case _ => None
+        }
+    }
+
+    // Extractor object that uncurries a function type, dealiasing along the way to reeturn a result value and flat list of arguments
+    class CurriedOnion(dists: Distributions) {
+      val dealiaser = new Dealiased(dists)
+      def unapply(tpe: UType): Option[(UType, List[UType])] = {
+        val myself = this
+        tpe match {
+          case Type.Function(_, arg, myself(inner, args)) =>
+            Some((inner, args :+ arg))
+          case dealiaser(myself(inner, args)) =>
+            Some((inner, args))
+          case other =>
+            Some((other, List()))
+        }
+      }
+    }
+  }
+  object Values {
+    // Extractor that helps handle currying
+    object ApplyChain {
+      def unapply(value: TypedValue): Option[(TypedValue, List[TypedValue])] = value match {
+        case Value.Apply(_, ApplyChain(inner, args), arg) => Some((inner, args :+ arg))
+        case other                                        => Some((other, List()))
+      }
+    }
+    object JustConstructor {
+      def unapply(value: TypedValue): Option[TypedValue] =
+        value match {
+          case Value.Apply(_, Value.Constructor(_, FQString("Morphir.SDK:Maybe:just")), something) =>
+            Some(something)
+          case _ => None
+        }
+    }
+    object NothingConstructor {
+      def unapply(value: TypedValue): Boolean =
+        value match {
+          case Value.Constructor(_, FQString("Morphir.SDK:Maybe:nothing")) =>
+            true
+          case _ => false
+        }
+    }
+
+    object NonNativeRef {
+      def unapply(value: TypedValue): Option[(UType, FQName)] =
+        value match {
+          case Value.Reference(tpe, name)
+              if (!Utils.isNative(name)) =>
+            Some((tpe, name))
+          case _ => None
+        }
+    }
+
+    object NativeRef {
+      def unapply(value: TypedValue): Option[(UType, FQName)] =
+        value match {
+          case Value.Reference(tpe, name)
+              if (Utils.isNative(name)) =>
+            Some((tpe, name))
+          case _ => None
+        }
+    }
+  }
+}