diff --git a/include/libvec/char.h b/include/libvec/char.h
index de1a681..2df6caa 100644
--- a/include/libvec/char.h
+++ b/include/libvec/char.h
@@ -7,14 +7,14 @@
 
 typedef struct
 {
-	char* _internal_arr;
-	size_t _internal_size;
-	size_t _internal_capacity;
-	size_t _internal_max_size;
-} _VecCharInternal;
+	char* array;
+	size_t size;
+	size_t capacity;
+	size_t max_size;
+} vec_char;
 
 __attribute__((overloadable)) size_t
-__null_check(const _VecCharInternal* ptr, err_t* status);
+__null_check(const vec_char* ptr, err_t* status);
 
 __attribute__((overloadable)) size_t
 __null_check(const char* ptr, err_t* status);
@@ -23,95 +23,91 @@ size_t
 __origin_override(err_t* status, char* str);
 
 void
-_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err);
+vec_char_print_vec(const vec_char* ptr, err_t* err);
 
-_VecCharInternal
-_vec_char_cpy(const char* src, const size_t src_size, err_t* err);
+vec_char
+vec_char_cpy(const char* src, const size_t src_size, err_t* err);
 
 void
-_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err);
+vec_char_push_back(vec_char* ptr, const char val, err_t* err);
 
 void
-_vec_char_pop_back(_VecCharInternal* ptr, err_t* err);
+vec_char_pop_back(vec_char* ptr, err_t* err);
 
 void
-_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err);
+vec_char_reserve(vec_char* ptr, const size_t capacity, err_t* err);
 
 void
-_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err);
+vec_char_shrink_to_fit(vec_char* ptr, err_t* err);
 
 void
-_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err);
+vec_char_swap(vec_char* ptr_a, vec_char* ptr_b, err_t* err);
 
 const char*
-_vec_char_data(const _VecCharInternal* ptr, err_t* err);
+vec_char_data(const vec_char* ptr, err_t* err);
 
 size_t
-_vec_char_size(const _VecCharInternal* ptr, err_t* err);
+vec_char_size(const vec_char* ptr, err_t* err);
 
 size_t
-_vec_char_capacity(const _VecCharInternal* ptr, err_t* err);
+vec_char_capacity(const vec_char* ptr, err_t* err);
 
 size_t
-_vec_char_max_size(const _VecCharInternal* ptr, err_t* err);
+vec_char_max_size(const vec_char* ptr, err_t* err);
 
 void
-_vec_char_delete(_VecCharInternal* ptr, err_t* err);
+vec_char_delete(vec_char* ptr, err_t* err);
 
 void
-_vec_char_clear(_VecCharInternal* ptr, err_t* err);
+vec_char_clear(vec_char* ptr, err_t* err);
 
 char*
-_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err);
+vec_char_at(const vec_char* ptr, const size_t idx, err_t* err);
 
 size_t
-_vec_char_begin(const _VecCharInternal* ptr, err_t* err);
+vec_char_begin(const vec_char* ptr, err_t* err);
 
 size_t
-_vec_char_end(const _VecCharInternal* ptr, err_t* err);
+vec_char_end(const vec_char* ptr, err_t* err);
 
 char
-_vec_char_front(const _VecCharInternal* ptr, err_t* err);
+vec_char_front(const vec_char* ptr, err_t* err);
 
 char
-_vec_char_back(const _VecCharInternal* ptr, err_t* err);
+vec_char_back(const vec_char* ptr, err_t* err);
 
 size_t
-_vec_char_empty(const _VecCharInternal* ptr, err_t* err);
+vec_char_empty(const vec_char* ptr, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err);
+vec_char_erase(vec_char* ptr, const size_t iter, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
-		const size_t iter_end, err_t* err);
+vec_char_erase(vec_char* ptr, const size_t iter_start, const size_t iter_end,
+	       err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err);
+vec_char_resize(vec_char* ptr, const size_t size, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
-		 err_t* err);
+vec_char_resize(vec_char* ptr, const size_t size, const char val, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
-		 const size_t iter_start, const size_t iter_end, err_t* err);
+vec_char_assign(vec_char* ptr, const vec_char* iterator,
+		const size_t iter_start, const size_t iter_end, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
-		 err_t* err);
+vec_char_assign(vec_char* ptr, const size_t amount, const char val, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
-		 err_t* err);
+vec_char_insert(vec_char* ptr, const size_t iter, const char val, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
-		 const char val, err_t* err);
+vec_char_insert(vec_char* ptr, const size_t iter, const size_t amount,
+		const char val, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
-		 const size_t iter, const size_t iter_start,
-		 const size_t iter_end, err_t* err);
+vec_char_insert(vec_char* ptr, const vec_char* iterator, const size_t iter,
+		const size_t iter_start, const size_t iter_end, err_t* err);
 
 #endif
diff --git a/include/libvec/float.h b/include/libvec/float.h
index de1a681..68ba77e 100644
--- a/include/libvec/float.h
+++ b/include/libvec/float.h
@@ -7,111 +7,101 @@
 
 typedef struct
 {
-	char* _internal_arr;
-	size_t _internal_size;
-	size_t _internal_capacity;
-	size_t _internal_max_size;
-} _VecCharInternal;
+	float* array;
+	size_t size;
+	size_t capacity;
+	size_t max_size;
+} vec_float;
 
-__attribute__((overloadable)) size_t
-__null_check(const _VecCharInternal* ptr, err_t* status);
+void
+vec_float_print_vec(const vec_float* ptr, err_t* err);
 
-__attribute__((overloadable)) size_t
-__null_check(const char* ptr, err_t* status);
+vec_float
+vec_float_cpy(const float* src, const size_t src_size, err_t* err);
+
+void
+vec_float_push_back(vec_float* ptr, const float val, err_t* err);
+
+void
+vec_float_pop_back(vec_float* ptr, err_t* err);
+
+void
+vec_float_reserve(vec_float* ptr, const size_t capacity, err_t* err);
+
+void
+vec_float_shrink_to_fit(vec_float* ptr, err_t* err);
+
+void
+vec_float_swap(vec_float* ptr_a, vec_float* ptr_b, err_t* err);
+
+const float*
+vec_float_data(const vec_float* ptr, err_t* err);
 
 size_t
-__origin_override(err_t* status, char* str);
-
-void
-_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err);
-
-_VecCharInternal
-_vec_char_cpy(const char* src, const size_t src_size, err_t* err);
-
-void
-_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err);
-
-void
-_vec_char_pop_back(_VecCharInternal* ptr, err_t* err);
-
-void
-_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err);
-
-void
-_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err);
-
-void
-_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err);
-
-const char*
-_vec_char_data(const _VecCharInternal* ptr, err_t* err);
+vec_float_size(const vec_float* ptr, err_t* err);
 
 size_t
-_vec_char_size(const _VecCharInternal* ptr, err_t* err);
+vec_float_capacity(const vec_float* ptr, err_t* err);
 
 size_t
-_vec_char_capacity(const _VecCharInternal* ptr, err_t* err);
-
-size_t
-_vec_char_max_size(const _VecCharInternal* ptr, err_t* err);
+vec_float_max_size(const vec_float* ptr, err_t* err);
 
 void
-_vec_char_delete(_VecCharInternal* ptr, err_t* err);
+vec_float_delete(vec_float* ptr, err_t* err);
 
 void
-_vec_char_clear(_VecCharInternal* ptr, err_t* err);
+vec_float_clear(vec_float* ptr, err_t* err);
 
-char*
-_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err);
+float*
+vec_float_at(const vec_float* ptr, const size_t idx, err_t* err);
 
 size_t
-_vec_char_begin(const _VecCharInternal* ptr, err_t* err);
+vec_float_begin(const vec_float* ptr, err_t* err);
 
 size_t
-_vec_char_end(const _VecCharInternal* ptr, err_t* err);
+vec_float_end(const vec_float* ptr, err_t* err);
 
-char
-_vec_char_front(const _VecCharInternal* ptr, err_t* err);
+float
+vec_float_front(const vec_float* ptr, err_t* err);
 
-char
-_vec_char_back(const _VecCharInternal* ptr, err_t* err);
+float
+vec_float_back(const vec_float* ptr, err_t* err);
 
 size_t
-_vec_char_empty(const _VecCharInternal* ptr, err_t* err);
+vec_float_empty(const vec_float* ptr, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err);
+vec_float_erase(vec_float* ptr, const size_t iter, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
-		const size_t iter_end, err_t* err);
+vec_float_erase(vec_float* ptr, const size_t iter_start, const size_t iter_end,
+		err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err);
+vec_float_resize(vec_float* ptr, const size_t size, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
+vec_float_resize(vec_float* ptr, const size_t size, const float val,
 		 err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
+vec_float_assign(vec_float* ptr, const vec_float* iterator,
 		 const size_t iter_start, const size_t iter_end, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
+vec_float_assign(vec_float* ptr, const size_t amount, const float val,
 		 err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
+vec_float_insert(vec_float* ptr, const size_t iter, const float val,
 		 err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
-		 const char val, err_t* err);
+vec_float_insert(vec_float* ptr, const size_t iter, const size_t amount,
+		 const float val, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
-		 const size_t iter, const size_t iter_start,
-		 const size_t iter_end, err_t* err);
+vec_float_insert(vec_float* ptr, const vec_float* iterator, const size_t iter,
+		 const size_t iter_start, const size_t iter_end, err_t* err);
 
 #endif
diff --git a/include/libvec/int.h b/include/libvec/int.h
index 9608520..a389052 100644
--- a/include/libvec/int.h
+++ b/include/libvec/int.h
@@ -7,14 +7,14 @@
 
 typedef struct
 {
-	int* _internal_arr;
-	size_t _internal_size;
-	size_t _internal_capacity;
-	size_t _internal_max_size;
-} _VecIntInternal;
+	int* array;
+	size_t size;
+	size_t capacity;
+	size_t max_size;
+} vec_int;
 
 __attribute__((overloadable)) size_t
-__null_check(const _VecIntInternal* ptr, err_t* status);
+__null_check(const vec_int* ptr, err_t* status);
 
 __attribute__((overloadable)) size_t
 __null_check(const int* ptr, err_t* status);
@@ -23,95 +23,91 @@ size_t
 __origin_override(err_t* status, char* str);
 
 void
-_vec_int_print_vec(const _VecIntInternal* ptr, err_t* err);
+vec_int_print_vec(const vec_int* ptr, err_t* err);
 
-_VecIntInternal
-_vec_int_cpy(const int* src, const size_t src_size, err_t* err);
+vec_int
+vec_int_cpy(const int* src, const size_t src_size, err_t* err);
 
 void
-_vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err);
+vec_int_push_back(vec_int* ptr, const int val, err_t* err);
 
 void
-_vec_int_pop_back(_VecIntInternal* ptr, err_t* err);
+vec_int_pop_back(vec_int* ptr, err_t* err);
 
 void
-_vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err);
+vec_int_reserve(vec_int* ptr, const size_t capacity, err_t* err);
 
 void
-_vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err);
+vec_int_shrink_to_fit(vec_int* ptr, err_t* err);
 
 void
-_vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err);
+vec_int_swap(vec_int* ptr_a, vec_int* ptr_b, err_t* err);
 
 const int*
-_vec_int_data(const _VecIntInternal* ptr, err_t* err);
+vec_int_data(const vec_int* ptr, err_t* err);
 
 size_t
-_vec_int_size(const _VecIntInternal* ptr, err_t* err);
+vec_int_size(const vec_int* ptr, err_t* err);
 
 size_t
-_vec_int_capacity(const _VecIntInternal* ptr, err_t* err);
+vec_int_capacity(const vec_int* ptr, err_t* err);
 
 size_t
-_vec_int_max_size(const _VecIntInternal* ptr, err_t* err);
+vec_int_max_size(const vec_int* ptr, err_t* err);
 
 void
-_vec_int_delete(_VecIntInternal* ptr, err_t* err);
+vec_int_delete(vec_int* ptr, err_t* err);
 
 void
-_vec_int_clear(_VecIntInternal* ptr, err_t* err);
+vec_int_clear(vec_int* ptr, err_t* err);
 
 int*
-_vec_int_at(const _VecIntInternal* ptr, const size_t idx, err_t* err);
+vec_int_at(const vec_int* ptr, const size_t idx, err_t* err);
 
 size_t
-_vec_int_begin(const _VecIntInternal* ptr, err_t* err);
+vec_int_begin(const vec_int* ptr, err_t* err);
 
 size_t
-_vec_int_end(const _VecIntInternal* ptr, err_t* err);
+vec_int_end(const vec_int* ptr, err_t* err);
 
 int
-_vec_int_front(const _VecIntInternal* ptr, err_t* err);
+vec_int_front(const vec_int* ptr, err_t* err);
 
 int
-_vec_int_back(const _VecIntInternal* ptr, err_t* err);
+vec_int_back(const vec_int* ptr, err_t* err);
 
 size_t
-_vec_int_empty(const _VecIntInternal* ptr, err_t* err);
+vec_int_empty(const vec_int* ptr, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_int_erase(_VecIntInternal* ptr, const size_t iter, err_t* err);
+vec_int_erase(vec_int* ptr, const size_t iter, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_int_erase(_VecIntInternal* ptr, const size_t iter_start,
+vec_int_erase(vec_int* ptr, const size_t iter_start, const size_t iter_end,
+	      err_t* err);
+
+__attribute__((overloadable)) void
+vec_int_resize(vec_int* ptr, const size_t size, err_t* err);
+
+__attribute__((overloadable)) void
+vec_int_resize(vec_int* ptr, const size_t size, const int val, err_t* err);
+
+__attribute__((overloadable)) void
+vec_int_assign(vec_int* ptr, const vec_int* iterator, const size_t iter_start,
 	       const size_t iter_end, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err);
+vec_int_assign(vec_int* ptr, const size_t amount, const int val, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
-		err_t* err);
+vec_int_insert(vec_int* ptr, const size_t iter, const int val, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
-		const size_t iter_start, const size_t iter_end, err_t* err);
+vec_int_insert(vec_int* ptr, const size_t iter, const size_t amount,
+	       const int val, err_t* err);
 
 __attribute__((overloadable)) void
-_vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
-		err_t* err);
-
-__attribute__((overloadable)) void
-_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val,
-		err_t* err);
-
-__attribute__((overloadable)) void
-_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
-		const int val, err_t* err);
-
-__attribute__((overloadable)) void
-_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
-		const size_t iter, const size_t iter_start,
-		const size_t iter_end, err_t* err);
+vec_int_insert(vec_int* ptr, const vec_int* iterator, const size_t iter,
+	       const size_t iter_start, const size_t iter_end, err_t* err);
 
 #endif
diff --git a/include/libvec/utils.h b/include/libvec/utils.h
index 888b9b7..792c5c4 100644
--- a/include/libvec/utils.h
+++ b/include/libvec/utils.h
@@ -4,8 +4,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#define CAPACITY 1024
-#define VEC_FAULT_BITS 32
 static const size_t VEC_MAX = SIZE_MAX / sizeof(int);
 
 #define ERROR_LIST(X)                                                      \
@@ -45,23 +43,23 @@ typedef struct
 } err_t;
 
 #define ERR_T_INIT { .flags = 0, .origin = NULL }
-#define VEC_INIT                   \
-	{ ._internal_arr = NULL,   \
-	  ._internal_size = 0,     \
-	  ._internal_capacity = 0, \
-	  ._internal_max_size = VEC_MAX }
-
-const char*
-vec_get_error_desc(ERROR_CODES err);
+#define VEC_INIT \
+	{ .array = NULL, .size = 0, .capacity = 0, .max_size = VEC_MAX }
 
 void
 vec_print_errs(const err_t err);
 
 void
-print_bits(unsigned int num);
+vec_print_bits(unsigned int num);
+
+size_t
+__origin_override(err_t* status, char* str);
+
+__attribute__((overloadable)) size_t
+__null_check(const float* ptr, err_t* status);
 
 #define LOG(msg) printf("LOG: %s\n", msg)     /**< Print log message*/
 #define DEBUG(msg) printf("DEBUG: %s\n", msg) /**< Print debug message*/
-#define find_len(arr) sizeof(arr) / sizeof(arr[0])
+#define find_len(arr) (sizeof(arr) / sizeof((arr)[0]))
 
 #endif
diff --git a/src/char.c b/src/char.c
index 58deb8b..136916b 100644
--- a/src/char.c
+++ b/src/char.c
@@ -1,5 +1,4 @@
-#include "libvec/char.h"
-
+#include <libvec/char.h>
 #include <libvec/utils.h>
 #include <stddef.h>
 #include <stdio.h>
@@ -7,7 +6,7 @@
 #include <string.h>
 
 __attribute__((overloadable)) size_t
-__null_check(const _VecCharInternal* ptr, err_t* status)
+__null_check(const vec_char* ptr, err_t* status)
 {
 	if (status == nullptr)
 	{
@@ -18,7 +17,7 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
 		status->flags |= ERR_VEC_NULL;
 		return ERR_VEC_NULL;
 	}
-	if (ptr->_internal_arr == nullptr)
+	if (ptr->array == nullptr)
 	{
 		status->flags |= ERR_BUF_NULL;
 	}
@@ -26,62 +25,24 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
 	return status->flags;
 }
 
-__attribute__((overloadable)) size_t
-__null_check(const char* ptr, err_t* status)
-{
-	if (status == nullptr)
-	{
-		return ERR_ERR_T_NULL;
-	}
-	if (ptr == nullptr)
-	{
-		status->flags |= ERR_BUF_NULL;
-	}
-	return status->flags;
-}
-
-size_t
-__origin_override(err_t* status, char* str)
-{
-	if (status == nullptr)
-	{
-		return ERR_ERR_T_NULL;
-	}
-	if (status->origin != nullptr)
-	{
-		status->flags |= ERR_ORIGIN_UNALTERABLE;
-		return status->flags;
-	}
-	else if (str == nullptr)
-	{
-		status->flags |= ERR_STR_NULL;
-		return status->flags;
-	}
-	else
-	{
-		status->origin = str;
-		return status->flags;
-	}
-}
-
 void
-_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err)
+vec_char_print_vec(const vec_char* ptr, err_t* err)
 {
 	if (__null_check(ptr, err) != 0)
 	{
 		return;
 	}
-	for (size_t i = 0; i < ptr->_internal_size; i++)
+	for (size_t i = 0; i < ptr->size; i++)
 	{
-		printf("%c ", ptr->_internal_arr[i]);
+		printf("%c ", ptr->array[i]);
 	}
 	printf("\n");
 }
 
-_VecCharInternal
-_vec_char_cpy(const char* src, const size_t src_size, err_t* err)
+vec_char
+vec_char_cpy(const char* src, const size_t src_size, err_t* err)
 {
-	_VecCharInternal self = VEC_INIT;
+	vec_char self = VEC_INIT;
 	err_t status = ERR_T_INIT;
 
 	size_t null = __null_check(src, err);
@@ -102,27 +63,27 @@ _vec_char_cpy(const char* src, const size_t src_size, err_t* err)
 		err->flags |= status.flags;
 		return self;
 	}
-	if (src_size > self._internal_max_size)
+	if (src_size > self.max_size)
 	{
 		__origin_override(err, "CPY");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return self;
 	}
-	self._internal_arr = malloc(src_size * sizeof(char));
-	if (self._internal_arr == nullptr)
+	self.array = malloc(src_size * sizeof(char));
+	if (self.array == nullptr)
 	{
 		__origin_override(err, "CPY");
 		err->flags |= ERR_ALLOC_FAIL;
 		return self;
 	}
-	memcpy(self._internal_arr, src, src_size * sizeof(char));
-	self._internal_size = src_size;
-	self._internal_capacity = src_size;
+	memcpy(self.array, src, src_size * sizeof(char));
+	self.size = src_size;
+	self.capacity = src_size;
 	return self;
 }
 
 void
-_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
+vec_char_push_back(vec_char* ptr, const char val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	char* res;
@@ -134,7 +95,7 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size + 1 > ptr->_internal_max_size)
+	if (ptr->size + 1 > ptr->max_size)
 	{
 		__origin_override(err, "PUSH_BACK");
 		err->flags |= ERR_SIZE_OVERFLOW;
@@ -150,43 +111,42 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
 			err->flags |= ERR_ALLOC_FAIL;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = 1;
-		ptr->_internal_size = 0;
+		ptr->array = res;
+		ptr->capacity = 1;
+		ptr->size = 0;
 	}
 
-	else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
+	else if (ptr->size + 1 > ptr->capacity)
 	{
-		size_t dst_cap =
-		    (ptr->_internal_capacity / 2) + ptr->_internal_capacity;
-		if (dst_cap == ptr->_internal_capacity)
+		size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
+		if (dst_cap == ptr->capacity)
 		{
 			dst_cap++;
 		}
-		if (dst_cap > ptr->_internal_max_size)
+		if (dst_cap > ptr->max_size)
 		{
-			dst_cap = ptr->_internal_max_size;
+			dst_cap = ptr->max_size;
 			DEBUG(
 			    "Capacity cannot be grown any further due "
 			    "to hitting max size");
 		}
-		res = realloc(ptr->_internal_arr, dst_cap * sizeof(char));
+		res = realloc(ptr->array, dst_cap * sizeof(char));
 		if (res == nullptr)
 		{
 			__origin_override(err, "PUSH_BACK");
 			err->flags |= ERR_SIZE_OVERFLOW;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = dst_cap;
+		ptr->array = res;
+		ptr->capacity = dst_cap;
 	}
-	ptr->_internal_arr[ptr->_internal_size] = val;
-	ptr->_internal_size++;
+	ptr->array[ptr->size] = val;
+	ptr->size++;
 	return;
 }
 
 void
-_vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
+vec_char_pop_back(vec_char* ptr, err_t* err)
 {
 	if (__null_check(ptr, err) != 0)
 	{
@@ -194,19 +154,19 @@ _vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "POP_BACK");
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
 
-	ptr->_internal_arr[ptr->_internal_size - 1] = 0;
-	ptr->_internal_size--;
+	ptr->array[ptr->size - 1] = 0;
+	ptr->size--;
 }
 
 void
-_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
+vec_char_reserve(vec_char* ptr, const size_t capacity, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -218,7 +178,7 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
 			return;
 		}
 	}
-	if (ptr->_internal_max_size < capacity)
+	if (ptr->max_size < capacity)
 	{
 		__origin_override(err, "RESERVE");
 		err->flags |= ERR_SIZE_OVERFLOW;
@@ -231,24 +191,24 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
 		return;
 	}
 
-	char* res = realloc(ptr->_internal_arr, capacity * sizeof(char));
+	char* res = realloc(ptr->array, capacity * sizeof(char));
 	if (res == nullptr)
 	{
 		__origin_override(err, "RESERVE");
 		err->flags |= ERR_ALLOC_FAIL;
 		return;
 	}
-	ptr->_internal_arr = res;
-	ptr->_internal_capacity = capacity;
-	if (ptr->_internal_size > capacity)
+	ptr->array = res;
+	ptr->capacity = capacity;
+	if (ptr->size > capacity)
 	{
-		ptr->_internal_size = capacity;
+		ptr->size = capacity;
 	}
 	return;
 }
 
 void
-_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
+vec_char_shrink_to_fit(vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -257,17 +217,17 @@ _vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "SHRINK_TO_FIT");
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
-	_vec_char_reserve(ptr, ptr->_internal_size, err);
+	vec_char_reserve(ptr, ptr->size, err);
 }
 
 void
-_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err)
+vec_char_swap(vec_char* ptr_a, vec_char* ptr_b, err_t* err)
 {
 	err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
 	if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
@@ -277,14 +237,14 @@ _vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err)
 		err->flags |= ERR_VEC_NULL;
 		return;
 	}
-	_VecCharInternal self = *ptr_a;
+	vec_char self = *ptr_a;
 	*ptr_a = *ptr_b;
 	*ptr_b = self;
 	return;
 }
 
 const char*
-_vec_char_data(const _VecCharInternal* ptr, err_t* err)
+vec_char_data(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -293,11 +253,11 @@ _vec_char_data(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return nullptr;
 	}
-	return &ptr->_internal_arr[0];
+	return &ptr->array[0];
 }
 
 size_t
-_vec_char_size(const _VecCharInternal* ptr, err_t* err)
+vec_char_size(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -306,11 +266,11 @@ _vec_char_size(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_size;
+	return ptr->size;
 }
 
 size_t
-_vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
+vec_char_capacity(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -319,11 +279,11 @@ _vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_capacity;
+	return ptr->capacity;
 }
 
 size_t
-_vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
+vec_char_max_size(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -332,11 +292,11 @@ _vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_max_size;
+	return ptr->max_size;
 }
 
 void
-_vec_char_delete(_VecCharInternal* ptr, err_t* err)
+vec_char_delete(vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -345,17 +305,17 @@ _vec_char_delete(_VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_arr != nullptr)
+	if (ptr->array != nullptr)
 	{
-		free(ptr->_internal_arr);
-		ptr->_internal_arr = nullptr;
+		free(ptr->array);
+		ptr->array = nullptr;
 	}
-	ptr->_internal_size = 0;
-	ptr->_internal_capacity = 0;
+	ptr->size = 0;
+	ptr->capacity = 0;
 }
 
 void
-_vec_char_clear(_VecCharInternal* ptr, err_t* err)
+vec_char_clear(vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -364,15 +324,15 @@ _vec_char_clear(_VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_size > 0)
+	if (ptr->size > 0)
 	{
-		memset(ptr->_internal_arr, 0, ptr->_internal_size);
-		ptr->_internal_size = 0;
+		memset(ptr->array, 0, ptr->size);
+		ptr->size = 0;
 	}
 }
 
 char*
-_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
+vec_char_at(const vec_char* ptr, const size_t idx, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -381,17 +341,17 @@ _vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
 		err->flags |= status.flags;
 		return nullptr;
 	}
-	if (idx >= ptr->_internal_size)
+	if (idx >= ptr->size)
 	{
 		__origin_override(err, "AT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return nullptr;
 	}
-	return &ptr->_internal_arr[idx];
+	return &ptr->array[idx];
 }
 
 size_t
-_vec_char_begin(const _VecCharInternal* ptr, err_t* err)
+vec_char_begin(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -404,7 +364,7 @@ _vec_char_begin(const _VecCharInternal* ptr, err_t* err)
 }
 
 size_t
-_vec_char_end(const _VecCharInternal* ptr, err_t* err)
+vec_char_end(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -413,17 +373,17 @@ _vec_char_end(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return status.flags;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "END");
 		err->flags |= ERR_SIZE_ZERO;
 		return status.flags;
 	}
-	return (size_t)(ptr->_internal_size - 1);
+	return (size_t)(ptr->size - 1);
 }
 
 char
-_vec_char_front(const _VecCharInternal* ptr, err_t* err)
+vec_char_front(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -432,16 +392,16 @@ _vec_char_front(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return -1;
 	}
-	if (_vec_char_at(ptr, 0, err) == nullptr)
+	if (vec_char_at(ptr, 0, err) == nullptr)
 	{
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return 0;
 	}
-	return *_vec_char_at(ptr, 0, err);
+	return *vec_char_at(ptr, 0, err);
 }
 
 char
-_vec_char_back(const _VecCharInternal* ptr, err_t* err)
+vec_char_back(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -450,16 +410,16 @@ _vec_char_back(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return -1;
 	}
-	if (_vec_char_at(ptr, 0, err) == nullptr)
+	if (vec_char_at(ptr, 0, err) == nullptr)
 	{
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return 0;
 	}
-	return *_vec_char_at(ptr, ptr->_internal_size - 1, err);
+	return *vec_char_at(ptr, ptr->size - 1, err);
 }
 
 size_t
-_vec_char_empty(const _VecCharInternal* ptr, err_t* err)
+vec_char_empty(const vec_char* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -468,15 +428,15 @@ _vec_char_empty(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return status.flags;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
-		return ptr->_internal_size;
+		return ptr->size;
 	}
 	return status.flags;
 }
 
 __attribute__((overloadable)) void
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err)
+vec_char_erase(vec_char* ptr, const size_t iter, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -485,20 +445,20 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter >= ptr->_internal_size)
+	if (iter >= ptr->size)
 	{
 		return;
 	}
-	memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
-		(ptr->_internal_size - iter - 1) * sizeof(char));
-	ptr->_internal_arr[ptr->_internal_size - 1] = 0;
-	ptr->_internal_size--;
+	memmove(&ptr->array[iter], &ptr->array[iter + 1],
+		(ptr->size - iter - 1) * sizeof(char));
+	ptr->array[ptr->size - 1] = 0;
+	ptr->size--;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
-		const size_t iter_end, err_t* err)
+vec_char_erase(vec_char* ptr, const size_t iter_start, const size_t iter_end,
+	       err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -508,23 +468,22 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
 		return;
 	}
 
-	if (ptr->_internal_size < iter_end || iter_end <= iter_start)
+	if (ptr->size < iter_end || iter_end <= iter_start)
 	{
 		__origin_override(err, "ERASE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 	size_t diff = iter_end - iter_start;
-	memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
-		(ptr->_internal_size - iter_end) * sizeof(char));
-	memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0,
-	       sizeof(char) * diff);
-	ptr->_internal_size -= diff;
+	memmove(&ptr->array[iter_start], &ptr->array[iter_end],
+		(ptr->size - iter_end) * sizeof(char));
+	memset(&ptr->array[ptr->size - diff], 0, sizeof(char) * diff);
+	ptr->size -= diff;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
+vec_char_resize(vec_char* ptr, const size_t size, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -535,32 +494,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size == size)
+	if (ptr->size == size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 
-	else if (size > ptr->_internal_max_size)
+	else if (size > ptr->max_size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
 
-	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
+	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
 	{
-		size_t max = ptr->_internal_max_size;
+		size_t max = ptr->max_size;
 		err_t verr = ERR_T_INIT;
-		_vec_char_reserve(ptr, size, &verr);
+		vec_char_reserve(ptr, size, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != size)
+		if (ptr->capacity != size)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
@@ -568,57 +527,54 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
 		}
 		for (size_t i = 0; i < size; i++)
 		{
-			ptr->_internal_arr[i] = 0;
+			ptr->array[i] = 0;
 		}
-		ptr->_internal_max_size = max;
-		ptr->_internal_size = size;
+		ptr->max_size = max;
+		ptr->size = size;
 		return;
 	}
-	else if (size > ptr->_internal_capacity)
+	else if (size > ptr->capacity)
 	{
-		size_t tmpcp = ptr->_internal_capacity;
-		size_t tmpmx = ptr->_internal_max_size;
+		size_t tmpcp = ptr->capacity;
+		size_t tmpmx = ptr->max_size;
 		err_t verr = ERR_T_INIT;
 		while (size > tmpcp)
 		{
 			tmpcp *= 2;
 		}
-		if (tmpcp > ptr->_internal_max_size)
+		if (tmpcp > ptr->max_size)
 		{
 			tmpcp = size;
 		}
-		_vec_char_reserve(ptr, tmpcp, &verr);
+		vec_char_reserve(ptr, tmpcp, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != tmpcp)
+		if (ptr->capacity != tmpcp)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
 			return;
 		}
-		ptr->_internal_max_size = tmpmx;
+		ptr->max_size = tmpmx;
 	}
-	if (size < ptr->_internal_size)
+	if (size < ptr->size)
 	{
-		memset(&ptr->_internal_arr[size], 0,
-		       ptr->_internal_size - size);
+		memset(&ptr->array[size], 0, ptr->size - size);
 	}
-	if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
+	if (ptr->size < size && size <= ptr->capacity)
 	{
-		memset(&ptr->_internal_arr[ptr->_internal_size], 0,
-		       size - ptr->_internal_size);
+		memset(&ptr->array[ptr->size], 0, size - ptr->size);
 	}
-	ptr->_internal_size = size;
+	ptr->size = size;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
-		 err_t* err)
+vec_char_resize(vec_char* ptr, const size_t size, const char val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -628,32 +584,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
 		err->flags |= ERR_VEC_NULL;
 		return;
 	}
-	if (ptr->_internal_size == size)
+	if (ptr->size == size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 
-	else if (size > ptr->_internal_max_size)
+	else if (size > ptr->max_size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
 
-	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
+	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
 	{
-		size_t max = ptr->_internal_max_size;
+		size_t max = ptr->max_size;
 		err_t verr = ERR_T_INIT;
-		_vec_char_reserve(ptr, size, &verr);
+		vec_char_reserve(ptr, size, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != size)
+		if (ptr->capacity != size)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
@@ -661,51 +617,49 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
 		}
 		for (size_t i = 0; i < size; i++)
 		{
-			ptr->_internal_arr[i] = val;
+			ptr->array[i] = val;
 		}
-		ptr->_internal_max_size = max;
-		ptr->_internal_size = size;
+		ptr->max_size = max;
+		ptr->size = size;
 		return;
 	}
-	else if (size > ptr->_internal_capacity)
+	else if (size > ptr->capacity)
 	{
-		size_t tmpcp = ptr->_internal_capacity;
-		size_t tmpmx = ptr->_internal_max_size;
+		size_t tmpcp = ptr->capacity;
+		size_t tmpmx = ptr->max_size;
 		err_t verr = ERR_T_INIT;
 		while (size > tmpcp)
 		{
 			tmpcp *= 2;
 		}
-		if (tmpcp > ptr->_internal_max_size)
+		if (tmpcp > ptr->max_size)
 		{
 			tmpcp = size;
 		}
-		_vec_char_reserve(ptr, tmpcp, &verr);
+		vec_char_reserve(ptr, tmpcp, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		ptr->_internal_max_size = tmpmx;
+		ptr->max_size = tmpmx;
 	}
-	if (size < ptr->_internal_size)
+	if (size < ptr->size)
 	{
-		memset(&ptr->_internal_arr[size], val,
-		       ptr->_internal_size - size);
+		memset(&ptr->array[size], val, ptr->size - size);
 	}
-	if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
+	if (ptr->size < size && size <= ptr->capacity)
 	{
-		memset(&ptr->_internal_arr[ptr->_internal_size], val,
-		       size - ptr->_internal_size);
+		memset(&ptr->array[ptr->size], val, size - ptr->size);
 	}
-	ptr->_internal_size = size;
+	ptr->size = size;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
-		 const size_t iter_start, const size_t iter_end, err_t* err)
+vec_char_assign(vec_char* ptr, const vec_char* iterator,
+		const size_t iter_start, const size_t iter_end, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0 ||
@@ -715,27 +669,27 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_arr == iterator->_internal_arr)
+	if (ptr->array == iterator->array)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= ERR_DOUBLE_BUF;
 		return;
 	}
-	if (iterator->_internal_size < iter_end || iter_end <= iter_start)
+	if (iterator->size < iter_end || iter_end <= iter_start)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
-			_vec_char_end(ptr, &status) + 1, &status);
+	vec_char_erase(ptr, _vec_char_begin(ptr, &status),
+		       vec_char_end(ptr, &status) + 1, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= status.flags;
 		return;
 	}
-	_vec_char_reserve(ptr, (iter_end - iter_start), &status);
+	vec_char_reserve(ptr, (iter_end - iter_start), &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
@@ -744,13 +698,13 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 	}
 	for (size_t i = iter_start; i < iter_end; i++)
 	{
-		char* res = _vec_char_at(iterator, i, &status);
+		char* res = vec_char_at(iterator, i, &status);
 		if (res == nullptr)
 		{
 			err->flags |= ERR_OUT_OF_BOUNDS;
 			return;
 		}
-		_vec_char_push_back(ptr, *res, &status);
+		vec_char_push_back(ptr, *res, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "ASSIGN");
@@ -762,8 +716,7 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 }
 
 __attribute__((overloadable)) void
-_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
-		 err_t* err)
+vec_char_assign(vec_char* ptr, const size_t amount, const char val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -778,15 +731,15 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
-	_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
-			_vec_char_end(ptr, &status) + 1, &status);
+	vec_char_erase(ptr, _vec_char_begin(ptr, &status),
+		       vec_char_end(ptr, &status) + 1, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= status.flags;
 		return;
 	}
-	_vec_char_reserve(ptr, amount, &status);
+	vec_char_reserve(ptr, amount, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
@@ -795,7 +748,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
 	}
 	for (size_t i = 0; i < amount; i++)
 	{
-		_vec_char_push_back(ptr, val, &status);
+		vec_char_push_back(ptr, val, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "ASSIGN");
@@ -807,8 +760,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
 }
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
-		 err_t* err)
+vec_char_insert(vec_char* ptr, const size_t iter, const char val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -827,43 +779,43 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
 			err->flags |= ERR_BUF_NULL;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = 1;
-		ptr->_internal_arr[0] = val;
-		ptr->_internal_size = 1;
+		ptr->array = res;
+		ptr->capacity = 1;
+		ptr->array[0] = val;
+		ptr->size = 1;
 		return;
 	}
-	if (ptr->_internal_max_size < ptr->_internal_size + 1)
+	if (ptr->max_size < ptr->size + 1)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
-	if (iter > ptr->_internal_size)
+	if (iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	_vec_char_push_back(ptr, 0, &status);
+	vec_char_push_back(ptr, 0, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= status.flags;
 		return;
 	}
-	for (size_t i = ptr->_internal_size - 1; i > iter; i--)
+	for (size_t i = ptr->size - 1; i > iter; i--)
 	{
-		ptr->_internal_arr[i] = ptr->_internal_arr[i - 1];
+		ptr->array[i] = ptr->array[i - 1];
 	}
-	ptr->_internal_arr[iter] = val;
+	ptr->array[iter] = val;
 
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
-		 const char val, err_t* err)
+vec_char_insert(vec_char* ptr, const size_t iter, const size_t amount,
+		const char val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -873,7 +825,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter > ptr->_internal_size)
+	if (iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
@@ -887,7 +839,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
 	}
 	for (size_t i = iter; i < iter + amount; i++)
 	{
-		_vec_char_insert(ptr, i, val, &status);
+		vec_char_insert(ptr, i, val, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "INSERT");
@@ -899,9 +851,8 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
 }
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
-		 const size_t iter, const size_t iter_start,
-		 const size_t iter_end, err_t* err)
+vec_char_insert(vec_char* ptr, const vec_char* iterator, const size_t iter,
+		const size_t iter_start, const size_t iter_end, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -912,14 +863,14 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter_end <= iter_start || iter_end > iterator->_internal_size ||
-	    iter > ptr->_internal_size)
+	if (iter_end <= iter_start || iter_end > iterator->size ||
+	    iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	if (ptr->_internal_arr == iterator->_internal_arr)
+	if (ptr->array == iterator->array)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_DOUBLE_BUF;
@@ -927,8 +878,8 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 	}
 	for (size_t i = iter_start; i < iter_end; i++)
 	{
-		_vec_char_insert(ptr, iter + (i - iter_start),
-				 iterator->_internal_arr[i], &status);
+		vec_char_insert(ptr, iter + (i - iter_start),
+				iterator->array[i], &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "INSERT");
diff --git a/src/float.c b/src/float.c
index 3937a42..67c5344 100644
--- a/src/float.c
+++ b/src/float.c
@@ -5,7 +5,7 @@
 #include <string.h>
 
 __attribute__((overloadable)) size_t
-__null_check(const _VecCharInternal* ptr, err_t* status)
+__null_check(const vec_float* ptr, err_t* status)
 {
 	if (status == nullptr)
 	{
@@ -16,7 +16,7 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
 		status->flags |= ERR_VEC_NULL;
 		return ERR_VEC_NULL;
 	}
-	if (ptr->_internal_arr == nullptr)
+	if (ptr->array == nullptr)
 	{
 		status->flags |= ERR_BUF_NULL;
 	}
@@ -24,62 +24,24 @@ __null_check(const _VecCharInternal* ptr, err_t* status)
 	return status->flags;
 }
 
-__attribute__((overloadable)) size_t
-__null_check(const char* ptr, err_t* status)
-{
-	if (status == nullptr)
-	{
-		return ERR_ERR_T_NULL;
-	}
-	if (ptr == nullptr)
-	{
-		status->flags |= ERR_BUF_NULL;
-	}
-	return status->flags;
-}
-
-size_t
-__origin_override(err_t* status, char* str)
-{
-	if (status == nullptr)
-	{
-		return ERR_ERR_T_NULL;
-	}
-	if (status->origin != nullptr)
-	{
-		status->flags |= ERR_ORIGIN_UNALTERABLE;
-		return status->flags;
-	}
-	else if (str == nullptr)
-	{
-		status->flags |= ERR_STR_NULL;
-		return status->flags;
-	}
-	else
-	{
-		status->origin = str;
-		return status->flags;
-	}
-}
-
 void
-_vec_char_print_vec(const _VecCharInternal* ptr, err_t* err)
+vec_float_print_vec(const vec_float* ptr, err_t* err)
 {
 	if (__null_check(ptr, err) != 0)
 	{
 		return;
 	}
-	for (size_t i = 0; i < ptr->_internal_size; i++)
+	for (size_t i = 0; i < ptr->size; i++)
 	{
-		printf("%c ", ptr->_internal_arr[i]);
+		printf("%f ", ptr->array[i]);
 	}
 	printf("\n");
 }
 
-_VecCharInternal
-_vec_char_cpy(const char* src, const size_t src_size, err_t* err)
+vec_float
+vec_float_cpy(const float* src, const size_t src_size, err_t* err)
 {
-	_VecCharInternal self = VEC_INIT;
+	vec_float self = VEC_INIT;
 	err_t status = ERR_T_INIT;
 
 	size_t null = __null_check(src, err);
@@ -100,30 +62,30 @@ _vec_char_cpy(const char* src, const size_t src_size, err_t* err)
 		err->flags |= status.flags;
 		return self;
 	}
-	if (src_size > self._internal_max_size)
+	if (src_size > self.max_size)
 	{
 		__origin_override(err, "CPY");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return self;
 	}
-	self._internal_arr = malloc(src_size * sizeof(char));
-	if (self._internal_arr == nullptr)
+	self.array = malloc(src_size * sizeof(float));
+	if (self.array == nullptr)
 	{
 		__origin_override(err, "CPY");
 		err->flags |= ERR_ALLOC_FAIL;
 		return self;
 	}
-	memcpy(self._internal_arr, src, src_size * sizeof(char));
-	self._internal_size = src_size;
-	self._internal_capacity = src_size;
+	memcpy(self.array, src, src_size * sizeof(float));
+	self.size = src_size;
+	self.capacity = src_size;
 	return self;
 }
 
 void
-_vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
+vec_float_push_back(vec_float* ptr, const float val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
-	char* res;
+	float* res;
 	__null_check(ptr, &status);
 	if ((status.flags & ERR_VEC_NULL) != 0)
 	{
@@ -132,7 +94,7 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size + 1 > ptr->_internal_max_size)
+	if (ptr->size + 1 > ptr->max_size)
 	{
 		__origin_override(err, "PUSH_BACK");
 		err->flags |= ERR_SIZE_OVERFLOW;
@@ -141,50 +103,49 @@ _vec_char_push_back(_VecCharInternal* ptr, const char val, err_t* err)
 
 	if ((status.flags & ERR_BUF_NULL) != 0)
 	{
-		res = malloc(1 * sizeof(char));
+		res = malloc(1 * sizeof(float));
 		if (res == nullptr)
 		{
 			__origin_override(err, "PUSH_BACK");
 			err->flags |= ERR_ALLOC_FAIL;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = 1;
-		ptr->_internal_size = 0;
+		ptr->array = res;
+		ptr->capacity = 1;
+		ptr->size = 0;
 	}
 
-	else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
+	else if (ptr->size + 1 > ptr->capacity)
 	{
-		size_t dst_cap =
-		    (ptr->_internal_capacity / 2) + ptr->_internal_capacity;
-		if (dst_cap == ptr->_internal_capacity)
+		size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
+		if (dst_cap == ptr->capacity)
 		{
 			dst_cap++;
 		}
-		if (dst_cap > ptr->_internal_max_size)
+		if (dst_cap > ptr->max_size)
 		{
-			dst_cap = ptr->_internal_max_size;
+			dst_cap = ptr->max_size;
 			DEBUG(
 			    "Capacity cannot be grown any further due "
 			    "to hitting max size");
 		}
-		res = realloc(ptr->_internal_arr, dst_cap * sizeof(char));
+		res = realloc(ptr->array, dst_cap * sizeof(float));
 		if (res == nullptr)
 		{
 			__origin_override(err, "PUSH_BACK");
 			err->flags |= ERR_SIZE_OVERFLOW;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = dst_cap;
+		ptr->array = res;
+		ptr->capacity = dst_cap;
 	}
-	ptr->_internal_arr[ptr->_internal_size] = val;
-	ptr->_internal_size++;
+	ptr->array[ptr->size] = val;
+	ptr->size++;
 	return;
 }
 
 void
-_vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
+vec_float_pop_back(vec_float* ptr, err_t* err)
 {
 	if (__null_check(ptr, err) != 0)
 	{
@@ -192,19 +153,19 @@ _vec_char_pop_back(_VecCharInternal* ptr, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "POP_BACK");
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
 
-	ptr->_internal_arr[ptr->_internal_size - 1] = 0;
-	ptr->_internal_size--;
+	ptr->array[ptr->size - 1] = 0;
+	ptr->size--;
 }
 
 void
-_vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
+vec_float_reserve(vec_float* ptr, const size_t capacity, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -216,7 +177,7 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
 			return;
 		}
 	}
-	if (ptr->_internal_max_size < capacity)
+	if (ptr->max_size < capacity)
 	{
 		__origin_override(err, "RESERVE");
 		err->flags |= ERR_SIZE_OVERFLOW;
@@ -229,24 +190,24 @@ _vec_char_reserve(_VecCharInternal* ptr, const size_t capacity, err_t* err)
 		return;
 	}
 
-	char* res = realloc(ptr->_internal_arr, capacity * sizeof(char));
+	float* res = realloc(ptr->array, capacity * sizeof(float));
 	if (res == nullptr)
 	{
 		__origin_override(err, "RESERVE");
 		err->flags |= ERR_ALLOC_FAIL;
 		return;
 	}
-	ptr->_internal_arr = res;
-	ptr->_internal_capacity = capacity;
-	if (ptr->_internal_size > capacity)
+	ptr->array = res;
+	ptr->capacity = capacity;
+	if (ptr->size > capacity)
 	{
-		ptr->_internal_size = capacity;
+		ptr->size = capacity;
 	}
 	return;
 }
 
 void
-_vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
+vec_float_shrink_to_fit(vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -255,17 +216,17 @@ _vec_char_shrink_to_fit(_VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "SHRINK_TO_FIT");
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
-	_vec_char_reserve(ptr, ptr->_internal_size, err);
+	vec_float_reserve(ptr, ptr->size, err);
 }
 
 void
-_vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err)
+vec_float_swap(vec_float* ptr_a, vec_float* ptr_b, err_t* err)
 {
 	err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
 	if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
@@ -275,14 +236,14 @@ _vec_char_swap(_VecCharInternal* ptr_a, _VecCharInternal* ptr_b, err_t* err)
 		err->flags |= ERR_VEC_NULL;
 		return;
 	}
-	_VecCharInternal self = *ptr_a;
+	vec_float self = *ptr_a;
 	*ptr_a = *ptr_b;
 	*ptr_b = self;
 	return;
 }
 
-const char*
-_vec_char_data(const _VecCharInternal* ptr, err_t* err)
+const float*
+vec_float_data(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -291,11 +252,11 @@ _vec_char_data(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return nullptr;
 	}
-	return &ptr->_internal_arr[0];
+	return &ptr->array[0];
 }
 
 size_t
-_vec_char_size(const _VecCharInternal* ptr, err_t* err)
+vec_float_size(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -304,11 +265,11 @@ _vec_char_size(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_size;
+	return ptr->size;
 }
 
 size_t
-_vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
+vec_float_capacity(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -317,11 +278,11 @@ _vec_char_capacity(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_capacity;
+	return ptr->capacity;
 }
 
 size_t
-_vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
+vec_float_max_size(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -330,11 +291,11 @@ _vec_char_max_size(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_max_size;
+	return ptr->max_size;
 }
 
 void
-_vec_char_delete(_VecCharInternal* ptr, err_t* err)
+vec_float_delete(vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -343,17 +304,17 @@ _vec_char_delete(_VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_arr != nullptr)
+	if (ptr->array != nullptr)
 	{
-		free(ptr->_internal_arr);
-		ptr->_internal_arr = nullptr;
+		free(ptr->array);
+		ptr->array = nullptr;
 	}
-	ptr->_internal_size = 0;
-	ptr->_internal_capacity = 0;
+	ptr->size = 0;
+	ptr->capacity = 0;
 }
 
 void
-_vec_char_clear(_VecCharInternal* ptr, err_t* err)
+vec_float_clear(vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -362,15 +323,15 @@ _vec_char_clear(_VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_size > 0)
+	if (ptr->size > 0)
 	{
-		memset(ptr->_internal_arr, 0, ptr->_internal_size);
-		ptr->_internal_size = 0;
+		memset(ptr->array, 0, ptr->size);
+		ptr->size = 0;
 	}
 }
 
-char*
-_vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
+float*
+vec_float_at(const vec_float* ptr, const size_t idx, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -379,17 +340,17 @@ _vec_char_at(const _VecCharInternal* ptr, const size_t idx, err_t* err)
 		err->flags |= status.flags;
 		return nullptr;
 	}
-	if (idx >= ptr->_internal_size)
+	if (idx >= ptr->size)
 	{
 		__origin_override(err, "AT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return nullptr;
 	}
-	return &ptr->_internal_arr[idx];
+	return &ptr->array[idx];
 }
 
 size_t
-_vec_char_begin(const _VecCharInternal* ptr, err_t* err)
+vec_float_begin(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -402,7 +363,7 @@ _vec_char_begin(const _VecCharInternal* ptr, err_t* err)
 }
 
 size_t
-_vec_char_end(const _VecCharInternal* ptr, err_t* err)
+vec_float_end(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -411,17 +372,17 @@ _vec_char_end(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return status.flags;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "END");
 		err->flags |= ERR_SIZE_ZERO;
 		return status.flags;
 	}
-	return (size_t)(ptr->_internal_size - 1);
+	return (size_t)(ptr->size - 1);
 }
 
-char
-_vec_char_front(const _VecCharInternal* ptr, err_t* err)
+float
+vec_float_front(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -430,16 +391,16 @@ _vec_char_front(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return -1;
 	}
-	if (_vec_char_at(ptr, 0, err) == nullptr)
+	if (vec_float_at(ptr, 0, err) == nullptr)
 	{
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return 0;
 	}
-	return *_vec_char_at(ptr, 0, err);
+	return *vec_float_at(ptr, 0, err);
 }
 
-char
-_vec_char_back(const _VecCharInternal* ptr, err_t* err)
+float
+vec_float_back(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -448,16 +409,16 @@ _vec_char_back(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return -1;
 	}
-	if (_vec_char_at(ptr, 0, err) == nullptr)
+	if (vec_float_at(ptr, 0, err) == nullptr)
 	{
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return 0;
 	}
-	return *_vec_char_at(ptr, ptr->_internal_size - 1, err);
+	return *vec_float_at(ptr, ptr->size - 1, err);
 }
 
 size_t
-_vec_char_empty(const _VecCharInternal* ptr, err_t* err)
+vec_float_empty(const vec_float* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -466,15 +427,15 @@ _vec_char_empty(const _VecCharInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return status.flags;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
-		return ptr->_internal_size;
+		return ptr->size;
 	}
 	return status.flags;
 }
 
 __attribute__((overloadable)) void
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err)
+vec_float_erase(vec_float* ptr, const size_t iter, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -483,20 +444,20 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter >= ptr->_internal_size)
+	if (iter >= ptr->size)
 	{
 		return;
 	}
-	memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
-		(ptr->_internal_size - iter - 1) * sizeof(char));
-	ptr->_internal_arr[ptr->_internal_size - 1] = 0;
-	ptr->_internal_size--;
+	memmove(&ptr->array[iter], &ptr->array[iter + 1],
+		(ptr->size - iter - 1) * sizeof(float));
+	ptr->array[ptr->size - 1] = 0;
+	ptr->size--;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
-		const size_t iter_end, err_t* err)
+vec_float_erase(vec_float* ptr, const size_t iter_start, const size_t iter_end,
+		err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -506,23 +467,22 @@ _vec_char_erase(_VecCharInternal* ptr, const size_t iter_start,
 		return;
 	}
 
-	if (ptr->_internal_size < iter_end || iter_end <= iter_start)
+	if (ptr->size < iter_end || iter_end <= iter_start)
 	{
 		__origin_override(err, "ERASE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 	size_t diff = iter_end - iter_start;
-	memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
-		(ptr->_internal_size - iter_end) * sizeof(char));
-	memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0,
-	       sizeof(char) * diff);
-	ptr->_internal_size -= diff;
+	memmove(&ptr->array[iter_start], &ptr->array[iter_end],
+		(ptr->size - iter_end) * sizeof(float));
+	memset(&ptr->array[ptr->size - diff], 0, sizeof(float) * diff);
+	ptr->size -= diff;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
+vec_float_resize(vec_float* ptr, const size_t size, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -533,32 +493,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size == size)
+	if (ptr->size == size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 
-	else if (size > ptr->_internal_max_size)
+	else if (size > ptr->max_size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
 
-	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
+	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
 	{
-		size_t max = ptr->_internal_max_size;
+		size_t max = ptr->max_size;
 		err_t verr = ERR_T_INIT;
-		_vec_char_reserve(ptr, size, &verr);
+		vec_float_reserve(ptr, size, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != size)
+		if (ptr->capacity != size)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
@@ -566,57 +526,54 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, err_t* err)
 		}
 		for (size_t i = 0; i < size; i++)
 		{
-			ptr->_internal_arr[i] = 0;
+			ptr->array[i] = 0;
 		}
-		ptr->_internal_max_size = max;
-		ptr->_internal_size = size;
+		ptr->max_size = max;
+		ptr->size = size;
 		return;
 	}
-	else if (size > ptr->_internal_capacity)
+	else if (size > ptr->capacity)
 	{
-		size_t tmpcp = ptr->_internal_capacity;
-		size_t tmpmx = ptr->_internal_max_size;
+		size_t tmpcp = ptr->capacity;
+		size_t tmpmx = ptr->max_size;
 		err_t verr = ERR_T_INIT;
 		while (size > tmpcp)
 		{
 			tmpcp *= 2;
 		}
-		if (tmpcp > ptr->_internal_max_size)
+		if (tmpcp > ptr->max_size)
 		{
 			tmpcp = size;
 		}
-		_vec_char_reserve(ptr, tmpcp, &verr);
+		vec_float_reserve(ptr, tmpcp, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != tmpcp)
+		if (ptr->capacity != tmpcp)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
 			return;
 		}
-		ptr->_internal_max_size = tmpmx;
+		ptr->max_size = tmpmx;
 	}
-	if (size < ptr->_internal_size)
+	if (size < ptr->size)
 	{
-		memset(&ptr->_internal_arr[size], 0,
-		       ptr->_internal_size - size);
+		memset(&ptr->array[size], 0, ptr->size - size);
 	}
-	if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
+	if (ptr->size < size && size <= ptr->capacity)
 	{
-		memset(&ptr->_internal_arr[ptr->_internal_size], 0,
-		       size - ptr->_internal_size);
+		memset(&ptr->array[ptr->size], 0, size - ptr->size);
 	}
-	ptr->_internal_size = size;
+	ptr->size = size;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
-		 err_t* err)
+vec_float_resize(vec_float* ptr, const size_t size, const float val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -626,32 +583,32 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
 		err->flags |= ERR_VEC_NULL;
 		return;
 	}
-	if (ptr->_internal_size == size)
+	if (ptr->size == size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 
-	else if (size > ptr->_internal_max_size)
+	else if (size > ptr->max_size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
 
-	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
+	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
 	{
-		size_t max = ptr->_internal_max_size;
+		size_t max = ptr->max_size;
 		err_t verr = ERR_T_INIT;
-		_vec_char_reserve(ptr, size, &verr);
+		vec_float_reserve(ptr, size, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != size)
+		if (ptr->capacity != size)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
@@ -659,50 +616,48 @@ _vec_char_resize(_VecCharInternal* ptr, const size_t size, const char val,
 		}
 		for (size_t i = 0; i < size; i++)
 		{
-			ptr->_internal_arr[i] = val;
+			ptr->array[i] = val;
 		}
-		ptr->_internal_max_size = max;
-		ptr->_internal_size = size;
+		ptr->max_size = max;
+		ptr->size = size;
 		return;
 	}
-	else if (size > ptr->_internal_capacity)
+	else if (size > ptr->capacity)
 	{
-		size_t tmpcp = ptr->_internal_capacity;
-		size_t tmpmx = ptr->_internal_max_size;
+		size_t tmpcp = ptr->capacity;
+		size_t tmpmx = ptr->max_size;
 		err_t verr = ERR_T_INIT;
 		while (size > tmpcp)
 		{
 			tmpcp *= 2;
 		}
-		if (tmpcp > ptr->_internal_max_size)
+		if (tmpcp > ptr->max_size)
 		{
 			tmpcp = size;
 		}
-		_vec_char_reserve(ptr, tmpcp, &verr);
+		vec_float_reserve(ptr, tmpcp, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		ptr->_internal_max_size = tmpmx;
+		ptr->max_size = tmpmx;
 	}
-	if (size < ptr->_internal_size)
+	if (size < ptr->size)
 	{
-		memset(&ptr->_internal_arr[size], val,
-		       ptr->_internal_size - size);
+		memset(&ptr->array[size], val, ptr->size - size);
 	}
-	if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
+	if (ptr->size < size && size <= ptr->capacity)
 	{
-		memset(&ptr->_internal_arr[ptr->_internal_size], val,
-		       size - ptr->_internal_size);
+		memset(&ptr->array[ptr->size], val, size - ptr->size);
 	}
-	ptr->_internal_size = size;
+	ptr->size = size;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
+vec_float_assign(vec_float* ptr, const vec_float* iterator,
 		 const size_t iter_start, const size_t iter_end, err_t* err)
 {
 	err_t status = ERR_T_INIT;
@@ -713,27 +668,27 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_arr == iterator->_internal_arr)
+	if (ptr->array == iterator->array)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= ERR_DOUBLE_BUF;
 		return;
 	}
-	if (iterator->_internal_size < iter_end || iter_end <= iter_start)
+	if (iterator->size < iter_end || iter_end <= iter_start)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
-			_vec_char_end(ptr, &status) + 1, &status);
+	vec_float_erase(ptr, vec_float_begin(ptr, &status),
+			vec_float_end(ptr, &status) + 1, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= status.flags;
 		return;
 	}
-	_vec_char_reserve(ptr, (iter_end - iter_start), &status);
+	vec_float_reserve(ptr, (iter_end - iter_start), &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
@@ -742,13 +697,13 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 	}
 	for (size_t i = iter_start; i < iter_end; i++)
 	{
-		char* res = _vec_char_at(iterator, i, &status);
+		float* res = vec_float_at(iterator, i, &status);
 		if (res == nullptr)
 		{
 			err->flags |= ERR_OUT_OF_BOUNDS;
 			return;
 		}
-		_vec_char_push_back(ptr, *res, &status);
+		vec_float_push_back(ptr, *res, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "ASSIGN");
@@ -760,7 +715,7 @@ _vec_char_assign(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 }
 
 __attribute__((overloadable)) void
-_vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
+vec_float_assign(vec_float* ptr, const size_t amount, const float val,
 		 err_t* err)
 {
 	err_t status = ERR_T_INIT;
@@ -776,15 +731,15 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
-	_vec_char_erase(ptr, _vec_char_begin(ptr, &status),
-			_vec_char_end(ptr, &status) + 1, &status);
+	vec_float_erase(ptr, vec_float_begin(ptr, &status),
+			vec_float_end(ptr, &status) + 1, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= status.flags;
 		return;
 	}
-	_vec_char_reserve(ptr, amount, &status);
+	vec_float_reserve(ptr, amount, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
@@ -793,7 +748,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
 	}
 	for (size_t i = 0; i < amount; i++)
 	{
-		_vec_char_push_back(ptr, val, &status);
+		vec_float_push_back(ptr, val, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "ASSIGN");
@@ -805,8 +760,7 @@ _vec_char_assign(_VecCharInternal* ptr, const size_t amount, const char val,
 }
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
-		 err_t* err)
+vec_float_insert(vec_float* ptr, const size_t iter, const float val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -818,50 +772,50 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const char val,
 	}
 	if ((status.flags & ERR_BUF_NULL) != 0)
 	{
-		char* res = malloc(1 * sizeof(char));
+		float* res = malloc(1 * sizeof(float));
 		if (res == nullptr)
 		{
 			__origin_override(err, "INSERT");
 			err->flags |= ERR_BUF_NULL;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = 1;
-		ptr->_internal_arr[0] = val;
-		ptr->_internal_size = 1;
+		ptr->array = res;
+		ptr->capacity = 1;
+		ptr->array[0] = val;
+		ptr->size = 1;
 		return;
 	}
-	if (ptr->_internal_max_size < ptr->_internal_size + 1)
+	if (ptr->max_size < ptr->size + 1)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
-	if (iter > ptr->_internal_size)
+	if (iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	_vec_char_push_back(ptr, 0, &status);
+	vec_float_push_back(ptr, 0, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= status.flags;
 		return;
 	}
-	for (size_t i = ptr->_internal_size - 1; i > iter; i--)
+	for (size_t i = ptr->size - 1; i > iter; i--)
 	{
-		ptr->_internal_arr[i] = ptr->_internal_arr[i - 1];
+		ptr->array[i] = ptr->array[i - 1];
 	}
-	ptr->_internal_arr[iter] = val;
+	ptr->array[iter] = val;
 
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
-		 const char val, err_t* err)
+vec_float_insert(vec_float* ptr, const size_t iter, const size_t amount,
+		 const float val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -871,7 +825,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter > ptr->_internal_size)
+	if (iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
@@ -885,7 +839,7 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
 	}
 	for (size_t i = iter; i < iter + amount; i++)
 	{
-		_vec_char_insert(ptr, i, val, &status);
+		vec_float_insert(ptr, i, val, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "INSERT");
@@ -897,9 +851,8 @@ _vec_char_insert(_VecCharInternal* ptr, const size_t iter, const size_t amount,
 }
 
 __attribute__((overloadable)) void
-_vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
-		 const size_t iter, const size_t iter_start,
-		 const size_t iter_end, err_t* err)
+vec_float_insert(vec_float* ptr, const vec_float* iterator, const size_t iter,
+		 const size_t iter_start, const size_t iter_end, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -910,14 +863,14 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter_end <= iter_start || iter_end > iterator->_internal_size ||
-	    iter > ptr->_internal_size)
+	if (iter_end <= iter_start || iter_end > iterator->size ||
+	    iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	if (ptr->_internal_arr == iterator->_internal_arr)
+	if (ptr->array == iterator->array)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_DOUBLE_BUF;
@@ -925,8 +878,8 @@ _vec_char_insert(_VecCharInternal* ptr, const _VecCharInternal* iterator,
 	}
 	for (size_t i = iter_start; i < iter_end; i++)
 	{
-		_vec_char_insert(ptr, iter + (i - iter_start),
-				 iterator->_internal_arr[i], &status);
+		vec_float_insert(ptr, iter + (i - iter_start),
+				 iterator->array[i], &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "INSERT");
diff --git a/src/int.c b/src/int.c
index 2cb813b..e1e7977 100644
--- a/src/int.c
+++ b/src/int.c
@@ -5,7 +5,7 @@
 #include <string.h>
 
 __attribute__((overloadable)) size_t
-__null_check(const _VecIntInternal* ptr, err_t* status)
+__null_check(const vec_int* ptr, err_t* status)
 {
 	if (status == nullptr)
 	{
@@ -16,7 +16,7 @@ __null_check(const _VecIntInternal* ptr, err_t* status)
 		status->flags |= ERR_VEC_NULL;
 		return ERR_VEC_NULL;
 	}
-	if (ptr->_internal_arr == nullptr)
+	if (ptr->array == nullptr)
 	{
 		status->flags |= ERR_BUF_NULL;
 	}
@@ -24,62 +24,24 @@ __null_check(const _VecIntInternal* ptr, err_t* status)
 	return status->flags;
 }
 
-__attribute__((overloadable)) size_t
-__null_check(const int* ptr, err_t* status)
-{
-	if (status == nullptr)
-	{
-		return ERR_ERR_T_NULL;
-	}
-	if (ptr == nullptr)
-	{
-		status->flags |= ERR_BUF_NULL;
-	}
-	return status->flags;
-}
-
-size_t
-__origin_override(err_t* status, char* str)
-{
-	if (status == nullptr)
-	{
-		return ERR_ERR_T_NULL;
-	}
-	if (status->origin != nullptr)
-	{
-		status->flags |= ERR_ORIGIN_UNALTERABLE;
-		return status->flags;
-	}
-	else if (str == nullptr)
-	{
-		status->flags |= ERR_STR_NULL;
-		return status->flags;
-	}
-	else
-	{
-		status->origin = str;
-		return status->flags;
-	}
-}
-
 void
-_vec_int_print_vec(const _VecIntInternal* ptr, err_t* err)
+vec_int_print_vec(const vec_int* ptr, err_t* err)
 {
 	if (__null_check(ptr, err) != 0)
 	{
 		return;
 	}
-	for (size_t i = 0; i < ptr->_internal_size; i++)
+	for (size_t i = 0; i < ptr->size; i++)
 	{
-		printf("%d ", ptr->_internal_arr[i]);
+		printf("%d ", ptr->array[i]);
 	}
 	printf("\n");
 }
 
-_VecIntInternal
-_vec_int_cpy(const int* src, const size_t src_size, err_t* err)
+vec_int
+vec_int_cpy(const int* src, const size_t src_size, err_t* err)
 {
-	_VecIntInternal self = VEC_INIT;
+	vec_int self = VEC_INIT;
 	err_t status = ERR_T_INIT;
 
 	size_t null = __null_check(src, err);
@@ -100,27 +62,27 @@ _vec_int_cpy(const int* src, const size_t src_size, err_t* err)
 		err->flags |= status.flags;
 		return self;
 	}
-	if (src_size > self._internal_max_size)
+	if (src_size > self.max_size)
 	{
 		__origin_override(err, "CPY");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return self;
 	}
-	self._internal_arr = malloc(src_size * sizeof(int));
-	if (self._internal_arr == nullptr)
+	self.array = malloc(src_size * sizeof(int));
+	if (self.array == nullptr)
 	{
 		__origin_override(err, "CPY");
 		err->flags |= ERR_ALLOC_FAIL;
 		return self;
 	}
-	memcpy(self._internal_arr, src, src_size * sizeof(int));
-	self._internal_size = src_size;
-	self._internal_capacity = src_size;
+	memcpy(self.array, src, src_size * sizeof(int));
+	self.size = src_size;
+	self.capacity = src_size;
 	return self;
 }
 
 void
-_vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err)
+vec_int_push_back(vec_int* ptr, const int val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	int* res;
@@ -132,7 +94,7 @@ _vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size + 1 > ptr->_internal_max_size)
+	if (ptr->size + 1 > ptr->max_size)
 	{
 		__origin_override(err, "PUSH_BACK");
 		err->flags |= ERR_SIZE_OVERFLOW;
@@ -148,43 +110,42 @@ _vec_int_push_back(_VecIntInternal* ptr, const int val, err_t* err)
 			err->flags |= ERR_ALLOC_FAIL;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = 1;
-		ptr->_internal_size = 0;
+		ptr->array = res;
+		ptr->capacity = 1;
+		ptr->size = 0;
 	}
 
-	else if (ptr->_internal_size + 1 > ptr->_internal_capacity)
+	else if (ptr->size + 1 > ptr->capacity)
 	{
-		size_t dst_cap =
-		    (ptr->_internal_capacity / 2) + ptr->_internal_capacity;
-		if (dst_cap == ptr->_internal_capacity)
+		size_t dst_cap = (ptr->capacity / 2) + ptr->capacity;
+		if (dst_cap == ptr->capacity)
 		{
 			dst_cap++;
 		}
-		if (dst_cap > ptr->_internal_max_size)
+		if (dst_cap > ptr->max_size)
 		{
-			dst_cap = ptr->_internal_max_size;
+			dst_cap = ptr->max_size;
 			DEBUG(
 			    "Capacity cannot be grown any further due "
 			    "to hitting max size");
 		}
-		res = realloc(ptr->_internal_arr, dst_cap * sizeof(int));
+		res = realloc(ptr->array, dst_cap * sizeof(int));
 		if (res == nullptr)
 		{
 			__origin_override(err, "PUSH_BACK");
 			err->flags |= ERR_SIZE_OVERFLOW;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = dst_cap;
+		ptr->array = res;
+		ptr->capacity = dst_cap;
 	}
-	ptr->_internal_arr[ptr->_internal_size] = val;
-	ptr->_internal_size++;
+	ptr->array[ptr->size] = val;
+	ptr->size++;
 	return;
 }
 
 void
-_vec_int_pop_back(_VecIntInternal* ptr, err_t* err)
+vec_int_pop_back(vec_int* ptr, err_t* err)
 {
 	if (__null_check(ptr, err) != 0)
 	{
@@ -192,19 +153,19 @@ _vec_int_pop_back(_VecIntInternal* ptr, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "POP_BACK");
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
 
-	ptr->_internal_arr[ptr->_internal_size - 1] = 0;
-	ptr->_internal_size--;
+	ptr->array[ptr->size - 1] = 0;
+	ptr->size--;
 }
 
 void
-_vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err)
+vec_int_reserve(vec_int* ptr, const size_t capacity, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -216,7 +177,7 @@ _vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err)
 			return;
 		}
 	}
-	if (ptr->_internal_max_size < capacity)
+	if (ptr->max_size < capacity)
 	{
 		__origin_override(err, "RESERVE");
 		err->flags |= ERR_SIZE_OVERFLOW;
@@ -229,24 +190,24 @@ _vec_int_reserve(_VecIntInternal* ptr, const size_t capacity, err_t* err)
 		return;
 	}
 
-	int* res = realloc(ptr->_internal_arr, capacity * sizeof(int));
+	int* res = realloc(ptr->array, capacity * sizeof(int));
 	if (res == nullptr)
 	{
 		__origin_override(err, "RESERVE");
 		err->flags |= ERR_ALLOC_FAIL;
 		return;
 	}
-	ptr->_internal_arr = res;
-	ptr->_internal_capacity = capacity;
-	if (ptr->_internal_size > capacity)
+	ptr->array = res;
+	ptr->capacity = capacity;
+	if (ptr->size > capacity)
 	{
-		ptr->_internal_size = capacity;
+		ptr->size = capacity;
 	}
 	return;
 }
 
 void
-_vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err)
+vec_int_shrink_to_fit(vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -255,17 +216,17 @@ _vec_int_shrink_to_fit(_VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "SHRINK_TO_FIT");
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
-	_vec_int_reserve(ptr, ptr->_internal_size, err);
+	vec_int_reserve(ptr, ptr->size, err);
 }
 
 void
-_vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err)
+vec_int_swap(vec_int* ptr_a, vec_int* ptr_b, err_t* err)
 {
 	err_t status_1 = ERR_T_INIT, status_2 = ERR_T_INIT;
 	if ((__null_check(ptr_a, &status_1) & ERR_VEC_NULL) != 0 ||
@@ -275,14 +236,14 @@ _vec_int_swap(_VecIntInternal* ptr_a, _VecIntInternal* ptr_b, err_t* err)
 		err->flags |= ERR_VEC_NULL;
 		return;
 	}
-	_VecIntInternal self = *ptr_a;
+	vec_int self = *ptr_a;
 	*ptr_a = *ptr_b;
 	*ptr_b = self;
 	return;
 }
 
 const int*
-_vec_int_data(const _VecIntInternal* ptr, err_t* err)
+vec_int_data(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -291,11 +252,11 @@ _vec_int_data(const _VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return nullptr;
 	}
-	return &ptr->_internal_arr[0];
+	return &ptr->array[0];
 }
 
 size_t
-_vec_int_size(const _VecIntInternal* ptr, err_t* err)
+vec_int_size(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -304,11 +265,11 @@ _vec_int_size(const _VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_size;
+	return ptr->size;
 }
 
 size_t
-_vec_int_capacity(const _VecIntInternal* ptr, err_t* err)
+vec_int_capacity(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -317,11 +278,11 @@ _vec_int_capacity(const _VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_capacity;
+	return ptr->capacity;
 }
 
 size_t
-_vec_int_max_size(const _VecIntInternal* ptr, err_t* err)
+vec_int_max_size(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -330,11 +291,11 @@ _vec_int_max_size(const _VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return 0;
 	}
-	return ptr->_internal_max_size;
+	return ptr->max_size;
 }
 
 void
-_vec_int_delete(_VecIntInternal* ptr, err_t* err)
+vec_int_delete(vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -343,17 +304,17 @@ _vec_int_delete(_VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_arr != nullptr)
+	if (ptr->array != nullptr)
 	{
-		free(ptr->_internal_arr);
-		ptr->_internal_arr = nullptr;
+		free(ptr->array);
+		ptr->array = nullptr;
 	}
-	ptr->_internal_size = 0;
-	ptr->_internal_capacity = 0;
+	ptr->size = 0;
+	ptr->capacity = 0;
 }
 
 void
-_vec_int_clear(_VecIntInternal* ptr, err_t* err)
+vec_int_clear(vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -362,16 +323,15 @@ _vec_int_clear(_VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_size > 0)
+	if (ptr->size > 0)
 	{
-		memset(ptr->_internal_arr, 0,
-		       ptr->_internal_size * sizeof(int));
-		ptr->_internal_size = 0;
+		memset(ptr->array, 0, ptr->size * sizeof(int));
+		ptr->size = 0;
 	}
 }
 
 int*
-_vec_int_at(const _VecIntInternal* ptr, const size_t idx, err_t* err)
+vec_int_at(const vec_int* ptr, const size_t idx, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -380,17 +340,17 @@ _vec_int_at(const _VecIntInternal* ptr, const size_t idx, err_t* err)
 		err->flags |= status.flags;
 		return nullptr;
 	}
-	if (idx >= ptr->_internal_size)
+	if (idx >= ptr->size)
 	{
 		__origin_override(err, "AT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return nullptr;
 	}
-	return &ptr->_internal_arr[idx];
+	return &ptr->array[idx];
 }
 
 size_t
-_vec_int_begin(const _VecIntInternal* ptr, err_t* err)
+vec_int_begin(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -403,7 +363,7 @@ _vec_int_begin(const _VecIntInternal* ptr, err_t* err)
 }
 
 size_t
-_vec_int_end(const _VecIntInternal* ptr, err_t* err)
+vec_int_end(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -412,17 +372,17 @@ _vec_int_end(const _VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return status.flags;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
 		__origin_override(err, "END");
 		err->flags |= ERR_SIZE_ZERO;
 		return status.flags;
 	}
-	return (size_t)(ptr->_internal_size - 1);
+	return (size_t)(ptr->size - 1);
 }
 
 int
-_vec_int_front(const _VecIntInternal* ptr, err_t* err)
+vec_int_front(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -431,16 +391,16 @@ _vec_int_front(const _VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return -1;
 	}
-	if (_vec_int_at(ptr, 0, err) == nullptr)
+	if (vec_int_at(ptr, 0, err) == nullptr)
 	{
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return 0;
 	}
-	return *_vec_int_at(ptr, 0, err);
+	return *vec_int_at(ptr, 0, err);
 }
 
 int
-_vec_int_back(const _VecIntInternal* ptr, err_t* err)
+vec_int_back(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -449,16 +409,16 @@ _vec_int_back(const _VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return -1;
 	}
-	if (_vec_int_at(ptr, 0, err) == nullptr)
+	if (vec_int_at(ptr, 0, err) == nullptr)
 	{
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return 0;
 	}
-	return *_vec_int_at(ptr, ptr->_internal_size - 1, err);
+	return *vec_int_at(ptr, ptr->size - 1, err);
 }
 
 size_t
-_vec_int_empty(const _VecIntInternal* ptr, err_t* err)
+vec_int_empty(const vec_int* ptr, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -467,15 +427,15 @@ _vec_int_empty(const _VecIntInternal* ptr, err_t* err)
 		err->flags |= status.flags;
 		return status.flags;
 	}
-	if (ptr->_internal_size == 0)
+	if (ptr->size == 0)
 	{
-		return ptr->_internal_size;
+		return ptr->size;
 	}
 	return status.flags;
 }
 
 __attribute__((overloadable)) void
-_vec_int_erase(_VecIntInternal* ptr, const size_t iter, err_t* err)
+vec_int_erase(vec_int* ptr, const size_t iter, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -484,20 +444,20 @@ _vec_int_erase(_VecIntInternal* ptr, const size_t iter, err_t* err)
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter >= ptr->_internal_size)
+	if (iter >= ptr->size)
 	{
 		return;
 	}
-	memmove(&ptr->_internal_arr[iter], &ptr->_internal_arr[iter + 1],
-		(ptr->_internal_size - iter - 1) * sizeof(int));
-	ptr->_internal_arr[ptr->_internal_size - 1] = 0;
-	ptr->_internal_size--;
+	memmove(&ptr->array[iter], &ptr->array[iter + 1],
+		(ptr->size - iter - 1) * sizeof(int));
+	ptr->array[ptr->size - 1] = 0;
+	ptr->size--;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_int_erase(_VecIntInternal* ptr, const size_t iter_start,
-	       const size_t iter_end, err_t* err)
+vec_int_erase(vec_int* ptr, const size_t iter_start, const size_t iter_end,
+	      err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -507,23 +467,22 @@ _vec_int_erase(_VecIntInternal* ptr, const size_t iter_start,
 		return;
 	}
 
-	if (ptr->_internal_size < iter_end || iter_end <= iter_start)
+	if (ptr->size < iter_end || iter_end <= iter_start)
 	{
 		__origin_override(err, "ERASE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 	size_t diff = iter_end - iter_start;
-	memmove(&ptr->_internal_arr[iter_start], &ptr->_internal_arr[iter_end],
-		(ptr->_internal_size - iter_end) * sizeof(int));
-	memset(&ptr->_internal_arr[ptr->_internal_size - diff], 0,
-	       sizeof(int) * diff);
-	ptr->_internal_size -= diff;
+	memmove(&ptr->array[iter_start], &ptr->array[iter_end],
+		(ptr->size - iter_end) * sizeof(int));
+	memset(&ptr->array[ptr->size - diff], 0, sizeof(int) * diff);
+	ptr->size -= diff;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err)
+vec_int_resize(vec_int* ptr, const size_t size, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -534,87 +493,85 @@ _vec_int_resize(_VecIntInternal* ptr, const size_t size, err_t* err)
 		return;
 	}
 
-	if (ptr->_internal_size == size)
+	if (ptr->size == size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 
-	else if (size > ptr->_internal_max_size)
+	else if (size > ptr->max_size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
 
-	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
+	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
 	{
-		size_t max = ptr->_internal_max_size;
+		size_t max = ptr->max_size;
 		err_t verr = ERR_T_INIT;
-		_vec_int_reserve(ptr, size, &verr);
+		vec_int_reserve(ptr, size, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != size)
+		if (ptr->capacity != size)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
 			return;
 		}
-		memset(ptr->_internal_arr, 0, size * sizeof(int));
-		ptr->_internal_max_size = max;
-		ptr->_internal_size = size;
+		memset(ptr->array, 0, size * sizeof(int));
+		ptr->max_size = max;
+		ptr->size = size;
 		return;
 	}
-	else if (size > ptr->_internal_capacity)
+	else if (size > ptr->capacity)
 	{
-		size_t tmpcp = ptr->_internal_capacity;
-		size_t tmpmx = ptr->_internal_max_size;
+		size_t tmpcp = ptr->capacity;
+		size_t tmpmx = ptr->max_size;
 		err_t verr = ERR_T_INIT;
 		while (size > tmpcp)
 		{
 			tmpcp *= 2;
 		}
-		if (tmpcp > ptr->_internal_max_size)
+		if (tmpcp > ptr->max_size)
 		{
 			tmpcp = size;
 		}
-		_vec_int_reserve(ptr, tmpcp, &verr);
+		vec_int_reserve(ptr, tmpcp, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != tmpcp)
+		if (ptr->capacity != tmpcp)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
 			return;
 		}
-		ptr->_internal_max_size = tmpmx;
+		ptr->max_size = tmpmx;
 	}
-	if (size < ptr->_internal_size)
+	if (size < ptr->size)
 	{
-		memset(&ptr->_internal_arr[size], 0,
-		       (ptr->_internal_size - size) * sizeof(int));
+		memset(&ptr->array[size], 0, (ptr->size - size) * sizeof(int));
 	}
-	if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
+	if (ptr->size < size && size <= ptr->capacity)
 	{
-		memset(&ptr->_internal_arr[ptr->_internal_size], 0,
-		       (size - ptr->_internal_size) * sizeof(int));
+		memset(&ptr->array[ptr->size], 0,
+		       (size - ptr->size) * sizeof(int));
 	}
-	ptr->_internal_size = size;
+	ptr->size = size;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
-		err_t* err)
+vec_int_resize(vec_int* ptr, const size_t size, const int val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -624,32 +581,32 @@ _vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
 		err->flags |= ERR_VEC_NULL;
 		return;
 	}
-	if (ptr->_internal_size == size)
+	if (ptr->size == size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
 
-	else if (size > ptr->_internal_max_size)
+	else if (size > ptr->max_size)
 	{
 		__origin_override(err, "RESIZE");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
 
-	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->_internal_size == 0)
+	else if ((status.flags & ERR_BUF_NULL) != 0 || ptr->size == 0)
 	{
-		size_t max = ptr->_internal_max_size;
+		size_t max = ptr->max_size;
 		err_t verr = ERR_T_INIT;
-		_vec_int_reserve(ptr, size, &verr);
+		vec_int_reserve(ptr, size, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		if (ptr->_internal_capacity != size)
+		if (ptr->capacity != size)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= ERR_ALLOC_FAIL;
@@ -657,55 +614,55 @@ _vec_int_resize(_VecIntInternal* ptr, const size_t size, const int val,
 		}
 		for (size_t i = 0; i < size; i++)
 		{
-			ptr->_internal_arr[i] = val;
+			ptr->array[i] = val;
 		}
-		ptr->_internal_max_size = max;
-		ptr->_internal_size = size;
+		ptr->max_size = max;
+		ptr->size = size;
 		return;
 	}
-	else if (size > ptr->_internal_capacity)
+	else if (size > ptr->capacity)
 	{
-		size_t tmpcp = ptr->_internal_capacity;
-		size_t tmpmx = ptr->_internal_max_size;
+		size_t tmpcp = ptr->capacity;
+		size_t tmpmx = ptr->max_size;
 		err_t verr = ERR_T_INIT;
 		while (size > tmpcp)
 		{
 			tmpcp *= 2;
 		}
-		if (tmpcp > ptr->_internal_max_size)
+		if (tmpcp > ptr->max_size)
 		{
 			tmpcp = size;
 		}
-		_vec_int_reserve(ptr, tmpcp, &verr);
+		vec_int_reserve(ptr, tmpcp, &verr);
 		if (verr.flags != 0)
 		{
 			__origin_override(err, "RESIZE");
 			err->flags |= verr.flags;
 			return;
 		}
-		ptr->_internal_max_size = tmpmx;
+		ptr->max_size = tmpmx;
 	}
-	if (size < ptr->_internal_size)
+	if (size < ptr->size)
 	{
-		for (size_t i = size; i < ptr->_internal_size; i++)
+		for (size_t i = size; i < ptr->size; i++)
 		{
-			ptr->_internal_arr[i] = 0;
+			ptr->array[i] = 0;
 		}
 	}
-	if (ptr->_internal_size < size && size <= ptr->_internal_capacity)
+	if (ptr->size < size && size <= ptr->capacity)
 	{
-		for (size_t i = ptr->_internal_size; i < size; i++)
+		for (size_t i = ptr->size; i < size; i++)
 		{
-			ptr->_internal_arr[i] = val;
+			ptr->array[i] = val;
 		}
 	}
-	ptr->_internal_size = size;
+	ptr->size = size;
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
-		const size_t iter_start, const size_t iter_end, err_t* err)
+vec_int_assign(vec_int* ptr, const vec_int* iterator, const size_t iter_start,
+	       const size_t iter_end, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0 ||
@@ -715,27 +672,27 @@ _vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
 		err->flags |= status.flags;
 		return;
 	}
-	if (ptr->_internal_arr == iterator->_internal_arr)
+	if (ptr->array == iterator->array)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= ERR_DOUBLE_BUF;
 		return;
 	}
-	if (iterator->_internal_size < iter_end || iter_end <= iter_start)
+	if (iterator->size < iter_end || iter_end <= iter_start)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	_vec_int_erase(ptr, _vec_int_begin(ptr, &status),
-		       _vec_int_end(ptr, &status) + 1, &status);
+	vec_int_erase(ptr, vec_int_begin(ptr, &status),
+		      vec_int_end(ptr, &status) + 1, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= status.flags;
 		return;
 	}
-	_vec_int_reserve(ptr, (iter_end - iter_start), &status);
+	vec_int_reserve(ptr, (iter_end - iter_start), &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
@@ -744,13 +701,13 @@ _vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
 	}
 	for (size_t i = iter_start; i < iter_end; i++)
 	{
-		int* res = _vec_int_at(iterator, i, &status);
+		int* res = vec_int_at(iterator, i, &status);
 		if (res == nullptr)
 		{
 			err->flags |= ERR_OUT_OF_BOUNDS;
 			return;
 		}
-		_vec_int_push_back(ptr, *res, &status);
+		vec_int_push_back(ptr, *res, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "ASSIGN");
@@ -762,8 +719,7 @@ _vec_int_assign(_VecIntInternal* ptr, const _VecIntInternal* iterator,
 }
 
 __attribute__((overloadable)) void
-_vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
-		err_t* err)
+vec_int_assign(vec_int* ptr, const size_t amount, const int val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	if (__null_check(ptr, &status) != 0)
@@ -778,15 +734,15 @@ _vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
 		err->flags |= ERR_SIZE_ZERO;
 		return;
 	}
-	_vec_int_erase(ptr, _vec_int_begin(ptr, &status),
-		       _vec_int_end(ptr, &status) + 1, &status);
+	vec_int_erase(ptr, vec_int_begin(ptr, &status),
+		      vec_int_end(ptr, &status) + 1, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
 		err->flags |= status.flags;
 		return;
 	}
-	_vec_int_reserve(ptr, amount, &status);
+	vec_int_reserve(ptr, amount, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "ASSIGN");
@@ -795,7 +751,7 @@ _vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
 	}
 	for (size_t i = 0; i < amount; i++)
 	{
-		_vec_int_push_back(ptr, val, &status);
+		vec_int_push_back(ptr, val, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "ASSIGN");
@@ -807,8 +763,7 @@ _vec_int_assign(_VecIntInternal* ptr, const size_t amount, const int val,
 }
 
 __attribute__((overloadable)) void
-_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val,
-		err_t* err)
+vec_int_insert(vec_int* ptr, const size_t iter, const int val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -827,43 +782,43 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const int val,
 			err->flags |= ERR_BUF_NULL;
 			return;
 		}
-		ptr->_internal_arr = res;
-		ptr->_internal_capacity = 1;
-		ptr->_internal_arr[0] = val;
-		ptr->_internal_size = 1;
+		ptr->array = res;
+		ptr->capacity = 1;
+		ptr->array[0] = val;
+		ptr->size = 1;
 		return;
 	}
-	if (ptr->_internal_max_size < ptr->_internal_size + 1)
+	if (ptr->max_size < ptr->size + 1)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_SIZE_OVERFLOW;
 		return;
 	}
-	if (iter > ptr->_internal_size)
+	if (iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	_vec_int_push_back(ptr, 0, &status);
+	vec_int_push_back(ptr, 0, &status);
 	if (status.flags != 0)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= status.flags;
 		return;
 	}
-	for (size_t i = ptr->_internal_size - 1; i > iter; i--)
+	for (size_t i = ptr->size - 1; i > iter; i--)
 	{
-		ptr->_internal_arr[i] = ptr->_internal_arr[i - 1];
+		ptr->array[i] = ptr->array[i - 1];
 	}
-	ptr->_internal_arr[iter] = val;
+	ptr->array[iter] = val;
 
 	return;
 }
 
 __attribute__((overloadable)) void
-_vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
-		const int val, err_t* err)
+vec_int_insert(vec_int* ptr, const size_t iter, const size_t amount,
+	       const int val, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -873,7 +828,7 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter > ptr->_internal_size)
+	if (iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
@@ -887,7 +842,7 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
 	}
 	for (size_t i = iter; i < iter + amount; i++)
 	{
-		_vec_int_insert(ptr, i, val, &status);
+		vec_int_insert(ptr, i, val, &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "INSERT");
@@ -899,9 +854,8 @@ _vec_int_insert(_VecIntInternal* ptr, const size_t iter, const size_t amount,
 }
 
 __attribute__((overloadable)) void
-_vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
-		const size_t iter, const size_t iter_start,
-		const size_t iter_end, err_t* err)
+vec_int_insert(vec_int* ptr, const vec_int* iterator, const size_t iter,
+	       const size_t iter_start, const size_t iter_end, err_t* err)
 {
 	err_t status = ERR_T_INIT;
 	__null_check(ptr, &status);
@@ -912,14 +866,14 @@ _vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
 		err->flags |= status.flags;
 		return;
 	}
-	if (iter_end <= iter_start || iter_end > iterator->_internal_size ||
-	    iter > ptr->_internal_size)
+	if (iter_end <= iter_start || iter_end > iterator->size ||
+	    iter > ptr->size)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_OUT_OF_BOUNDS;
 		return;
 	}
-	if (ptr->_internal_arr == iterator->_internal_arr)
+	if (ptr->array == iterator->array)
 	{
 		__origin_override(err, "INSERT");
 		err->flags |= ERR_DOUBLE_BUF;
@@ -927,8 +881,8 @@ _vec_int_insert(_VecIntInternal* ptr, const _VecIntInternal* iterator,
 	}
 	for (size_t i = iter_start; i < iter_end; i++)
 	{
-		_vec_int_insert(ptr, iter + (i - iter_start),
-				iterator->_internal_arr[i], &status);
+		vec_int_insert(ptr, iter + (i - iter_start), iterator->array[i],
+			       &status);
 		if (status.flags != 0)
 		{
 			__origin_override(err, "INSERT");
diff --git a/src/main.c b/src/main.c
index 4a9b8e6..07b627a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -41,7 +41,8 @@ main()
 	unsigned int mask = 0;
 	mask = ERR_BUF_NULL ^ status.flags;
 
-	print_bits(mask);
-	print_bits(status.flags);
+	vec_print_bits(mask);
+	vec_print_bits(status.flags);
+	vec_print_errs(status);
 	return 0;
 }
diff --git a/src/utils.c b/src/utils.c
index 8c9d673..71d0c55 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -38,18 +38,13 @@ vec_print_errs(const err_t err)
 void
 print_bits(unsigned int num)
 {
-	// Determine the number of bits in an unsigned int (usually 32)
-	int total_bits = sizeof(num) * 8;
+	unsigned int total_bits = sizeof(num) * 8;
 
-	// Loop from the most significant bit (MSB) down to the least
-	// significant bit (LSB)
-	for (int i = total_bits - 1; i >= 0; i--)
+	for (unsigned int i = total_bits - 1; i >= 0; i--)
 	{
-		// Shift a 1 to the i-th position and check if that bit is set
-		int bit = (num >> i) & 1;
-		printf("%d", bit);
+		unsigned int bit = (num >> i) & 1;
+		printf("%d ", bit);
 
-		// Optional: Add a space every 4 or 8 bits for readability
 		if (i % 8 == 0)
 		{
 			printf(" ");
@@ -58,14 +53,40 @@ print_bits(unsigned int num)
 	printf("\n");
 }
 
-// void
-// _vec_update_origin(err_t* err, char* str)
-// {
-// 	err_t res;
-// 	if (err == nullptr)
-// 	{
-// 		res.err = 0;
-// 		res.value = 0;
-// 	}
-// 	if (!err->origin) err->origin = str;
-// }
+size_t
+__origin_override(err_t* status, char* str)
+{
+	if (status == nullptr)
+	{
+		return ERR_ERR_T_NULL;
+	}
+	if (status->origin != nullptr)
+	{
+		status->flags |= ERR_ORIGIN_UNALTERABLE;
+		return status->flags;
+	}
+	else if (str == nullptr)
+	{
+		status->flags |= ERR_STR_NULL;
+		return status->flags;
+	}
+	else
+	{
+		status->origin = str;
+		return status->flags;
+	}
+}
+
+__attribute__((overloadable)) size_t
+__null_check(const float* ptr, err_t* status)
+{
+	if (status == nullptr)
+	{
+		return ERR_ERR_T_NULL;
+	}
+	if (ptr == nullptr)
+	{
+		status->flags |= ERR_BUF_NULL;
+	}
+	return status->flags;
+}