Add optional types

20 files changed, 557 insertions, 375 deletions

diff --git a/Makefile b/Makefile
index 21f65d7e..89eaa619 100644
--- a/Makefile
+++ b/Makefile
@@ -30,7 +30,8 @@ CFLAGS_PLACEHOLDER="$$(echo -e '\033[2m<flags...>\033[m')"
 LDLIBS=-lgc -lcord -lm -lunistring -lgmp -ldl
 BUILTIN_OBJS=builtins/siphash.o builtins/array.o builtins/bool.o builtins/channel.o builtins/nums.o builtins/functions.o builtins/integers.o \
 						 builtins/pointer.o builtins/memory.o builtins/text.o builtins/thread.o builtins/c_string.o builtins/table.o \
-						 builtins/types.o builtins/util.o builtins/files.o builtins/range.o builtins/shell.o builtins/path.o builtins/nextline.o
+						 builtins/types.o builtins/util.o builtins/files.o builtins/range.o builtins/shell.o builtins/path.o builtins/nextline.o \
+						 builtins/optionals.o
 TESTS=$(patsubst %.tm,%.tm.testresult,$(wildcard test/*.tm))
 
 all: libtomo.so tomo
diff --git a/ast.c b/ast.c
index 0dfddb9a..869168f9 100644
--- a/ast.c
+++ b/ast.c
@@ -168,13 +168,14 @@ CORD type_ast_to_xml(type_ast_t *t)
 #define T(type, ...) case type: { auto data = t->__data.type; (void)data; return CORD_asprintf(__VA_ARGS__); }
     T(UnknownTypeAST, "<UnknownType/>")
     T(VarTypeAST, "%s", data.name)
-    T(PointerTypeAST, "<PointerType is_optional=\"%s\" is_stack=\"%s\" is_readonly=\"%s\">%r</PointerType>",
-      data.is_optional ? "yes" : "no", data.is_stack ? "yes" : "no", data.is_readonly ? "yes" : "no", type_ast_to_xml(data.pointed))
+    T(PointerTypeAST, "<PointerType is_stack=\"%s\" is_readonly=\"%s\">%r</PointerType>",
+      data.is_stack ? "yes" : "no", data.is_readonly ? "yes" : "no", type_ast_to_xml(data.pointed))
     T(ArrayTypeAST, "<ArrayType>%r</ArrayType>", type_ast_to_xml(data.item))
     T(SetTypeAST, "<TableType>%r</TableType>", type_ast_to_xml(data.item))
     T(ChannelTypeAST, "<ChannelType>%r</ChannelType>", type_ast_to_xml(data.item))
     T(TableTypeAST, "<TableType>%r %r</TableType>", type_ast_to_xml(data.key), type_ast_to_xml(data.value))
     T(FunctionTypeAST, "<FunctionType>%r %r</FunctionType>", arg_list_to_xml(data.args), type_ast_to_xml(data.ret))
+    T(OptionalTypeAST, "<OptionalType>%r</OptionalType>", data.type)
 #undef T
     default: return CORD_EMPTY;
     }
diff --git a/ast.h b/ast.h
index 0306cef3..116f6ea7 100644
--- a/ast.h
+++ b/ast.h
@@ -61,6 +61,7 @@ typedef enum {
     ChannelTypeAST,
     TableTypeAST,
     FunctionTypeAST,
+    OptionalTypeAST,
 } type_ast_e;
 
 typedef struct tag_ast_s {
@@ -83,7 +84,7 @@ struct type_ast_s {
         } VarTypeAST;
         struct {
             type_ast_t *pointed;
-            bool is_optional:1, is_stack:1, is_readonly:1;
+            bool is_stack:1, is_readonly:1;
         } PointerTypeAST;
         struct {
             type_ast_t *item;
@@ -98,6 +99,9 @@ struct type_ast_s {
             arg_ast_t *args;
             type_ast_t *ret;
         } FunctionTypeAST;
+        struct {
+            type_ast_t *type;
+        } OptionalTypeAST;
     } __data;
 };
 
diff --git a/builtins/functions.c b/builtins/functions.c
index b4e1a5cc..d6778d4c 100644
--- a/builtins/functions.c
+++ b/builtins/functions.c
@@ -16,6 +16,7 @@
 #include "files.h"
 #include "functions.h"
 #include "integers.h"
+#include "optionals.h"
 #include "pointer.h"
 #include "siphash.h"
 #include "string.h"
@@ -113,6 +114,9 @@ PUREFUNC public uint64_t generic_hash(const void *obj, const TypeInfo *type)
     case ArrayInfo: return Array$hash(obj, type);
     case ChannelInfo: return Channel$hash((const channel_t**)obj, type);
     case TableInfo: return Table$hash(obj, type);
+    case OptionalInfo: {
+        errx(1, "Optional hash not implemented");
+    }
     case EmptyStruct: return 0;
     case CustomInfo:
         if (!type->CustomInfo.hash)
@@ -135,6 +139,9 @@ PUREFUNC public int32_t generic_compare(const void *x, const void *y, const Type
     case ArrayInfo: return Array$compare(x, y, type);
     case ChannelInfo: return Channel$compare((const channel_t**)x, (const channel_t**)y, type);
     case TableInfo: return Table$compare(x, y, type);
+    case OptionalInfo: {
+        errx(1, "Optional compare not implemented");
+    }
     case EmptyStruct: return 0;
     case CustomInfo:
         if (!type->CustomInfo.compare)
@@ -157,6 +164,9 @@ PUREFUNC public bool generic_equal(const void *x, const void *y, const TypeInfo
     case ChannelInfo: return Channel$equal((const channel_t**)x, (const channel_t**)y, type);
     case TableInfo: return Table$equal(x, y, type);
     case EmptyStruct: return true;
+    case OptionalInfo: {
+        errx(1, "Optional equal not implemented");
+    }
     case CustomInfo:
         if (!type->CustomInfo.equal)
             goto use_generic_compare;
@@ -177,6 +187,7 @@ public Text_t generic_as_text(const void *obj, bool colorize, const TypeInfo *ty
     case ChannelInfo: return Channel$as_text((const channel_t**)obj, colorize, type);
     case TableInfo: return Table$as_text(obj, colorize, type);
     case TypeInfoInfo: return Type$as_text(obj, colorize, type);
+    case OptionalInfo: return Optional$as_text(obj, colorize, type);
     case EmptyStruct: return colorize ?
                       Text$concat(Text("\x1b[0;1m"), Text$from_str(type->EmptyStruct.name), Text("\x1b[m()"))
                           : Text$concat(Text$from_str(type->EmptyStruct.name), Text("()"));
diff --git a/builtins/optionals.c b/builtins/optionals.c
new file mode 100644
index 00000000..869ee4cd
--- /dev/null
+++ b/builtins/optionals.c
@@ -0,0 +1,49 @@
+// Optional types
+
+#include "bool.h"
+#include "datatypes.h"
+#include "text.h"
+#include "util.h"
+
+public const Array_t NULL_ARRAY = {.length=-1};
+public const Bool_t NULL_BOOL = -1;
+public const Int_t NULL_INT = {.small=0};
+public const Table_t NULL_TABLE = {.entries.length=-1};
+public const closure_t NULL_CLOSURE = {.fn=NULL};
+public const Text_t NULL_TEXT = {.length=-1};
+
+static inline bool is_null(const void *obj, const TypeInfo *non_optional_type)
+{
+    if (non_optional_type == &Int$info)
+        return ((Int_t*)obj)->small == 0;
+    else if (non_optional_type == &Bool$info)
+        return *((Bool_t*)obj) == NULL_BOOL;
+    else if (non_optional_type == &Num$info)
+        return isnan(*((Num_t*)obj));
+
+    switch (non_optional_type->tag) {
+        case PointerInfo: return *(void**)obj == NULL;
+        case TextInfo: return ((Text_t*)obj)->length < 0;
+        case ArrayInfo: return ((Array_t*)obj)->length < 0;
+        case TableInfo: return ((Table_t*)obj)->entries.length < 0;
+        case FunctionInfo: return *(void**)obj == NULL;
+        default: {
+            Text_t t = generic_as_text(NULL, false, non_optional_type);
+            errx(1, "is_null() not implemented for: %k", &t);
+        }
+    }
+}
+
+#pragma GCC diagnostic ignored "-Wstack-protector"
+public Text_t Optional$as_text(const void *obj, bool colorize, const TypeInfo *type)
+{
+    if (!obj)
+        return Text$concat(generic_as_text(obj, colorize, type->OptionalInfo.type), Text("?"));
+
+    if (is_null(obj, type->OptionalInfo.type))
+        return Text$concat(colorize ? Text("\x1b[31m!") : Text("!"), generic_as_text(NULL, false, type->OptionalInfo.type),
+                           colorize ? Text("\x1b[m") : Text(""));
+    return Text$concat(generic_as_text(obj, colorize, type->OptionalInfo.type), colorize ? Text("\x1b[33m?\x1b[m") : Text("?"));
+}
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1
diff --git a/builtins/optionals.h b/builtins/optionals.h
new file mode 100644
index 00000000..a0b9b0e0
--- /dev/null
+++ b/builtins/optionals.h
@@ -0,0 +1,25 @@
+#pragma once
+
+// Optional types
+
+#include <gc/cord.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "types.h"
+#include "util.h"
+
+#define Bool_t bool
+#define yes (Bool_t)true
+#define no (Bool_t)false
+
+extern const Bool_t NULL_BOOL;
+extern const Table_t NULL_TABLE;
+extern const Array_t NULL_ARRAY;
+extern const Int_t NULL_INT;
+extern const closure_t NULL_CLOSURE;
+extern const Text_t NULL_TEXT;
+
+Text_t Optional$as_text(const void *obj, bool colorize, const TypeInfo *type);
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/builtins/pointer.c b/builtins/pointer.c
index 0d89e8a6..9067ebd7 100644
--- a/builtins/pointer.c
+++ b/builtins/pointer.c
@@ -27,10 +27,6 @@ public Text_t Pointer$as_text(const void *x, bool colorize, const TypeInfo *type
             text = Text$concat(Text("\x1b[34;1m"), Text$from_str(ptr_info.sigil), typename, Text("\x1b[m"));
         else
             text = Text$concat(Text$from_str(ptr_info.sigil), typename);
-
-        if (ptr_info.is_optional)
-            text = Text$concat(text, Text("?"));
-
         return text;
     }
     const void *ptr = *(const void**)x;
@@ -55,8 +51,6 @@ public Text_t Pointer$as_text(const void *x, bool colorize, const TypeInfo *type
                 Text(".."),
                 Int32$as_text(&depth, false, &Int32$info),
                 colorize ? Text("\x1b[m") : Text(""));
-            if (ptr_info.is_optional)
-                text = Text$concat(text, colorize ? Text("\x1b[34;1m?\x1b[m") : Text("?"));
             return text;
         }
     }
@@ -73,9 +67,6 @@ public Text_t Pointer$as_text(const void *x, bool colorize, const TypeInfo *type
         text = Text$concat(Text("\x1b[34;1m"), Text$from_str(ptr_info.sigil), Text("\x1b[m"), pointed);
     else
         text = Text$concat(Text$from_str(ptr_info.sigil), pointed);
-
-    if (ptr_info.is_optional)
-        text = Text$concat(text, Text("?"));
     return text;
 }
 
diff --git a/builtins/tomo.h b/builtins/tomo.h
index 29f71f71..4a52da7c 100644
--- a/builtins/tomo.h
+++ b/builtins/tomo.h
@@ -21,6 +21,7 @@
 #include "macros.h"
 #include "memory.h"
 #include "nums.h"
+#include "optionals.h"
 #include "path.h"
 #include "pointer.h"
 #include "range.h"
diff --git a/builtins/types.c b/builtins/types.c
index 6d9e2408..79f65f71 100644
--- a/builtins/types.c
+++ b/builtins/types.c
@@ -39,6 +39,7 @@ public Text_t Func$as_text(const void *fn, bool colorize, const TypeInfo *type)
 {
     (void)fn;
     Text_t text = Text$from_str(type->FunctionInfo.type_str);
+    if (fn) text = Text$concat(text, Text(": ..."));
     if (fn && colorize)
         text = Text$concat(Text("\x1b[32;1m"), text, Text("\x1b[m"));
     return text;
diff --git a/builtins/types.h b/builtins/types.h
index f06730a7..a6cc40c6 100644
--- a/builtins/types.h
+++ b/builtins/types.h
@@ -17,7 +17,8 @@ typedef Text_t (*text_fn_t)(const void*, bool, const struct TypeInfo*);
 typedef struct TypeInfo {
     int64_t size, align;
     struct { // Anonymous tagged union for convenience 
-        enum { CustomInfo, PointerInfo, TextInfo, ArrayInfo, ChannelInfo, TableInfo, FunctionInfo, TypeInfoInfo, OpaqueInfo, EmptyStruct } tag;
+        enum { CustomInfo, PointerInfo, TextInfo, ArrayInfo, ChannelInfo, TableInfo, FunctionInfo,
+            OptionalInfo, TypeInfoInfo, OpaqueInfo, EmptyStruct } tag;
         union {
             struct {
                 equal_fn_t equal;
@@ -27,7 +28,6 @@ typedef struct TypeInfo {
             } CustomInfo;
             struct {
                 const char *sigil;
-                bool is_optional;
                 const struct TypeInfo *pointed;
             } PointerInfo;
             struct {
@@ -45,6 +45,9 @@ typedef struct TypeInfo {
             struct {
                 const char *type_str;
             } TypeInfoInfo;
+            struct {
+                const struct TypeInfo *type;
+            } OptionalInfo;
 #pragma GCC diagnostic ignored "-Wpedantic"
             struct {} OpaqueInfo;
             struct {
@@ -54,8 +57,8 @@ typedef struct TypeInfo {
     };
 } TypeInfo;
 
-#define Pointer$info(sigil_expr, pointed_info, opt) &((TypeInfo){.size=sizeof(void*), .align=__alignof__(void*), \
-                                                      .tag=PointerInfo, .PointerInfo={.sigil=sigil_expr, .pointed=pointed_info, .is_optional=opt}})
+#define Pointer$info(sigil_expr, pointed_info) &((TypeInfo){.size=sizeof(void*), .align=__alignof__(void*), \
+                                                      .tag=PointerInfo, .PointerInfo={.sigil=sigil_expr, .pointed=pointed_info}})
 #define Array$info(item_info) &((TypeInfo){.size=sizeof(Array_t), .align=__alignof__(Array_t), \
                                 .tag=ArrayInfo, .ArrayInfo.item=item_info})
 #define Set$info(item_info) &((TypeInfo){.size=sizeof(Table_t), .align=__alignof__(Table_t), \
@@ -70,6 +73,8 @@ typedef struct TypeInfo {
                                  .tag=FunctionInfo, .FunctionInfo.type_str=typestr})
 #define TypeInfo$info(typestr) &((TypeInfo){.size=sizeof(TypeInfo), .align=__alignof__(TypeInfo), \
                                  .tag=TypeInfoInfo, .TypeInfoInfo.type_str=typestr})
+#define Optional$info(t) &((TypeInfo){.size=(t)->size, .align=(t)->align, \
+                           .tag=OptionalInfo, .OptionalInfo.type=t})
 
 extern const TypeInfo TypeInfo$info;
 extern const TypeInfo Void$info;
diff --git a/compile.c b/compile.c
index 99f94237..5ccfafe3 100644
--- a/compile.c
+++ b/compile.c
@@ -55,13 +55,17 @@ static bool promote(env_t *env, CORD *code, type_t *actual, type_t *needed)
     }
 
     // Automatic dereferencing:
-    if (actual->tag == PointerType && !Match(actual, PointerType)->is_optional
+    if (actual->tag == PointerType
         && can_promote(Match(actual, PointerType)->pointed, needed)) {
         *code = CORD_all("*(", *code, ")");
         return promote(env, code, Match(actual, PointerType)->pointed, needed);
     }
 
-    // Optional and stack ref promotion:
+    // Optional promotion:
+    if (needed->tag == OptionalType && type_eq(actual, Match(needed, OptionalType)->type))
+        return true;
+
+    // Stack ref promotion:
     if (actual->tag == PointerType && needed->tag == PointerType)
         return true;
 
@@ -194,6 +198,12 @@ CORD compile_type(type_t *t)
         auto e = Match(t, EnumType);
         return CORD_all(namespace_prefix(e->env->libname, e->env->namespace->parent), e->name, "_t");
     }
+    case OptionalType: {
+        type_t *nonnull = Match(t, OptionalType)->type;
+        if (!supports_optionals(nonnull))
+            compiler_err(NULL, NULL, NULL, "Optional types are not supported for: %T", t);
+        return compile_type(nonnull);
+    }
     case TypeInfoType: return "TypeInfo";
     default: compiler_err(NULL, NULL, NULL, "Compiling type is not implemented for type with tag %d", t->tag);
     }
@@ -213,11 +223,12 @@ static CORD compile_lvalue(env_t *env, ast_t *ast)
     if (ast->tag == Index) {
         auto index = Match(ast, Index);
         type_t *container_t = get_type(env, index->indexed);
-        if (!index->index && container_t->tag == PointerType) {
-            if (Match(container_t, PointerType)->is_optional)
-                code_err(index->indexed, "This pointer might be null, so it can't be safely used as an assignment target");
+        if (container_t->tag == OptionalType)
+            code_err(index->indexed, "This value might be null, so it can't be safely used as an assignment target");
+
+        if (!index->index && container_t->tag == PointerType)
             return compile(env, ast);
-        }
+
         container_t = value_type(container_t);
         if (container_t->tag == ArrayType) {
             CORD target_code = compile_to_pointer_depth(env, index->indexed, 1, false);
@@ -269,6 +280,36 @@ static CORD compile_inline_block(env_t *env, ast_t *ast)
     return code;
 }
 
+static CORD compile_optional_into_nonnull(env_t *env, binding_t *b)
+{
+    (void)env;
+    // TODO: implement
+    return (b->code);
+}
+
+static CORD compile_optional_check(env_t *env, ast_t *ast)
+{
+    type_t *t = get_type(env, ast);
+    t = Match(t, OptionalType)->type;
+    if (t->tag == PointerType || t->tag == FunctionType)
+        return CORD_all("(", compile(env, ast), " != NULL)");
+    else if (t->tag == BigIntType)
+        return CORD_all("((", compile(env, ast), ").small != 0)");
+    else if (t->tag == ClosureType)
+        return CORD_all("((", compile(env, ast), ").fn != NULL)");
+    else if (t->tag == NumType)
+        return CORD_all("!isnan(", compile(env, ast), ")");
+    else if (t->tag == ArrayType)
+        return CORD_all("((", compile(env, ast), ").length >= 0)");
+    else if (t->tag == TableType || t->tag == SetType)
+        return CORD_all("((", compile(env, ast), ").entries.length >= 0)");
+    else if (t->tag == BoolType)
+        return CORD_all("((", compile(env, ast), ") != NULL_BOOL)");
+    else if (t->tag == TextType)
+        return CORD_all("((", compile(env, ast), ").length >= 0)");
+    errx(1, "Optional check not implemented for: %T", t);
+}
+
 CORD compile_statement(env_t *env, ast_t *ast)
 {
     switch (ast->tag) {
@@ -280,21 +321,6 @@ CORD compile_statement(env_t *env, ast_t *ast)
         auto when = Match(ast, When);
         type_t *subject_t = get_type(env, when->subject);
 
-        if (subject_t->tag == PointerType) {
-            ast_t *var = when->clauses->args->ast;
-            CORD var_code = compile(env, var);
-            env_t *non_null_scope = fresh_scope(env);
-            auto ptr = Match(subject_t, PointerType);
-            type_t *non_optional_t = Type(PointerType, .pointed=ptr->pointed, .is_stack=ptr->is_stack,
-                                          .is_readonly=ptr->is_readonly, .is_optional=false);
-            set_binding(non_null_scope, Match(var, Var)->name, new(binding_t, .type=non_optional_t, .code=var_code));
-            return CORD_all(
-                "{\n",
-                compile_declaration(subject_t, var_code), "  = ", compile(env, when->subject), ";\n"
-                "if (", var_code, ")\n", compile_statement(non_null_scope, when->clauses->body),
-                "\nelse\n", compile_statement(env, when->else_body), "\n}");
-        }
-
         auto enum_t = Match(subject_t, EnumType);
         CORD code = CORD_all("{ ", compile_type(subject_t), " subject = ", compile(env, when->subject), ";\n"
                              "switch (subject.tag) {");
@@ -742,7 +768,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
                 "static Table_t cache = {};\n",
                 compile_type(args_t), " args = {", all_args, "};\n"
                 "const TypeInfo *table_type = Table$info(", compile_type_info(env, args_t), ", ", compile_type_info(env, ret_t), ");\n",
-                compile_declaration(Type(PointerType, .pointed=ret_t, .is_optional=true), "cached"), " = Table$get_raw(cache, &args, table_type);\n"
+                compile_declaration(Type(PointerType, .pointed=ret_t), "cached"), " = Table$get_raw(cache, &args, table_type);\n"
                 "if (cached) return *cached;\n",
                 compile_declaration(ret_t, "ret"), " = ", name, "$uncached(", all_args, ");\n",
                 pop_code,
@@ -1172,19 +1198,32 @@ CORD compile_statement(env_t *env, ast_t *ast)
         auto if_ = Match(ast, If);
         type_t *cond_t = get_type(env, if_->condition);
         if (cond_t->tag == PointerType) {
-            if (!Match(cond_t, PointerType)->is_optional)
-                code_err(if_->condition, "This pointer will always be non-null, so it should not be used in a conditional.");
-        } else if (cond_t->tag != BoolType && cond_t->tag != TextType) {
+            code_err(if_->condition, "This pointer will always be non-null, so it should not be used in a conditional.");
+        } else if (cond_t->tag != BoolType && cond_t->tag != TextType && cond_t->tag != OptionalType) {
             code_err(if_->condition, "Only boolean values, optional pointers, and text can be used in conditionals (this is a %T)", cond_t);
         }
 
+        env_t *truthy_scope = env; 
         CORD condition;
-        if (cond_t->tag == TextType)
+        if (cond_t->tag == TextType) {
             condition = CORD_all("(", compile(env, if_->condition), ").length");
-        else
+        } else if (cond_t->tag == OptionalType) {
+            if (if_->condition->tag == Var) {
+                truthy_scope = fresh_scope(env);
+                const char *varname = Match(if_->condition, Var)->name;
+                binding_t *b = get_binding(env, varname);
+                binding_t *nonnull_b = new(binding_t);
+                *nonnull_b = *b;
+                nonnull_b->type = Match(cond_t, OptionalType)->type;
+                nonnull_b->code = compile_optional_into_nonnull(env, b);
+                set_binding(truthy_scope, varname, nonnull_b);
+            }
+            condition = compile_optional_check(env, if_->condition);
+        } else {
             condition = compile(env, if_->condition);
+        }
 
-        CORD code = CORD_all("if (", condition, ")", compile_statement(env, if_->body));
+        CORD code = CORD_all("if (", condition, ")", compile_statement(truthy_scope, if_->body));
         if (if_->else_body)
             code = CORD_all(code, "\nelse ", compile_statement(env, if_->else_body));
         return code;
@@ -1280,6 +1319,7 @@ CORD expr_as_text(env_t *env, CORD expr, type_t *t, CORD color)
     case TableType: return CORD_asprintf("Table$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
     case FunctionType: case ClosureType: return CORD_asprintf("Func$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
     case PointerType: return CORD_asprintf("Pointer$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
+    case OptionalType: return CORD_asprintf("Optional$as_text(stack(%r), %r, %r)", expr, color, compile_type_info(env, t));
     case StructType: case EnumType:
         return CORD_asprintf("(%r)->CustomInfo.as_text(stack(%r), %r, %r)",
                              compile_type_info(env, t), expr, color, compile_type_info(env, t));
@@ -1317,8 +1357,6 @@ CORD compile_to_pointer_depth(env_t *env, ast_t *ast, int64_t target_depth, bool
             ++depth;
         } else {
             auto ptr = Match(t, PointerType);
-            if (ptr->is_optional)
-                code_err(ast, "You can't dereference this value, since it's not guaranteed to be non-null");
             val = CORD_all("*(", val, ")");
             t = ptr->pointed;
             --depth;
@@ -1327,8 +1365,6 @@ CORD compile_to_pointer_depth(env_t *env, ast_t *ast, int64_t target_depth, bool
 
     while (t->tag == PointerType) {
         auto ptr = Match(t, PointerType);
-        if (ptr->is_optional)
-            code_err(ast, "You can't dereference this value, since it's not guaranteed to be non-null");
         t = ptr->pointed;
     }
 
@@ -1594,7 +1630,18 @@ CORD compile(env_t *env, ast_t *ast)
     switch (ast->tag) {
     case Nil: {
         type_t *t = parse_type_ast(env, Match(ast, Nil)->type);
-        return CORD_all("((", compile_type(t), ")NULL)");
+        switch (t->tag) {
+        case BigIntType: return "NULL_INT";
+        case BoolType: return "NULL_BOOL";
+        case ArrayType: return "NULL_ARRAY";
+        case TableType: return "NULL_TABLE";
+        case SetType: return "NULL_TABLE";
+        case TextType: return "NULL_TEXT";
+        case PointerType: return CORD_all("((", compile_type(t), ")NULL)");
+        case ClosureType: return "NULL_CLOSURE";
+        case NumType: return "nan(\"null\")";
+        default: code_err(ast, "Nil isn't implemented for this type: %T", t);
+        }
     }
     case Bool: return Match(ast, Bool)->b ? "yes" : "no";
     case Var: {
@@ -1668,8 +1715,8 @@ CORD compile(env_t *env, ast_t *ast)
             return CORD_all("((", compile(env, value), ").entries.length == 0)");
         else if (t->tag == TextType)
             return CORD_all("(", compile(env, value), " == CORD_EMPTY)");
-        else if (t->tag == PointerType && Match(t, PointerType)->is_optional)
-            return CORD_all("(", compile(env, value), " == NULL)");
+        else if (t->tag == OptionalType)
+            return CORD_all("!(", compile_optional_check(env, value), ")");
 
         code_err(ast, "I don't know how to negate values of type %T", t);
     }
@@ -2058,7 +2105,7 @@ CORD compile(env_t *env, ast_t *ast)
         if (!table->entries) {
             CORD code = "((Table_t){";
             if (table->fallback)
-                code = CORD_all(code, ".fallback=", compile(env, table->fallback),",");
+                code = CORD_all(code, ".fallback=heap(", compile(env, table->fallback),")");
             return CORD_cat(code, "})");
         }
 
@@ -2883,7 +2930,7 @@ CORD compile(env_t *env, ast_t *ast)
                                 "values.data += ", CORD_asprintf("%zu", offset), ";\n"
                                 "values; })");
             } else if (streq(f->field, "fallback")) {
-                return CORD_all("(", compile_to_pointer_depth(env, f->fielded, 0, false), ").fallback");
+                return CORD_all("({ Table_t *_fallback = (", compile_to_pointer_depth(env, f->fielded, 0, false), ").fallback; _fallback ? *_fallback : NULL_TABLE; })");
             }
             code_err(ast, "There is no '%s' field on tables", f->field);
         }
@@ -2903,8 +2950,6 @@ CORD compile(env_t *env, ast_t *ast)
             if (indexed_type->tag != PointerType)
                 code_err(ast, "Only pointers can use the '[]' operator to dereference the entire value.");
             auto ptr = Match(indexed_type, PointerType);
-            if (ptr->is_optional)
-                code_err(ast, "This pointer is potentially null, so it can't be safely dereferenced");
             if (ptr->pointed->tag == ArrayType) {
                 return CORD_all("({ Array_t *arr = ", compile(env, indexing->indexed), "; ARRAY_INCREF(*arr); *arr; })");
             } else if (ptr->pointed->tag == TableType || ptr->pointed->tag == SetType) {
@@ -3083,10 +3128,9 @@ CORD compile_type_info(env_t *env, type_t *t)
         auto ptr = Match(t, PointerType);
         CORD sigil = ptr->is_stack ? "&" : "@";
         if (ptr->is_readonly) sigil = CORD_cat(sigil, "%");
-        return CORD_asprintf("Pointer$info(%r, %r, %s)",
+        return CORD_asprintf("Pointer$info(%r, %r)",
                              CORD_quoted(sigil),
-                             compile_type_info(env, ptr->pointed),
-                             ptr->is_optional ? "yes" : "no");
+                             compile_type_info(env, ptr->pointed));
     }
     case FunctionType: {
         return CORD_asprintf("Function$info(%r)", CORD_quoted(type_to_cord(t)));
@@ -3094,6 +3138,9 @@ CORD compile_type_info(env_t *env, type_t *t)
     case ClosureType: {
         return CORD_asprintf("Closure$info(%r)", CORD_quoted(type_to_cord(t)));
     }
+    case OptionalType: {
+        return CORD_asprintf("Optional$info(%r)", compile_type_info(env, Match(t, OptionalType)->type));
+    }
     case TypeInfoType: return "&TypeInfo$info";
     case MemoryType: return "&Memory$info";
     case VoidType: return "&Void$info";
diff --git a/environment.c b/environment.c
index 94401ec9..10b95f8e 100644
--- a/environment.c
+++ b/environment.c
@@ -287,7 +287,7 @@ env_t *new_compilation_unit(CORD *libname)
         )},
         {"Shell", Type(TextType, .lang="Shell", .env=namespace_env(env, "Shell")), "Shell_t", "Shell$info", TypedArray(ns_entry_t,
             {"escape_text", "Shell$escape_text", "func(text:Text)->Shell"},
-            {"run", "Shell$run", "func(command:Shell, status=!&Int32?)->Text"},
+            {"run", "Shell$run", "func(command:Shell, status=!&Int32)->Text"},
         )},
         {"Text", TEXT_TYPE, "Text_t", "Text$info", TypedArray(ns_entry_t,
             {"as_c_string", "Text$as_c_string", "func(text:Text)->CString"},
diff --git a/parse.c b/parse.c
index b094f6c9..95b05cbc 100644
--- a/parse.c
+++ b/parse.c
@@ -84,6 +84,7 @@ static ast_t *parse_comprehension_suffix(parse_ctx_t *ctx, ast_t *lhs);
 static ast_t *parse_optional_conditional_suffix(parse_ctx_t *ctx, ast_t *lhs);
 static ast_t *parse_optional_suffix(parse_ctx_t *ctx, ast_t *lhs);
 static arg_ast_t *parse_args(parse_ctx_t *ctx, const char **pos, bool allow_unnamed);
+static type_ast_t *parse_non_optional_type(parse_ctx_t *ctx, const char *pos);
 static type_ast_t *parse_type(parse_ctx_t *ctx, const char *pos);
 static PARSER(parse_array);
 static PARSER(parse_block);
@@ -576,10 +577,14 @@ type_ast_t *parse_pointer_type(parse_ctx_t *ctx, const char *pos) {
     spaces(&pos);
     bool is_readonly = match(&pos, "%");
     spaces(&pos);
-    type_ast_t *type = expect(ctx, start, &pos, parse_type,
+    type_ast_t *type = expect(ctx, start, &pos, parse_non_optional_type,
                               "I couldn't parse a pointer type after this point");
-    bool optional = match(&pos, "?");
-    return NewTypeAST(ctx->file, start, pos, PointerTypeAST, .pointed=type, .is_optional=optional, .is_stack=is_stack, .is_readonly=is_readonly);
+    type_ast_t *ptr_type = NewTypeAST(ctx->file, start, pos, PointerTypeAST, .pointed=type, .is_stack=is_stack, .is_readonly=is_readonly);
+    spaces(&pos);
+    if (match(&pos, "?"))
+        return NewTypeAST(ctx->file, start, pos, OptionalTypeAST, .type=ptr_type);
+    else
+        return ptr_type;
 }
 
 type_ast_t *parse_type_name(parse_ctx_t *ctx, const char *pos) {
@@ -598,7 +603,7 @@ type_ast_t *parse_type_name(parse_ctx_t *ctx, const char *pos) {
     return NewTypeAST(ctx->file, start, pos, VarTypeAST, .name=id);
 }
 
-type_ast_t *parse_type(parse_ctx_t *ctx, const char *pos) {
+type_ast_t *parse_non_optional_type(parse_ctx_t *ctx, const char *pos) {
     const char *start = pos;
     type_ast_t *type = NULL;
     bool success = (false
@@ -620,10 +625,18 @@ type_ast_t *parse_type(parse_ctx_t *ctx, const char *pos) {
         type->end = pos;
     }
 
-    if (!type) return NULL;
+    return type;
+}
 
+type_ast_t *parse_type(parse_ctx_t *ctx, const char *pos) {
+    const char *start = pos;
+    type_ast_t *type = parse_non_optional_type(ctx, pos);
     pos = type->end;
-    return type;
+    spaces(&pos);
+    if (match(&pos, "?"))
+        return NewTypeAST(ctx->file, start, pos, OptionalTypeAST, .type=type);
+    else
+        return type;
 }
 
 PARSER(parse_num) {
@@ -749,7 +762,7 @@ PARSER(parse_table) {
             return NULL;
         value_type = expect(ctx, pos-1, &pos, parse_type, "I couldn't parse a value type for this table");
         whitespace(&pos);
-        match(&pos, ";");
+        match(&pos, ",");
     }
 
     for (;;) {
@@ -891,6 +904,7 @@ PARSER(parse_reduction) {
                 || (new_term=parse_field_suffix(ctx, key))
                 || (new_term=parse_method_call_suffix(ctx, key))
                 || (new_term=parse_fncall_suffix(ctx, key))
+                || (new_term=parse_optional_suffix(ctx, key))
                 );
             if (progress) key = new_term;
         }
@@ -1134,20 +1148,44 @@ PARSER(parse_heap_alloc) {
     const char *start = pos;
     if (!match(&pos, "@")) return NULL;
     spaces(&pos);
-    ast_t *val = expect(ctx, start, &pos, parse_term, "I expected an expression for this '@'");
+    ast_t *val = expect(ctx, start, &pos, parse_term_no_suffix, "I expected an expression for this '@'");
+
+    for (;;) {
+        ast_t *new_term;
+        if ((new_term=parse_index_suffix(ctx, val))
+            || (new_term=parse_fncall_suffix(ctx, val))
+            || (new_term=parse_field_suffix(ctx, val))) {
+            val = new_term;
+        } else break;
+    }
+    pos = val->end;
+
     ast_t *ast = NewAST(ctx->file, start, pos, HeapAllocate, .value=val);
     ast_t *optional = parse_optional_suffix(ctx, ast);
-    return optional ? optional : ast; 
+    if (optional) ast = optional;
+    return ast;
 }
 
 PARSER(parse_stack_reference) {
     const char *start = pos;
     if (!match(&pos, "&")) return NULL;
     spaces(&pos);
-    ast_t *val = expect(ctx, start, &pos, parse_term, "I expected an expression for this '&'");
+    ast_t *val = expect(ctx, start, &pos, parse_term_no_suffix, "I expected an expression for this '&'");
+
+    for (;;) {
+        ast_t *new_term;
+        if ((new_term=parse_index_suffix(ctx, val))
+            || (new_term=parse_fncall_suffix(ctx, val))
+            || (new_term=parse_field_suffix(ctx, val))) {
+            val = new_term;
+        } else break;
+    }
+    pos = val->end;
+
     ast_t *ast = NewAST(ctx->file, start, pos, StackReference, .value=val);
     ast_t *optional = parse_optional_suffix(ctx, ast);
-    return optional ? optional : ast; 
+    if (optional) ast = optional;
+    return ast;
 }
 
 PARSER(parse_not) {
@@ -1425,6 +1463,7 @@ PARSER(parse_lambda) {
     spaces(&pos);
     expect_closing(ctx, &pos, ")", "I was expecting a ')' to finish this anonymous function's arguments");
     ast_t *body = optional(ctx, &pos, parse_block);
+    if (!body) body = NewAST(ctx->file, pos, pos, Block, .statements=NULL);
     return NewAST(ctx->file, start, pos, Lambda, .id=ctx->next_lambda_id++, .args=args, .body=body);
 }
 
@@ -1488,6 +1527,7 @@ PARSER(parse_term) {
             || (new_term=parse_field_suffix(ctx, term))
             || (new_term=parse_method_call_suffix(ctx, term))
             || (new_term=parse_fncall_suffix(ctx, term))
+            || (new_term=parse_optional_suffix(ctx, term))
             );
         if (progress) term = new_term;
     }
@@ -1630,6 +1670,7 @@ static ast_t *parse_infix_expr(parse_ctx_t *ctx, const char *pos, int min_tightn
                     || (new_term=parse_field_suffix(ctx, key))
                     || (new_term=parse_method_call_suffix(ctx, key))
                     || (new_term=parse_fncall_suffix(ctx, key))
+                    || (new_term=parse_optional_suffix(ctx, key))
                     );
                 if (progress) key = new_term;
             }
diff --git a/repl.c b/repl.c
index 81962c38..372fcba4 100644
--- a/repl.c
+++ b/repl.c
@@ -139,7 +139,7 @@ const TypeInfo *type_to_type_info(type_t *t)
         if (ptr->is_readonly) sigil = CORD_cat(sigil, "%");
         const TypeInfo *pointed_info = type_to_type_info(ptr->pointed);
         const TypeInfo pointer_info = {.size=sizeof(void*), .align=__alignof__(void*),
-            .tag=PointerInfo, .PointerInfo={.sigil=sigil, .pointed=pointed_info, .is_optional=ptr->is_optional}};
+            .tag=PointerInfo, .PointerInfo={.sigil=sigil, .pointed=pointed_info}};
         return memcpy(GC_MALLOC(sizeof(TypeInfo)), &pointer_info, sizeof(TypeInfo));
     }
     default: errx(1, "Unsupported type: %T", t);
@@ -494,8 +494,6 @@ void eval(env_t *env, ast_t *ast, void *dest)
         }
         case PointerType: {
             auto ptr = Match(indexed_t, PointerType);
-            if (ptr->is_optional)
-                repl_err(ast, "You can't dereference an optional pointer because it might be null");
             size_t pointed_size = type_size(ptr->pointed);
             void *pointer;
             eval(env, index->indexed, &pointer);
diff --git a/test/arrays.tm b/test/arrays.tm
index 16f411a2..5856e0a4 100644
--- a/test/arrays.tm
+++ b/test/arrays.tm
@@ -168,8 +168,8 @@ func main():
 	>> [10, 20, 30]:find(999)
 	= 0
 
-    >> [10, 20]:first(func(i:&Int): i:is_prime())
-    = !Int
-    >> [4, 5, 6]:first(func(i:&Int): i:is_prime())
-    = @%5?
+	# >> [10, 20]:first(func(i:&Int): i:is_prime())
+	# = !Int
+	# >> [4, 5, 6]:first(func(i:&Int): i:is_prime())
+	# = @%5?
 
diff --git a/test/optionals.tm b/test/optionals.tm
index 5f6fb78a..d8cbf741 100644
--- a/test/optionals.tm
+++ b/test/optionals.tm
@@ -1,15 +1,123 @@
+func maybe_int(should_i:Bool)->Int?:
+    if should_i:
+        return 123
+    else:
+        return !Int
 
-func main():
-    >> opt := @5?
-    when opt is @nonnull:
-        >> nonnull[]
-        = 5
+func maybe_array(should_i:Bool)->[Int]?:
+    if should_i:
+        return [10, 20, 30]
+    else:
+        return ![Int]
+
+func maybe_bool(should_i:Bool)->Bool?:
+    if should_i:
+        return no
+    else:
+        return !Bool
+
+func maybe_text(should_i:Bool)->Text?:
+    if should_i:
+        return "Hello"
+    else:
+        return !Text
+
+func maybe_num(should_i:Bool)->Num?:
+    if should_i:
+        return 12.3
     else:
-        fail("Oops")
+        return !Num
 
-    >> opt = !@Int
-    when opt is @nonnull:
-        fail("Oops")
+func maybe_lambda(should_i:Bool)-> func()?:
+    if should_i:
+        return func(): say("hi!")
     else:
-        >> opt
+        return !func()
+
+func main():
+    >> 5?
+    = 5? : Int?
+
+    >> if no:
+        !Int
+    else:
+        5
+    = 5? : Int?
+
+    do:
+        !! Ints:
+        >> yep := maybe_int(yes)
+        = 123?
+        >> nope := maybe_int(no)
         = !Int
+        >> if yep: >> yep
+        else: fail("Falsey: $yep")
+        >> if nope:
+            fail("Truthy: $nope")
+        else: !! Falsey: $nope
+
+    do:
+        !! ...
+        !! Arrays:
+        >> yep := maybe_array(yes)
+        = [10, 20, 30]?
+        >> nope := maybe_array(no)
+        = ![Int]
+        >> if yep: >> yep
+        else: fail("Falsey: $yep")
+        >> if nope:
+            fail("Truthy: $nope")
+        else: !! Falsey: $nope
+
+    do:
+        !! ...
+        !! Bools:
+        >> yep := maybe_bool(yes)
+        = no?
+        >> nope := maybe_bool(no)
+        = !Bool
+        >> if yep: >> yep
+        else: fail("Falsey: $yep")
+        >> if nope:
+            fail("Truthy: $nope")
+        else: !! Falsey: $nope
+
+    do:
+        !! ...
+        !! Text:
+        >> yep := maybe_text(yes)
+        = "Hello"?
+        >> nope := maybe_text(no)
+        = !Text
+        >> if yep: >> yep
+        else: fail("Falsey: $yep")
+        >> if nope:
+            fail("Truthy: $nope")
+        else: !! Falsey: $nope
+
+    do:
+        !! ...
+        !! Nums:
+        >> yep := maybe_num(yes)
+        = 12.3?
+        >> nope := maybe_num(no)
+        = !Num
+        >> if yep: >> yep
+        else: fail("Falsey: $yep")
+        >> if nope:
+            fail("Truthy: $nope")
+        else: !! Falsey: $nope
+
+    do:
+        !! ...
+        !! Lambdas:
+        >> yep := maybe_lambda(yes)
+        = func(): ...?
+        >> nope := maybe_lambda(no)
+        = !func()
+        >> if yep: >> yep
+        else: fail("Falsey: $yep")
+        >> if nope:
+            fail("Truthy: $nope")
+        else: !! Falsey: $nope
+
diff --git a/test/tables.tm b/test/tables.tm
index 7b3595b6..e59283ed 100644
--- a/test/tables.tm
+++ b/test/tables.tm
@@ -38,7 +38,7 @@ func main():
 	>> t2.length
 	= 1
 	>> t2.fallback
-	= @%{"one":1, "two":2}?
+	= {"one":1, "two":2}?
 
 	t2_str := ""
 	for k,v in t2:
diff --git a/typecheck.c b/typecheck.c
index 5d3ffb48..d82ddcbf 100644
--- a/typecheck.c
+++ b/typecheck.c
@@ -43,7 +43,7 @@ type_t *parse_type_ast(env_t *env, type_ast_t *ast)
         type_t *pointed_t = parse_type_ast(env, ptr->pointed);
         if (pointed_t->tag == VoidType)
             code_err(ast, "Void pointers are not supported. You probably meant 'Memory' instead of 'Void'");
-        return Type(PointerType, .is_optional=ptr->is_optional, .pointed=pointed_t, .is_stack=ptr->is_stack, .is_readonly=ptr->is_readonly);
+        return Type(PointerType, .pointed=pointed_t, .is_stack=ptr->is_stack, .is_readonly=ptr->is_readonly);
     }
     case ArrayTypeAST: {
         type_ast_t *item_type = Match(ast, ArrayTypeAST)->item;
@@ -109,6 +109,13 @@ type_t *parse_type_ast(env_t *env, type_ast_t *ast)
         REVERSE_LIST(type_args);
         return Type(ClosureType, Type(FunctionType, .args=type_args, .ret=ret_t));
     }
+    case OptionalTypeAST: {
+        auto opt = Match(ast, OptionalTypeAST);
+        type_t *t = parse_type_ast(env, opt->type);
+        if (t->tag == VoidType || t->tag == AbortType || t->tag == ReturnType)
+            code_err(ast, "Optional %T types are not supported.", t);
+        return Type(OptionalType, .type=t);
+    }
     case UnknownTypeAST: code_err(ast, "I don't know how to get this type");
     }
     errx(1, "Unreachable");
@@ -438,60 +445,43 @@ type_t *get_method_type(env_t *env, ast_t *self, const char *name)
 
 type_t *get_clause_type(env_t *env, type_t *subject_t, when_clause_t *clause)
 {
-    if (subject_t->tag == PointerType) {
-        if (!Match(subject_t, PointerType)->is_optional)
-            code_err(clause->body, "This %T pointer type is not optional, so this 'when' statement is tautological", subject_t);
-
-        const char *tag_name = Match(clause->tag_name, Var)->name;
-        if (!streq(tag_name, "@"))
-            code_err(clause->tag_name, "'when' clauses on optional pointers only support @var, not tags like '%s'", tag_name);
-
-        assert(clause->args);
-        env_t *scope = fresh_scope(env);
-        auto ptr = Match(subject_t, PointerType);
-        set_binding(scope, Match(clause->args->ast, Var)->name,
-                    new(binding_t, .type=Type(PointerType, .pointed=ptr->pointed, .is_stack=ptr->is_stack, .is_readonly=ptr->is_readonly)));
-
-        return get_type(scope, clause->body);
-    } else {
-        assert(subject_t->tag == EnumType);
-        tag_t * const tags = Match(subject_t, EnumType)->tags;
-
-        const char *tag_name = Match(clause->tag_name, Var)->name;
-        type_t *tag_type = NULL;
-        for (tag_t *tag = tags; tag; tag = tag->next) {
-            if (streq(tag->name, tag_name)) {
-                tag_type = tag->type;
-                break;
-            }
+    assert(subject_t->tag == EnumType);
+    tag_t * const tags = Match(subject_t, EnumType)->tags;
+
+    const char *tag_name = Match(clause->tag_name, Var)->name;
+    type_t *tag_type = NULL;
+    for (tag_t *tag = tags; tag; tag = tag->next) {
+        if (streq(tag->name, tag_name)) {
+            tag_type = tag->type;
+            break;
         }
+    }
 
-        if (!tag_type)
-            code_err(clause->tag_name, "There is no tag '%s' for the type %T", tag_name, subject_t);
+    if (!tag_type)
+        code_err(clause->tag_name, "There is no tag '%s' for the type %T", tag_name, subject_t);
 
-        // Don't return early so we validate the tags
-        if (!clause->args)
-            return get_type(env, clause->body);
+    // Don't return early so we validate the tags
+    if (!clause->args)
+        return get_type(env, clause->body);
 
-        env_t *scope = fresh_scope(env);
-        auto tag_struct = Match(tag_type, StructType);
-        if (!clause->args->next && tag_struct->fields && tag_struct->fields->next) {
-            set_binding(scope, Match(clause->args->ast, Var)->name, new(binding_t, .type=tag_type));
-        } else {
-            ast_list_t *var = clause->args;
-            arg_t *field = tag_struct->fields;
-            while (var || field) {
-                if (!var)
-                    code_err(clause->tag_name, "The field %T.%s.%s wasn't accounted for", subject_t, tag_name, field->name);
-                if (!field)
-                    code_err(var->ast, "This is one more field than %T has", subject_t);
-                set_binding(scope, Match(var->ast, Var)->name, new(binding_t, .type=field->type));
-                var = var->next;
-                field = field->next;
-            }
-        }
-        return get_type(scope, clause->body);
-    }
+    env_t *scope = fresh_scope(env);
+    auto tag_struct = Match(tag_type, StructType);
+    if (!clause->args->next && tag_struct->fields && tag_struct->fields->next) {
+        set_binding(scope, Match(clause->args->ast, Var)->name, new(binding_t, .type=tag_type));
+    } else {
+        ast_list_t *var = clause->args;
+        arg_t *field = tag_struct->fields;
+        while (var || field) {
+            if (!var)
+                code_err(clause->tag_name, "The field %T.%s.%s wasn't accounted for", subject_t, tag_name, field->name);
+            if (!field)
+                code_err(var->ast, "This is one more field than %T has", subject_t);
+            set_binding(scope, Match(var->ast, Var)->name, new(binding_t, .type=field->type));
+            var = var->next;
+            field = field->next;
+        }
+    }
+    return get_type(scope, clause->body);
 }
 
 type_t *get_type(env_t *env, ast_t *ast)
@@ -500,10 +490,7 @@ type_t *get_type(env_t *env, ast_t *ast)
     switch (ast->tag) {
     case Nil: {
         type_t *t = parse_type_ast(env, Match(ast, Nil)->type);
-        if (t->tag != PointerType)
-            code_err(ast, "This type is not a pointer type, so it doesn't work with a '!' nil expression");
-        auto ptr = Match(t, PointerType);
-        return Type(PointerType, .is_optional=true, .pointed=ptr->pointed, .is_stack=ptr->is_stack, .is_readonly=ptr->is_readonly);
+        return Type(OptionalType, .type=t);
     }
     case Bool: {
         return Type(BoolType);
@@ -533,7 +520,7 @@ type_t *get_type(env_t *env, ast_t *ast)
         type_t *pointed = get_type(env, Match(ast, HeapAllocate)->value);
         if (has_stack_memory(pointed))
             code_err(ast, "Stack references cannot be moved to the heap because they may outlive the stack frame they were created in.");
-        return Type(PointerType, .is_optional=false, .pointed=pointed);
+        return Type(PointerType, .pointed=pointed);
     }
     case StackReference: {
         // Supported:
@@ -558,10 +545,10 @@ type_t *get_type(env_t *env, ast_t *ast)
 
             type_t *ref_type = get_type(env, value);
             type_t *base_type = get_type(env, base);
-            if (base_type->tag == PointerType) {
+            if (base_type->tag == OptionalType) {
+                code_err(base, "This value might be null, so it can't be safely dereferenced");
+            } else if (base_type->tag == PointerType) {
                 auto ptr = Match(base_type, PointerType);
-                if (ptr->is_optional)
-                    code_err(base, "This value might be null, so it can't be safely dereferenced");
                 return Type(PointerType, .pointed=ref_type, .is_stack=ptr->is_stack, .is_readonly=ptr->is_readonly);
             } else if (base->tag == Var) {
                 return Type(PointerType, .pointed=ref_type, .is_stack=true);
@@ -573,12 +560,9 @@ type_t *get_type(env_t *env, ast_t *ast)
     case Optional: {
         ast_t *value = Match(ast, Optional)->value;
         type_t *t = get_type(env, value);
-        if (t->tag != PointerType)
-            code_err(ast, "This value is not a pointer, it has type %T, so it can't be optional", t);
-        auto ptr = Match(t, PointerType);
-        if (ptr->is_optional)
+        if (t->tag == OptionalType)
             code_err(ast, "This value is already optional, it can't be converted to optional");
-        return Type(PointerType, .pointed=ptr->pointed, .is_optional=true, .is_stack=ptr->is_stack, .is_readonly=ptr->is_readonly);
+        return Type(OptionalType, .type=t);
     }
     case TextLiteral: return TEXT_TYPE;
     case TextJoin: {
@@ -740,12 +724,11 @@ type_t *get_type(env_t *env, ast_t *ast)
     case Index: {
         auto indexing = Match(ast, Index);
         type_t *indexed_t = get_type(env, indexing->indexed);
-        if (indexed_t->tag == PointerType && !indexing->index) {
-            auto ptr = Match(indexed_t, PointerType);
-            if (ptr->is_optional)
-                code_err(ast, "You're attempting to dereference a pointer whose type indicates it could be nil");
-            return ptr->pointed;
-        }
+        if (indexed_t->tag == OptionalType && !indexing->index)
+            code_err(ast, "You're attempting to dereference a value whose type indicates it could be nil");
+
+        if (indexed_t->tag == PointerType && !indexing->index)
+            return Match(indexed_t, PointerType)->pointed;
 
         type_t *value_t = value_type(indexed_t);
         if (value_t->tag == ArrayType) {
@@ -791,7 +774,7 @@ type_t *get_type(env_t *env, ast_t *ast)
             else if (streq(call->name, "clear")) return Type(VoidType);
             else if (streq(call->name, "counts")) return Type(TableType, .key_type=item_type, .value_type=INT_TYPE);
             else if (streq(call->name, "find")) return INT_TYPE;
-            else if (streq(call->name, "first")) return Type(PointerType, .pointed=item_type, .is_optional=true, .is_readonly=true);
+            else if (streq(call->name, "first")) return Type(OptionalType, .type=Type(PointerType, .pointed=item_type, .is_readonly=true));
             else if (streq(call->name, "from")) return self_value_t;
             else if (streq(call->name, "has")) return Type(BoolType);
             else if (streq(call->name, "heap_pop")) return item_type;
@@ -845,8 +828,7 @@ type_t *get_type(env_t *env, ast_t *ast)
                     code_err(ast, "The table method :get_or_null() is only supported for tables whose value type is a pointer, not %T",
                              table->value_type);
                 auto ptr = Match(table->value_type, PointerType);
-                return Type(PointerType, .pointed=ptr->pointed, .is_stack=ptr->is_stack,
-                            .is_readonly=ptr->is_readonly, .is_optional=true);
+                return Type(OptionalType, .type=Type(PointerType, .pointed=ptr->pointed, .is_stack=ptr->is_stack, .is_readonly=ptr->is_readonly));
             } else if (streq(call->name, "has")) return Type(BoolType);
             else if (streq(call->name, "remove")) return Type(VoidType);
             else if (streq(call->name, "set")) return Type(VoidType);
@@ -939,7 +921,7 @@ type_t *get_type(env_t *env, ast_t *ast)
         type_t *t = get_type(env, Match(ast, Not)->value);
         if (t->tag == IntType || t->tag == NumType || t->tag == BoolType)
             return t;
-        if (t->tag == PointerType && Match(t, PointerType)->is_optional)
+        if (t->tag == OptionalType)
             return Type(BoolType);
 
         ast_t *value = Match(ast, Not)->value;
@@ -1005,12 +987,14 @@ type_t *get_type(env_t *env, ast_t *ast)
                 return lhs_t;
             } else if (rhs_t->tag == AbortType || rhs_t->tag == ReturnType) {
                 return lhs_t;
+            } else if (rhs_t->tag == OptionalType) {
+                if (can_promote(lhs_t, rhs_t))
+                    return rhs_t;
             } else if (lhs_t->tag == PointerType && rhs_t->tag == PointerType) {
                 auto lhs_ptr = Match(lhs_t, PointerType);
                 auto rhs_ptr = Match(rhs_t, PointerType);
                 if (type_eq(lhs_ptr->pointed, rhs_ptr->pointed))
-                    return Type(PointerType, .pointed=lhs_ptr->pointed, .is_optional=lhs_ptr->is_optional || rhs_ptr->is_optional,
-                                .is_readonly=lhs_ptr->is_readonly || rhs_ptr->is_readonly);
+                    return Type(PointerType, .pointed=lhs_ptr->pointed, .is_readonly=lhs_ptr->is_readonly || rhs_ptr->is_readonly);
             } else if (is_int_type(lhs_t) && is_int_type(rhs_t)) {
                 return get_math_type(env, ast, lhs_t, rhs_t);
             }
@@ -1024,15 +1008,17 @@ type_t *get_type(env_t *env, ast_t *ast)
                 return lhs_t;
             } else if (is_int_type(lhs_t) && is_int_type(rhs_t)) {
                 return get_math_type(env, ast, lhs_t, rhs_t);
+            } else if (lhs_t->tag == OptionalType) {
+                if (can_promote(rhs_t, lhs_t))
+                    return rhs_t;
             } else if (lhs_t->tag == PointerType) {
                 auto lhs_ptr = Match(lhs_t, PointerType);
                 if (rhs_t->tag == AbortType || rhs_t->tag == ReturnType) {
-                    return Type(PointerType, .pointed=lhs_ptr->pointed, .is_optional=false, .is_readonly=lhs_ptr->is_readonly);
+                    return Type(PointerType, .pointed=lhs_ptr->pointed, .is_readonly=lhs_ptr->is_readonly);
                 } else if (rhs_t->tag == PointerType) {
                     auto rhs_ptr = Match(rhs_t, PointerType);
                     if (type_eq(rhs_ptr->pointed, lhs_ptr->pointed))
-                        return Type(PointerType, .pointed=lhs_ptr->pointed, .is_optional=lhs_ptr->is_optional && rhs_ptr->is_optional,
-                                    .is_readonly=lhs_ptr->is_readonly || rhs_ptr->is_readonly);
+                        return Type(PointerType, .pointed=lhs_ptr->pointed, .is_readonly=lhs_ptr->is_readonly || rhs_ptr->is_readonly);
                 }
             }
             code_err(ast, "I can't figure out the type of this `or` expression because the left side is a %T, but the right side is a %T",
@@ -1157,7 +1143,6 @@ type_t *get_type(env_t *env, ast_t *ast)
         REVERSE_LIST(args);
 
         type_t *ret = get_type(scope, lambda->body);
-        assert(ret);
         if (ret->tag == ReturnType)
             ret = Match(ret, ReturnType)->ret;
         if (ret->tag == AbortType)
@@ -1192,104 +1177,77 @@ type_t *get_type(env_t *env, ast_t *ast)
         auto when = Match(ast, When);
         type_t *subject_t = get_type(env, when->subject);
         type_t *overall_t = NULL;
-        if (subject_t->tag == PointerType) {
-            if (!Match(subject_t, PointerType)->is_optional)
-                code_err(when->subject, "This %T pointer type is not optional, so this 'when' statement is tautological", subject_t);
-
-            bool handled_at = false;
-            for (when_clause_t *clause = when->clauses; clause; clause = clause->next) {
-                const char *tag_name = Match(clause->tag_name, Var)->name;
-                if (!streq(tag_name, "@"))
-                    code_err(clause->tag_name, "'when' clauses on optional pointers only support @var, not tags like '%s'", tag_name);
-                if (handled_at)
-                    code_err(clause->tag_name, "This 'when' statement has already handled the case of non-null pointers!");
-                handled_at = true;
-
-                assert(clause->args);
-                type_t *clause_type = get_clause_type(env, subject_t, clause);
-                type_t *merged = type_or_type(overall_t, clause_type);
-                if (!merged)
-                    code_err(clause->body, "The type of this branch is %T, which conflicts with the earlier branch type of %T",
-                             clause_type, overall_t);
-                overall_t = merged;
-            }
-            if (!handled_at)
-                code_err(ast, "This 'when' statement doesn't handle non-null pointers");
-            if (!when->else_body)
-                code_err(ast, "This 'when' statement doesn't handle null pointers");
-            return overall_t;
-        } else if (subject_t->tag == EnumType) {
-            tag_t * const tags = Match(subject_t, EnumType)->tags;
-
-            typedef struct match_s {
-                tag_t *tag;
-                bool handled;
-                struct match_s *next;
-            } match_t;
-            match_t *matches = NULL;
-            for (tag_t *tag = tags; tag; tag = tag->next)
-                matches = new(match_t, .tag=tag, .handled=false, .next=matches);
-
-            for (when_clause_t *clause = when->clauses; clause; clause = clause->next) {
-                const char *tag_name = Match(clause->tag_name, Var)->name;
-                CORD valid_tags = CORD_EMPTY;
-                for (match_t *m = matches; m; m = m->next) {
-                    if (streq(m->tag->name, tag_name)) {
-                        if (m->handled)
-                            code_err(clause->tag_name, "This tag was already handled earlier");
-                        m->handled = true;
-                        goto found_matching_tag;
-                    }
-                    if (valid_tags) valid_tags = CORD_cat(valid_tags, ", ");
-                    valid_tags = CORD_cat(valid_tags, m->tag->name);
-                }
+        if (subject_t->tag != EnumType)
+            code_err(when->subject, "'when' statements are only for enum types and optional pointers, not %T", subject_t);
 
-                code_err(clause->tag_name, "There is no tag '%s' for the type %T (valid tags: %s)",
-                         tag_name, subject_t, CORD_to_char_star(valid_tags));
-              found_matching_tag:;
-            }
+        tag_t * const tags = Match(subject_t, EnumType)->tags;
 
-            for (when_clause_t *clause = when->clauses; clause; clause = clause->next) {
-                type_t *clause_type = get_clause_type(env, subject_t, clause);
-                type_t *merged = type_or_type(overall_t, clause_type);
-                if (!merged)
-                    code_err(clause->body, "The type of this branch is %T, which conflicts with the earlier branch type of %T",
-                             clause_type, overall_t);
-                overall_t = merged;
+        typedef struct match_s {
+            tag_t *tag;
+            bool handled;
+            struct match_s *next;
+        } match_t;
+        match_t *matches = NULL;
+        for (tag_t *tag = tags; tag; tag = tag->next)
+            matches = new(match_t, .tag=tag, .handled=false, .next=matches);
+
+        for (when_clause_t *clause = when->clauses; clause; clause = clause->next) {
+            const char *tag_name = Match(clause->tag_name, Var)->name;
+            CORD valid_tags = CORD_EMPTY;
+            for (match_t *m = matches; m; m = m->next) {
+                if (streq(m->tag->name, tag_name)) {
+                    if (m->handled)
+                        code_err(clause->tag_name, "This tag was already handled earlier");
+                    m->handled = true;
+                    goto found_matching_tag;
+                }
+                if (valid_tags) valid_tags = CORD_cat(valid_tags, ", ");
+                valid_tags = CORD_cat(valid_tags, m->tag->name);
             }
 
-            if (when->else_body) {
-                bool any_unhandled = false;
-                for (match_t *m = matches; m; m = m->next) {
-                    if (!m->handled) {
-                        any_unhandled = true;
-                        break;
-                    }
-                }
-                // HACK: `while when ...` is handled by the parser adding an implicit
-                // `else: stop`, which has an empty source code span.
-                if (!any_unhandled && when->else_body->end > when->else_body->start)
-                    code_err(when->else_body, "This 'else' block will never run because every tag is handled");
+            code_err(clause->tag_name, "There is no tag '%s' for the type %T (valid tags: %s)",
+                     tag_name, subject_t, CORD_to_char_star(valid_tags));
+          found_matching_tag:;
+        }
 
-                type_t *else_t = get_type(env, when->else_body);
-                type_t *merged = type_or_type(overall_t, else_t);
-                if (!merged)
-                    code_err(when->else_body,
-                             "I was expecting this block to have a %T value (based on earlier clauses), but it actually has a %T value.",
-                             overall_t, else_t);
-                return merged;
-            } else {
-                CORD unhandled = CORD_EMPTY;
-                for (match_t *m = matches; m; m = m->next) {
-                    if (!m->handled)
-                        unhandled = unhandled ? CORD_all(unhandled, ", ", m->tag->name) : m->tag->name;
+        for (when_clause_t *clause = when->clauses; clause; clause = clause->next) {
+            type_t *clause_type = get_clause_type(env, subject_t, clause);
+            type_t *merged = type_or_type(overall_t, clause_type);
+            if (!merged)
+                code_err(clause->body, "The type of this branch is %T, which conflicts with the earlier branch type of %T",
+                         clause_type, overall_t);
+            overall_t = merged;
+        }
+
+        if (when->else_body) {
+            bool any_unhandled = false;
+            for (match_t *m = matches; m; m = m->next) {
+                if (!m->handled) {
+                    any_unhandled = true;
+                    break;
                 }
-                if (unhandled)
-                    code_err(ast, "This 'when' statement doesn't handle the tags: %s", CORD_to_const_char_star(unhandled));
-                return overall_t;
             }
+            // HACK: `while when ...` is handled by the parser adding an implicit
+            // `else: stop`, which has an empty source code span.
+            if (!any_unhandled && when->else_body->end > when->else_body->start)
+                code_err(when->else_body, "This 'else' block will never run because every tag is handled");
+
+            type_t *else_t = get_type(env, when->else_body);
+            type_t *merged = type_or_type(overall_t, else_t);
+            if (!merged)
+                code_err(when->else_body,
+                         "I was expecting this block to have a %T value (based on earlier clauses), but it actually has a %T value.",
+                         overall_t, else_t);
+            return merged;
         } else {
-            code_err(when->subject, "'when' statements are only for enum types and optional pointers, not %T", subject_t);
+            CORD unhandled = CORD_EMPTY;
+            for (match_t *m = matches; m; m = m->next) {
+                if (!m->handled)
+                    unhandled = unhandled ? CORD_all(unhandled, ", ", m->tag->name) : m->tag->name;
+            }
+            if (unhandled)
+                code_err(ast, "This 'when' statement doesn't handle the tags: %s", CORD_to_const_char_star(unhandled));
+            return overall_t;
         }
     }
 
diff --git a/types.c b/types.c
index f7c3ba2e..c91e6eb2 100644
--- a/types.c
+++ b/types.c
@@ -65,12 +65,15 @@ CORD type_to_cord(type_t *t) {
             auto ptr = Match(t, PointerType);
             CORD sigil = ptr->is_stack ? "&" : "@";
             if (ptr->is_readonly) sigil = CORD_cat(sigil, "%");
-            return CORD_all(sigil, type_to_cord(ptr->pointed), ptr->is_optional ? "?" : CORD_EMPTY);
+            return CORD_all(sigil, type_to_cord(ptr->pointed));
         }
         case EnumType: {
             auto tagged = Match(t, EnumType);
             return tagged->name;
         }
+        case OptionalType: {
+            return CORD_all(type_to_cord(Match(t, OptionalType)->type), "?");
+        }
         case TypeInfoType: {
             return CORD_all("TypeInfo(", Match(t, TypeInfoType)->name, ")");
         }
@@ -111,21 +114,20 @@ bool type_eq(type_t *a, type_t *b)
 bool type_is_a(type_t *t, type_t *req)
 {
     if (type_eq(t, req)) return true;
+    if (req->tag == OptionalType)
+        return type_is_a(t, Match(req, OptionalType)->type);
     if (t->tag == PointerType && req->tag == PointerType) {
         auto t_ptr = Match(t, PointerType);
         auto req_ptr = Match(req, PointerType);
         if (type_eq(t_ptr->pointed, req_ptr->pointed))
-            return (!t_ptr->is_stack && !t_ptr->is_optional && req_ptr->is_stack)
-                || (!t_ptr->is_stack && req_ptr->is_optional);
+            return (!t_ptr->is_stack && req_ptr->is_stack) || (!t_ptr->is_stack);
     }
     return false;
 }
 
 static type_t *non_optional(type_t *t)
 {
-    if (t->tag != PointerType) return t;
-    auto ptr = Match(t, PointerType);
-    return ptr->is_optional ? Type(PointerType, .is_optional=false, .pointed=ptr->pointed) : t;
+    return t->tag == OptionalType ? Match(t, OptionalType)->type : t;
 }
 
 PUREFUNC type_t *value_type(type_t *t)
@@ -217,6 +219,7 @@ PUREFUNC bool has_heap_memory(type_t *t)
     case TableType: return true;
     case SetType: return true;
     case PointerType: return true;
+    case OptionalType: return has_heap_memory(Match(t, OptionalType)->type);
     case BigIntType: return true;
     case StructType: {
         for (arg_t *field = Match(t, StructType)->fields; field; field = field->next) {
@@ -243,6 +246,7 @@ PUREFUNC bool can_send_over_channel(type_t *t)
     case ChannelType: return true;
     case TableType: return true;
     case PointerType: return false;
+    case OptionalType: return can_send_over_channel(Match(t, OptionalType)->type);
     case StructType: {
         for (arg_t *field = Match(t, StructType)->fields; field; field = field->next) {
             if (!can_send_over_channel(field->type))
@@ -265,6 +269,7 @@ PUREFUNC bool has_stack_memory(type_t *t)
 {
     switch (t->tag) {
     case PointerType: return Match(t, PointerType)->is_stack;
+    case OptionalType: return has_stack_memory(Match(t, OptionalType)->type);
     default: return false;
     }
 }
@@ -294,11 +299,13 @@ PUREFUNC bool can_promote(type_t *actual, type_t *needed)
         return true;
 
     // Automatic dereferencing:
-    if (actual->tag == PointerType && !Match(actual, PointerType)->is_optional
-        && can_promote(Match(actual, PointerType)->pointed, needed))
+    if (actual->tag == PointerType && can_promote(Match(actual, PointerType)->pointed, needed))
         return true;
 
     // Optional promotion:
+    if (needed->tag == OptionalType && can_promote(actual, Match(needed, OptionalType)->type))
+        return true;
+
     if (needed->tag == PointerType && actual->tag == PointerType) {
         auto needed_ptr = Match(needed, PointerType);
         auto actual_ptr = Match(actual, PointerType);
@@ -309,9 +316,6 @@ PUREFUNC bool can_promote(type_t *actual, type_t *needed)
         else if (actual_ptr->is_stack && !needed_ptr->is_stack)
             // Can't use &x for a function that wants a @Foo or ?Foo
             return false;
-        else if (actual_ptr->is_optional && !needed_ptr->is_optional)
-            // Can't use !Foo for a function that wants @Foo
-            return false;
         else if (actual_ptr->is_readonly && !needed_ptr->is_readonly)
             // Can't use pointer to readonly data when we need a pointer that can write to the data
             return false;
@@ -354,66 +358,6 @@ PUREFUNC bool can_promote(type_t *actual, type_t *needed)
     return false;
 }
 
-PUREFUNC bool can_leave_uninitialized(type_t *t)
-{
-    switch (t->tag) {
-    case PointerType: return Match(t, PointerType)->is_optional;
-    case ArrayType: case IntType: case NumType: case BoolType:
-        return true;
-    case ChannelType: return false;
-    case StructType: {
-        for (arg_t *field = Match(t, StructType)->fields; field; field = field->next) {
-            if (!can_leave_uninitialized(field->type))
-                return false;
-        }
-        return true;
-    }
-    case EnumType: {
-        for (tag_t *tag = Match(t, EnumType)->tags; tag; tag = tag->next) {
-            if (tag->type && !can_leave_uninitialized(tag->type))
-                return false;
-        }
-        return true;
-    }
-    default: return false;
-    }
-}
-
-PUREFUNC static bool _can_have_cycles(type_t *t, Table_t *seen)
-{
-    switch (t->tag) {
-        case ArrayType: return _can_have_cycles(Match(t, ArrayType)->item_type, seen);
-        case ChannelType: return _can_have_cycles(Match(t, ChannelType)->item_type, seen);
-        case TableType: {
-            auto table = Match(t, TableType);
-            return _can_have_cycles(table->key_type, seen) || _can_have_cycles(table->value_type, seen);
-        }
-        case SetType: return _can_have_cycles(Match(t, SetType)->item_type, seen);
-        case StructType: {
-            for (arg_t *field = Match(t, StructType)->fields; field; field = field->next) {
-                if (_can_have_cycles(field->type, seen))
-                    return true;
-            }
-            return false;
-        }
-        case PointerType: return _can_have_cycles(Match(t, PointerType)->pointed, seen);
-        case EnumType: {
-            for (tag_t *tag = Match(t, EnumType)->tags; tag; tag = tag->next) {
-                if (tag->type && _can_have_cycles(tag->type, seen))
-                    return true;
-            }
-            return false;
-        }
-        default: return false;
-    }
-}
-
-PUREFUNC bool can_have_cycles(type_t *t)
-{
-    Table_t seen = {0};
-    return _can_have_cycles(t, &seen);
-}
-
 PUREFUNC bool is_int_type(type_t *t)
 {
     return t->tag == IntType || t->tag == BigIntType;
@@ -424,48 +368,15 @@ PUREFUNC bool is_numeric_type(type_t *t)
     return t->tag == IntType || t->tag == BigIntType || t->tag == NumType;
 }
 
-type_t *replace_type(type_t *t, type_t *target, type_t *replacement)
+PUREFUNC bool supports_optionals(type_t *t)
 {
-    if (type_eq(t, target))
-        return replacement;
-
-#define COPY(t) memcpy(GC_MALLOC(sizeof(type_t)), (t), sizeof(type_t))
-#define REPLACED_MEMBER(t, tag, member) ({ t = memcpy(GC_MALLOC(sizeof(type_t)), (t), sizeof(type_t)); Match((struct type_s*)(t), tag)->member = replace_type(Match((t), tag)->member, target, replacement); t; })
     switch (t->tag) {
-        case ArrayType: return REPLACED_MEMBER(t, ArrayType, item_type);
-        case SetType: return REPLACED_MEMBER(t, SetType, item_type);
-        case ChannelType: return REPLACED_MEMBER(t, ChannelType, item_type);
-        case TableType: {
-            t = REPLACED_MEMBER(t, TableType, key_type);
-            t = REPLACED_MEMBER(t, TableType, value_type);
-            return t;
-        }
-        case FunctionType: {
-            auto fn = Match(t, FunctionType);
-            t = REPLACED_MEMBER(t, FunctionType, ret);
-            arg_t *args = LIST_MAP(fn->args, old_arg, .type=replace_type(old_arg->type, target, replacement));
-            Match((struct type_s*)t, FunctionType)->args = args;
-            return t;
-        }
-        case StructType: {
-            auto struct_ = Match(t, StructType);
-            arg_t *fields = LIST_MAP(struct_->fields, field, .type=replace_type(field->type, target, replacement));
-            t = COPY(t);
-            Match((struct type_s*)t, StructType)->fields = fields;
-            return t;
-        }
-        case PointerType: return REPLACED_MEMBER(t, PointerType, pointed);
-        case EnumType: {
-            auto tagged = Match(t, EnumType);
-            tag_t *tags = LIST_MAP(tagged->tags, tag, .type=replace_type(tag->type, target, replacement));
-            t = COPY(t);
-            Match((struct type_s*)t, EnumType)->tags = tags;
-            return t;
-        }
-        default: return t;
+    case BoolType: case CStringType: case BigIntType: case NumType: case TextType:
+    case ArrayType: case SetType: case TableType: case FunctionType: case ClosureType:
+    case PointerType:
+        return true;
+    default: return false;
     }
-#undef COPY
-#undef REPLACED_MEMBER
 }
 
 PUREFUNC size_t type_size(type_t *t)
@@ -495,6 +406,20 @@ PUREFUNC size_t type_size(type_t *t)
     case FunctionType: return sizeof(void*);
     case ClosureType: return sizeof(struct {void *fn, *userdata;});
     case PointerType: return sizeof(void*);
+    case OptionalType: {
+        type_t *nonnull = Match(t, OptionalType)->type;
+        switch (nonnull->tag) {
+        case IntType:
+            switch (Match(t, IntType)->bits) {
+            case TYPE_IBITS64: return sizeof(struct { int64_t x; bool is_null; });
+            case TYPE_IBITS32: return sizeof(int64_t);
+            case TYPE_IBITS16: return sizeof(int32_t);
+            case TYPE_IBITS8: return sizeof(int16_t);
+            default: errx(1, "Invalid integer bit size");
+            }
+        default: return type_size(nonnull);
+        }
+    }
     case StructType: {
         arg_t *fields = Match(t, StructType)->fields;
         size_t size = t->tag == StructType ? 0 : sizeof(void*);
@@ -558,6 +483,20 @@ PUREFUNC size_t type_align(type_t *t)
     case FunctionType: return __alignof__(void*);
     case ClosureType: return __alignof__(struct {void *fn, *userdata;});
     case PointerType: return __alignof__(void*);
+    case OptionalType: {
+        type_t *nonnull = Match(t, OptionalType)->type;
+        switch (nonnull->tag) {
+        case IntType:
+            switch (Match(t, IntType)->bits) {
+            case TYPE_IBITS64: return __alignof__(struct { int64_t x; bool is_null; });
+            case TYPE_IBITS32: return __alignof__(int64_t);
+            case TYPE_IBITS16: return __alignof__(int32_t);
+            case TYPE_IBITS8: return __alignof__(int16_t);
+            default: errx(1, "Invalid integer bit size");
+            }
+        default: return type_align(nonnull);
+        }
+    }
     case StructType: {
         arg_t *fields = Match(t, StructType)->fields;
         size_t align = t->tag == StructType ? 0 : sizeof(void*);
@@ -633,9 +572,9 @@ type_t *get_field_type(type_t *t, const char *field_name)
         else if (streq(field_name, "values"))
             return Type(ArrayType, Match(t, TableType)->value_type);
         else if (streq(field_name, "default"))
-            return Type(PointerType, .pointed=Match(t, TableType)->value_type, .is_readonly=true, .is_optional=true);
+            return Type(OptionalType, Match(t, TableType)->value_type);
         else if (streq(field_name, "fallback"))
-            return Type(PointerType, .pointed=t, .is_readonly=true, .is_optional=true);
+            return Type(OptionalType, .type=t);
         return NULL;
     }
     case ArrayType: {
diff --git a/types.h b/types.h
index 95b4d4c0..82efab37 100644
--- a/types.h
+++ b/types.h
@@ -57,6 +57,7 @@ struct type_s {
         PointerType,
         StructType,
         EnumType,
+        OptionalType,
         TypeInfoType,
         ModuleType,
     } tag;
@@ -97,7 +98,7 @@ struct type_s {
         } ClosureType;
         struct {
             type_t *pointed;
-            bool is_optional:1, is_stack:1, is_readonly:1;
+            bool is_stack:1, is_readonly:1;
         } PointerType;
         struct {
             const char *name;
@@ -112,6 +113,9 @@ struct type_s {
             struct env_s *env;
         } EnumType;
         struct {
+            type_t *type;
+        } OptionalType;
+        struct {
             const char *name;
             type_t *type;
             struct env_s *env;
@@ -139,11 +143,9 @@ PUREFUNC bool has_heap_memory(type_t *t);
 PUREFUNC bool has_stack_memory(type_t *t);
 PUREFUNC bool can_send_over_channel(type_t *t);
 PUREFUNC bool can_promote(type_t *actual, type_t *needed);
-PUREFUNC bool can_leave_uninitialized(type_t *t);
-PUREFUNC bool can_have_cycles(type_t *t);
 PUREFUNC bool is_int_type(type_t *t);
 PUREFUNC bool is_numeric_type(type_t *t);
-type_t *replace_type(type_t *t, type_t *target, type_t *replacement);
+PUREFUNC bool supports_optionals(type_t *t);
 PUREFUNC size_t type_size(type_t *t);
 PUREFUNC size_t type_align(type_t *t);
 PUREFUNC size_t padded_type_size(type_t *t);