diff --git a/src/core/array.c b/src/core/array.c
index d6d4c2bb..a7990813 100644
--- a/src/core/array.c
+++ b/src/core/array.c
@@ -119,20 +119,20 @@ Janet janet_array_peek(JanetArray *array) {
 /* C Functions */
 
 static Janet cfun_new(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     int32_t cap = janet_getinteger(argv, 0);
     JanetArray *array = janet_array(cap);
     return janet_wrap_array(array);
 }
 
 static Janet cfun_pop(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetArray *array = janet_getarray(argv, 0);
     return janet_array_pop(array);
 }
 
 static Janet cfun_peek(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetArray *array = janet_getarray(argv, 0);
     return janet_array_peek(array);
 }
@@ -148,7 +148,7 @@ static Janet cfun_push(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_ensure(int32_t argc, Janet *argv) {
-    janet_arity(argc, 3, 3);
+    janet_fixarity(argc, 3);
     JanetArray *array = janet_getarray(argv, 0);
     int32_t newcount = janet_getinteger(argv, 1);
     int32_t growth = janet_getinteger(argv, 2);
diff --git a/src/core/buffer.c b/src/core/buffer.c
index ea558a0a..77a5a513 100644
--- a/src/core/buffer.c
+++ b/src/core/buffer.c
@@ -154,7 +154,7 @@ void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x) {
 /* C functions */
 
 static Janet cfun_new(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     int32_t cap = janet_getinteger(argv, 0);
     JanetBuffer *buffer = janet_buffer(cap);
     return janet_wrap_buffer(buffer);
@@ -196,14 +196,14 @@ static Janet cfun_chars(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_clear(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     buffer->count = 0;
     return argv[0];
 }
 
 static Janet cfun_popn(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     int32_t n = janet_getinteger(argv, 1);
     if (n < 0) janet_panic("n must be non-negative");
diff --git a/src/core/capi.c b/src/core/capi.c
index 69d93d50..622ef91f 100644
--- a/src/core/capi.c
+++ b/src/core/capi.c
@@ -50,6 +50,11 @@ void janet_panic_abstract(Janet x, int32_t n, const JanetAbstractType *at) {
     janet_panicf("bad slot #%d, expected %s, got %v", n, at->name, x);
 }
 
+void janet_fixarity(int32_t arity, int32_t fix) {
+    if (arity != fix)
+        janet_panicf("arity mismatch, expected %d, got %d", fix, arity);
+}
+
 void janet_arity(int32_t arity, int32_t min, int32_t max) {
     if (min >= 0 && arity < min)
         janet_panicf("arity mismatch, expected at least %d, got %d", min, arity);
diff --git a/src/core/corelib.c b/src/core/corelib.c
index bf0fbe48..203bdfa8 100644
--- a/src/core/corelib.c
+++ b/src/core/corelib.c
@@ -68,7 +68,7 @@ JanetModule janet_native(const char *name, const uint8_t **error) {
 static Janet janet_core_native(int32_t argc, Janet *argv) {
     JanetModule init;
     JanetTable *env = janet_table(0);
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     const uint8_t *path = janet_getstring(argv, 0);
     const uint8_t *error = NULL;
     init = janet_native((const char *)path, &error);
@@ -163,13 +163,13 @@ static Janet janet_core_buffer(int32_t argc, Janet *argv) {
 }
 
 static Janet janet_core_is_abstract(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     return janet_wrap_boolean(janet_checktype(argv[0], JANET_ABSTRACT));
 }
 
 static Janet janet_core_scannumber(int32_t argc, Janet *argv) {
     double number;
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 1);
     if (janet_scan_number(view.bytes, view.len, &number))
         return janet_wrap_nil();
@@ -211,7 +211,7 @@ static Janet janet_core_struct(int32_t argc, Janet *argv) {
 
 static Janet janet_core_gensym(int32_t argc, Janet *argv) {
     (void) argv;
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     return janet_wrap_symbol(janet_symbol_gen());
 }
 
@@ -223,7 +223,7 @@ static Janet janet_core_gccollect(int32_t argc, Janet *argv) {
 }
 
 static Janet janet_core_gcsetinterval(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     int32_t val = janet_getinteger(argv, 0);
     if (val < 0)
         janet_panic("expected non-negative integer");
@@ -233,12 +233,12 @@ static Janet janet_core_gcsetinterval(int32_t argc, Janet *argv) {
 
 static Janet janet_core_gcinterval(int32_t argc, Janet *argv) {
     (void) argv;
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     return janet_wrap_number(janet_vm_gc_interval);
 }
 
 static Janet janet_core_type(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetType t = janet_type(argv[0]);
     if (t == JANET_ABSTRACT) {
         return janet_ckeywordv(janet_abstract_type(janet_unwrap_abstract(argv[0]))->name);
@@ -248,7 +248,7 @@ static Janet janet_core_type(int32_t argc, Janet *argv) {
 }
 
 static Janet janet_core_next(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     JanetDictView view = janet_getdictionary(argv, 0);
     const JanetKV *end = view.kvs + view.cap;
     const JanetKV *kv = janet_checktype(argv[1], JANET_NIL)
@@ -262,7 +262,7 @@ static Janet janet_core_next(int32_t argc, Janet *argv) {
 }
 
 static Janet janet_core_hash(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     return janet_wrap_number(janet_hash(argv[0]));
 }
 
diff --git a/src/core/debug.c b/src/core/debug.c
index fcc2eefa..0f963f93 100644
--- a/src/core/debug.c
+++ b/src/core/debug.c
@@ -94,7 +94,7 @@ void janet_debug_find(
 /* Helper to find funcdef and bytecode offset to insert or remove breakpoints.
  * Takes a source file name and byte offset. */
 static void helper_find(int32_t argc, Janet *argv, JanetFuncDef **def, int32_t *bytecode_offset) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     const uint8_t *source = janet_getstring(argv, 0);
     int32_t source_offset = janet_getinteger(argv, 1);
     janet_debug_find(def, bytecode_offset, source, source_offset);
@@ -143,7 +143,7 @@ static Janet cfun_unfbreak(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_lineage(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     JanetArray *array = janet_array(0);
     while (fiber) {
@@ -200,7 +200,7 @@ static Janet doframe(JanetStackFrame *frame) {
 }
 
 static Janet cfun_stack(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     JanetArray *array = janet_array(0);
     {
@@ -216,7 +216,7 @@ static Janet cfun_stack(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_argstack(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     JanetArray *array = janet_array(fiber->stacktop - fiber->stackstart);
     memcpy(array->data, fiber->data + fiber->stackstart, array->capacity * sizeof(Janet));
diff --git a/src/core/fiber.c b/src/core/fiber.c
index 9fd0f77d..fe5c6082 100644
--- a/src/core/fiber.c
+++ b/src/core/fiber.c
@@ -342,7 +342,7 @@ static Janet cfun_new(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_status(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     uint32_t s = (fiber->flags & JANET_FIBER_STATUS_MASK) >>
         JANET_FIBER_STATUS_OFFSET;
@@ -351,18 +351,18 @@ static Janet cfun_status(int32_t argc, Janet *argv) {
 
 static Janet cfun_current(int32_t argc, Janet *argv) {
     (void) argv;
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     return janet_wrap_fiber(janet_vm_fiber);
 }
 
 static Janet cfun_maxstack(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     return janet_wrap_integer(fiber->maxstack);
 }
 
 static Janet cfun_setmaxstack(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     JanetFiber *fiber = janet_getfiber(argv, 0);
     int32_t maxs = janet_getinteger(argv, 1);
     if (maxs < 0) {
diff --git a/src/core/io.c b/src/core/io.c
index f963cb3c..a435d6c4 100644
--- a/src/core/io.c
+++ b/src/core/io.c
@@ -226,7 +226,7 @@ static Janet janet_io_fwrite(int32_t argc, Janet *argv) {
 
 /* Flush the bytes in the file */
 static Janet janet_io_fflush(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
     if (iof->flags & IO_CLOSED)
         janet_panic("file is closed");
@@ -249,7 +249,7 @@ static int janet_io_gc(void *p, size_t len) {
 
 /* Close a file */
 static Janet janet_io_fclose(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
     if (iof->flags & IO_CLOSED)
         janet_panic("file is closed");
diff --git a/src/core/marsh.c b/src/core/marsh.c
index c17921dd..0f1dd2c7 100644
--- a/src/core/marsh.c
+++ b/src/core/marsh.c
@@ -406,30 +406,32 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
             goto done;
         case JANET_TABLE:
             {
-                const JanetKV *kv = NULL;
                 JanetTable *t = janet_unwrap_table(x);
                 MARK_SEEN();
                 pushbyte(st, t->proto ? LB_TABLE_PROTO : LB_TABLE);
                 pushint(st, t->count);
                 if (t->proto)
                     marshal_one(st, janet_wrap_table(t->proto), flags + 1);
-                while ((kv = janet_table_next(t, kv))) {
-                    marshal_one(st, kv->key, flags + 1);
-                    marshal_one(st, kv->value, flags + 1);
+                for (int32_t i = 0; i < t->capacity; i++) {
+                    if (janet_checktype(t->data[i].key, JANET_NIL))
+                        continue;
+                    marshal_one(st, t->data[i].key, flags + 1);
+                    marshal_one(st, t->data[i].value, flags + 1);
                 }
             }
             goto done;
         case JANET_STRUCT:
             {
                 int32_t count;
-                const JanetKV *kv = NULL;
                 const JanetKV *struct_ = janet_unwrap_struct(x);
                 count = janet_struct_length(struct_);
                 pushbyte(st, LB_STRUCT);
                 pushint(st, count);
-                while ((kv = janet_struct_next(struct_, kv))) {
-                    marshal_one(st, kv->key, flags + 1);
-                    marshal_one(st, kv->value, flags + 1);
+                for (int32_t i = 0; i < janet_struct_capacity(struct_); i++) {
+                    if (janet_checktype(struct_[i].key, JANET_NIL))
+                        continue;
+                    marshal_one(st, struct_[i].key, flags + 1);
+                    marshal_one(st, struct_[i].value, flags + 1);
                 }
                 /* Mark as seen AFTER marshaling */
                 MARK_SEEN();
@@ -1102,7 +1104,7 @@ int janet_unmarshal(
 /* C functions */
 
 static Janet cfun_env_lookup(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetTable *env = janet_gettable(argv, 0);
     return janet_wrap_table(janet_env_lookup(env));
 }
diff --git a/src/core/math.c b/src/core/math.c
index ab440b21..d24443ff 100644
--- a/src/core/math.c
+++ b/src/core/math.c
@@ -26,21 +26,21 @@
 /* Get a random number */
 Janet janet_rand(int32_t argc, Janet *argv) {
     (void) argv;
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     double r = (rand() % RAND_MAX) / ((double) RAND_MAX);
     return janet_wrap_number(r);
 }
 
 /* Seed the random number generator */
 Janet janet_srand(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     int32_t x = janet_getinteger(argv, 0);
     srand((unsigned) x);
     return janet_wrap_nil();
 }
 
 Janet janet_remainder(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     double x = janet_getnumber(argv, 0);
     double y = janet_getnumber(argv, 1);
     return janet_wrap_number(fmod(x, y));
@@ -48,7 +48,7 @@ Janet janet_remainder(int32_t argc, Janet *argv) {
 
 #define JANET_DEFINE_MATHOP(name, fop)\
 Janet janet_##name(int32_t argc, Janet *argv) {\
-    janet_arity(argc, 1, 1); \
+    janet_fixarity(argc, 1); \
     double x = janet_getnumber(argv, 0); \
     return janet_wrap_number(fop(x)); \
 }
@@ -72,7 +72,7 @@ JANET_DEFINE_MATHOP(floor, floor)
 
 #define JANET_DEFINE_MATH2OP(name, fop)\
 Janet janet_##name(int32_t argc, Janet *argv) {\
-    janet_arity(argc, 2, 2); \
+    janet_fixarity(argc, 2); \
     double lhs = janet_getnumber(argv, 0); \
     double rhs = janet_getnumber(argv, 1); \
     return janet_wrap_number(fop(lhs, rhs)); \
@@ -82,7 +82,7 @@ JANET_DEFINE_MATH2OP(atan2, atan2)
 JANET_DEFINE_MATH2OP(pow, pow)
 
 static Janet janet_not(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     return janet_wrap_boolean(!janet_truthy(argv[0]));
 }
 
diff --git a/src/core/os.c b/src/core/os.c
index a628f924..84a0479f 100644
--- a/src/core/os.c
+++ b/src/core/os.c
@@ -41,7 +41,7 @@
 #endif
 
 static Janet os_which(int32_t argc, Janet *argv) {
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     (void) argv;
     #ifdef JANET_WINDOWS
         return janet_ckeywordv("windows");
@@ -156,7 +156,7 @@ static Janet os_shell(int32_t argc, Janet *argv) {
 }
 
 static Janet os_getenv(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     const uint8_t *k = janet_getstring(argv, 0);
     const char *cstr = (const char *) k;
     const char *res = getenv(cstr);
@@ -198,7 +198,7 @@ static Janet os_exit(int32_t argc, Janet *argv) {
 }
 
 static Janet os_time(int32_t argc, Janet *argv) {
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     (void) argv;
     double dtime = (double)(time(NULL));
     return janet_wrap_number(dtime);
@@ -232,7 +232,7 @@ static int gettime(struct timespec *spec) {
 #endif
 
 static Janet os_clock(int32_t argc, Janet *argv) {
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     (void) argv;
     struct timespec tv;
     if (gettime(&tv)) janet_panic("could not get time");
@@ -241,7 +241,7 @@ static Janet os_clock(int32_t argc, Janet *argv) {
 }
 
 static Janet os_sleep(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     double delay = janet_getnumber(argv, 0);
     if (delay < 0) janet_panic("invalid argument to sleep");
 #ifdef JANET_WINDOWS
@@ -258,7 +258,7 @@ static Janet os_sleep(int32_t argc, Janet *argv) {
 }
 
 static Janet os_cwd(int32_t argc, Janet *argv) {
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     (void) argv;
     char buf[FILENAME_MAX];
     char *ptr;
diff --git a/src/core/parse.c b/src/core/parse.c
index 52c8ef6e..f496db1e 100644
--- a/src/core/parse.c
+++ b/src/core/parse.c
@@ -623,7 +623,7 @@ static JanetAbstractType janet_parse_parsertype = {
 /* C Function parser */
 static Janet cfun_parser(int32_t argc, Janet *argv) {
     (void) argv;
-    janet_arity(argc, 0, 0);
+    janet_fixarity(argc, 0);
     JanetParser *p = janet_abstract(&janet_parse_parsertype, sizeof(JanetParser));
     janet_parser_init(p);
     return janet_wrap_abstract(p);
@@ -655,13 +655,13 @@ static Janet cfun_consume(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_has_more(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
     return janet_wrap_boolean(janet_parser_has_more(p));
 }
 
 static Janet cfun_byte(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
     int32_t i = janet_getinteger(argv, 1);
     janet_parser_consume(p, 0xFF & i);
@@ -669,7 +669,7 @@ static Janet cfun_byte(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_status(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
     const char *stat = NULL;
     switch (janet_parser_status(p)) {
@@ -687,7 +687,7 @@ static Janet cfun_status(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_error(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
     const char *err = janet_parser_error(p);
     if (err) return janet_cstringv(err);
@@ -695,20 +695,20 @@ static Janet cfun_error(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_produce(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
     return janet_parser_produce(p);
 }
 
 static Janet cfun_flush(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
     janet_parser_flush(p);
     return argv[0];
 }
 
 static Janet cfun_where(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
     return janet_wrap_integer(p->offset);
 }
@@ -717,7 +717,7 @@ static Janet cfun_state(int32_t argc, Janet *argv) {
     size_t i;
     const uint8_t *str;
     size_t oldcount;
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
     oldcount = p->bufcount;
     for (i = 0; i < p->statecount; i++) {
diff --git a/src/core/string.c b/src/core/string.c
index aa210e4c..4031df1f 100644
--- a/src/core/string.c
+++ b/src/core/string.c
@@ -832,7 +832,7 @@ static Janet cfun_slice(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_repeat(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     JanetByteView view = janet_getbytes(argv, 0);
     int32_t rep = janet_getinteger(argv, 1);
     if (rep < 0) janet_panic("expected non-negative number of repetitions");
@@ -849,7 +849,7 @@ static Janet cfun_repeat(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_bytes(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     Janet *tup = janet_tuple_begin(view.len);
     int32_t i;
@@ -870,7 +870,7 @@ static Janet cfun_frombytes(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_asciilower(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
     for (int32_t i = 0; i < view.len; i++) {
@@ -885,7 +885,7 @@ static Janet cfun_asciilower(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_asciiupper(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
     for (int32_t i = 0; i < view.len; i++) {
@@ -900,7 +900,7 @@ static Janet cfun_asciiupper(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_reverse(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
     int32_t i, j;
diff --git a/src/core/struct.c b/src/core/struct.c
index 8b160e61..6fe96c4f 100644
--- a/src/core/struct.c
+++ b/src/core/struct.c
@@ -158,17 +158,6 @@ Janet janet_struct_get(const JanetKV *st, Janet key) {
     return kv ? kv->value : janet_wrap_nil();
 }
 
-/* Get the next key in a struct */
-const JanetKV *janet_struct_next(const JanetKV *st, const JanetKV *kv) {
-    const JanetKV *end = st + janet_struct_capacity(st);
-    kv = (kv == NULL) ? st : kv + 1;
-    while (kv < end) {
-        if (!janet_checktype(kv->key, JANET_NIL)) return kv;
-        kv++;
-    }
-    return NULL;
-}
-
 /* Convert struct to table */
 JanetTable *janet_struct_to_table(const JanetKV *st) {
     JanetTable *table = janet_table(janet_struct_capacity(st));
diff --git a/src/core/table.c b/src/core/table.c
index d2eacbcd..c4cb409e 100644
--- a/src/core/table.c
+++ b/src/core/table.c
@@ -158,17 +158,6 @@ void janet_table_clear(JanetTable *t) {
     t->deleted = 0;
 }
 
-/* Find next key in an object. Returns NULL if no next key. */
-const JanetKV *janet_table_next(JanetTable *t, const JanetKV *kv) {
-    JanetKV *end = t->data + t->capacity;
-    kv = (kv == NULL) ? t->data : kv + 1;
-    while (kv < end) {
-        if (!janet_checktype(kv->key, JANET_NIL)) return kv;
-        kv++;
-    }
-    return NULL;
-}
-
 /* Convert table to struct */
 const JanetKV *janet_table_to_struct(JanetTable *t) {
     JanetKV *st = janet_struct_begin(t->count);
@@ -206,13 +195,13 @@ void janet_table_merge_struct(JanetTable *table, const JanetKV *other) {
 /* C Functions */
 
 static Janet cfun_new(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     int32_t cap = janet_getinteger(argv, 0);
     return janet_wrap_table(janet_table(cap));
 }
 
 static Janet cfun_getproto(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetTable *t = janet_gettable(argv, 0);
     return t->proto
         ? janet_wrap_table(t->proto)
@@ -220,7 +209,7 @@ static Janet cfun_getproto(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_setproto(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     JanetTable *table = janet_gettable(argv, 0);
     JanetTable *proto = NULL;
     if (!janet_checktype(argv[1], JANET_NIL)) {
@@ -231,13 +220,13 @@ static Janet cfun_setproto(int32_t argc, Janet *argv) {
 }
 
 static Janet cfun_tostruct(int32_t argc, Janet *argv) {
-    janet_arity(argc, 1, 1);
+    janet_fixarity(argc, 1);
     JanetTable *t = janet_gettable(argv, 0);
     return janet_wrap_struct(janet_table_to_struct(t));
 }
 
 static Janet cfun_rawget(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     JanetTable *table = janet_gettable(argv, 0);
     return janet_table_rawget(table, argv[1]);
 }
diff --git a/src/include/janet/janet.h b/src/include/janet/janet.h
index 61b09e50..e1ac1189 100644
--- a/src/include/janet/janet.h
+++ b/src/include/janet/janet.h
@@ -1032,7 +1032,6 @@ JANET_API JanetKV *janet_struct_begin(int32_t count);
 JANET_API void janet_struct_put(JanetKV *st, Janet key, Janet value);
 JANET_API const JanetKV *janet_struct_end(JanetKV *st);
 JANET_API Janet janet_struct_get(const JanetKV *st, Janet key);
-JANET_API const JanetKV *janet_struct_next(const JanetKV *st, const JanetKV *kv);
 JANET_API JanetTable *janet_struct_to_table(const JanetKV *st);
 JANET_API int janet_struct_equal(const JanetKV *lhs, const JanetKV *rhs);
 JANET_API int janet_struct_compare(const JanetKV *lhs, const JanetKV *rhs);
@@ -1046,7 +1045,6 @@ JANET_API Janet janet_table_get(JanetTable *t, Janet key);
 JANET_API Janet janet_table_rawget(JanetTable *t, Janet key);
 JANET_API Janet janet_table_remove(JanetTable *t, Janet key);
 JANET_API void janet_table_put(JanetTable *t, Janet key, Janet value);
-JANET_API const JanetKV *janet_table_next(JanetTable *t, const JanetKV *kv);
 JANET_API const JanetKV *janet_table_to_struct(JanetTable *t);
 JANET_API void janet_table_merge_table(JanetTable *table, JanetTable *other);
 JANET_API void janet_table_merge_struct(JanetTable *table, const JanetKV *other);
@@ -1150,6 +1148,7 @@ JANET_API void janet_panics(const uint8_t *message);
 JANET_API void janet_panic_type(Janet x, int32_t n, int expected);
 JANET_API void janet_panic_abstract(Janet x, int32_t n, const JanetAbstractType *at);
 JANET_API void janet_arity(int32_t arity, int32_t min, int32_t max);
+JANET_API void janet_fixarity(int32_t arity, int32_t fix);
 
 JANET_API double janet_getnumber(const Janet *argv, int32_t n);
 JANET_API JanetArray *janet_getarray(const Janet *argv, int32_t n);
diff --git a/src/mainclient/line.c b/src/mainclient/line.c
index 1ff410bb..8f005555 100644
--- a/src/mainclient/line.c
+++ b/src/mainclient/line.c
@@ -24,7 +24,7 @@
 
 /* Common */
 Janet janet_line_getter(int32_t argc, Janet *argv) {
-    janet_arity(argc, 2, 2);
+    janet_fixarity(argc, 2);
     const uint8_t *str = janet_getstring(argv, 0);
     JanetBuffer *buf = janet_getbuffer(argv, 1);
     janet_line_get(str, buf);
diff --git a/src/webclient/main.c b/src/webclient/main.c
index 41a7013b..21eaa7a9 100644
--- a/src/webclient/main.c
+++ b/src/webclient/main.c
@@ -32,11 +32,11 @@ static const uint8_t *line_prompt = NULL;
 
 /* Yield to JS event loop from janet. Takes a repl prompt
  * and a buffer to fill with input data. */
-static int repl_yield(JanetArgs args) {
-    JANET_FIXARITY(args, 2);
-    JANET_ARG_STRING(line_prompt, args, 0);
-    JANET_ARG_BUFFER(line_buffer, args, 1);
-    JANET_RETURN_NIL(args);
+static Janet repl_yield(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 2);
+    line_prompt = janet_getstring(argv, 0);
+    line_buffer = janet_getbuffer(argv, 1);
+    return janet_wrap_nil();
 }
 
 /* Re-enter the loop */
@@ -53,14 +53,11 @@ static int enter_loop(void) {
 }
 
 /* Allow JS interop from within janet */
-static int cfun_js(JanetArgs args) {
-    const uint8_t *bytes;
-    int32_t len;
-    JANET_FIXARITY(args, 1);
-    JANET_ARG_BYTES(bytes, len, args, 0);
-    (void) len;
-    emscripten_run_script((const char *)bytes);
-    JANET_RETURN_NIL(args);
+static Janet cfun_js(int32_t argc, Janet *argv) {
+    janet_fixarity(argc, 1);
+    JanetByteView bytes = janet_getbytes(argv, 0);
+    emscripten_run_script((const char *)bytes.bytes);
+    return janet_wrap_nil();
 }
 
 /* Intialize the repl */