From 3046d85284110f1101b5841d81080a38bf9cfaee Mon Sep 17 00:00:00 2001
From: Devin Bidwell <dbidwell94@biddydev.com>
Date: Mon, 8 Sep 2025 14:26:31 -0700
Subject: [PATCH 1/3] Add expect and inspect to Result type. Add inspect to
 Option type

---
 src/option/index.ts       |  10 ++
 src/option/option.test.ts | 329 +++++++++++++++++++++++---------------
 src/result/index.ts       |  26 +++
 src/result/result.test.ts | 283 ++++++++++++++++++++------------
 4 files changed, 416 insertions(+), 232 deletions(-)

diff --git a/src/option/index.ts b/src/option/index.ts
index c79b641..9df866d 100644
--- a/src/option/index.ts
+++ b/src/option/index.ts
@@ -77,6 +77,12 @@ export interface OptionUtils<T> {
    * @returns The value of the `Option<T>` if it is a `Some<T>`.
    */
   expect(message: string): T;
+  /**
+   * Peek into the inner value of this Option<T>, and if `isSome()` then the callback function will be run.
+   * @param callback the callback to run if this Option `isSome`
+   * @returns this `Option<T>`
+   */
+  inspect(callback: (value: T) => void): Option<T>;
   /**
    * Converts this `Option<T>` type into a `Result<T, E>` type. The `Result<T, E>` will be an `Err<E>` if the `Option<T>` is a `None`.
    * @param error The error to return if the `Option<T>` is a `None`.
@@ -146,6 +152,10 @@ function buildOption<T>(innerType: Some<T> | None): Option<T> {
       if (this.isSome()) return this.value;
       throw new OptionIsEmptyError(message);
     },
+    inspect(callback) {
+      if (this.isSome()) callback(this.value);
+      return this;
+    },
     okOr(error) {
       if (this.isNone()) {
         if (error instanceof Error) return result.err(error);
diff --git a/src/option/option.test.ts b/src/option/option.test.ts
index c4a11b6..f88014c 100644
--- a/src/option/option.test.ts
+++ b/src/option/option.test.ts
@@ -1,212 +1,279 @@
 import { OptionIsEmptyError, option } from ".";
 
 describe("src/utility/option.ts", () => {
-  it("Constructs an Option<T> type with a provided value", () => {
-    const optionValue = option.some(1);
+  describe("some", () => {
+    it("Constructs an Option<T> type with a provided value", () => {
+      const optionValue = option.some(1);
 
-    expect(optionValue.isSome()).toBeTruthy();
+      expect(optionValue.isSome()).toBeTruthy();
+    });
   });
 
-  it("Constructs an Option<T> with no provided value", () => {
-    const optionValue = option.none();
+  describe("none", () => {
+    it("Constructs an Option<T> with no provided value", () => {
+      const optionValue = option.none();
 
-    expect(optionValue.isNone()).toBeTruthy();
+      expect(optionValue.isNone()).toBeTruthy();
+    });
   });
 
-  it("Throws an error on unwrap() if the Option<T> is empty", () => {
-    const optionValue = option.none();
+  describe("unwrap", () => {
+    it("Throws an error on unwrap() if the Option<T> is empty", () => {
+      const optionValue = option.none();
 
-    expect(() => optionValue.unwrap()).toThrow(OptionIsEmptyError);
-  });
+      expect(() => optionValue.unwrap()).toThrow(OptionIsEmptyError);
+    });
 
-  it("Provdes a default value on unwrapOrDefault() if the Option<T> is empty", () => {
-    const optionValue = option.none();
+    it("Returns the inner value if called on a Some variant", () => {
+      const optValue = option.some(123);
 
-    expect(optionValue.unwrapOr(3)).toEqual(3);
+      expect(() => optValue.unwrap()).not.toThrow();
+
+      expect(optValue.unwrap()).toEqual(123);
+    });
   });
 
-  it("Throws an error if the argument for unwrapOr() is undefined or null", () => {
-    const optionValue = option.none();
+  describe("unwrapOr", () => {
+    it("Provdes a default value on unwrapOrDefault() if the Option<T> is empty", () => {
+      const optionValue = option.none();
 
-    expect(() => optionValue.unwrapOr(null as never)).toThrow(
-      OptionIsEmptyError,
-    );
-  });
+      expect(optionValue.unwrapOr(3)).toEqual(3);
+    });
 
-  it("Returns the contained value when unwrap() is called with a value value in the Option<T>", () => {
-    const optionValue = option.some(3);
+    it("Throws an error if the argument for unwrapOr() is undefined or null", () => {
+      const optionValue = option.none();
 
-    expect(optionValue.unwrap()).toEqual(3);
-  });
+      expect(() => optionValue.unwrapOr(null as never)).toThrow(
+        OptionIsEmptyError,
+      );
+    });
 
-  it("Returns the contained value when unwrapOrDefault() is called with a valid value in the Option<T>", () => {
-    const optionValue = option.some(3);
+    it("Returns the contained value when called with a valid value in the Option<T>", () => {
+      const optionValue = option.some(3);
 
-    expect(optionValue.unwrapOr(2)).toEqual(3);
+      expect(optionValue.unwrapOr(2)).toEqual(3);
+    });
   });
 
-  it("Allows direct access of the value if the Option<T> is a Some<T>", () => {
-    const optionValue = option.some(3);
+  describe("option.value", () => {
+    it("Allows direct access of the value if the Option<T> is a Some<T>", () => {
+      const optionValue = option.some(3);
 
-    expect(optionValue).toHaveProperty("value");
-  });
+      expect(optionValue).toHaveProperty("value");
+    });
 
-  it("Does not have the value property if the Option<T> is a None", () => {
-    const optionValue = option.none();
+    it("Does not have the value property if the Option<T> is a None", () => {
+      const optionValue = option.none();
 
-    expect(optionValue).not.toHaveProperty("value");
+      expect(optionValue).not.toHaveProperty("value");
+    });
   });
 
-  it("Transforms the Option<T> into a Result Failure<E> when calling okOr() on a None type", () => {
-    const optionValue = option.none();
+  describe("okOr", () => {
+    it("Transforms the Option<T> into a Result Failure<E> when calling okOr() on a None type", () => {
+      const optionValue = option.none();
 
-    expect(optionValue.okOr(new Error()).isError()).toBeTruthy();
-  });
+      expect(optionValue.okOr(new Error()).isError()).toBeTruthy();
+    });
 
-  it("Transforms the Option<T> into a Result Success<T> with calling okOr() on a Some<T> type", () => {
-    const optionValue = option.some(2);
+    it("Transforms the Option<T> into a Result Success<T> with calling okOr() on a Some<T> type", () => {
+      const optionValue = option.some(2);
 
-    expect(optionValue.okOr(new Error()).isOk()).toBeTruthy();
-  });
+      expect(optionValue.okOr(new Error()).isOk()).toBeTruthy();
+    });
 
-  it("Constructs a base Error class if okOr() is called with a string type", () => {
-    const optionValue = option.none();
+    it("Constructs a base Error class if okOr() is called with a string type", () => {
+      const optionValue = option.none();
 
-    expect(optionValue.okOr("This is an error").isError()).toBeTruthy();
+      expect(optionValue.okOr("This is an error").isError()).toBeTruthy();
+    });
   });
 
-  it("Throws an error using the provided message when calling expect() on a None type", () => {
-    const optionValue = option.none();
+  describe("expect", () => {
+    it("Throws an error using the provided message when calling expect() on a None type", () => {
+      const optionValue = option.none();
 
-    expect(() => optionValue.expect("This is an error")).toThrow(
-      "This is an error",
-    );
-  });
+      expect(() => optionValue.expect("This is an error")).toThrow(
+        "This is an error",
+      );
+    });
 
-  it("Doesn't throw an error when calling expect() on a Some<T> type", () => {
-    const optionValue = option.some(2);
+    it("Doesn't throw an error when calling expect() on a Some<T> type", () => {
+      const optionValue = option.some(2);
 
-    expect(() => optionValue.expect("This is an error")).not.toThrow();
+      expect(() => optionValue.expect("This is an error")).not.toThrow();
+    });
   });
 
-  it("Returns a None type if map() is called on an existing None type", () => {
-    const optionValue = option.none<number>();
+  describe("inspect", () => {
+    it("calls the callback if called on a Some variant", () => {
+      const spy = jest.fn();
+      option.some(123).inspect((val) => spy(val));
 
-    expect(optionValue.map((value) => value + 1).isNone()).toBeTruthy();
-  });
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spy).toHaveBeenCalledWith(123);
+    });
 
-  it("Returns a Some<T> if map() is called on a Some<T> type, having applied the mapped function to the inner type", () => {
-    const optionValue = option.some(1);
+    it("does not call the callback if called on a None variant", () => {
+      const spy = jest.fn();
+      option.none<number>().inspect((val) => spy(val));
 
-    expect(optionValue.map((value) => value + 1).unwrap()).toEqual(2);
-  });
+      expect(spy).not.toHaveBeenCalled();
+    });
 
-  it("Creates a serializable Option<T> when serialize() is called on an Option<T> type", () => {
-    const optionValue = option.some(1);
+    it("returns the same instance when called on a Some variant", () => {
+      const spy = jest.fn();
+      const opt = option.some(123);
+      const inspectOpt = opt.inspect((val) => spy(val));
 
-    expect(optionValue.serialize()).toEqual({
-      _marker: 0,
-      value: 1,
+      expect(spy).toHaveBeenCalledWith(123);
+      expect(opt).toEqual(inspectOpt);
     });
 
-    const noneOptionValue = option.none();
+    it("returns the same instance when called on a None variant", () => {
+      const spy = jest.fn();
+      const opt = option.none<number>();
+      const inspectOpt = opt.inspect((val) => spy(val));
 
-    expect(noneOptionValue.serialize()).toEqual({
-      _marker: 1,
+      expect(spy).not.toHaveBeenCalled();
+      expect(opt).toEqual(inspectOpt);
     });
   });
 
-  it("Converts a SerializableOption<T> back into an Option<T> when calling fromSerializableOption()", () => {
-    const serializable = option.some(1).serialize();
+  describe("map", () => {
+    it("Returns a None type if map() is called on an existing None type", () => {
+      const optionValue = option.none<number>();
 
-    expect(option.fromSerializableOption(serializable).isSome()).toBeTruthy();
+      expect(optionValue.map((value) => value + 1).isNone()).toBeTruthy();
+    });
 
-    const noneSerializable = option.none().serialize();
+    it("Returns a Some<T> if map() is called on a Some<T> type, having applied the mapped function to the inner type", () => {
+      const optionValue = option.some(1);
 
-    expect(
-      option.fromSerializableOption(noneSerializable).isNone(),
-    ).toBeTruthy();
+      expect(optionValue.map((value) => value + 1).unwrap()).toEqual(2);
+    });
   });
 
-  it("Returns a None type if `fromSerializableOption()` is called with no object or undefined", () => {
-    const result = option.fromSerializableOption(undefined);
+  describe("serialize", () => {
+    it("Creates a serializable Option<T> when serialize() is called on an Option<T> type", () => {
+      const optionValue = option.some(1);
+
+      expect(optionValue.serialize()).toEqual({
+        _marker: 0,
+        value: 1,
+      });
 
-    expect(result.isNone()).toBeTruthy();
+      const noneOptionValue = option.none();
+
+      expect(noneOptionValue.serialize()).toEqual({
+        _marker: 1,
+      });
+    });
   });
 
-  it.each([[1], [{}], ["testString"], [[]]])(
-    "Returns a None type if `fromSerializableOption()` is called with a non-Option<T> type",
-    (testValue) => {
-      const result = option.fromSerializableOption(testValue as never);
+  describe("fromSerializableOption", () => {
+    it("Converts a SerializableOption<T> back into an Option<T> when calling fromSerializableOption()", () => {
+      const serializable = option.some(1).serialize();
 
-      expect(result.isNone()).toBeTruthy();
-    },
-  );
+      expect(option.fromSerializableOption(serializable).isSome()).toBeTruthy();
 
-  it("Performs andThen on a Some<T> type, returning a new Option<NewT>", () => {
-    const optionValue = option.some(1);
+      const noneSerializable = option.none().serialize();
 
-    const newOption = optionValue.andThen((val) => option.some(val + 1));
+      expect(
+        option.fromSerializableOption(noneSerializable).isNone(),
+      ).toBeTruthy();
+    });
+
+    it("Returns a None type if `fromSerializableOption()` is called with no object or undefined", () => {
+      const result = option.fromSerializableOption(undefined);
 
-    expect(newOption.unwrap()).toEqual(2);
+      expect(result.isNone()).toBeTruthy();
+    });
+
+    it.each([[1], [{}], ["testString"], [[]]])(
+      "Returns a None type if `fromSerializableOption()` is called with a non-Option<T> type",
+      (testValue) => {
+        const result = option.fromSerializableOption(testValue as never);
+
+        expect(result.isNone()).toBeTruthy();
+      },
+    );
   });
 
-  it("Does not perform andThen on a None type, returning a None type", () => {
-    const optionValue = option.none<number>();
+  describe("andThen", () => {
+    it("Performs andThen on a Some<T> type, returning a new Option<NewT>", () => {
+      const optionValue = option.some(1);
 
-    const newOption = optionValue.andThen((val) => option.some(val + 1));
+      const newOption = optionValue.andThen((val) => option.some(val + 1));
 
-    expect(newOption.isNone()).toBeTruthy();
+      expect(newOption.unwrap()).toEqual(2);
+    });
+
+    it("Does not perform andThen on a None type, returning a None type", () => {
+      const optionValue = option.none<number>();
+
+      const newOption = optionValue.andThen((val) => option.some(val + 1));
+
+      expect(newOption.isNone()).toBeTruthy();
+    });
   });
 
-  it("Constructs an Option<T> type from an unknown value, returning a Some<T> if the value is not null or undefined, otherwise returning None", () => {
-    const testValue = "test";
-    const result = option.unknown(testValue);
-    expect(result.isSome()).toBeTruthy();
-    expect(result.unwrap()).toEqual(testValue);
-    const nullValue: unknown = null;
-    const nullResult = option.unknown(nullValue);
-    expect(nullResult.isNone()).toBeTruthy();
+  describe("option.unknown", () => {
+    it("Constructs an Option<T> type from an unknown value, returning a Some<T> if the value is not null or undefined, otherwise returning None", () => {
+      const testValue = "test";
+      const result = option.unknown(testValue);
+      expect(result.isSome()).toBeTruthy();
+      expect(result.unwrap()).toEqual(testValue);
+      const nullValue: unknown = null;
+      const nullResult = option.unknown(nullValue);
+      expect(nullResult.isNone()).toBeTruthy();
+    });
   });
 
-  it.each([
-    ["option.some", option.some(123), option.isSome as (val: any) => boolean],
-    [
-      "option.some.serialize",
-      option.some(123).serialize(),
-      option.isSome as (val: any) => boolean,
-    ],
-    ["option.none", option.none(), option.isNone as (val: any) => boolean],
-    [
-      "option.none.serialize",
-      option.none().serialize(),
-      option.isNone as (val: any) => boolean,
-    ],
-  ])("Properly checks the return type of %s", (_, optVal, validator) => {
-    expect(validator(optVal)).toBeTruthy();
+  describe("option.isSome", () => {
+    it.each([
+      ["option.some", option.some(123), option.isSome as (val: any) => boolean],
+      [
+        "option.some.serialize",
+        option.some(123).serialize(),
+        option.isSome as (val: any) => boolean,
+      ],
+      ["option.none", option.none(), option.isNone as (val: any) => boolean],
+      [
+        "option.none.serialize",
+        option.none().serialize(),
+        option.isNone as (val: any) => boolean,
+      ],
+    ])("Properly checks the return type of %s", (_, optVal, validator) => {
+      expect(validator(optVal)).toBeTruthy();
+    });
   });
 
-  it("Returns `undefined` if unsafeUnwrap() was called on a None type", () => {
-    const opt = option.unknown(undefined);
+  describe("unsafeUnwrap", () => {
+    it("Returns `undefined` if unsafeUnwrap() was called on a None type", () => {
+      const opt = option.unknown(undefined);
 
-    expect(opt.unsafeUnwrap()).toEqual(undefined);
-  });
+      expect(opt.unsafeUnwrap()).toEqual(undefined);
+    });
 
-  it("Returns the inner value of Some<T> if unsafeUnwrap was called on a Some type", () => {
-    const opt = option.some(123);
+    it("Returns the inner value of Some<T> if unsafeUnwrap was called on a Some type", () => {
+      const opt = option.some(123);
 
-    expect(opt.unsafeUnwrap()).toEqual(123);
+      expect(opt.unsafeUnwrap()).toEqual(123);
+    });
   });
 
-  it("returns the raw default value if unsafeUnwrapOr() was called on a None type", () => {
-    const opt = option.unknown(undefined);
+  describe("unsafeUnwrapOr", () => {
+    it("returns the raw default value if unsafeUnwrapOr() was called on a None type", () => {
+      const opt = option.unknown(undefined);
 
-    expect(opt.unsafeUnwrapOr(null)).toEqual(null);
-  });
+      expect(opt.unsafeUnwrapOr(null)).toEqual(null);
+    });
 
-  it("Returns the inner value of Some<T> if unsafeUnwrapOr() was called on a Some<T> type", () => {
-    const opt = option.some(123);
+    it("Returns the inner value of Some<T> if unsafeUnwrapOr() was called on a Some<T> type", () => {
+      const opt = option.some(123);
 
-    expect(opt.unsafeUnwrapOr(null)).toEqual(123);
+      expect(opt.unsafeUnwrapOr(null)).toEqual(123);
+    });
   });
 });
diff --git a/src/result/index.ts b/src/result/index.ts
index fc9b646..3714bf5 100644
--- a/src/result/index.ts
+++ b/src/result/index.ts
@@ -70,6 +70,20 @@ export interface ResultUtils<T, E extends Error = Error> {
    * @returns The inner type if it was a `Success<T>`
    */
   unwrapOrElse(error: E): T;
+  /**
+   * Unwraps the inner value of this `Result<T>`. If this Result was an error variant, then an
+   * error will be thrown with the message specified.
+   * @param message The message to set on an `Error` if this Result is not a Success variant.
+   * @returns The inner value of this Result if this Result is a Success variant.
+   * @throws {Error} - If this result was a Failure variant.
+   */
+  expect(message: string): T;
+  /**
+   * Peek into the inner value of this Result<T>, and if `isOk()` then the callback function will be run.
+   * @param callback the callback to run if this Result `isOk`
+   * @returns this `Result<T>`
+   */
+  inspect(callback: (value: T) => void): Result<T>;
   /**
    * Useful if you do not care if there is an error, you only want to know if there is a value.
    * @returns An `Option<T>` if the inner type was a `Success<T>`, otherwise `None`
@@ -152,6 +166,18 @@ function buildResult<T, E extends Error>(
       }
       return option.none();
     },
+    expect(message) {
+      if (this.isError()) {
+        throw new Error(message);
+      }
+      return this.value;
+    },
+    inspect(callback) {
+      if (this.isOk()) {
+        callback(this.value);
+      }
+      return this;
+    },
     mapOk<NewT>(fn: (value: T) => NewT): Result<NewT, E> {
       if (this.isOk()) {
         return ok(fn(this.value));
diff --git a/src/result/result.test.ts b/src/result/result.test.ts
index c03b621..217c8f8 100644
--- a/src/result/result.test.ts
+++ b/src/result/result.test.ts
@@ -6,173 +6,254 @@ class NewErrorClass extends Error {
   }
 }
 describe("src/utility/result.ts", () => {
-  it("Calling unwrap() on a Success<T> provides the Success<T> value", () => {
-    const resultValue = result.ok(1);
+  describe("unwrap", () => {
+    it("Calling unwrap() on a Success<T> provides the Success<T> value", () => {
+      const resultValue = result.ok(1);
 
-    expect(resultValue.unwrap()).toEqual(1);
-  });
+      expect(resultValue.unwrap()).toEqual(1);
+    });
 
-  it("Calling unwrap() on a Failure<E> provides the Failure<E> error", () => {
-    const resultValue = result.err(new NewErrorClass());
+    it("Calling unwrap() on a Failure<E> provides the Failure<E> error", () => {
+      const resultValue = result.err(new NewErrorClass());
 
-    expect(() => resultValue.unwrap()).toThrow(NewErrorClass);
+      expect(() => resultValue.unwrap()).toThrow(NewErrorClass);
+    });
   });
 
-  it("Returns if the Result<T, E> is a Success<T>", () => {
-    const resultValue = result.ok(3);
+  describe("isOk", () => {
+    it("Returns if the Result<T, E> is a Success<T>", () => {
+      const resultValue = result.ok(3);
 
-    expect(resultValue.isOk()).toBeTruthy();
+      expect(resultValue.isOk()).toBeTruthy();
+    });
   });
 
-  it("Returns if the Result<T, E> is a Failure<E>", () => {
-    const resultValue = result.err(new Error());
+  describe("isError", () => {
+    it("Returns if the Result<T, E> is a Failure<E>", () => {
+      const resultValue = result.err(new Error());
 
-    expect(resultValue.isError()).toBeTruthy();
+      expect(resultValue.isError()).toBeTruthy();
+    });
   });
 
-  it("Provides a defaultValue when unwrapOr() is called on a Failure<E> type", () => {
-    const resultValue = result.err(new Error());
+  describe("unwrapOr", () => {
+    it("Provides a defaultValue when unwrapOr() is called on a Failure<E> type", () => {
+      const resultValue = result.err(new Error());
 
-    expect(resultValue.unwrapOr(2)).toEqual(2);
-  });
+      expect(resultValue.unwrapOr(2)).toEqual(2);
+    });
 
-  it("Provides the Success<T> value if unwrapOr() is called on a Success<T> type", () => {
-    const resultValue = result.ok(2);
+    it("Provides the Success<T> value if unwrapOr() is called on a Success<T> type", () => {
+      const resultValue = result.ok(2);
 
-    expect(resultValue.unwrapOr(5)).toEqual(2);
+      expect(resultValue.unwrapOr(5)).toEqual(2);
+    });
   });
 
-  it("Throws the supplied Error if unwrapOrElse() is called on a Failure<E> type", () => {
-    const resultValue = result.err(new Error());
+  describe("unwrapOrElse", () => {
+    it("Throws the supplied Error if unwrapOrElse() is called on a Failure<E> type", () => {
+      const resultValue = result.err(new Error());
 
-    expect(() => resultValue.unwrapOrElse(new NewErrorClass())).toThrow(
-      NewErrorClass
-    );
-  });
+      expect(() => resultValue.unwrapOrElse(new NewErrorClass())).toThrow(
+        NewErrorClass,
+      );
+    });
 
-  it("Provides the Success<T> value if unwrapOrElse() is called on a Success<T> type", () => {
-    const resultValue = result.ok(3);
+    it("Provides the Success<T> value if unwrapOrElse() is called on a Success<T> type", () => {
+      const resultValue = result.ok(3);
 
-    expect(resultValue.unwrapOrElse(new NewErrorClass())).toEqual(3);
+      expect(resultValue.unwrapOrElse(new NewErrorClass())).toEqual(3);
+    });
   });
 
-  it("Converts the Success<T> to an Option<T> if ok() is called on a Success<T> type", () => {
-    const resultValue = result.ok(3);
+  describe("ok", () => {
+    it("Converts the Success<T> to an Option<T> if ok() is called on a Success<T> type", () => {
+      const resultValue = result.ok(3);
 
-    expect(resultValue.ok().isSome()).toBeTruthy();
-  });
+      expect(resultValue.ok().isSome()).toBeTruthy();
+    });
 
-  it("Converts the Failure<E> to an Option<T> if ok() is called on a Failure<E> type", () => {
-    const resultValue = result.err(new Error());
+    it("Converts the Failure<E> to an Option<T> if ok() is called on a Failure<E> type", () => {
+      const resultValue = result.err(new Error());
 
-    expect(resultValue.ok().isNone()).toBeTruthy();
+      expect(resultValue.ok().isNone()).toBeTruthy();
+    });
   });
 
-  it("Converts the Success<T> to an Option<E> if err() is called on a Success<T> type", () => {
-    const resultValue = result.ok(2);
+  describe("err", () => {
+    it("Converts the Success<T> to an Option<E> if err() is called on a Success<T> type", () => {
+      const resultValue = result.ok(2);
 
-    expect(resultValue.err().isNone()).toBeTruthy();
-  });
+      expect(resultValue.err().isNone()).toBeTruthy();
+    });
 
-  it("Converts the Failure<E> to an Option<E> if err() is called on a Failure<E> type", () => {
-    const resultValue = result.err(new Error());
+    it("Converts the Failure<E> to an Option<E> if err() is called on a Failure<E> type", () => {
+      const resultValue = result.err(new Error());
 
-    expect(resultValue.err().isSome()).toBeTruthy();
+      expect(resultValue.err().isSome()).toBeTruthy();
+    });
   });
 
-  it("Maps the Success<T> value to a new value if mapOk() is called on a Success<T> type", () => {
-    const resultValue = result.ok(2);
+  describe("mapOk", () => {
+    it("Maps the Success<T> value to a new value if mapOk() is called on a Success<T> type", () => {
+      const resultValue = result.ok(2);
 
-    expect(resultValue.mapOk((x) => x.toString()).unwrap()).toEqual("2");
-  });
+      expect(resultValue.mapOk((x) => x.toString()).unwrap()).toEqual("2");
+    });
 
-  it("Does not map the Success<T> value if mapOk() is called on a Failure<E> type", () => {
-    const resultValue = result.err<number>(new Error());
+    it("Does not map the Success<T> value if mapOk() is called on a Failure<E> type", () => {
+      const resultValue = result.err<number>(new Error());
 
-    expect(resultValue.mapOk((x) => x * 2).isError()).toBeTruthy();
+      expect(resultValue.mapOk((x) => x * 2).isError()).toBeTruthy();
+    });
   });
 
-  it("Maps the Success<T> value to a new Result<NewT, E> if andThen() is called on a Success<T> type", () => {
-    const resultValue = result.ok(2);
+  describe("mapErr", () => {
+    it("Maps the Failure<E> error to a new error if mapErr() is called on a Failure<E> type", () => {
+      const resultValue = result.err(new Error());
 
-    expect(
-      resultValue.andThen((x) => result.ok(x.toString())).unwrap()
-    ).toEqual("2");
-  });
+      expect(
+        resultValue.mapErr(() => new NewErrorClass()).isError(),
+      ).toBeTruthy();
+    });
 
-  it("Does not map the Success<T> value if andThen() is called on a Failure<E> type", () => {
-    const resultValue = result.err<number>(new Error());
+    it("Does not map the Failure<E> error if mapErr() is called on a Success<T> type", () => {
+      const resultValue = result.ok(2);
 
-    expect(resultValue.andThen((x) => result.ok(x * 2)).isError()).toBeTruthy();
+      expect(resultValue.mapErr(() => new NewErrorClass()).isOk()).toBeTruthy();
+    });
   });
 
-  it("Maps the Failure<E> error to a new error if mapErr() is called on a Failure<E> type", () => {
-    const resultValue = result.err(new Error());
+  describe("andThen", () => {
+    it("Maps the Success<T> value to a new Result<NewT, E> if andThen() is called on a Success<T> type", () => {
+      const resultValue = result.ok(2);
 
-    expect(
-      resultValue.mapErr(() => new NewErrorClass()).isError()
-    ).toBeTruthy();
-  });
+      expect(
+        resultValue.andThen((x) => result.ok(x.toString())).unwrap(),
+      ).toEqual("2");
+    });
 
-  it("Does not map the Failure<E> error if mapErr() is called on a Success<T> type", () => {
-    const resultValue = result.ok(2);
+    it("Does not map the Success<T> value if andThen() is called on a Failure<E> type", () => {
+      const resultValue = result.err<number>(new Error());
 
-    expect(resultValue.mapErr(() => new NewErrorClass()).isOk()).toBeTruthy();
+      expect(
+        resultValue.andThen((x) => result.ok(x * 2)).isError(),
+      ).toBeTruthy();
+    });
   });
 
-  it("Constructs a Failire<E> error with a default Error if provided with a string instead of an Error", () => {
-    const resultValue = result.err("This is an error");
+  describe("err Constructor", () => {
+    it("Constructs a Failire<E> error with a default Error if provided with a string instead of an Error", () => {
+      const resultValue = result.err("This is an error");
 
-    expect(() => resultValue.unwrap()).toThrow(Error);
-  });
+      expect(() => resultValue.unwrap()).toThrow(Error);
+    });
 
-  it("Constructs a Failure<E> error with an Error with no message if err() is called with no parameters", () => {
-    const resultValue = result.err();
+    it("Constructs a Failure<E> error with an Error with no message if err() is called with no parameters", () => {
+      const resultValue = result.err();
 
-    expect(() => resultValue.unwrap()).toThrow(Error);
+      expect(() => resultValue.unwrap()).toThrow(Error);
+    });
   });
 
-  it("Constructs a Result<T> from a promise when calling fromPromise() with a promise that resolves", async () => {
-    const resultValue = await result.fromPromise(Promise.resolve(3));
+  describe("fromPromise", () => {
+    it("Constructs a Result<T> from a promise when calling fromPromise() with a promise that resolves", async () => {
+      const resultValue = await result.fromPromise(Promise.resolve(3));
 
-    expect(resultValue.unwrap()).toEqual(3);
-  });
+      expect(resultValue.unwrap()).toEqual(3);
+    });
 
-  it("Constructs a Result<T> from a promise when calling fromPromise() with a promise that rejects", async () => {
-    const resultValue = await result.fromPromise(
-      Promise.reject(new NewErrorClass())
-    );
+    it("Constructs a Result<T> from a promise when calling fromPromise() with a promise that rejects", async () => {
+      const resultValue = await result.fromPromise(
+        Promise.reject(new NewErrorClass()),
+      );
 
-    expect(() => resultValue.unwrap()).toThrow(NewErrorClass);
-  });
+      expect(() => resultValue.unwrap()).toThrow(NewErrorClass);
+    });
 
-  it("Constructs a Result<T> from a promise that throws something other than an Error", async () => {
-    const resultValue = await result.fromPromise(Promise.reject(2));
+    it("Constructs a Result<T> from a promise that throws something other than an Error", async () => {
+      const resultValue = await result.fromPromise(Promise.reject(2));
 
-    expect(() => resultValue.unwrap()).toThrow(UnknownError);
-  });
+      expect(() => resultValue.unwrap()).toThrow(UnknownError);
+    });
+
+    it("Constructs a Result<T, E> from a Result containing a promise that resolves", async () => {
+      const resultValue = result.ok(Promise.resolve(3));
 
-  it("Constructs a Result<T, E> from a Result containing a promise that resolves", async () => {
-    const resultValue = result.ok(Promise.resolve(3));
+      const finalResult = await result.fromPromise(resultValue);
 
-    const finalResult = await result.fromPromise(resultValue);
+      expect(finalResult.unwrap()).toEqual(3);
+    });
 
-    expect(finalResult.unwrap()).toEqual(3);
+    it("Constructs a Result<T, E> from a Result containing a promise that rejects", async () => {
+      const resultValue = result.ok(Promise.reject(new NewErrorClass()));
+
+      const finalResult = await result.fromPromise(resultValue);
+
+      expect(() => finalResult.unwrap()).toThrow(NewErrorClass);
+    });
+
+    it("Constructs a Result<T, E> from a Result that is of a Failure<E> type", async () => {
+      const resultValue = result.err<Promise<number>>(new Error());
+
+      const finalResult = await result.fromPromise(resultValue);
+
+      expect(finalResult.isError()).toBeTruthy();
+    });
   });
 
-  it("Constructs a Result<T, E> from a Result containing a promise that rejects", async () => {
-    const resultValue = result.ok(Promise.reject(new NewErrorClass()));
+  describe("expect", () => {
+    it("Does not throw if the Result is a Success variant", () => {
+      const res = result.ok(2);
+
+      expect(() => res.expect("Some Message")).not.toThrow();
+    });
 
-    const finalResult = await result.fromPromise(resultValue);
+    it("Throws with the expected message if called on a Failure type", () => {
+      const expectedMessage = "Some Message";
+      const res = result.err<number>();
 
-    expect(() => finalResult.unwrap()).toThrow(NewErrorClass);
+      expect(() => res.expect(expectedMessage)).toThrow(
+        new Error(expectedMessage),
+      );
+    });
   });
 
-  it("Constructs a Result<T, E> from a Result that is of a Failure<E> type", async () => {
-    const resultValue = result.err<Promise<number>>(new Error());
+  describe("inspect", () => {
+    it("Calls the callback function if called on a Success variant", () => {
+      const spy = jest.fn();
+      const res = result.ok(123);
+      res.inspect((value) => spy(value));
+
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spy).toHaveBeenCalledWith(123);
+    });
+
+    it("Does not call callback function if called on a Failure variant", () => {
+      const spy = jest.fn();
+      const res = result.err<number>();
+
+      res.inspect((value) => spy(value));
+
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("Returns the same instance of Result when called with a Success variant", () => {
+      const spy = jest.fn();
+      const res = result.ok(123);
+      const inspectRes = res.inspect((val) => spy(val));
+
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(inspectRes).toEqual(res);
+    });
 
-    const finalResult = await result.fromPromise(resultValue);
+    it("Returns the same instance of Result when called with a Failure variant", () => {
+      const spy = jest.fn();
+      const res = result.err<number>();
+      const inspectRes = res.inspect((val) => spy(val));
 
-    expect(finalResult.isError()).toBeTruthy();
+      expect(spy).not.toHaveBeenCalled();
+      expect(inspectRes).toEqual(res);
+    });
   });
 });

From 0a2117f945bbbc63a6829a39e9043d5e843d08be Mon Sep 17 00:00:00 2001
From: Devin Bidwell <dbidwell94@biddydev.com>
Date: Mon, 8 Sep 2025 14:26:37 -0700
Subject: [PATCH 2/3] 1.2.0

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e630eab..a19b620 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@dbidwell94/ts-utils",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@dbidwell94/ts-utils",
-      "version": "1.1.0",
+      "version": "1.2.0",
       "license": "MIT",
       "devDependencies": {
         "@types/jest": "^30.0.0",
diff --git a/package.json b/package.json
index ad6bdb1..ca83f11 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@dbidwell94/ts-utils",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A collection of helpful TypeScript utilities with the aim of having limited production dependencies.",
   "main": "dist/index.js",
   "files": [

From 9b7dfe39eb9adccb653a007131696a489dacb700 Mon Sep 17 00:00:00 2001
From: Devin Bidwell <dbidwell94@biddydev.com>
Date: Mon, 8 Sep 2025 14:30:21 -0700
Subject: [PATCH 3/3] bump minor version and update changelog

---
 CHANGELOG.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 314fd2a..83e1bc9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.2.0]
+
+- Added new utility types to `Option` and `Result` types
+  - Option
+    - inspect(callback) -- Calls the provided `callback` if called on
+      a `Some` variant
+  - Result
+    - inspect(callback) -- Calls the provided `callback` if called on
+      a `Failure` variant
+    - expect(message) -- Unwraps the inner value if variant is `Success`,
+      otherwise throws an `Error` with the provided `message`
+- Update test structure to be more readable and easier to add tests
+
 ## [1.1.0]
 
 - Added new unsafe functions to the `Option` type to return unchecked values.