diff --git a/lang/object.c b/lang/object.c
index 1d6a433..9a721b7 100644
--- a/lang/object.c
+++ b/lang/object.c
@@ -39,18 +39,17 @@
 	return obj->priv_data;
 }
 
-void object_hold(VmState state, Object object) {
+void object_hold(VmState state, Object obj) {
 	(void)state;
-	if (object == object_none())
+	if (obj == object_none())
 		return;
-	struct object *obj = (struct object *)object;
 	atomic_fetch_add_explicit(&obj->ref_count, 1, memory_order_relaxed);
 }
 
 void object_drop(VmState state, Object *objptr) {
 	if (*objptr == object_none())
 		return;
-	struct object *obj = (struct object *)*objptr;
+	Object obj = *objptr;
 	atomic_int count = atomic_fetch_sub_explicit(
 		&obj->ref_count, 1, memory_order_relaxed);
 	if (count == 1) {
@@ -61,10 +60,9 @@
 	*objptr = object_none();
 }
 
-void dispatch_call(VmState state, Object object, const char *name) {
-	if (object == object_none())
+void dispatch_call(VmState state, Object obj, const char *name) {
+	if (obj == object_none())
 		vm_abort_msg(state, "dispatch_call: cannot dispatch on none");
-	struct object *obj = (struct object *)object;
 	struct object_call *call = obj->class_data->calls;
 	while (call->name != NULL) {
 		if (strcmp(call->name, name) == 0) {
diff --git a/lang/vm.c b/lang/vm.c
index 1c47406..a9e9c07 100644
--- a/lang/vm.c
+++ b/lang/vm.c
@@ -34,49 +34,44 @@
 }
 
 void vm_destroy(VmState *state) {
-	struct vm_state **priv = (struct vm_state **)state;
-	object_list_drop(*state, &(*priv)->stack);
-	free((*priv)->stack_trace);
-	free(*priv);
+	object_list_drop(*state, &(*state)->stack);
+	free((*state)->stack_trace);
+	free(*state);
 }
 
 void vm_stack_set(VmState state, int index, Object obj) {
-	struct vm_state *priv = (struct vm_state *)state;
-	int offset = priv->stack_base + index;
+	int offset = state->stack_base + index;
 	vm_abort_if(state, index < 0, "vm_stack_set: negative value");
-	vm_abort_if(state, offset >= priv->stack_next,
+	vm_abort_if(state, offset >= state->stack_next,
 		"vm_stack_set: stack overflow");
-	object_list_set(state, priv->stack, offset, obj);
+	object_list_set(state, state->stack, offset, obj);
 }
 
 Object vm_stack_get(VmState state, int index) {
-	struct vm_state *priv = (struct vm_state *)state;
-	int offset = priv->stack_base + index;
+	int offset = state->stack_base + index;
 	vm_abort_if(state, index < 0, "vm_stack_get: negative value");
-	vm_abort_if(state, offset >= priv->stack_next,
+	vm_abort_if(state, offset >= state->stack_next,
 		"vm_stack_get: stack overflow");
-	Object obj = object_list_get(state, priv->stack, offset);
+	Object obj = object_list_get(state, state->stack, offset);
 	return obj;
 }
 
 void vm_stack_push(VmState state, Object obj) {
-	struct vm_state *priv = (struct vm_state *)state;
 	// stack_next starts at 0, stack_size starts at 1
 	// Convert stack_size to a max stack offset to compensate
-	int max_stack = object_list_length(state, priv->stack) - 1;
+	int max_stack = object_list_length(state, state->stack) - 1;
 	// Check if stack_next is outside the stack before
 	// writing to it
-	vm_abort_if(state, priv->stack_next > max_stack,
+	vm_abort_if(state, state->stack_next > max_stack,
 		"vm_stack_push: stack overflow");
-	object_list_set(state, priv->stack, priv->stack_next++, obj);
+	object_list_set(state, state->stack, state->stack_next++, obj);
 }
 
 Object vm_stack_pop(VmState state) {
-	struct vm_state *priv = (struct vm_state *)state;
-	vm_abort_if(state, priv->stack_next <= priv->stack_base,
+	vm_abort_if(state, state->stack_next <= state->stack_base,
 		"vm_stack_pop: stack base underflow");
-	Object obj = object_list_get(state, priv->stack, --priv->stack_next);
-	object_list_set(state, priv->stack, priv->stack_next, object_none());
+	Object obj = object_list_get(state, state->stack, --state->stack_next);
+	object_list_set(state, state->stack, state->stack_next, object_none());
 	return obj;
 }
 
@@ -89,40 +84,36 @@
 }
 
 int vm_stack_depth(VmState state) {
-	struct vm_state *priv = (struct vm_state *)state;
-	return priv->stack_next - priv->stack_base;
+	return state->stack_next - state->stack_base;
 }
 
 void vm_call(VmState state, Object obj, const char *name, int arg_count) {
-	struct vm_state *priv = (struct vm_state *)state;
-	int old_base = priv->stack_base;
-	priv->stack_base = priv->stack_next - arg_count;
+	int old_base = state->stack_base;
+	state->stack_base = state->stack_next - arg_count;
 	object_hold(state, obj);
 	do {
-		stacktrace_push(priv->stack_trace, name);
+		stacktrace_push(state->stack_trace, name);
 		debug_msg("Calling %s\n", name);
-		dispatch_call(priv, obj, name);
+		dispatch_call(state, obj, name);
 		debug_msg("Exiting %s\n", name);
-		stacktrace_pop(priv->stack_trace);
+		stacktrace_pop(state->stack_trace);
 		object_drop(state, &obj);
-		obj = priv->tail_obj;
-		name = priv->tail_name;
-		priv->tail_obj = object_none();
-		priv->tail_name = NULL;
+		obj = state->tail_obj;
+		name = state->tail_name;
+		state->tail_obj = object_none();
+		state->tail_name = NULL;
 	} while (name != NULL);
-	priv->stack_base = old_base;
+	state->stack_base = old_base;
 }
 
 void vm_tailcall(VmState state, Object obj, const char *name) {
-	struct vm_state *priv = (struct vm_state *)state;
 	object_hold(state, obj);
-	priv->tail_obj = obj;
-	priv->tail_name = name;
+	state->tail_obj = obj;
+	state->tail_name = name;
 }
 
 __attribute__((noreturn)) void vm_abort_msg(VmState state, const char *msg) {
-	struct vm_state *priv = (struct vm_state *)state;
-	stacktrace_print(priv->stack_trace);
+	stacktrace_print(state->stack_trace);
 	abort_print(msg);
 }