wip

play/patterns.zion

@@ -22,19 +22,19 @@ type Pattern is {
 }
 
 fn pattern_from_type(t DataType) Pattern {
-	match t {
-        DataType(typename, ctors) {
-            ctor_patterns := new [CtorPatternValue]
-            for ctor in ctors {
-                arg_patterns := new [Pattern]
-                for arg_type in ctor.arg_types {
-                    append(arg_patterns, AllOf(arg_type))
-                }
-                append(ctor_patterns, CtorPatternValue(typename, ctor.name, arg_patterns))
-            }
-            return CtorPatterns(ctor_patterns)
+  match t {
+    DataType(typename, ctors) {
+      ctor_patterns := new [CtorPatternValue]
+      for ctor in ctors {
+        arg_patterns := new [Pattern]
+        for arg_type in ctor.arg_types {
+          append(arg_patterns, AllOf(arg_type))
         }
-	}
+        append(ctor_patterns, CtorPatternValue(typename, ctor.name, arg_patterns))
+      }
+      return CtorPatterns(ctor_patterns)
+    }
+  }
 }
 
 type Pair T S is Pair(lhs T, rhs S)

runtime/zion_rt.c

@@ -114,7 +114,7 @@ const char *zion_strerror(int errnum, char *buf, int64_t bufsize) {
 }
 void *zion_malloc(uint64_t cb) {
   void *pb = GC_MALLOC(cb);
-  // printf("allocated %" PRId64 " bytes at 0x%08" PRIx64 "\n", cb, (uint64_t)pb);
+  printf("allocated %" PRId64 " bytes at 0x%08" PRIx64 "\n", cb, (uint64_t)pb);
   return pb;
 }
 

src/match.cpp

@@ -458,7 +458,10 @@ void difference(Location location,
   } else if (lhs.args.size() == 0) {
     send(theNothing);
   } else {
-    assert(lhs.args.size() == rhs.args.size());
+    if (lhs.args.size() != rhs.args.size()) {
+      throw zion::user_error(location, "pattern %s does not match pattern %s",
+                             lhs.str().c_str(), rhs.str().c_str());
+    }
     size_t i = 0;
     auto send_ctor_pattern = [location, &i, &lhs, &send](Pattern::ref arg) {
       if (dyncast<const Nothing>(arg)) {

src/parser.cpp

@@ -1758,7 +1758,8 @@ const Predicate *parse_ctor_predicate(ParseState &ps,
   } else {
     return new CtorPredicate(
         ctor_name.location,
-        {new TuplePredicate(location, params, maybe<Identifier>())}, ctor_name,
+        params,
+        ctor_name,
         name_assignment);
   }
 }

src/types.cpp

@@ -1006,6 +1006,16 @@ types::Refs get_ctor_param_terms(Location location,
   assert(outer_ctor_terms.size() >= 1);
 
   types::Refs ctor_param_terms = get_ctor_param_terms(outer_ctor_terms);
+  if (params_count > 1) {
+    /* no-unary-tuple: ugh, this is so hacky */
+    if (ctor_param_terms.size() == 1) {
+      if (auto tuple_type = dyncast<const types::TypeTuple>(ctor_param_terms.front())) {
+        ctor_param_terms = tuple_type->dimensions;
+      } else {
+        throw zion::user_error(location, "wrong number of params given to pattern");
+      }
+    }
+  }
 
   if (ctor_param_terms.size() != params_count) {
     throw zion::user_error(location,