diff --git a/compiler/builtins/src/std.rs b/compiler/builtins/src/std.rs
index e7f40f2b7d..60f15bcd8d 100644
--- a/compiler/builtins/src/std.rs
+++ b/compiler/builtins/src/std.rs
@@ -68,28 +68,53 @@ const TOP_LEVEL_CLOSURE_VAR: VarId = VarId::from_u32(5);
 pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
     let mut types = HashMap::with_capacity_and_hasher(NUM_BUILTIN_IMPORTS, default_hasher());
 
-    let mut add_type = |symbol, typ| {
-        debug_assert!(
-            !types.contains_key(&symbol),
-            "Duplicate type definition for {:?}",
-            symbol
-        );
+    macro_rules! add_type {
+        ($symbol:expr, $typ:expr $(,)?) => {{
+            debug_assert!(
+                !types.contains_key(&$symbol),
+                "Duplicate type definition for {:?}",
+                $symbol
+            );
 
-        // TODO instead of using Region::zero for all of these,
-        // instead use the Region where they were defined in their
-        // source .roc files! This can give nicer error messages.
-        types.insert(symbol, (typ, Region::zero()));
-    };
+            // TODO instead of using Region::zero for all of these,
+            // instead use the Region where they were defined in their
+            // source .roc files! This can give nicer error messages.
+            types.insert($symbol, ($typ, Region::zero()));
+        }};
+    }
+
+    macro_rules! add_top_level_function_type {
+        ($symbol:expr, $arguments:expr, $result:expr $(,)?) => {{
+            debug_assert!(
+                !types.contains_key(&$symbol),
+                "Duplicate type definition for {:?}",
+                $symbol
+            );
+
+            let ext = Box::new(SolvedType::Flex(TOP_LEVEL_CLOSURE_VAR));
+            // in the future, we will enable the line below
+            // let closure_var = Box::new(SolvedType::TagUnion(
+            //         vec![(TagName::Closure($symbol), vec![])],
+            //         ext,
+            //     ));
+            let closure_var = ext;
+
+            let typ = SolvedType::Func($arguments, closure_var, $result);
+
+            // TODO instead of using Region::zero for all of these,
+            // instead use the Region where they were defined in their
+            // source .roc files! This can give nicer error messages.
+            types.insert($symbol, (typ, Region::zero()));
+        }};
+    }
 
     // Num module
 
     // add or (+) : Num a, Num a -> Num a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_ADD,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(num_type(flex(TVAR1))),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(num_type(flex(TVAR1))),
     );
 
     fn overflow() -> SolvedType {
@@ -100,190 +125,171 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
     }
 
     // addChecked : Num a, Num a -> Result (Num a) [ Overflow ]*
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_ADD_CHECKED,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(result_type(num_type(flex(TVAR1)), overflow())),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(result_type(num_type(flex(TVAR1)), overflow())),
     );
 
     // addWrap : Int range, Int range -> Int range
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_ADD_WRAP,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // sub or (-) : Num a, Num a -> Num a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_SUB,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(num_type(flex(TVAR1))),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(num_type(flex(TVAR1))),
     );
 
     // subWrap : Int range, Int range -> Int range
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_SUB_WRAP,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // subChecked : Num a, Num a -> Result (Num a) [ Overflow ]*
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_SUB_CHECKED,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(result_type(num_type(flex(TVAR1)), overflow())),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(result_type(num_type(flex(TVAR1)), overflow())),
     );
 
     // mul or (*) : Num a, Num a -> Num a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_MUL,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(num_type(flex(TVAR1))),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(num_type(flex(TVAR1))),
     );
 
     // mulWrap : Int range, Int range -> Int range
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_MUL_WRAP,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // mulChecked : Num a, Num a -> Result (Num a) [ Overflow ]*
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_MUL_CHECKED,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(result_type(num_type(flex(TVAR1)), overflow())),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(result_type(num_type(flex(TVAR1)), overflow())),
     );
 
     // abs : Num a -> Num a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_ABS,
-        top_level_function(vec![num_type(flex(TVAR1))], Box::new(num_type(flex(TVAR1)))),
+        vec![num_type(flex(TVAR1))],
+        Box::new(num_type(flex(TVAR1)))
     );
 
     // neg : Num a -> Num a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_NEG,
-        top_level_function(vec![num_type(flex(TVAR1))], Box::new(num_type(flex(TVAR1)))),
+        vec![num_type(flex(TVAR1))],
+        Box::new(num_type(flex(TVAR1)))
     );
 
     // isEq or (==) : a, a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::BOOL_EQ,
-        top_level_function(vec![flex(TVAR1), flex(TVAR1)], Box::new(bool_type())),
+        vec![flex(TVAR1), flex(TVAR1)],
+        Box::new(bool_type())
     );
 
     // isNeq or (!=) : a, a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::BOOL_NEQ,
-        top_level_function(vec![flex(TVAR1), flex(TVAR1)], Box::new(bool_type())),
+        vec![flex(TVAR1), flex(TVAR1)],
+        Box::new(bool_type())
     );
 
     // isLt or (<) : Num a, Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_LT,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(bool_type()),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(bool_type()),
     );
 
     // isLte or (<=) : Num a, Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_LTE,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(bool_type()),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(bool_type()),
     );
 
     // isGt or (>) : Num a, Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_GT,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(bool_type()),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(bool_type()),
     );
 
     // isGte or (>=) : Num a, Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_GTE,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(bool_type()),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(bool_type()),
     );
 
     // compare : Num a, Num a -> [ LT, EQ, GT ]
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_COMPARE,
-        top_level_function(
-            vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
-            Box::new(ordering_type()),
-        ),
+        vec![num_type(flex(TVAR1)), num_type(flex(TVAR1))],
+        Box::new(ordering_type()),
     );
 
     // toFloat : Num * -> Float *
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_TO_FLOAT,
-        top_level_function(
-            vec![num_type(flex(TVAR1))],
-            Box::new(float_type(flex(TVAR2))),
-        ),
+        vec![num_type(flex(TVAR1))],
+        Box::new(float_type(flex(TVAR2))),
     );
 
     // isNegative : Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_IS_NEGATIVE,
-        top_level_function(vec![num_type(flex(TVAR1))], Box::new(bool_type())),
+        vec![num_type(flex(TVAR1))],
+        Box::new(bool_type())
     );
 
     // isPositive : Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_IS_POSITIVE,
-        top_level_function(vec![num_type(flex(TVAR1))], Box::new(bool_type())),
+        vec![num_type(flex(TVAR1))],
+        Box::new(bool_type())
     );
 
     // isZero : Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_IS_ZERO,
-        top_level_function(vec![num_type(flex(TVAR1))], Box::new(bool_type())),
+        vec![num_type(flex(TVAR1))],
+        Box::new(bool_type())
     );
 
     // isEven : Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_IS_EVEN,
-        top_level_function(vec![num_type(flex(TVAR1))], Box::new(bool_type())),
+        vec![num_type(flex(TVAR1))],
+        Box::new(bool_type())
     );
 
     // isOdd : Num a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_IS_ODD,
-        top_level_function(vec![num_type(flex(TVAR1))], Box::new(bool_type())),
+        vec![num_type(flex(TVAR1))],
+        Box::new(bool_type())
     );
 
     // maxInt : Int range
-    add_type(Symbol::NUM_MAX_INT, int_type(flex(TVAR1)));
+    add_type!(Symbol::NUM_MAX_INT, int_type(flex(TVAR1)));
 
     // minInt : Int range
-    add_type(Symbol::NUM_MIN_INT, int_type(flex(TVAR1)));
+    add_type!(Symbol::NUM_MIN_INT, int_type(flex(TVAR1)));
 
     // div : Int, Int -> Result Int [ DivByZero ]*
     let div_by_zero = SolvedType::TagUnion(
@@ -291,122 +297,99 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
         Box::new(SolvedType::Wildcard),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_DIV_INT,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(result_type(int_type(flex(TVAR1)), div_by_zero.clone())),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(result_type(int_type(flex(TVAR1)), div_by_zero.clone())),
     );
 
     // bitwiseAnd : Int a, Int a -> Int a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_BITWISE_AND,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // bitwiseXor : Int a, Int a -> Int a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_BITWISE_XOR,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // bitwiseOr : Int a, Int a -> Int a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_BITWISE_OR,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // shiftLeftBy : Int a, Int a -> Int a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_SHIFT_LEFT,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // shiftRightBy : Int a, Int a -> Int a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_SHIFT_RIGHT,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // shiftRightZfBy : Int a, Int a -> Int a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_SHIFT_RIGHT_ZERO_FILL,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // intCast : Int a -> Int b
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_INT_CAST,
-        top_level_function(vec![int_type(flex(TVAR1))], Box::new(int_type(flex(TVAR2)))),
+        vec![int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR2)))
     );
 
     // rem : Int a, Int a -> Result (Int a) [ DivByZero ]*
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_REM,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(result_type(int_type(flex(TVAR1)), div_by_zero.clone())),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(result_type(int_type(flex(TVAR1)), div_by_zero.clone())),
     );
 
     // mod : Int a, Int a -> Result (Int a) [ DivByZero ]*
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_MOD_INT,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(result_type(int_type(flex(TVAR1)), div_by_zero.clone())),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(result_type(int_type(flex(TVAR1)), div_by_zero.clone())),
     );
 
     // isMultipleOf : Int a, Int a -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_IS_MULTIPLE_OF,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(bool_type()),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(bool_type()),
     );
 
     // maxI128 : I128
-    add_type(Symbol::NUM_MAX_I128, i128_type());
+    add_type!(Symbol::NUM_MAX_I128, i128_type());
 
     // Float module
 
     // div : Float a, Float a -> Float a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_DIV_FLOAT,
-        top_level_function(
-            vec![float_type(flex(TVAR1)), float_type(flex(TVAR1))],
-            Box::new(result_type(float_type(flex(TVAR1)), div_by_zero.clone())),
-        ),
+        vec![float_type(flex(TVAR1)), float_type(flex(TVAR1))],
+        Box::new(result_type(float_type(flex(TVAR1)), div_by_zero.clone())),
     );
 
     // mod : Float a, Float a -> Result (Float a) [ DivByZero ]*
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_MOD_FLOAT,
-        top_level_function(
-            vec![float_type(flex(TVAR1)), float_type(flex(TVAR1))],
-            Box::new(result_type(float_type(flex(TVAR1)), div_by_zero)),
-        ),
+        vec![float_type(flex(TVAR1)), float_type(flex(TVAR1))],
+        Box::new(result_type(float_type(flex(TVAR1)), div_by_zero)),
     );
 
     // sqrt : Float a -> Float a
@@ -415,12 +398,10 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
         Box::new(SolvedType::Wildcard),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_SQRT,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(result_type(float_type(flex(TVAR1)), sqrt_of_negative)),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(result_type(float_type(flex(TVAR1)), sqrt_of_negative)),
     );
 
     // log : Float a -> Float a
@@ -429,205 +410,184 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
         Box::new(SolvedType::Wildcard),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_LOG,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(result_type(float_type(flex(TVAR1)), log_needs_positive)),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(result_type(float_type(flex(TVAR1)), log_needs_positive)),
     );
 
     // round : Float a -> Int b
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_ROUND,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR2))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR2))),
     );
 
     // sin : Float a -> Float a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_SIN,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(float_type(flex(TVAR1))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(float_type(flex(TVAR1))),
     );
 
     // cos : Float a -> Float a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_COS,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(float_type(flex(TVAR1))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(float_type(flex(TVAR1))),
     );
 
     // tan : Float a -> Float a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_TAN,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(float_type(flex(TVAR1))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(float_type(flex(TVAR1))),
     );
 
     // maxFloat : Float a
-    add_type(Symbol::NUM_MAX_FLOAT, float_type(flex(TVAR1)));
+    add_type!(Symbol::NUM_MAX_FLOAT, float_type(flex(TVAR1)));
 
     // minFloat : Float a
-    add_type(Symbol::NUM_MIN_FLOAT, float_type(flex(TVAR1)));
+    add_type!(Symbol::NUM_MIN_FLOAT, float_type(flex(TVAR1)));
 
     // pow : Float a, Float a -> Float a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_POW,
-        top_level_function(
-            vec![float_type(flex(TVAR1)), float_type(flex(TVAR1))],
-            Box::new(float_type(flex(TVAR1))),
-        ),
+        vec![float_type(flex(TVAR1)), float_type(flex(TVAR1))],
+        Box::new(float_type(flex(TVAR1))),
     );
 
     // ceiling : Float a -> Int b
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_CEILING,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR2))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR2))),
     );
 
     // powInt : Int a, Int a -> Int a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_POW_INT,
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR1))),
-        ),
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR1))),
     );
 
     // floor : Float a -> Int b
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_FLOOR,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(int_type(flex(TVAR2))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(int_type(flex(TVAR2))),
     );
 
     // atan : Float a -> Float a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_ATAN,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(float_type(flex(TVAR1))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(float_type(flex(TVAR1))),
     );
 
     // acos : Float a -> Float a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_ACOS,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(float_type(flex(TVAR1))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(float_type(flex(TVAR1))),
     );
 
     // asin : Float a -> Float a
-    add_type(
+    add_top_level_function_type!(
         Symbol::NUM_ASIN,
-        top_level_function(
-            vec![float_type(flex(TVAR1))],
-            Box::new(float_type(flex(TVAR1))),
-        ),
+        vec![float_type(flex(TVAR1))],
+        Box::new(float_type(flex(TVAR1))),
     );
 
     // Bool module
 
     // and : Bool, Bool -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::BOOL_AND,
-        top_level_function(vec![bool_type(), bool_type()], Box::new(bool_type())),
+        vec![bool_type(), bool_type()],
+        Box::new(bool_type())
     );
 
     // or : Bool, Bool -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::BOOL_OR,
-        top_level_function(vec![bool_type(), bool_type()], Box::new(bool_type())),
+        vec![bool_type(), bool_type()],
+        Box::new(bool_type())
     );
 
     // xor : Bool, Bool -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::BOOL_XOR,
-        top_level_function(vec![bool_type(), bool_type()], Box::new(bool_type())),
+        vec![bool_type(), bool_type()],
+        Box::new(bool_type())
     );
 
     // not : Bool -> Bool
-    add_type(
-        Symbol::BOOL_NOT,
-        top_level_function(vec![bool_type()], Box::new(bool_type())),
-    );
+    add_top_level_function_type!(Symbol::BOOL_NOT, vec![bool_type()], Box::new(bool_type()));
 
     // Str module
 
     // Str.split : Str, Str -> List Str
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_SPLIT,
-        top_level_function(
-            vec![str_type(), str_type()],
-            Box::new(list_type(str_type())),
-        ),
+        vec![str_type(), str_type()],
+        Box::new(list_type(str_type())),
     );
 
     // Str.concat : Str, Str -> Str
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_CONCAT,
-        top_level_function(vec![str_type(), str_type()], Box::new(str_type())),
+        vec![str_type(), str_type()],
+        Box::new(str_type()),
     );
 
     // Str.joinWith : List Str, Str -> Str
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_JOIN_WITH,
-        top_level_function(
-            vec![list_type(str_type()), str_type()],
-            Box::new(str_type()),
-        ),
+        vec![list_type(str_type()), str_type()],
+        Box::new(str_type()),
     );
 
     // isEmpty : Str -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_IS_EMPTY,
-        top_level_function(vec![str_type()], Box::new(bool_type())),
+        vec![str_type()],
+        Box::new(bool_type())
     );
 
     // startsWith : Str, Str -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_STARTS_WITH,
-        top_level_function(vec![str_type(), str_type()], Box::new(bool_type())),
+        vec![str_type(), str_type()],
+        Box::new(bool_type())
     );
 
     // startsWithCodePoint : Str, U32 -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_STARTS_WITH_CODE_POINT,
-        top_level_function(vec![str_type(), u32_type()], Box::new(bool_type())),
+        vec![str_type(), u32_type()],
+        Box::new(bool_type())
     );
 
     // endsWith : Str, Str -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_ENDS_WITH,
-        top_level_function(vec![str_type(), str_type()], Box::new(bool_type())),
+        vec![str_type(), str_type()],
+        Box::new(bool_type())
     );
 
     // countGraphemes : Str -> Nat
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_COUNT_GRAPHEMES,
-        top_level_function(vec![str_type()], Box::new(nat_type())),
+        vec![str_type()],
+        Box::new(nat_type())
     );
 
     // fromInt : Int a -> Str
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_FROM_INT,
-        top_level_function(vec![int_type(flex(TVAR1))], Box::new(str_type())),
+        vec![int_type(flex(TVAR1))],
+        Box::new(str_type())
     );
 
     // fromUtf8 : List U8 -> Result Str [ BadUtf8 Utf8Problem ]*
@@ -640,24 +600,24 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
         Box::new(SolvedType::Wildcard),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_FROM_UTF8,
-        top_level_function(
-            vec![list_type(u8_type())],
-            Box::new(result_type(str_type(), bad_utf8)),
-        ),
+        vec![list_type(u8_type())],
+        Box::new(result_type(str_type(), bad_utf8)),
     );
 
     // toBytes : Str -> List U8
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_TO_BYTES,
-        top_level_function(vec![str_type()], Box::new(list_type(u8_type()))),
+        vec![str_type()],
+        Box::new(list_type(u8_type()))
     );
 
     // fromFloat : Float a -> Str
-    add_type(
+    add_top_level_function_type!(
         Symbol::STR_FROM_FLOAT,
-        top_level_function(vec![float_type(flex(TVAR1))], Box::new(str_type())),
+        vec![float_type(flex(TVAR1))],
+        Box::new(str_type())
     );
 
     // List module
@@ -668,12 +628,10 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
         Box::new(SolvedType::Wildcard),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_GET,
-        top_level_function(
-            vec![list_type(flex(TVAR1)), nat_type()],
-            Box::new(result_type(flex(TVAR1), index_out_of_bounds)),
-        ),
+        vec![list_type(flex(TVAR1)), nat_type()],
+        Box::new(result_type(flex(TVAR1), index_out_of_bounds)),
     );
 
     // first : List elem -> Result elem [ ListWasEmpty ]*
@@ -682,92 +640,74 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
         Box::new(SolvedType::Wildcard),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_FIRST,
-        top_level_function(
-            vec![list_type(flex(TVAR1))],
-            Box::new(result_type(flex(TVAR1), list_was_empty.clone())),
-        ),
+        vec![list_type(flex(TVAR1))],
+        Box::new(result_type(flex(TVAR1), list_was_empty.clone())),
     );
 
     // last : List elem -> Result elem [ ListWasEmpty ]*
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_LAST,
-        top_level_function(
-            vec![list_type(flex(TVAR1))],
-            Box::new(result_type(flex(TVAR1), list_was_empty)),
-        ),
+        vec![list_type(flex(TVAR1))],
+        Box::new(result_type(flex(TVAR1), list_was_empty)),
     );
 
     // set : List elem, Nat, elem -> List elem
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_SET,
-        top_level_function(
-            vec![list_type(flex(TVAR1)), nat_type(), flex(TVAR1)],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![list_type(flex(TVAR1)), nat_type(), flex(TVAR1)],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // concat : List elem, List elem -> List elem
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_CONCAT,
-        top_level_function(
-            vec![list_type(flex(TVAR1)), list_type(flex(TVAR1))],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![list_type(flex(TVAR1)), list_type(flex(TVAR1))],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // contains : List elem, elem -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_CONTAINS,
-        top_level_function(
-            vec![list_type(flex(TVAR1)), flex(TVAR1)],
-            Box::new(bool_type()),
-        ),
+        vec![list_type(flex(TVAR1)), flex(TVAR1)],
+        Box::new(bool_type()),
     );
 
     // sum :  List (Num a) -> Num a
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_SUM,
-        top_level_function(
-            vec![list_type(num_type(flex(TVAR1)))],
-            Box::new(num_type(flex(TVAR1))),
-        ),
+        vec![list_type(num_type(flex(TVAR1)))],
+        Box::new(num_type(flex(TVAR1))),
     );
 
     // product :  List (Num a) -> Num a
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_PRODUCT,
-        top_level_function(
-            vec![list_type(num_type(flex(TVAR1)))],
-            Box::new(num_type(flex(TVAR1))),
-        ),
+        vec![list_type(num_type(flex(TVAR1)))],
+        Box::new(num_type(flex(TVAR1))),
     );
 
     // walk : List elem, (elem -> accum -> accum), accum -> accum
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_WALK,
-        top_level_function(
-            vec![
-                list_type(flex(TVAR1)),
-                closure(vec![flex(TVAR1), flex(TVAR2)], TVAR3, Box::new(flex(TVAR2))),
-                flex(TVAR2),
-            ],
-            Box::new(flex(TVAR2)),
-        ),
+        vec![
+            list_type(flex(TVAR1)),
+            closure(vec![flex(TVAR1), flex(TVAR2)], TVAR3, Box::new(flex(TVAR2))),
+            flex(TVAR2),
+        ],
+        Box::new(flex(TVAR2)),
     );
 
     // walkBackwards : List elem, (elem -> accum -> accum), accum -> accum
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_WALK_BACKWARDS,
-        top_level_function(
-            vec![
-                list_type(flex(TVAR1)),
-                closure(vec![flex(TVAR1), flex(TVAR2)], TVAR3, Box::new(flex(TVAR2))),
-                flex(TVAR2),
-            ],
-            Box::new(flex(TVAR2)),
-        ),
+        vec![
+            list_type(flex(TVAR1)),
+            closure(vec![flex(TVAR1), flex(TVAR2)], TVAR3, Box::new(flex(TVAR2))),
+            flex(TVAR2),
+        ],
+        Box::new(flex(TVAR2)),
     );
 
     fn until_type(content: SolvedType) -> SolvedType {
@@ -782,38 +722,35 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
     }
 
     // walkUntil : List elem, (elem -> accum -> [ Continue accum, Stop accum ]), accum -> accum
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_WALK_UNTIL,
-        top_level_function(
-            vec![
-                list_type(flex(TVAR1)),
-                closure(
-                    vec![flex(TVAR1), flex(TVAR2)],
-                    TVAR3,
-                    Box::new(until_type(flex(TVAR2))),
-                ),
-                flex(TVAR2),
-            ],
-            Box::new(flex(TVAR2)),
-        ),
+        vec![
+            list_type(flex(TVAR1)),
+            closure(
+                vec![flex(TVAR1), flex(TVAR2)],
+                TVAR3,
+                Box::new(until_type(flex(TVAR2))),
+            ),
+            flex(TVAR2),
+        ],
+        Box::new(flex(TVAR2)),
     );
 
     // keepIf : List elem, (elem -> Bool) -> List elem
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_KEEP_IF,
-        top_level_function(
-            vec![
-                list_type(flex(TVAR1)),
-                closure(vec![flex(TVAR1)], TVAR2, Box::new(bool_type())),
-            ],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![
+            list_type(flex(TVAR1)),
+            closure(vec![flex(TVAR1)], TVAR2, Box::new(bool_type())),
+        ],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // keepOks : List before, (before -> Result after *) -> List after
-    add_type(Symbol::LIST_KEEP_OKS, {
+    {
         let_tvars! { star, cvar, before, after};
-        top_level_function(
+        add_top_level_function_type!(
+            Symbol::LIST_KEEP_OKS,
             vec![
                 list_type(flex(before)),
                 closure(
@@ -824,12 +761,14 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
             ],
             Box::new(list_type(flex(after))),
         )
-    });
+    };
 
     // keepErrs: List before, (before -> Result * after) -> List after
-    add_type(Symbol::LIST_KEEP_ERRS, {
+    {
         let_tvars! { star, cvar, before, after};
-        top_level_function(
+
+        add_top_level_function_type!(
+            Symbol::LIST_KEEP_ERRS,
             vec![
                 list_type(flex(before)),
                 closure(
@@ -840,44 +779,43 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
             ],
             Box::new(list_type(flex(after))),
         )
-    });
+    };
 
     // range : Int a, Int a -> List (Int a)
-    add_type(Symbol::LIST_RANGE, {
-        top_level_function(
-            vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
-            Box::new(list_type(int_type(flex(TVAR1)))),
-        )
-    });
+    add_top_level_function_type!(
+        Symbol::LIST_RANGE,
+        vec![int_type(flex(TVAR1)), int_type(flex(TVAR1))],
+        Box::new(list_type(int_type(flex(TVAR1)))),
+    );
 
     // map : List before, (before -> after) -> List after
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_MAP,
-        top_level_function(
-            vec![
-                list_type(flex(TVAR1)),
-                closure(vec![flex(TVAR1)], TVAR3, Box::new(flex(TVAR2))),
-            ],
-            Box::new(list_type(flex(TVAR2))),
-        ),
+        vec![
+            list_type(flex(TVAR1)),
+            closure(vec![flex(TVAR1)], TVAR3, Box::new(flex(TVAR2))),
+        ],
+        Box::new(list_type(flex(TVAR2))),
     );
 
     // mapWithIndex : List before, (Nat, before -> after) -> List after
-    add_type(Symbol::LIST_MAP_WITH_INDEX, {
+    {
         let_tvars! { cvar, before, after};
-        top_level_function(
+        add_top_level_function_type!(
+            Symbol::LIST_MAP_WITH_INDEX,
             vec![
                 list_type(flex(before)),
                 closure(vec![nat_type(), flex(before)], cvar, Box::new(flex(after))),
             ],
             Box::new(list_type(flex(after))),
         )
-    });
+    };
 
     // map2 : List a, List b, (a, b -> c) -> List c
-    add_type(Symbol::LIST_MAP2, {
+    {
         let_tvars! {a, b, c, cvar};
-        top_level_function(
+        add_top_level_function_type!(
+            Symbol::LIST_MAP2,
             vec![
                 list_type(flex(a)),
                 list_type(flex(b)),
@@ -885,13 +823,14 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
             ],
             Box::new(list_type(flex(c))),
         )
-    });
+    };
 
-    // map3 : List a, List b, List c, (a, b, c -> d) -> List d
-    add_type(Symbol::LIST_MAP3, {
+    {
         let_tvars! {a, b, c, d, cvar};
 
-        top_level_function(
+        // map3 : List a, List b, List c, (a, b, c -> d) -> List d
+        add_top_level_function_type!(
+            Symbol::LIST_MAP3,
             vec![
                 list_type(flex(a)),
                 list_type(flex(b)),
@@ -900,114 +839,102 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
             ],
             Box::new(list_type(flex(d))),
         )
-    });
+    };
 
     // append : List elem, elem -> List elem
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_APPEND,
-        top_level_function(
-            vec![list_type(flex(TVAR1)), flex(TVAR1)],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![list_type(flex(TVAR1)), flex(TVAR1)],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // prepend : List elem, elem -> List elem
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_PREPEND,
-        top_level_function(
-            vec![list_type(flex(TVAR1)), flex(TVAR1)],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![list_type(flex(TVAR1)), flex(TVAR1)],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // join : List (List elem) -> List elem
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_JOIN,
-        top_level_function(
-            vec![list_type(list_type(flex(TVAR1)))],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![list_type(list_type(flex(TVAR1)))],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // single : a -> List a
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_SINGLE,
-        top_level_function(vec![flex(TVAR1)], Box::new(list_type(flex(TVAR1)))),
+        vec![flex(TVAR1)],
+        Box::new(list_type(flex(TVAR1)))
     );
 
     // repeat : Nat, elem -> List elem
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_REPEAT,
-        top_level_function(
-            vec![nat_type(), flex(TVAR1)],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![nat_type(), flex(TVAR1)],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // reverse : List elem -> List elem
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_REVERSE,
-        top_level_function(
-            vec![list_type(flex(TVAR1))],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![list_type(flex(TVAR1))],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // len : List * -> Nat
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_LEN,
-        top_level_function(vec![list_type(flex(TVAR1))], Box::new(nat_type())),
+        vec![list_type(flex(TVAR1))],
+        Box::new(nat_type())
     );
 
     // isEmpty : List * -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_IS_EMPTY,
-        top_level_function(vec![list_type(flex(TVAR1))], Box::new(bool_type())),
+        vec![list_type(flex(TVAR1))],
+        Box::new(bool_type())
     );
 
     // sortWith : List a, (a, a -> Ordering) -> List a
-    add_type(
+    add_top_level_function_type!(
         Symbol::LIST_SORT_WITH,
-        top_level_function(
-            vec![
-                list_type(flex(TVAR1)),
-                closure(
-                    vec![flex(TVAR1), flex(TVAR1)],
-                    TVAR2,
-                    Box::new(ordering_type()),
-                ),
-            ],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![
+            list_type(flex(TVAR1)),
+            closure(
+                vec![flex(TVAR1), flex(TVAR1)],
+                TVAR2,
+                Box::new(ordering_type()),
+            ),
+        ],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // Dict module
 
     // Dict.hashTestOnly : Nat, v -> Nat
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_TEST_HASH,
-        top_level_function(vec![u64_type(), flex(TVAR2)], Box::new(nat_type())),
+        vec![u64_type(), flex(TVAR2)],
+        Box::new(nat_type())
     );
 
     // len : Dict * * -> Nat
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_LEN,
-        top_level_function(
-            vec![dict_type(flex(TVAR1), flex(TVAR2))],
-            Box::new(nat_type()),
-        ),
+        vec![dict_type(flex(TVAR1), flex(TVAR2))],
+        Box::new(nat_type()),
     );
 
     // empty : Dict * *
-    add_type(Symbol::DICT_EMPTY, dict_type(flex(TVAR1), flex(TVAR2)));
+    add_type!(Symbol::DICT_EMPTY, dict_type(flex(TVAR1), flex(TVAR2)));
 
     // single : k, v -> Dict k v
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_SINGLE,
-        top_level_function(
-            vec![flex(TVAR1), flex(TVAR2)],
-            Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
-        ),
+        vec![flex(TVAR1), flex(TVAR2)],
+        Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
     );
 
     // get : Dict k v, k -> Result v [ KeyNotFound ]*
@@ -1016,264 +943,220 @@ pub fn types() -> MutMap<Symbol, (SolvedType, Region)> {
         Box::new(SolvedType::Wildcard),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_GET,
-        top_level_function(
-            vec![dict_type(flex(TVAR1), flex(TVAR2)), flex(TVAR1)],
-            Box::new(result_type(flex(TVAR2), key_not_found)),
-        ),
+        vec![dict_type(flex(TVAR1), flex(TVAR2)), flex(TVAR1)],
+        Box::new(result_type(flex(TVAR2), key_not_found)),
     );
 
     // Dict.insert : Dict k v, k, v -> Dict k v
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_INSERT,
-        top_level_function(
-            vec![
-                dict_type(flex(TVAR1), flex(TVAR2)),
-                flex(TVAR1),
-                flex(TVAR2),
-            ],
-            Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
-        ),
+        vec![
+            dict_type(flex(TVAR1), flex(TVAR2)),
+            flex(TVAR1),
+            flex(TVAR2),
+        ],
+        Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
     );
 
     // Dict.remove : Dict k v, k -> Dict k v
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_REMOVE,
-        top_level_function(
-            vec![dict_type(flex(TVAR1), flex(TVAR2)), flex(TVAR1)],
-            Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
-        ),
+        vec![dict_type(flex(TVAR1), flex(TVAR2)), flex(TVAR1)],
+        Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
     );
 
     // Dict.contains : Dict k v, k -> Bool
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_CONTAINS,
-        top_level_function(
-            vec![dict_type(flex(TVAR1), flex(TVAR2)), flex(TVAR1)],
-            Box::new(bool_type()),
-        ),
+        vec![dict_type(flex(TVAR1), flex(TVAR2)), flex(TVAR1)],
+        Box::new(bool_type()),
     );
 
     // Dict.keys : Dict k v -> List k
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_KEYS,
-        top_level_function(
-            vec![dict_type(flex(TVAR1), flex(TVAR2))],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![dict_type(flex(TVAR1), flex(TVAR2))],
+        Box::new(list_type(flex(TVAR1))),
     );
 
     // Dict.values : Dict k v -> List v
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_VALUES,
-        top_level_function(
-            vec![dict_type(flex(TVAR1), flex(TVAR2))],
-            Box::new(list_type(flex(TVAR2))),
-        ),
+        vec![dict_type(flex(TVAR1), flex(TVAR2))],
+        Box::new(list_type(flex(TVAR2))),
     );
 
     // Dict.union : Dict k v, Dict k v -> Dict k v
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_UNION,
-        top_level_function(
-            vec![
-                dict_type(flex(TVAR1), flex(TVAR2)),
-                dict_type(flex(TVAR1), flex(TVAR2)),
-            ],
-            Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
-        ),
+        vec![
+            dict_type(flex(TVAR1), flex(TVAR2)),
+            dict_type(flex(TVAR1), flex(TVAR2)),
+        ],
+        Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
     );
 
     // Dict.intersection : Dict k v, Dict k v -> Dict k v
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_INTERSECTION,
-        top_level_function(
-            vec![
-                dict_type(flex(TVAR1), flex(TVAR2)),
-                dict_type(flex(TVAR1), flex(TVAR2)),
-            ],
-            Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
-        ),
+        vec![
+            dict_type(flex(TVAR1), flex(TVAR2)),
+            dict_type(flex(TVAR1), flex(TVAR2)),
+        ],
+        Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
     );
 
     // Dict.difference : Dict k v, Dict k v -> Dict k v
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_DIFFERENCE,
-        top_level_function(
-            vec![
-                dict_type(flex(TVAR1), flex(TVAR2)),
-                dict_type(flex(TVAR1), flex(TVAR2)),
-            ],
-            Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
-        ),
+        vec![
+            dict_type(flex(TVAR1), flex(TVAR2)),
+            dict_type(flex(TVAR1), flex(TVAR2)),
+        ],
+        Box::new(dict_type(flex(TVAR1), flex(TVAR2))),
     );
 
     // Dict.walk : Dict k v, (k, v, accum -> accum), accum -> accum
-    add_type(
+    add_top_level_function_type!(
         Symbol::DICT_WALK,
-        top_level_function(
-            vec![
-                dict_type(flex(TVAR1), flex(TVAR2)),
-                closure(
-                    vec![flex(TVAR1), flex(TVAR2), flex(TVAR3)],
-                    TVAR4,
-                    Box::new(flex(TVAR3)),
-                ),
-                flex(TVAR3),
-            ],
-            Box::new(flex(TVAR3)),
-        ),
+        vec![
+            dict_type(flex(TVAR1), flex(TVAR2)),
+            closure(
+                vec![flex(TVAR1), flex(TVAR2), flex(TVAR3)],
+                TVAR4,
+                Box::new(flex(TVAR3)),
+            ),
+            flex(TVAR3),
+        ],
+        Box::new(flex(TVAR3)),
     );
 
     // Set module
 
     // empty : Set a
-    add_type(Symbol::SET_EMPTY, set_type(flex(TVAR1)));
+    add_type!(Symbol::SET_EMPTY, set_type(flex(TVAR1)));
 
     // single : a -> Set a
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_SINGLE,
-        top_level_function(vec![flex(TVAR1)], Box::new(set_type(flex(TVAR1)))),
+        vec![flex(TVAR1)],
+        Box::new(set_type(flex(TVAR1)))
     );
 
     // len : Set * -> Nat
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_LEN,
-        top_level_function(vec![set_type(flex(TVAR1))], Box::new(nat_type())),
+        vec![set_type(flex(TVAR1))],
+        Box::new(nat_type())
     );
 
     // toList : Set a -> List a
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_TO_LIST,
-        top_level_function(
-            vec![set_type(flex(TVAR1))],
-            Box::new(list_type(flex(TVAR1))),
-        ),
+        vec![set_type(flex(TVAR1))],
+        Box::new(list_type(flex(TVAR1))),
     );
 
-    // fromList : Set a -> List a
-    add_type(
+    // fromList : List a -> Set a
+    add_top_level_function_type!(
         Symbol::SET_FROM_LIST,
-        top_level_function(
-            vec![list_type(flex(TVAR1))],
-            Box::new(set_type(flex(TVAR1))),
-        ),
+        vec![list_type(flex(TVAR1))],
+        Box::new(set_type(flex(TVAR1))),
     );
 
     // union : Set a, Set a -> Set a
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_UNION,
-        top_level_function(
-            vec![set_type(flex(TVAR1)), set_type(flex(TVAR1))],
-            Box::new(set_type(flex(TVAR1))),
-        ),
+        vec![set_type(flex(TVAR1)), set_type(flex(TVAR1))],
+        Box::new(set_type(flex(TVAR1))),
     );
 
     // difference : Set a, Set a -> Set a
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_DIFFERENCE,
-        top_level_function(
-            vec![set_type(flex(TVAR1)), set_type(flex(TVAR1))],
-            Box::new(set_type(flex(TVAR1))),
-        ),
+        vec![set_type(flex(TVAR1)), set_type(flex(TVAR1))],
+        Box::new(set_type(flex(TVAR1))),
     );
 
     // intersection : Set a, Set a -> Set a
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_INTERSECTION,
-        top_level_function(
-            vec![set_type(flex(TVAR1)), set_type(flex(TVAR1))],
-            Box::new(set_type(flex(TVAR1))),
-        ),
+        vec![set_type(flex(TVAR1)), set_type(flex(TVAR1))],
+        Box::new(set_type(flex(TVAR1))),
     );
 
     // Set.walk : Set a, (a, b -> b), b -> b
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_WALK,
-        top_level_function(
-            vec![
-                set_type(flex(TVAR1)),
-                closure(vec![flex(TVAR1), flex(TVAR2)], TVAR3, Box::new(flex(TVAR2))),
-                flex(TVAR2),
-            ],
-            Box::new(flex(TVAR2)),
-        ),
+        vec![
+            set_type(flex(TVAR1)),
+            closure(vec![flex(TVAR1), flex(TVAR2)], TVAR3, Box::new(flex(TVAR2))),
+            flex(TVAR2),
+        ],
+        Box::new(flex(TVAR2)),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_INSERT,
-        top_level_function(
-            vec![set_type(flex(TVAR1)), flex(TVAR1)],
-            Box::new(set_type(flex(TVAR1))),
-        ),
+        vec![set_type(flex(TVAR1)), flex(TVAR1)],
+        Box::new(set_type(flex(TVAR1))),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_REMOVE,
-        top_level_function(
-            vec![set_type(flex(TVAR1)), flex(TVAR1)],
-            Box::new(set_type(flex(TVAR1))),
-        ),
+        vec![set_type(flex(TVAR1)), flex(TVAR1)],
+        Box::new(set_type(flex(TVAR1))),
     );
 
-    add_type(
+    add_top_level_function_type!(
         Symbol::SET_CONTAINS,
-        top_level_function(
-            vec![set_type(flex(TVAR1)), flex(TVAR1)],
-            Box::new(bool_type()),
-        ),
+        vec![set_type(flex(TVAR1)), flex(TVAR1)],
+        Box::new(bool_type()),
     );
 
     // Result module
 
     // map : Result a err, (a -> b) -> Result b err
-    add_type(
+    add_top_level_function_type!(
         Symbol::RESULT_MAP,
-        top_level_function(
-            vec![
-                result_type(flex(TVAR1), flex(TVAR3)),
-                closure(vec![flex(TVAR1)], TVAR4, Box::new(flex(TVAR2))),
-            ],
-            Box::new(result_type(flex(TVAR2), flex(TVAR3))),
-        ),
+        vec![
+            result_type(flex(TVAR1), flex(TVAR3)),
+            closure(vec![flex(TVAR1)], TVAR4, Box::new(flex(TVAR2))),
+        ],
+        Box::new(result_type(flex(TVAR2), flex(TVAR3))),
     );
 
     // mapErr : Result a x, (x -> y) -> Result a x
-    add_type(
+    add_top_level_function_type!(
         Symbol::RESULT_MAP_ERR,
-        top_level_function(
-            vec![
-                result_type(flex(TVAR1), flex(TVAR3)),
-                closure(vec![flex(TVAR3)], TVAR4, Box::new(flex(TVAR2))),
-            ],
-            Box::new(result_type(flex(TVAR1), flex(TVAR2))),
-        ),
+        vec![
+            result_type(flex(TVAR1), flex(TVAR3)),
+            closure(vec![flex(TVAR3)], TVAR4, Box::new(flex(TVAR2))),
+        ],
+        Box::new(result_type(flex(TVAR1), flex(TVAR2))),
     );
 
     // after : Result a err, (a -> Result b err) -> Result b err
-    add_type(
+    add_top_level_function_type!(
         Symbol::RESULT_AFTER,
-        top_level_function(
-            vec![
-                result_type(flex(TVAR1), flex(TVAR3)),
-                closure(
-                    vec![flex(TVAR1)],
-                    TVAR4,
-                    Box::new(result_type(flex(TVAR2), flex(TVAR3))),
-                ),
-            ],
-            Box::new(result_type(flex(TVAR2), flex(TVAR3))),
-        ),
+        vec![
+            result_type(flex(TVAR1), flex(TVAR3)),
+            closure(
+                vec![flex(TVAR1)],
+                TVAR4,
+                Box::new(result_type(flex(TVAR2), flex(TVAR3))),
+            ),
+        ],
+        Box::new(result_type(flex(TVAR2), flex(TVAR3))),
     );
 
     // withDefault : Result a x, a -> a
-    add_type(
+    add_top_level_function_type!(
         Symbol::RESULT_WITH_DEFAULT,
-        top_level_function(
-            vec![result_type(flex(TVAR1), flex(TVAR3)), flex(TVAR1)],
-            Box::new(flex(TVAR1)),
-        ),
+        vec![result_type(flex(TVAR1), flex(TVAR3)), flex(TVAR1)],
+        Box::new(flex(TVAR1)),
     );
 
     types