Polymorphic type

Cargo.toml

@@ -22,6 +22,7 @@ log = "0.4.8"
 env_logger = "0.7.1"
 regex = "1.3.7"
 wasm = { version = "0.1.2", package = "web-assembler" }
+itertools = "0.10.3"
 
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]

ml_example/online.sml

@@ -0,0 +1,5 @@
+fun fib 0 = 1
+|   fib 1 = 1
+|   fib n = fib (n - 1) + fib (n - 2)
+
+val () = printInt (fib 39)

ml_example/polymorphic_function.sml

@@ -0,0 +1,9 @@
+fun id x = x
+val x = id 1
+val y = id false
+val id2 = id
+val x = id2 1
+val y = id2 false
+val id3 = id2
+val x = id3 1
+val y = id3 false

ml_example/stringFromInt2digits.sml

@@ -0,0 +1 @@
+val s = stringFromInt 9

src/ast/case_simplify.rs

@@ -709,7 +709,9 @@ impl CaseSimplifyPass {
     ) -> bool {
         use Type::*;
         match ty {
-            Real | Variable(_) | Fun(_, _) => panic!("no way to pattern match against this type"),
+            Real | Variable(_) | Fun(_, _) | TyAbs(_, _) => {
+                panic!("no way to pattern match against this type")
+            }
             Char | Int => false,
             Tuple(_) => {
                 // unlikely reachable, but writing incase it reaches.

src/ast/desugar.rs

@@ -187,6 +187,7 @@ impl Desugar {
             } => self.transform_externcall(span, module, fun, args, argty, retty),
             Fn { param, body } => self.transform_fn(span, param, body),
             App { fun, arg } => self.transform_app(span, fun, arg),
+            TyApp { fun, arg } => self.transform_tyapp(span, fun, arg),
             Case { cond, clauses } => self.transform_case(span, cond, clauses),
             Tuple { tuple } => self.transform_tuple(span, tuple),
             Constructor { arg, name } => self.transform_constructor(span, arg, name),
@@ -284,6 +285,10 @@ impl Desugar {
         }
     }
 
+    fn transform_tyapp(&mut self, _: Span, fun: Symbol, arg: Vec<Empty>) -> UntypedCoreExprKind {
+        ExprKind::TyApp { fun, arg }
+    }
+
     fn transform_if(
         &mut self,
         span: Span,

src/ast/mod.rs

@@ -1,6 +1,7 @@
 mod case_simplify;
 mod collect_langitems;
 mod desugar;
+mod monomorphize;
 mod pp;
 mod rename;
 mod resolve_overload;
@@ -11,6 +12,7 @@ mod var2constructor;
 pub use self::case_simplify::CaseSimplify;
 pub use self::collect_langitems::CollectLangItems;
 pub use self::desugar::Desugar;
+pub use self::monomorphize::Monomorphize;
 pub use self::rename::Rename;
 pub use self::resolve_overload::ResolveOverload;
 pub use self::typing::Typer;
@@ -198,6 +200,10 @@ pub enum ExprKind<
         fun: Box<Expr<Ty, DE, DS, DP>>,
         arg: Box<Expr<Ty, DE, DS, DP>>,
     },
+    TyApp {
+        fun: Symbol,
+        arg: Vec<Ty>,
+    },
     Case {
         cond: Box<Expr<Ty, DE, DS, DP>>,
         clauses: Vec<(Pattern<Ty, DP>, Expr<Ty, DE, DS, DP>)>,
@@ -301,7 +307,7 @@ pub struct SymbolTable {
 
 type TypeId = u64;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Type {
     Variable(TypeId),
     Char,
@@ -310,6 +316,7 @@ pub enum Type {
     Fun(Box<Type>, Box<Type>),
     Tuple(Vec<Type>),
     Datatype(Symbol),
+    TyAbs(Vec<TypeId>, Box<Type>),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -476,6 +483,10 @@ impl<Ty> CoreExpr<Ty> {
                 fun: fun.map_ty(f).boxed(),
                 arg: arg.map_ty(f).boxed(),
             },
+            TyApp { fun, arg } => TyApp {
+                fun,
+                arg: arg.into_iter().map(f).collect(),
+            },
             Case { cond, clauses } => Case {
                 cond: cond.map_ty(&mut *f).boxed(),
                 clauses: clauses
@@ -506,6 +517,7 @@ impl<Ty> CoreExpr<Ty> {
             ExternCall { .. } => false,
             Fn { .. } => true,
             App { .. } => false,
+            TyApp { .. } => true,
             // TODO: check compatibility with fn
             Case { .. } => false,
             Tuple { tuple } => tuple.iter().all(|e| e.is_value()),