diff --git a/compile.c b/compile.c
index 84d4836..1dd9b3b 100644
--- a/compile.c
+++ b/compile.c
@@ -39,7 +39,7 @@ static CORD compile_string_literal(CORD literal);
 
 CORD promote_to_optional(type_t *t, CORD code)
 {
-    if (t == THREAD_TYPE || t == PATH_TYPE || t->tag == MomentType) {
+    if (t == THREAD_TYPE || t == PATH_TYPE || t == PATH_TYPE_TYPE || t->tag == MomentType) {
         return code;
     } else if (t->tag == IntType) {
         switch (Match(t, IntType)->bits) {
@@ -505,6 +505,7 @@ CORD compile_type(type_t *t)
     else if (t == RNG_TYPE) return "RNG_t";
     else if (t == MATCH_TYPE) return "Match_t";
     else if (t == PATH_TYPE) return "Path_t";
+    else if (t == PATH_TYPE_TYPE) return "PathType_t";
 
     switch (t->tag) {
     case ReturnType: errx(1, "Shouldn't be compiling ReturnType to a type");
@@ -571,6 +572,8 @@ CORD compile_type(type_t *t)
                 return "OptionalMatch_t";
             if (nonnull == PATH_TYPE)
                 return "OptionalPath_t";
+            if (nonnull == PATH_TYPE_TYPE)
+                return "OptionalPathType_t";
             auto s = Match(nonnull, StructType);
             return CORD_all(namespace_prefix(s->env, s->env->namespace->parent), "$Optional", s->name, "$$type");
         }
@@ -682,7 +685,7 @@ CORD optional_into_nonnone(type_t *t, CORD value)
     case IntType:
         return CORD_all(value, ".i");
     case StructType:
-        if (t == THREAD_TYPE || t == MATCH_TYPE || t == PATH_TYPE)
+        if (t == THREAD_TYPE || t == MATCH_TYPE || t == PATH_TYPE || t == PATH_TYPE_TYPE)
             return value;
         return CORD_all(value, ".value");
     default:
@@ -699,7 +702,9 @@ CORD check_none(type_t *t, CORD value)
     else if (t == MATCH_TYPE)
         return CORD_all("((", value, ").index.small == 0)");
     else if (t == PATH_TYPE)
-        return CORD_all("((", value, ").type == PATH_NONE)");
+        return CORD_all("((", value, ").type.$tag == PATH_NONE)");
+    else if (t == PATH_TYPE_TYPE)
+        return CORD_all("((", value, ").$tag == PATH_NONE)");
     else if (t->tag == BigIntType)
         return CORD_all("((", value, ").small == 0)");
     else if (t->tag == ClosureType)
@@ -2192,6 +2197,7 @@ CORD compile_none(type_t *t)
 
     if (t == THREAD_TYPE) return "NULL";
     else if (t == PATH_TYPE) return "NONE_PATH";
+    else if (t == PATH_TYPE_TYPE) return "((OptionalPathType_t){})";
 
     switch (t->tag) {
     case BigIntType: return "NONE_INT";
@@ -3838,6 +3844,7 @@ CORD compile_type_info(type_t *t)
     else if (t == RNG_TYPE) return "&RNG$info";
     else if (t == MATCH_TYPE) return "&Match$info";
     else if (t == PATH_TYPE) return "&Path$info";
+    else if (t == PATH_TYPE_TYPE) return "&PathType$info";
 
     switch (t->tag) {
     case BoolType: case ByteType: case IntType: case BigIntType: case NumType: case CStringType: case MomentType:
diff --git a/environment.c b/environment.c
index 3ba36a3..7b4bb5b 100644
--- a/environment.c
+++ b/environment.c
@@ -17,6 +17,7 @@ type_t *MATCH_TYPE = NULL;
 type_t *RNG_TYPE = NULL;
 public type_t *PATH_TYPE = NULL;
 public type_t *THREAD_TYPE = NULL;
+public type_t *PATH_TYPE_TYPE = NULL;
 
 static type_t *declare_type(env_t *env, const char *def_str)
 {
@@ -66,8 +67,9 @@ env_t *global_env(void)
     (void)bind_type(env, "Int", Type(BigIntType));
     (void)bind_type(env, "Int32", Type(IntType, .bits=TYPE_IBITS32));
     (void)bind_type(env, "Memory", Type(MemoryType));
+    PATH_TYPE_TYPE = declare_type(env, "enum PathType(Relative, Absolute, Home)");
     MATCH_TYPE = declare_type(env, "struct Match(text:Text, index:Int, captures:[Text])");
-    PATH_TYPE = declare_type(env, "struct Path(type:Int32, components:[Text])");
+    PATH_TYPE = declare_type(env, "struct Path(type:PathType, components:[Text])");
     THREAD_TYPE = declare_type(env, "struct Thread(; opaque)");
     RNG_TYPE = declare_type(env, "struct RNG(state:@Memory)");
 
@@ -308,6 +310,11 @@ env_t *global_env(void)
             {"unix_timestamp", "Moment$unix_timestamp", "func(moment:Moment -> Int64)"},
             {"year", "Moment$year", "func(moment:Moment,timezone=none:Text -> Int)"},
         )},
+        {"PathType", PATH_TYPE_TYPE, "PathType_t", "PathType$info", TypedArray(ns_entry_t,
+            {"Relative", "((PathType_t){.$tag=PATH_RELATIVE})", "PathType"},
+            {"Absolute", "((PathType_t){.$tag=PATH_ABSOLUTE})", "PathType"},
+            {"Home", "((PathType_t){.$tag=PATH_HOME})", "PathType"},
+        )},
         {"Path", PATH_TYPE, "Path_t", "Path$info", TypedArray(ns_entry_t,
             {"accessed", "Path$accessed", "func(path:Path, follow_symlinks=yes -> Moment?)"},
             {"append", "Path$append", "func(path:Path, text:Text, permissions=Int32(0o644))"},
diff --git a/environment.h b/environment.h
index aa82089..fbd75c8 100644
--- a/environment.h
+++ b/environment.h
@@ -75,6 +75,7 @@ extern type_t *TEXT_TYPE;
 extern type_t *MATCH_TYPE;
 extern type_t *RNG_TYPE;
 extern type_t *PATH_TYPE;
+extern type_t *PATH_TYPE_TYPE;
 extern type_t *THREAD_TYPE;
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/stdlib/datatypes.h b/stdlib/datatypes.h
index dc121c8..b81ff74 100644
--- a/stdlib/datatypes.h
+++ b/stdlib/datatypes.h
@@ -97,7 +97,12 @@ typedef struct Text_s {
 #define OptionalPattern_t Text_t
 
 typedef struct {
-    enum { PATH_NONE, PATH_RELATIVE, PATH_ABSOLUTE, PATH_HOME } type;
+    enum { PATH_NONE, PATH_RELATIVE, PATH_ABSOLUTE, PATH_HOME } $tag;
+} PathType_t;
+#define OptionalPathType_t PathType_t
+
+typedef struct {
+    PathType_t type;
     Array_t components;
 } Path_t;
 #define OptionalPath_t Path_t
diff --git a/stdlib/paths.c b/stdlib/paths.c
index bac37b2..ba98e9f 100644
--- a/stdlib/paths.c
+++ b/stdlib/paths.c
@@ -17,11 +17,13 @@
 #include <unistr.h>
 
 #include "arrays.h"
+#include "enums.h"
 #include "files.h"
 #include "integers.h"
 #include "optionals.h"
 #include "paths.h"
 #include "patterns.h"
+#include "structs.h"
 #include "text.h"
 #include "types.h"
 #include "util.h"
@@ -30,7 +32,9 @@
 #include "siphash.h"
 #include "siphash-internals.h"
 
-static const Path_t HOME_PATH = {.type=PATH_HOME}, ROOT_PATH = {.type=PATH_ABSOLUTE}, CURDIR_PATH = {.type=PATH_RELATIVE};
+static const Path_t HOME_PATH = {.type.$tag=PATH_HOME},
+             ROOT_PATH = {.type.$tag=PATH_ABSOLUTE},
+             CURDIR_PATH = {.type.$tag=PATH_RELATIVE};
 
 static void clean_components(Array_t *components)
 {
@@ -60,16 +64,16 @@ public Path_t Path$from_str(const char *str)
 
     Path_t result = {.components={}};
     if (str[0] == '/') {
-        result.type = PATH_ABSOLUTE;
+        result.type.$tag = PATH_ABSOLUTE;
         str += 1;
     } else if (str[0] == '~' && str[1] == '/') {
-        result.type = PATH_HOME;
+        result.type.$tag = PATH_HOME;
         str += 2;
     } else if (str[0] == '.' && str[1] == '/') {
-        result.type = PATH_RELATIVE;
+        result.type.$tag = PATH_RELATIVE;
         str += 2;
     } else {
-        result.type = PATH_RELATIVE;
+        result.type.$tag = PATH_RELATIVE;
     }
 
     while (str && *str) {
@@ -100,12 +104,12 @@ public Path_t Path$from_text(Text_t text)
 
 public Path_t Path$expand_home(Path_t path)
 {
-    if (path.type == PATH_HOME) {
+    if (path.type.$tag == PATH_HOME) {
         Path_t pwd = Path$from_str(getenv("HOME"));
         Array_t components = Array$concat(pwd.components, path.components, sizeof(Text_t));
         assert(components.length == path.components.length + pwd.components.length);
         clean_components(&components);
-        path = (Path_t){.type=PATH_ABSOLUTE, .components=components};
+        path = (Path_t){.type.$tag=PATH_ABSOLUTE, .components=components};
     }
     return path;
 }
@@ -116,7 +120,7 @@ public Path_t Path$_concat(int n, Path_t items[n])
     Path_t result = items[0];
     ARRAY_INCREF(result.components);
     for (int i = 1; i < n; i++) {
-        if (items[i].type != PATH_RELATIVE)
+        if (items[i].type.$tag != PATH_RELATIVE)
             fail("Cannot concatenate an absolute or home-based path onto another path: (%s)\n",
                  Path$as_c_string(items[i]));
         Array$insert_all(&result.components, items[i].components, I(0), sizeof(Text_t));
@@ -127,8 +131,8 @@ public Path_t Path$_concat(int n, Path_t items[n])
 
 public Path_t Path$resolved(Path_t path, Path_t relative_to)
 {
-    if (path.type == PATH_RELATIVE && !(relative_to.type == PATH_RELATIVE && relative_to.components.length == 0)) {
-        Path_t result = {.type=relative_to.type};
+    if (path.type.$tag == PATH_RELATIVE && !(relative_to.type.$tag == PATH_RELATIVE && relative_to.components.length == 0)) {
+        Path_t result = {.type.$tag=relative_to.type.$tag};
         result.components = relative_to.components;
         ARRAY_INCREF(result.components);
         Array$insert_all(&result.components, path.components, I(0), sizeof(Text_t));
@@ -140,11 +144,11 @@ public Path_t Path$resolved(Path_t path, Path_t relative_to)
 
 public Path_t Path$relative_to(Path_t path, Path_t relative_to)
 {
-    if (path.type != relative_to.type)
+    if (path.type.$tag != relative_to.type.$tag)
         fail("Cannot create a path relative to a different path with a mismatching type: (%k) relative to (%k)",
              (Text_t[1]){Path$as_text(&path, false, &Path$info)}, (Text_t[1]){Path$as_text(&relative_to, false, &Path$info)});
 
-    Path_t result = {.type=PATH_RELATIVE};
+    Path_t result = {.type.$tag=PATH_RELATIVE};
     int64_t shared = 0;
     for (; shared < path.components.length && shared < relative_to.components.length; shared++) {
         Text_t *p = (Text_t*)(path.components.data + shared*path.components.stride);
@@ -532,13 +536,13 @@ public Path_t Path$write_unique(Path_t path, Text_t text)
 
 public Path_t Path$parent(Path_t path)
 {
-    if (path.type == PATH_ABSOLUTE && path.components.length == 0) {
+    if (path.type.$tag == PATH_ABSOLUTE && path.components.length == 0) {
         return path;
     } else if (path.components.length > 0 && !Text$equal_values(*(Text_t*)(path.components.data + path.components.stride*(path.components.length-1)),
                                                          Text(".."))) {
-        return (Path_t){.type=path.type, .components=Array$slice(path.components, I(1), I(-2))};
+        return (Path_t){.type.$tag=path.type.$tag, .components=Array$slice(path.components, I(1), I(-2))};
     } else {
-        Path_t result = {.type=path.type, .components=path.components};
+        Path_t result = {.type.$tag=path.type.$tag, .components=path.components};
         ARRAY_INCREF(result.components);
         Array$insert_value(&result.components, Text(".."), I(0), sizeof(Text_t));
         return result;
@@ -549,9 +553,9 @@ public PUREFUNC Text_t Path$base_name(Path_t path)
 {
     if (path.components.length >= 1)
         return *(Text_t*)(path.components.data + path.components.stride*(path.components.length-1));
-    else if (path.type == PATH_HOME)
+    else if (path.type.$tag == PATH_HOME)
         return Text("~");
-    else if (path.type == PATH_RELATIVE)
+    else if (path.type.$tag == PATH_RELATIVE)
         return Text(".");
     else
         return EMPTY_TEXT;
@@ -573,7 +577,7 @@ public Text_t Path$extension(Path_t path, bool full)
 public Path_t Path$with_component(Path_t path, Text_t component)
 {
     Path_t result = {
-        .type=path.type,
+        .type.$tag=path.type.$tag,
         .components=path.components,
     };
     ARRAY_INCREF(result.components);
@@ -588,7 +592,7 @@ public Path_t Path$with_extension(Path_t path, Text_t extension, bool replace)
         fail("A path with no components can't have an extension!");
 
     Path_t result = {
-        .type=path.type,
+        .type.$tag=path.type.$tag,
         .components=path.components,
     };
     ARRAY_INCREF(result.components);
@@ -675,7 +679,7 @@ public PUREFUNC uint64_t Path$hash(const void *obj, const TypeInfo_t *type)
     (void)type;
     Path_t *path = (Path_t*)obj;
     siphash sh;
-    siphashinit(&sh, (uint64_t)path->type);
+    siphashinit(&sh, (uint64_t)path->type.$tag);
     for (int64_t i = 0; i < path->components.length; i++) {
         uint64_t item_hash = Text$hash(path->components.data + i*path->components.stride, &Text$info);
         siphashadd64bits(&sh, item_hash);
@@ -687,7 +691,7 @@ public PUREFUNC int32_t Path$compare(const void *va, const void *vb, const TypeI
 {
     (void)type;
     Path_t *a = (Path_t*)va, *b = (Path_t*)vb;
-    int diff = ((int)a->type - (int)b->type);
+    int diff = ((int)a->type.$tag - (int)b->type.$tag);
     if (diff != 0) return diff;
     return Array$compare(&a->components, &b->components, Array$info(&Text$info));
 }
@@ -696,32 +700,32 @@ public PUREFUNC bool Path$equal(const void *va, const void *vb, const TypeInfo_t
 {
     (void)type;
     Path_t *a = (Path_t*)va, *b = (Path_t*)vb;
-    if (a->type != b->type) return false;
+    if (a->type.$tag != b->type.$tag) return false;
     return Array$equal(&a->components, &b->components, Array$info(&Text$info));
 }
 
 public PUREFUNC bool Path$equal_values(Path_t a, Path_t b)
 {
-    if (a.type != b.type) return false;
+    if (a.type.$tag != b.type.$tag) return false;
     return Array$equal(&a.components, &b.components, Array$info(&Text$info));
 }
 
 public const char *Path$as_c_string(Path_t path)
 {
     if (path.components.length == 0) {
-        if (path.type == PATH_ABSOLUTE) return "/";
-        else if (path.type == PATH_RELATIVE) return ".";
-        else if (path.type == PATH_HOME) return "~";
+        if (path.type.$tag == PATH_ABSOLUTE) return "/";
+        else if (path.type.$tag == PATH_RELATIVE) return ".";
+        else if (path.type.$tag == PATH_HOME) return "~";
     }
 
     size_t len = 0, capacity = 16;
     char *buf = GC_MALLOC_ATOMIC(capacity);
-    if (path.type == PATH_ABSOLUTE) {
+    if (path.type.$tag == PATH_ABSOLUTE) {
         buf[len++] = '/';
-    } else if (path.type == PATH_HOME) {
+    } else if (path.type.$tag == PATH_HOME) {
         buf[len++] = '~';
         buf[len++] = '/';
-    } else if (path.type == PATH_RELATIVE) {
+    } else if (path.type.$tag == PATH_RELATIVE) {
         if (!Text$equal_values(*(Text_t*)path.components.data, Text(".."))) {
             buf[len++] = '.';
             buf[len++] = '/';
@@ -750,11 +754,11 @@ public Text_t Path$as_text(const void *obj, bool color, const TypeInfo_t *type)
     if (!obj) return Text("Path");
     Path_t *path = (Path_t*)obj;
     Text_t text = Text$join(Text("/"), path->components);
-    if (path->type == PATH_HOME)
+    if (path->type.$tag == PATH_HOME)
         text = Text$concat(path->components.length > 0 ? Text("~/") : Text("~"), text);
-    else if (path->type == PATH_ABSOLUTE)
+    else if (path->type.$tag == PATH_ABSOLUTE)
         text = Text$concat(Text("/"), text);
-    else if (path->type == PATH_RELATIVE && (path->components.length == 0 || !Text$equal_values(*(Text_t*)(path->components.data), Text(".."))))
+    else if (path->type.$tag == PATH_RELATIVE && (path->components.length == 0 || !Text$equal_values(*(Text_t*)(path->components.data), Text(".."))))
         text = Text$concat(path->components.length > 0 ? Text("./") : Text("."), text);
 
     if (color)
@@ -766,14 +770,14 @@ public Text_t Path$as_text(const void *obj, bool color, const TypeInfo_t *type)
 public CONSTFUNC bool Path$is_none(const void *obj, const TypeInfo_t *type)
 {
     (void)type;
-    return ((Path_t*)obj)->type == PATH_NONE;
+    return ((Path_t*)obj)->type.$tag == PATH_NONE;
 }
 
 public void Path$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type)
 {
     (void)type;
     Path_t *path = (Path_t*)obj;
-    fputc((int)path->type, out);
+    fputc((int)path->type.$tag, out);
     Array$serialize(&path->components, out, pointers, Array$info(&Text$info));
 }
 
@@ -781,7 +785,7 @@ public void Path$deserialize(FILE *in, void *obj, Array_t *pointers, const TypeI
 {
     (void)type;
     Path_t path = {};
-    path.type = fgetc(in);
+    path.type.$tag = fgetc(in);
     Array$deserialize(in, &path.components, pointers, Array$info(&Text$info));
     *(Path_t*)obj = path;
 }
@@ -801,4 +805,16 @@ public const TypeInfo_t Path$info = {
     }
 };
 
+public const TypeInfo_t PathType$info = {
+    .size=sizeof(PathType_t),
+    .align=__alignof__(PathType_t),
+    .metamethods=PackedDataEnum$metamethods,
+    .tag=EnumInfo,
+    .EnumInfo={
+        .name="PathType",
+        .num_tags=3,
+        .tags=((NamedType_t[3]){{.name="Relative"}, {.name="Absolute"}, {.name="Home"}}),
+    },
+};
+
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/stdlib/paths.h b/stdlib/paths.h
index f65bd3c..6c6cebd 100644
--- a/stdlib/paths.h
+++ b/stdlib/paths.h
@@ -65,6 +65,7 @@ void Path$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInf
 void Path$deserialize(FILE *in, void *obj, Array_t *pointers, const TypeInfo_t *type);
 
 extern const TypeInfo_t Path$info;
+extern const TypeInfo_t PathType$info;
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
 
diff --git a/types.c b/types.c
index fde7644..506850e 100644
--- a/types.c
+++ b/types.c
@@ -497,6 +497,7 @@ PUREFUNC size_t type_size(type_t *t)
 {
     if (t == THREAD_TYPE) return sizeof(pthread_t*);
     if (t == PATH_TYPE) return sizeof(Path_t);
+    if (t == PATH_TYPE_TYPE) return sizeof(PathType_t);
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch-default"
     switch (t->tag) {
@@ -585,6 +586,7 @@ PUREFUNC size_t type_align(type_t *t)
 {
     if (t == THREAD_TYPE) return __alignof__(pthread_t*);
     if (t == PATH_TYPE) return __alignof__(Path_t);
+    if (t == PATH_TYPE_TYPE) return __alignof__(PathType_t);
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wswitch-default"
     switch (t->tag) {