Implement parametric polymorphism

runtime/runtime.c

@@ -45,3 +45,23 @@ int simpl_string_print(const struct simpl_string* s) {
   free(cstring);
   return 0;
 }
+
+uint32_t simpl_tagged_size(const struct simpl_type_tag* const tag) {
+    return tag->size;
+}
+
+const struct simpl_type_tag* const simpl_tagged_tag(struct simpl_tagged_value* value) {
+    return value->type_tag;
+}
+
+void* simpl_tagged_unbox(struct simpl_tagged_value* value) {
+    return value->data;
+}
+
+
+struct simpl_tagged_value* simpl_tagged_box(struct simpl_type_tag* tag, void* data) {
+    struct simpl_tagged_value *value = simpl_malloc(sizeof(struct simpl_tagged_value));
+    value->type_tag = tag;
+    value->data = data;
+    return value;
+}

runtime/runtime.h

@@ -1,4 +1,5 @@
 #include <stdlib.h>
+#include <stdint.h>
 
 #ifndef RUNTIME_H
 #define RUNTIME_H
@@ -38,4 +39,44 @@ char* simpl_string_cstring(const struct simpl_string* s);
 
 int simpl_string_print(const struct simpl_string* s);
 
+/**
+ * Describes static information about a type. This struct should not be visible
+ * from SimPL programs.
+ */
+struct simpl_type_tag {
+    /**
+     * The size (e.g. when compiled) of the type, in bytes.
+     */
+    uint32_t size;
+};
+
+/**
+ * Returns the size recorded in the type tag.
+ */
+uint32_t simpl_tag_size(const struct simpl_type_tag* const);
+
+/**
+ * A value tagged with its type tag. Used for polymorphic functions and
+ * variables.
+ */
+struct simpl_tagged_value {
+    const struct simpl_type_tag* type_tag;
+    void* data;
+};
+
+/**
+ * Returns the type tag of a tagged value.
+ */
+const struct simpl_type_tag* const simpl_tagged_tag(struct simpl_tagged_value*);
+
+/**
+ * Returns a pointer to the boxed value of a tagged value.
+ */
+void* simpl_tagged_unbox(struct simpl_tagged_value*);
+
+/**
+ * Boxes the given value
+ */
+struct simpl_tagged_value* simpl_tagged_box(struct simpl_type_tag* tag, void* data);
+
 #endif

sample.spl

@@ -5,78 +5,82 @@ data MaybeI = { JustI Double | Nothing }
 # data Barbar a = { Asdf Int a }
 
 # fun id (x : a) : a := { x }
-
-fun not (b : Bool) : Bool := { if b then false else true }
-
-fun and (p : Bool, q : Bool) : Bool := { if p then (if q then true else false) else false }
-
-fun or (p : Bool, q : Bool) : Bool := { if p then true else (if q then true else false) }
-
-fun factorial (x : Int) : Int := {
-  if (x <= 0) then 1
-  else x * @factorial(x - 1)
-}
-
-fun even (x: Int) : Bool := {
-  if (x <= 0) then true
-  else @not(@odd(x - 2))
-}
-
-fun odd (x: Int) : Bool := {
-  if (x <= 1) then true
-  else @not(@even(x - 2))
-}
-
-fun nested_ifs : Double := {
-  (if true then (if true then 4.0 else 5.0) else (if false then 2.0 else 3.0) + 1.0) * 2.0
-}
-
-fun main : Int := {
-  case JustI 10.0 of
-    JustI x =>
-      let msg = println("In Just branch") in
-      let mynum = @abs(-1) in
-      (if (@even(4)) then @double_me(5) else @factorial(6)) * @asdf * mynum
-    Nothing =>
-      let msg = println("In Nothing branch") in
-      let res = 4 in
-      @double_me(res + 1)
-}
-
-fun asdf : Int := {
-  (if false then 5 else 10) + 2
-}
-
-fun double_me (x : Int) : Int := { x * 2 }
-
-fun foo : Foo := {
-  Bar 5.0
-}
-
-fun foo2 : Bool := {
-  case Bar 5.0 of
-    Bar x => true
-}
-
-fun lots_of_lets : Double := {
-  let x = if true then 1.0 else 2.0 in
-  let y = if true then x * 2.0 else x * 2.0 + 1.0 in
-  y
-}
-
-fun fun_ptr : Int -> Int := { &double_me }
-
-fun fun_ptr_test (b : Bool) : Int := {
-  let f = if b then &double_me else &factorial in
-  @f(4)
-}
-
-fun cast_test_1 : Int := {
-  (1 + 1) * (cast 2.0 as Int)
-}
-
-fun cast_test_2 : Int := {
-  (1 * 1) + (cast 2.0 as Int)
-}
-
-fun abs (x : Int) : Int := extern
+# 
+# fun eqargs (x : a, y : a, z: b) : a := { x }
+
+fun main : Int := { let x = &asdf in 5 }
+
+# fun not (b : Bool) : Bool := { if b then false else true }
+# 
+# fun and (p : Bool, q : Bool) : Bool := { if p then (if q then true else false) else false }
+# 
+# fun or (p : Bool, q : Bool) : Bool := { if p then true else (if q then true else false) }
+# 
+# fun factorial (x : Int) : Int := {
+#   if (x <= 0) then 1
+#   else x * @factorial(x - 1)
+# }
+# 
+# fun even (x: Int) : Bool := {
+#   if (x <= 0) then true
+#   else @not(@odd(x - 2))
+# }
+# 
+# fun odd (x: Int) : Bool := {
+#   if (x <= 1) then true
+#   else @not(@even(x - 2))
+# }
+# 
+# fun nested_ifs : Double := {
+#   (if true then (if true then 4.0 else 5.0) else (if false then 2.0 else 3.0) + 1.0) * 2.0
+# }
+# 
+# fun main : Int := {
+#   case JustI 10.0 of
+#     JustI x =>
+#       let msg = println("In Just branch") in
+#       let mynum = @abs(-1) in
+#       (if (@even(4)) then @double_me(5) else @factorial(6)) * @asdf * mynum
+#     Nothing =>
+#       let msg = println("In Nothing branch") in
+#       let res = 4 in
+#       @double_me(res + 1)
+# }
+# 
+# fun asdf : Int := {
+#   (if false then 5 else 10) + 2
+# }
+# 
+# fun double_me (x : Int) : Int := { x * 2 }
+# 
+# fun foo : Foo := {
+#   Bar 5.0
+# }
+# 
+# fun foo2 : Bool := {
+#   case Bar 5.0 of
+#     Bar x => true
+# }
+# 
+# fun lots_of_lets : Double := {
+#   let x = if true then 1.0 else 2.0 in
+#   let y = if true then x * 2.0 else x * 2.0 + 1.0 in
+#   y
+# }
+# 
+# fun fun_ptr : Int -> Int := { &double_me }
+# 
+# fun fun_ptr_test (b : Bool) : Int := {
+#   let f = if b then &double_me else &factorial in
+#   @f(4)
+# }
+# 
+# fun cast_test_1 : Int := {
+#   (1 + 1) * (cast 2.0 as Int)
+# }
+# 
+# fun cast_test_2 : Int := {
+#   (1 * 1) + (cast 2.0 as Int)
+# }
+# 
+# fun abs (x : Int) : Int := extern