From c66b0189226b1355f78b941aca822968a2aa6108 Mon Sep 17 00:00:00 2001
From: Dylan Turner <dylan.turner@tutanota.com>
Date: Thu, 3 Oct 2024 12:12:53 -0500
Subject: [PATCH] Simplify error handling

No need for message strings bc only 2 simple errors can occure

Signed-off-by: Dylan Turner <dylan.turner@tutanota.com>
---
 examples/hworld/src/main.c |  35 ++---------
 examples/test/src/main.c   | 121 ++++++++++---------------------------
 examples/wtest/src/main.c  | 120 ++++++++++--------------------------
 include/pklstr.h           |  54 ++++++++---------
 src/str.c                  | 107 ++++++++++++--------------------
 src/wstr.c                 | 108 ++++++++++++---------------------
 6 files changed, 174 insertions(+), 371 deletions(-)

diff --git a/examples/hworld/src/main.c b/examples/hworld/src/main.c
index f1ebfac..1b01a54 100644
--- a/examples/hworld/src/main.c
+++ b/examples/hworld/src/main.c
@@ -9,21 +9,8 @@ int main(int argc, char **argv) {
 
     string_result_t new_string_res = string_from("Hello, world!", CHAR_DEF_ALLOC);
     if (new_string_res.is_err) {
-        switch (new_string_res.err.code) {
-            case PKLSTR_ERR_ALLOC_FAILED:
-                fprintf(stderr, "Error allocating space for string_t\n");
-                return 1;
-            default:
-                fprintf(
-                    stderr, "An unhandled error occurred: %lu",
-                    (size_t) new_string_res.err.code
-                );
-                if (new_string_res.err.msg) {
-                    fprintf(stderr, " - %s", new_string_res.err.msg);
-                }
-                fprintf(stderr, "\n");
-                return 1;
-        }
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) new_string_res.err);
+        return 1;
     }
     string_t new_string = new_string_res.ok;
     printf("English: %s\n", new_string.str);
@@ -31,22 +18,8 @@ int main(int argc, char **argv) {
 
     wstring_result_t new_wstring_res = wstring_from(L"こんにちは世界！", WCHAR_DEF_ALLOC);
     if (new_wstring_res.is_err) {
-        printf("Error!\n");
-        switch (new_wstring_res.err.code) {
-            case PKLSTR_ERR_ALLOC_FAILED:
-                fprintf(stderr, "Error allocating space for wstring_t\n");
-                return 1;
-            default:
-                fprintf(
-                    stderr, "An unhandled error occurred: %lu",
-                    (size_t) new_wstring_res.err.code
-                );
-                if (new_wstring_res.err.msg) {
-                    fprintf(stderr, " - %s", new_wstring_res.err.msg);
-                }
-                fprintf(stderr, "\n");
-                return 1;
-        }
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) new_string_res.err);
+        return 1;
     }
     wstring_t new_wstring = new_wstring_res.ok;
     printf("Japanese: %ls\n", new_wstring.str);
diff --git a/examples/test/src/main.c b/examples/test/src/main.c
index 28bbfef..e4690d2 100644
--- a/examples/test/src/main.c
+++ b/examples/test/src/main.c
@@ -7,11 +7,7 @@ int main(int argc, char **argv) {
     printf("Testing allocation...\n");
     string_result_t string_res = string_from("Hello, world", CHAR_DEF_ALLOC);
     if (string_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string_res.err.code);
-        if (string_res.err.msg) {
-            fprintf(stderr, " - %s", string_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string_res.err);
         return 1;
     }
     string_t string = string_res.ok;
@@ -21,13 +17,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Testing char append...\n");
-    result_t char_append_res = string_append_char(&string, '!');
-    if (char_append_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) char_append_res.err.code);
-        if (string_res.err.msg) {
-            fprintf(stderr, " - %s", char_append_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t char_append_res = string_append_char(&string, '!');
+    if (char_append_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) char_append_res.some);
         return 1;
     }
     printf(
@@ -36,13 +28,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Testing str append (no resize)...\n");
-    result_t str_append_res1 = string_append_str(&string, " More!");
-    if (str_append_res1.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) str_append_res1.err.code);
-        if (str_append_res1.err.msg) {
-            fprintf(stderr, " - %s", str_append_res1.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t str_append_res1 = string_append_str(&string, " More!");
+    if (str_append_res1.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) str_append_res1.some);
         return 1;
     }
     printf(
@@ -51,13 +39,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Testing str append (double)...\n");
-    result_t str_append_res2 = string_append_str(&string, " More!");
-    if (str_append_res2.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) str_append_res2.err.code);
-        if (str_append_res2.err.msg) {
-            fprintf(stderr, " - %s", str_append_res2.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t str_append_res2 = string_append_str(&string, " More!");
+    if (str_append_res2.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) str_append_res2.some);
         return 1;
     }
     printf(
@@ -66,13 +50,10 @@ int main(int argc, char **argv) {
     );
 
     printf("Testing str append (more than double)...\n");
-    result_t str_append_res3 = string_append_str(&string, " Way Way Way Way Way Way More!");
-    if (str_append_res3.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) str_append_res3.err.code);
-        if (str_append_res3.err.msg) {
-            fprintf(stderr, " - %s", str_append_res3.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t str_append_res3 =
+        string_append_str(&string, " Way Way Way Way Way Way More!");
+    if (str_append_res3.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) str_append_res3.some);
         return 1;
     }
     printf(
@@ -83,21 +64,13 @@ int main(int argc, char **argv) {
     printf("Testing string append...\n");
     string_result_t string_res2 = string_from(" Even More", CHAR_DEF_ALLOC);
     if (string_res2.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string_res2.err.code);
-        if (string_res2.err.msg) {
-            fprintf(stderr, " - %s", string_res2.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string_res2.err);
         return 1;
     }
     string_t string2 = string_res2.ok;
-    result_t string_append_res = string_append_string(&string, &string2);
-    if (string_append_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string_append_res.err.code);
-        if (string_append_res.err.msg) {
-            fprintf(stderr, " - %s", string_append_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t string_append_res = string_append_string(&string, &string2);
+    if (string_append_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string_append_res.some);
         return 1;
     }
     string_free(&string2);
@@ -110,11 +83,7 @@ int main(int argc, char **argv) {
     printf("Resetting to a new string...\n");
     string_result_t string2_res = string_from("Hello world!", CHAR_DEF_ALLOC);
     if (string2_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string2_res.err.code);
-        if (string2_res.err.msg) {
-            fprintf(stderr, " - %s", string2_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string2_res.err);
         return 1;
     }
     string_t string3 = string2_res.ok;
@@ -124,13 +93,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Inserting a char...\n");
-    result_t char_ins_res = string_insert_char_at(&string3, ',', 5);
-    if (char_ins_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) char_ins_res.err.code);
-        if (char_ins_res.err.msg) {
-            fprintf(stderr, " - %s", char_ins_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t char_ins_res = string_insert_char_at(&string3, ',', 5);
+    if (char_ins_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) char_ins_res.some);
         return 1;
     }
     printf(
@@ -139,13 +104,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Inserting a str...\n");
-    result_t str_ins_res = string_insert_str_at(&string3, " beautiful", 6);
-    if (str_ins_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) str_ins_res.err.code);
-        if (str_ins_res.err.msg) {
-            fprintf(stderr, " - %s", str_ins_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t str_ins_res = string_insert_str_at(&string3, " beautiful", 6);
+    if (str_ins_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) str_ins_res.some);
         return 1;
     }
     printf(
@@ -156,21 +117,13 @@ int main(int argc, char **argv) {
     printf("Inserting a string...\n");
     string_result_t string4_res = string_from("It's a great day! ", CHAR_DEF_ALLOC);
     if (string4_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string4_res.err.code);
-        if (string4_res.err.msg) {
-            fprintf(stderr, " - %s", string4_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string4_res.err);
         return 1;
     }
     string_t string4 = string4_res.ok;
-    result_t string_ins_res = string_insert_string_at(&string3, &string4, 0);
-    if (string_ins_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string_ins_res.err.code);
-        if (string_ins_res.err.msg) {
-            fprintf(stderr, " - %s", string_ins_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t string_ins_res = string_insert_string_at(&string3, &string4, 0);
+    if (string_ins_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string_ins_res.some);
         return 1;
     }
     string_free(&string4);
@@ -180,13 +133,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Removing a piece...\n");
-    result_t rm_res = string_remove_at(&string3, 24, 10);
-    if (rm_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) rm_res.err.code);
-        if (rm_res.err.msg) {
-            fprintf(stderr, " - %s", rm_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t rm_res = string_remove_at(&string3, 24, 10);
+    if (rm_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) rm_res.some);
         return 1;
     }
     printf(
@@ -197,11 +146,7 @@ int main(int argc, char **argv) {
     printf("Grab a substring...\n");
     string_result_t sub_res = string_substring(&string3, 18, 5);
     if (sub_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) sub_res.err.code);
-        if (sub_res.err.msg) {
-            fprintf(stderr, " - %s", sub_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) sub_res.err);
         return 1;
     }
     string_free(&string3);
diff --git a/examples/wtest/src/main.c b/examples/wtest/src/main.c
index 3074821..004b2c4 100644
--- a/examples/wtest/src/main.c
+++ b/examples/wtest/src/main.c
@@ -10,11 +10,7 @@ int main(int argc, char **argv) {
     printf("Testing allocation...\n");
     wstring_result_t string_res = wstring_from(L"こんにちは世界", WCHAR_DEF_ALLOC);
     if (string_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string_res.err.code);
-        if (string_res.err.msg) {
-            fprintf(stderr, " - %s", string_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string_res.err);
         return 1;
     }
     wstring_t string = string_res.ok;
@@ -24,13 +20,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Testing char append...\n");
-    result_t char_append_res = wstring_append_char(&string, L'！');
-    if (char_append_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) char_append_res.err.code);
-        if (string_res.err.msg) {
-            fprintf(stderr, " - %s", char_append_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t char_append_res = wstring_append_char(&string, L'！');
+    if (char_append_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) char_append_res.some);
         return 1;
     }
     printf(
@@ -39,13 +31,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Testing str append (no resize)...\n");
-    result_t str_append_res1 = wstring_append_str(&string, L" More!");
-    if (str_append_res1.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) str_append_res1.err.code);
-        if (str_append_res1.err.msg) {
-            fprintf(stderr, " - %s", str_append_res1.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t str_append_res1 = wstring_append_str(&string, L" More!");
+    if (str_append_res1.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) str_append_res1.some);
         return 1;
     }
     printf(
@@ -54,13 +42,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Testing str append (double)...\n");
-    result_t str_append_res2 = wstring_append_str(&string, L" More!");
-    if (str_append_res2.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) str_append_res2.err.code);
-        if (str_append_res2.err.msg) {
-            fprintf(stderr, " - %s", str_append_res2.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t str_append_res2 = wstring_append_str(&string, L" More!");
+    if (str_append_res2.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) str_append_res2.some);
         return 1;
     }
     printf(
@@ -69,13 +53,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Testing str append (more than double)...\n");
-    result_t str_append_res3 = wstring_append_str(&string, L" Way Way Way Way Way Way More!");
-    if (str_append_res3.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) str_append_res3.err.code);
-        if (str_append_res3.err.msg) {
-            fprintf(stderr, " - %s", str_append_res3.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t str_append_res3 = wstring_append_str(&string, L" Way Way Way Way Way Way More!");
+    if (str_append_res3.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) str_append_res3.some);
         return 1;
     }
     printf(
@@ -86,21 +66,13 @@ int main(int argc, char **argv) {
     printf("Testing string append...\n");
     wstring_result_t string_res2 = wstring_from(L" Even More", WCHAR_DEF_ALLOC);
     if (string_res2.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string_res2.err.code);
-        if (string_res2.err.msg) {
-            fprintf(stderr, " - %s", string_res2.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string_res2.err);
         return 1;
     }
     wstring_t string2 = string_res2.ok;
-    result_t string_append_res = wstring_append_string(&string, &string2);
-    if (string_append_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string_append_res.err.code);
-        if (string_append_res.err.msg) {
-            fprintf(stderr, " - %s", string_append_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t string_append_res = wstring_append_string(&string, &string2);
+    if (string_append_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string_append_res.some);
         return 1;
     }
     wstring_free(&string2);
@@ -113,11 +85,7 @@ int main(int argc, char **argv) {
     printf("Resetting to a new string...\n");
     wstring_result_t string2_res = wstring_from(L"こんにちは世界！", WCHAR_DEF_ALLOC);
     if (string2_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string2_res.err.code);
-        if (string2_res.err.msg) {
-            fprintf(stderr, " - %s", string2_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string2_res.err);
         return 1;
     }
     wstring_t string3 = string2_res.ok;
@@ -127,13 +95,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Inserting a char...\n");
-    result_t char_ins_res = wstring_insert_char_at(&string3, L' ', 5);
-    if (char_ins_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) char_ins_res.err.code);
-        if (char_ins_res.err.msg) {
-            fprintf(stderr, " - %s", char_ins_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t char_ins_res = wstring_insert_char_at(&string3, L' ', 5);
+    if (char_ins_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) char_ins_res.some);
         return 1;
     }
     printf(
@@ -142,13 +106,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Inserting a str...\n");
-    result_t str_ins_res = wstring_insert_str_at(&string3, L" beautiful", 6);
-    if (str_ins_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) str_ins_res.err.code);
-        if (str_ins_res.err.msg) {
-            fprintf(stderr, " - %s", str_ins_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t str_ins_res = wstring_insert_str_at(&string3, L" beautiful", 6);
+    if (str_ins_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) str_ins_res.some);
         return 1;
     }
     printf(
@@ -159,21 +119,13 @@ int main(int argc, char **argv) {
     printf("Inserting a string...\n");
     wstring_result_t string4_res = wstring_from(L"It's a great day! ", WCHAR_DEF_ALLOC);
     if (string4_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string4_res.err.code);
-        if (string4_res.err.msg) {
-            fprintf(stderr, " - %s", string4_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string4_res.err);
         return 1;
     }
     wstring_t string4 = string4_res.ok;
-    result_t string_ins_res = wstring_insert_string_at(&string3, &string4, 0);
-    if (string_ins_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) string_ins_res.err.code);
-        if (string_ins_res.err.msg) {
-            fprintf(stderr, " - %s", string_ins_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t string_ins_res = wstring_insert_string_at(&string3, &string4, 0);
+    if (string_ins_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) string_ins_res.some);
         return 1;
     }
     wstring_free(&string4);
@@ -183,13 +135,9 @@ int main(int argc, char **argv) {
     );
 
     printf("Removing a piece...\n");
-    result_t rm_res = wstring_remove_at(&string3, 23, 11);
-    if (rm_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) rm_res.err.code);
-        if (rm_res.err.msg) {
-            fprintf(stderr, " - %s", rm_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+    pklstr_err_option_t rm_res = wstring_remove_at(&string3, 23, 11);
+    if (rm_res.is_some) {
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) rm_res.some);
         return 1;
     }
     printf(
@@ -200,11 +148,7 @@ int main(int argc, char **argv) {
     printf("Grab a substring...\n");
     wstring_result_t sub_res = wstring_substring(&string3, 18, 7);
     if (sub_res.is_err) {
-        fprintf(stderr, "Error occurred: %lu", (size_t) sub_res.err.code);
-        if (sub_res.err.msg) {
-            fprintf(stderr, " - %s", sub_res.err.msg);
-        }
-        fprintf(stderr, "\n");
+        fprintf(stderr, "Error occurred: %lu\n", (size_t) sub_res.err);
         return 1;
     }
     wstring_free(&string3);
diff --git a/include/pklstr.h b/include/pklstr.h
index f0be8da..4a22ff0 100644
--- a/include/pklstr.h
+++ b/include/pklstr.h
@@ -25,7 +25,7 @@
 // -------- Types --------
 
 // Allocator used by the string library. A default is provided (based on malloc)
-// This should return NULL on error. Size_t is the number of characters in the string no '\0'
+// This should return NULL on error. Size_t is the number of characters in the string, include '\0'
 typedef char *(*char_malloc_t)(const size_t);
 
 // Same as char_malloc_t above, but for reallocating memory to grow it (default based on realloc)
@@ -63,12 +63,6 @@ typedef struct {
 typedef enum {
     PKLSTR_ERR_ALLOC_FAILED,        // Malloc/Realloc failed
     PKLSTR_ERR_OUT_OF_BOUNDS        // Index provided to a function was outside the string's len
-} pklstr_err_code_t;
-
-// Errors
-typedef struct {
-    pklstr_err_code_t code;
-    char *msg;
 } pklstr_err_t;
 
 // "Result<String, PklstrErr>" - Either a valid string_t (ok) or an error (err)
@@ -87,14 +81,14 @@ typedef struct {
     };
 } wstring_result_t;
 
-// "Result<(), PklstrErr>" - Either an error, or nothing (success)
+// "Option<PklstrErr>" - Either an error, or nothing (success)
 typedef struct {
-    bool is_err;
+    bool is_some;
     union {
-        struct {} ok;
-        pklstr_err_t err;
+        pklstr_err_t some;
+        struct {} none;
     };
-} result_t;
+} pklstr_err_option_t;
 
 // "Option<size_t>" - Either an index or nothing
 typedef struct {
@@ -150,21 +144,27 @@ void wstring_free(wstring_t *ref_string);
 
 // Insertion/Removal
 
-result_t string_append_char(string_t *ref_string, const char c);
-result_t string_append_str(string_t *ref_string, const char *str);
-result_t string_append_string(string_t *ref_string, const string_t *other);
-result_t string_insert_char_at(string_t *ref_string, const char c, const size_t index);
-result_t string_insert_str_at(string_t *ref_string, const char *str, const size_t index);
-result_t string_insert_string_at(string_t *ref_string, const string_t *other, const size_t index);
-result_t string_remove_at(string_t *ref_string, const size_t index, const size_t len);
-
-result_t wstring_append_char(wstring_t *ref_string, const wchar_t c);
-result_t wstring_append_str(wstring_t *ref_string, const wchar_t *str);
-result_t wstring_append_string(wstring_t *ref_string, const wstring_t *other);
-result_t wstring_insert_char_at(wstring_t *ref_string, const wchar_t c, const size_t index);
-result_t wstring_insert_str_at(wstring_t *ref_string, const wchar_t *str, const size_t index);
-result_t wstring_insert_string_at(wstring_t *ref_string, const wstring_t *other, const size_t index);
-result_t wstring_remove_at(wstring_t *ref_string, const size_t index, const size_t len);
+pklstr_err_option_t string_append_char(string_t *ref_string, const char c);
+pklstr_err_option_t string_append_str(string_t *ref_string, const char *str);
+pklstr_err_option_t string_append_string(string_t *ref_string, const string_t *other);
+pklstr_err_option_t string_insert_char_at(string_t *ref_string, const char c, const size_t index);
+pklstr_err_option_t string_insert_str_at(string_t *ref_string, const char *str, const size_t index);
+pklstr_err_option_t string_insert_string_at(string_t *ref_string, const string_t *other, const size_t index);
+pklstr_err_option_t string_remove_at(string_t *ref_string, const size_t index, const size_t len);
+
+pklstr_err_option_t wstring_append_char(wstring_t *ref_string, const wchar_t c);
+pklstr_err_option_t wstring_append_str(wstring_t *ref_string, const wchar_t *str);
+pklstr_err_option_t wstring_append_string(wstring_t *ref_string, const wstring_t *other);
+pklstr_err_option_t wstring_insert_char_at(
+    wstring_t *ref_string, const wchar_t c, const size_t index
+);
+pklstr_err_option_t wstring_insert_str_at(
+    wstring_t *ref_string, const wchar_t *str, const size_t index
+);
+pklstr_err_option_t wstring_insert_string_at(
+    wstring_t *ref_string, const wstring_t *other, const size_t index
+);
+pklstr_err_option_t wstring_remove_at(wstring_t *ref_string, const size_t index, const size_t len);
 
 // Other
 
diff --git a/src/str.c b/src/str.c
index 78c9691..4f350bd 100644
--- a/src/str.c
+++ b/src/str.c
@@ -11,10 +11,7 @@ string_result_t string_new(char_malloc_t malloc, char_realloc_t realloc, char_fr
     if (!empty) {
         return (string_result_t) {
             .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_ALLOC_FAILED,
-                .msg = NULL
-            }
+            .err = PKLSTR_ERR_ALLOC_FAILED
         };
     }
     return (string_result_t) {
@@ -38,10 +35,7 @@ string_result_t string_from(
     if (!str_mem) {
         return (string_result_t) {
             .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_ALLOC_FAILED,
-                .msg = NULL
-            }
+            .err = PKLSTR_ERR_ALLOC_FAILED
         };
     }
     memcpy(str_mem, str, len);
@@ -67,18 +61,15 @@ void string_free(string_t *ref_string) {
 
 // Insertion/Removal
 
-result_t string_append_char(string_t *ref_string, const char c) {
+pklstr_err_option_t string_append_char(string_t *ref_string, const char c) {
     if (ref_string->len + 2 > ref_string->cap) {
         // Resize (double)
         size_t new_cap = ref_string->len * 2 + 1;
         ref_string->str = ref_string->realloc(ref_string->str, new_cap);
         if (!ref_string->str) {
-            return (result_t) {
-                .is_err = true,
-                .err = (pklstr_err_t) {
-                    .code = PKLSTR_ERR_ALLOC_FAILED,
-                    .msg = NULL
-                }
+            return (pklstr_err_option_t) {
+                .is_some = true,
+                .some = PKLSTR_ERR_ALLOC_FAILED
             };
         }
         ref_string->cap = new_cap;
@@ -86,10 +77,10 @@ result_t string_append_char(string_t *ref_string, const char c) {
     ref_string->str[ref_string->len] = c;
     ref_string->len += 1;
     ref_string->str[ref_string->len] = '\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
-result_t string_append_str(string_t *ref_string, const char *str) {
+pklstr_err_option_t string_append_str(string_t *ref_string, const char *str) {
     size_t str_to_add_len = strlen(str);
     size_t raw_cap = ref_string->len + str_to_add_len + 1;
     size_t double_cap = ref_string->len * 2 + 1;
@@ -98,12 +89,9 @@ result_t string_append_str(string_t *ref_string, const char *str) {
             // Do one big allocation instead of multiple doubles
             ref_string->str = ref_string->realloc(ref_string->str, raw_cap);
             if (!ref_string->str) {
-                return (result_t) {
-                    .is_err = true,
-                    .err = (pklstr_err_t) {
-                        .code = PKLSTR_ERR_ALLOC_FAILED,
-                        .msg = NULL
-                    }
+                return (pklstr_err_option_t) {
+                    .is_some = true,
+                    .some = PKLSTR_ERR_ALLOC_FAILED
                 };
             }
             ref_string->cap = raw_cap;
@@ -111,12 +99,9 @@ result_t string_append_str(string_t *ref_string, const char *str) {
             // Double
             ref_string->str = ref_string->realloc(ref_string->str, double_cap);
             if (!ref_string->str) {
-                return (result_t) {
-                    .is_err = true,
-                    .err = (pklstr_err_t) {
-                        .code = PKLSTR_ERR_ALLOC_FAILED,
-                        .msg = NULL
-                    }
+                return (pklstr_err_option_t) {
+                    .is_some = true,
+                    .some = PKLSTR_ERR_ALLOC_FAILED
                 };
             }
             ref_string->cap = double_cap;
@@ -125,26 +110,23 @@ result_t string_append_str(string_t *ref_string, const char *str) {
     memcpy(ref_string->str + ref_string->len, str, str_to_add_len);
     ref_string->len += str_to_add_len;
     ref_string->str[ref_string->len] = '\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
-result_t string_append_string(string_t *ref_string, const string_t *other) {
+pklstr_err_option_t string_append_string(string_t *ref_string, const string_t *other) {
     // Could be more efficient bc could use ->len instead of call to strlen, but not huge deal
     return string_append_str(ref_string, other->str);
 }
 
-result_t string_insert_char_at(string_t *ref_string, const char c, const size_t index) {
+pklstr_err_option_t string_insert_char_at(string_t *ref_string, const char c, const size_t index) {
     if (index >= ref_string->len) {
-        return (result_t) {
-            .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_OUT_OF_BOUNDS,
-                .msg = NULL
-            }
+        return (pklstr_err_option_t) {
+            .is_some = true,
+            .some = PKLSTR_ERR_OUT_OF_BOUNDS
         };
     }
-    result_t append = string_append_char(ref_string, c); // Make room for the new character
-    if (append.is_err) {
+    pklstr_err_option_t append = string_append_char(ref_string, c); // Make room for the new character
+    if (append.is_some) {
         return append;
     }
     // Shift the string
@@ -153,22 +135,20 @@ result_t string_insert_char_at(string_t *ref_string, const char c, const size_t
     }
     ref_string->str[index] = c;
     ref_string->str[ref_string->len] = '\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
-result_t string_insert_str_at(string_t *ref_string, const char *str, const size_t index) {
+pklstr_err_option_t string_insert_str_at(
+        string_t *ref_string, const char *str, const size_t index) {
     if (index >= ref_string->len) {
-        return (result_t) {
-            .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_OUT_OF_BOUNDS,
-                .msg = NULL
-            }
+        return (pklstr_err_option_t) {
+            .is_some = true,
+            .some = PKLSTR_ERR_OUT_OF_BOUNDS
         };
     }
     size_t len = strlen(str);
-    result_t append = string_append_str(ref_string, str);
-    if (append.is_err) {
+    pklstr_err_option_t append = string_append_str(ref_string, str);
+    if (append.is_some) {
         return append;
     }
     for (size_t i = ref_string->len - 1; i > index + len - 1; i--) {
@@ -178,29 +158,24 @@ result_t string_insert_str_at(string_t *ref_string, const char *str, const size_
         ref_string->str[i + index] = str[i];
     }
     ref_string->str[ref_string->len] = '\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
-result_t string_insert_string_at(string_t *ref_string, const string_t *other, const size_t index) {
+pklstr_err_option_t string_insert_string_at(
+        string_t *ref_string, const string_t *other, const size_t index) {
     return string_insert_str_at(ref_string, other->str, index);
 }
 
-result_t string_remove_at(string_t *ref_string, const size_t index, const size_t len) {
+pklstr_err_option_t string_remove_at(string_t *ref_string, const size_t index, const size_t len) {
     if (index + len >= ref_string->len) {
-        return (result_t) {
-            .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_OUT_OF_BOUNDS,
-                .msg = NULL
-            }
-        };
+        return (pklstr_err_option_t) { .is_some = true, .some = PKLSTR_ERR_OUT_OF_BOUNDS };
     }
     for (int i = 0; i < len; i++) {
         ref_string->str[i + index] = ref_string->str[i + index + len];
     }
     ref_string->len -= len;
     ref_string->str[ref_string->len] = '\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
 // Other
@@ -209,20 +184,14 @@ string_result_t string_substring(string_t *ref_string, const size_t start, const
     if (start + len >= ref_string->len) {
         return (string_result_t) {
             .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_OUT_OF_BOUNDS,
-                .msg = NULL
-            }
+            .err = PKLSTR_ERR_OUT_OF_BOUNDS
         };
     }
     char *str_mem = ref_string->malloc(len + 1);
     if (!str_mem) {
         return (string_result_t) {
             .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_ALLOC_FAILED,
-                .msg = NULL
-            }
+            .err = PKLSTR_ERR_ALLOC_FAILED
         };
     }
     memcpy(str_mem, ref_string->str + start, len);
diff --git a/src/wstr.c b/src/wstr.c
index 403293d..b4fb5e3 100644
--- a/src/wstr.c
+++ b/src/wstr.c
@@ -26,10 +26,7 @@ wstring_result_t wstring_new(wchar_malloc_t malloc, wchar_realloc_t realloc, wch
     if (!empty) {
         return (wstring_result_t) {
             .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_ALLOC_FAILED,
-                .msg = NULL
-            }
+            .err = PKLSTR_ERR_ALLOC_FAILED
         };
     }
     return (wstring_result_t) {
@@ -54,10 +51,7 @@ wstring_result_t wstring_from(
     if (!str_mem) {
         return (wstring_result_t) {
             .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_ALLOC_FAILED,
-                .msg = NULL
-            }
+            .err = PKLSTR_ERR_ALLOC_FAILED
         };
     }
     memcpy(str_mem, str, capacity);
@@ -83,18 +77,15 @@ void wstring_free(wstring_t *ref_string) {
 
 // Insertion/Removal
 
-result_t wstring_append_char(wstring_t *ref_string, const wchar_t c) {
+pklstr_err_option_t wstring_append_char(wstring_t *ref_string, const wchar_t c) {
     if ((ref_string->len + 2) * sizeof(wchar_t) > ref_string->cap) {
         // Resize (double)
         size_t new_cap = (ref_string->len * 2 + 1) * sizeof(wchar_t);
         ref_string->str = ref_string->realloc(ref_string->str, new_cap);
         if (!ref_string->str) {
-            return (result_t) {
-                .is_err = true,
-                .err = (pklstr_err_t) {
-                    .code = PKLSTR_ERR_ALLOC_FAILED,
-                    .msg = NULL
-                }
+            return (pklstr_err_option_t) {
+                .is_some = true,
+                .some = PKLSTR_ERR_ALLOC_FAILED
             };
         }
         ref_string->cap = new_cap;
@@ -102,10 +93,10 @@ result_t wstring_append_char(wstring_t *ref_string, const wchar_t c) {
     ref_string->str[ref_string->len] = c;
     ref_string->len += 1;
     ref_string->str[ref_string->len] = L'\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
-result_t wstring_append_str(wstring_t *ref_string, const wchar_t *str) {
+pklstr_err_option_t wstring_append_str(wstring_t *ref_string, const wchar_t *str) {
     size_t str_to_add_len = wstrlen(str);
     size_t raw_cap = (ref_string->len + str_to_add_len + 1) * sizeof(wchar_t);
     size_t double_cap = (ref_string->len * 2 + 1) * sizeof(wchar_t);
@@ -114,12 +105,9 @@ result_t wstring_append_str(wstring_t *ref_string, const wchar_t *str) {
             // Do one big allocation instead of multiple doubles
             ref_string->str = ref_string->realloc(ref_string->str, raw_cap);
             if (!ref_string->str) {
-                return (result_t) {
-                    .is_err = true,
-                    .err = (pklstr_err_t) {
-                        .code = PKLSTR_ERR_ALLOC_FAILED,
-                        .msg = NULL
-                    }
+                return (pklstr_err_option_t) {
+                    .is_some = true,
+                    .some = PKLSTR_ERR_ALLOC_FAILED
                 };
             }
             ref_string->cap = raw_cap;
@@ -127,12 +115,9 @@ result_t wstring_append_str(wstring_t *ref_string, const wchar_t *str) {
             // Double
             ref_string->str = ref_string->realloc(ref_string->str, double_cap);
             if (!ref_string->str) {
-                return (result_t) {
-                    .is_err = true,
-                    .err = (pklstr_err_t) {
-                        .code = PKLSTR_ERR_ALLOC_FAILED,
-                        .msg = NULL
-                    }
+                return (pklstr_err_option_t) {
+                    .is_some = true,
+                    .some = PKLSTR_ERR_ALLOC_FAILED
                 };
             }
             ref_string->cap = double_cap;
@@ -143,26 +128,23 @@ result_t wstring_append_str(wstring_t *ref_string, const wchar_t *str) {
     }
     ref_string->len += str_to_add_len;
     ref_string->str[ref_string->len] = L'\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
-result_t wstring_append_string(wstring_t *ref_string, const wstring_t *other) {
+pklstr_err_option_t wstring_append_string(wstring_t *ref_string, const wstring_t *other) {
     // Could be more efficient bc could use ->len instead of call to strlen, but not huge deal
     return wstring_append_str(ref_string, other->str);
 }
 
-result_t wstring_insert_char_at(wstring_t *ref_string, const wchar_t c, const size_t index) {
+pklstr_err_option_t wstring_insert_char_at(wstring_t *ref_string, const wchar_t c, const size_t index) {
     if (index >= ref_string->len) {
-        return (result_t) {
-            .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_OUT_OF_BOUNDS,
-                .msg = NULL
-            }
+        return (pklstr_err_option_t) {
+            .is_some = true,
+            .some = PKLSTR_ERR_OUT_OF_BOUNDS
         };
     }
-    result_t append = wstring_append_char(ref_string, c); // Make room for the new character
-    if (append.is_err) {
+    pklstr_err_option_t append = wstring_append_char(ref_string, c); // Make room for the new character
+    if (append.is_some) {
         return append;
     }
     // Shift the string
@@ -171,22 +153,19 @@ result_t wstring_insert_char_at(wstring_t *ref_string, const wchar_t c, const si
     }
     ref_string->str[index] = c;
     ref_string->str[ref_string->len] = '\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
-result_t wstring_insert_str_at(wstring_t *ref_string, const wchar_t *str, const size_t index) {
+pklstr_err_option_t wstring_insert_str_at(wstring_t *ref_string, const wchar_t *str, const size_t index) {
     if (index >= ref_string->len) {
-        return (result_t) {
-            .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_OUT_OF_BOUNDS,
-                .msg = NULL
-            }
+        return (pklstr_err_option_t) {
+            .is_some = true,
+            .some = PKLSTR_ERR_OUT_OF_BOUNDS
         };
     }
     size_t len = wstrlen(str);
-    result_t append = wstring_append_str(ref_string, str);
-    if (append.is_err) {
+    pklstr_err_option_t append = wstring_append_str(ref_string, str);
+    if (append.is_some) {
         return append;
     }
     for (size_t i = ref_string->len - 1; i > index + len - 1; i--) {
@@ -196,21 +175,20 @@ result_t wstring_insert_str_at(wstring_t *ref_string, const wchar_t *str, const
         ref_string->str[i + index] = str[i];
     }
     ref_string->str[ref_string->len] = '\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
-result_t wstring_insert_string_at(wstring_t *ref_string, const wstring_t *other, const size_t index) {
+pklstr_err_option_t wstring_insert_string_at(
+        wstring_t *ref_string, const wstring_t *other, const size_t index) {
     return wstring_insert_str_at(ref_string, other->str, index);
 }
 
-result_t wstring_remove_at(wstring_t *ref_string, const size_t index, const size_t len) {
+pklstr_err_option_t wstring_remove_at(
+        wstring_t *ref_string, const size_t index, const size_t len) {
     if (index + len >= ref_string->len) {
-        return (result_t) {
-            .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_OUT_OF_BOUNDS,
-                .msg = NULL
-            }
+        return (pklstr_err_option_t) {
+            .is_some = true,
+            .some = PKLSTR_ERR_OUT_OF_BOUNDS
         };
     }
     for (int i = 0; i < len; i++) {
@@ -218,7 +196,7 @@ result_t wstring_remove_at(wstring_t *ref_string, const size_t index, const size
     }
     ref_string->len -= len;
     ref_string->str[ref_string->len] = '\0';
-    return (result_t) { .is_err = false, .ok = {} };
+    return (pklstr_err_option_t) { .is_some = false, .none = {} };
 }
 
 // Other
@@ -227,20 +205,14 @@ wstring_result_t wstring_substring(wstring_t *ref_string, const size_t start, co
     if (start + len >= ref_string->len) {
         return (wstring_result_t) {
             .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_OUT_OF_BOUNDS,
-                .msg = NULL
-            }
+            .err = PKLSTR_ERR_OUT_OF_BOUNDS
         };
     }
     wchar_t *str_mem = ref_string->malloc(sizeof(wchar_t) * (len + 1));
     if (!str_mem) {
         return (wstring_result_t) {
             .is_err = true,
-            .err = (pklstr_err_t) {
-                .code = PKLSTR_ERR_ALLOC_FAILED,
-                .msg = NULL
-            }
+            .err =  PKLSTR_ERR_ALLOC_FAILED
         };
     }
     memcpy(str_mem, ref_string->str + start, len * sizeof(wchar_t));