ferric-oxide 1.0.0

package/README.md

@@ -0,0 +1,225 @@
+# Rust like utils for typescript
+
+Rust is famous for its exceptional design choices that helps reduce some class of bugs beforehand. It also force us to wrtite good code. You can now taste these features in typesriupt too.
+
+## Installation
+
+```bash
+npm i @mr-m1m3/rusts
+```
+
+## Usage
+
+Basically rusts exports classes that implements spceific rust standard library modules.
+
+Currently rusts exports following classes:
+
+* [Maybe](#Maybe) (`Option<T>` equivalent of rust)
+* [Result](#Result)
+
+#### Maybe `<T>`
+
+Basically a wrapper around `null`. Use it when a value can either be something or nothing.
+
+```typescript
+
+import {Maybe} from "@mr-m1m3/rusts";
+
+// contains some value
+const maybe_a_number = new Maybe(100);
+
+// doesn't contain value
+const or_maybe_not = new Maybe(null);
+
+// methods
+/*
+ * .is_value() -> returns `true` because it contains a value otherwise resturns false
+ */
+maybe_a_number.is_value(); // true
+or_maybe_not.is_value(); //false
+
+/*
+ * is_not_a_value() -> opposite of .is_value()
+ */
+or_maybe_not.is_not_a_value(); // true
+maybe_a_number.is_not_a_value(); // false
+
+/*
+ * .unwrap() -> returns the value if it contains any or throws if it doesn't
+ */
+maybe_a_number.unwrap(); // 100
+or_maybe_not.unwrap(); // throws
+
+
+/*
+ * .expect(msg: string) -> same as .unwrap() but you can specify a message to be displayed as error
+ */
+maybe_a_number.expect('oops!'); // logs: 100
+or_maybe_not.expect('oops!'); // throws an error showing: oops!
+
+
+/*
+ * .unwrap_or(default: T) -> returns the value if it contains any; provided default if it doesn't
+ */
+maybe_a_number.unwrap_or(420); // 100
+or_maybe_not.unwrap_or(420); // 420
+
+/*
+ * .unwrap_or_else(fn: () => T) -> same as .unwrap_or() but takes a function calulate the default value
+ */
+maybe_a_number.unwrap_or_else(() => Math.random() * 15); // 100
+or_maybe_not.unwrap_or_else(() => Math.random() * 15); // a random number
+
+/*
+ * .map() -> converts `Maybe` of one type to Maybe of another type.
+ */
+maybe_a_number.map((n) => `number is one hundred`); // Maybe<string>
+or_maybe_not.map((n) => `contains null`); // Maybe<string>
+
+
+/*
+ * .transform(fn: (T) => U) -> transform the whole Maybe<T> to another type
+ */
+
+maybe_a_number.transform((val) => {
+    if(val.is_value()){
+        return {
+            is_value: true
+        }
+    }else{
+        return {
+            is_value: false
+        }
+    }
+}); // {is_value: true}
+```
+
+#### Result `<T, E>`
+
+typescript equivalent of rust `Result<T, E>`. It is use extensively in error handling. If a function can fail, it should always return `Result<T, E>` instead of throwing. Whoever calling the function should be the one to decide what to do with it. This approach also helps easily type a function that can fail. It takes advantage of typescript\'s discriminated union. Here, `T` represents the expected value and `E` represent the value if something happens really bad.
+
+You can call two static methods from this function.
+
+- `Result.Ok(expected_val)` returns an instance that contains the value we expect when all went well.
+- `Result.Err(err_val)` returns an instance that contains the value that will be returned when an error happens.
+
+Imagine, you have a function that looks like this:
+
+```typescript
+function could_fail(): Data{
+    //..//
+    if(condition){
+        return {/*...*/}
+    }
+    throw Error(/**/);
+}
+```
+
+However, the caller can't really tell beforehand that this function can throw. Also, it is now difficult to return organized error details to the caller. What we can do now is use `Result<Data, ErrMsg>`. What we are expressing is that the function can return either of type `Data` or `ErrMsg` and the caller must check explicitely before using the value. Now, inside the function body, we return `Result.Ok(data: Data)` and instead of throwing, we return `Result.Err(err_msg: ErrMsg)`.
+
+```typescript
+function could_fail(): Result<Data, ErrMsg>{
+    //..//
+    if(condition){
+        return Result.Ok({/*...*/});
+    }
+    throw Result.Err({/**/});
+}
+```
+
+The instance comes with some useful methods:
+
+```typescript
+import Result from "@mr-m1m3/rusts/result";
+
+type Data = {
+  name: string;
+  age: number;
+};
+type ErrMsg = {
+  msg: string;
+  status: number;
+};
+
+//                        +-------> ok variant or the value of a successfull operation
+//                        | +-----> error variant or the value of a failed operation
+//                        | |
+//                Result<T, E>
+
+const ok_variant: Result<Data, ErrMsg> = Result.Ok({
+  name: "John Doe",
+  age: 30,
+});
+
+const err_variant: Result<Data, ErrMsg> = Result.Err({
+  msg: "oops!",
+  status: 500,
+});
+
+/**
+ * .is_ok() -> returns true if the instance contains the value of a successfull operation aka if it was instantiated with Result.Ok();
+ */
+ok_variant.is_ok(); // true
+err_variant.is_ok(); // false
+
+/**
+ * .is_error() -> returns true if the instance contains the value of a failed operation aka if it was instantiated with Result.Err();
+ */
+ok_variant.is_error(); // false
+err_variant.is_error(); // true
+
+/*
+ * .ok_value() -> returns Maybe<T>.
+ */
+ok_variant.ok_value();
+err_variant.ok_value();
+
+/*
+ * .err_value() -> returns Maybe<E>.
+ */
+ok_variant.err_value();
+err_variant.err_value();
+
+/*
+* .map<U, Q>(
+    ok_mapper: (ok_val: T) => U,
+    err_mapper: (err_val: E) => Q,
+  ) -> converts to another instcance of Result that has `U` as Ok variant and `Q` as Error variant
+       calls first callback with the ok value to get the new ok value if exists otherwise calls second callback with error value to get the new error value.
+       returned Result variant will be an ok variant if it itself is the ok variant.
+*/
+ok_variant.map(
+  (ok_val) => "mission passed",
+  (error_val) => 0,
+); // Result<string, number>
+err_variant.map(
+  (ok_val) => new Date(),
+  (error_val) => "aura ---",
+); // Result<Date, string>
+
+/**
+ * .map_ok<U>((ok_val) => U) -> same as .map() but only takes in one callback that is called with ok value to get the new ok value
+                                returned Result contains the same error value as it itself contains
+ */
+ok_variant.map_ok((ok_val) => "mission passed"); // Result<string, ErrMsg>
+err_variant.map_ok((ok_val) => "mission passed"); // Result<string, ErrMsg>
+
+/**
+ * .map_err<Q>((ok_val) => Q) -> same as .map() but only takes in one callback that is called with error value to get the new error value
+                                returned Result contains the same ok value as it itself contains
+ */
+ok_variant.map_err((err_val) => "mission failed"); // Result<Data, string>
+err_variant.map_err((err_val) => "mission failed"); // Result<Data, string>
+
+/*
+ * .transform(callback) -> transformsthe entire Result instance to another type and returns. applies the provided callback on the instance to get the new type.
+ */
+
+ok_variant.transform((result_instnce) => {
+  return {
+    is_ok: result_instnce.is_ok(),
+    is_error: result_instnce.is_error(),
+  };
+}); // {is_ok: true, is_error: false}
+
+```

package/dist/index.js

@@ -0,0 +1,4 @@
+import Maybe from "./maybe/maybe.js";
+import Result from "./result/result.js";
+export { Maybe, Result };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,kBAAkB,CAAC;AACrC,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC"}

package/dist/maybe/maybe.js

@@ -0,0 +1,51 @@
+export default class Maybe {
+    constructor(val = null) {
+        this.value = val;
+    }
+    //useful methods
+    is_value() {
+        if (this.value === null) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    is_not_a_value() {
+        return !this.is_value();
+    }
+    expect(msg) {
+        if (this.is_value()) {
+            return this.value;
+        }
+        else {
+            throw new Error(msg);
+        }
+    }
+    unwrap() {
+        return this.expect('Expected a value but didnt get one.');
+    }
+    unwrap_or(def) {
+        if (this.is_value()) {
+            return this.value;
+        }
+        else {
+            return def;
+        }
+    }
+    unwrap_or_else(fn) {
+        return this.unwrap_or(fn());
+    }
+    map(fn) {
+        if (this.is_value()) {
+            return new Maybe(fn(this.value));
+        }
+        else {
+            return new Maybe(null);
+        }
+    }
+    transform(fn) {
+        return fn(this);
+    }
+}
+//# sourceMappingURL=maybe.js.map

package/dist/maybe/maybe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybe.js","sourceRoot":"","sources":["../../src/maybe/maybe.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,KAAK;IAGxB,YAAY,MAAgB,IAAI;QAC9B,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;IACnB,CAAC;IACD,gBAAgB;IACT,QAAQ;QACb,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YACxB,OAAO,KAAK,CAAC;QACf,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACM,cAAc;QACnB,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC1B,CAAC;IACM,MAAM,CAAC,GAAW;QACvB,IAAI,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,KAAU,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IACM,MAAM;QACX,OAAO,IAAI,CAAC,MAAM,CAAC,qCAAqC,CAAC,CAAA;IAC3D,CAAC;IACM,SAAS,CAAC,GAAM;QACrB,IAAI,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,KAAU,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,OAAO,GAAG,CAAC;QACb,CAAC;IACH,CAAC;IACM,cAAc,CAAC,EAAW;QAC/B,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,CAAA;IAC7B,CAAC;IACM,GAAG,CAAI,EAAe;QAC3B,IAAI,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACpB,OAAO,IAAI,KAAK,CAAI,EAAE,CAAC,IAAI,CAAC,KAAU,CAAC,CAAC,CAAC;QAC3C,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,KAAK,CAAI,IAAI,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IACM,SAAS,CAAK,EAA6B;QAChD,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;IAClB,CAAC;CACF"}

package/dist/maybe/maybe.test.js

@@ -0,0 +1,81 @@
+import { describe, test, expect } from "vitest";
+import { Maybe } from "@/index.js";
+const has_value = new Maybe("value");
+const not_a_value = new Maybe(null);
+describe("Maybe<T>", () => {
+    describe(".is_value()", () => {
+        test("should be true", () => {
+            expect.soft(has_value.is_value()).toBe(true);
+        });
+        test("should be false", () => {
+            expect.soft(not_a_value.is_value()).toBe(false);
+        });
+    });
+    describe(".is_not_a_value()", () => {
+        test("should be false", () => {
+            expect.soft(has_value.is_not_a_value()).toBe(false);
+        });
+        test("should be true", () => {
+            expect.soft(not_a_value.is_not_a_value()).toBe(true);
+        });
+    });
+    describe(".expect.soft(msg: string)", () => {
+        test("should be the actual value it holds", () => {
+            expect.soft(has_value.expect("doesn't hold a value")).toBe("value");
+        });
+        test("should throw with the message passed", () => {
+            expect.soft(() => not_a_value.expect("error msg")).toThrow("error msg");
+        });
+    });
+    describe(".unwrap()", () => {
+        test("should be the actual value it holds", () => {
+            expect.soft(has_value.unwrap()).toBe("value");
+        });
+        test("should throw with default message: `Expected a value but didnt get one.`", () => {
+            expect.soft(() => {
+                not_a_value.unwrap();
+            }).toThrow("Expected a value but didnt get one.");
+        });
+    });
+    describe(".unwrap_or()", () => {
+        test("should be the actual value it holds", () => {
+            expect.soft(has_value.unwrap_or("default")).toBe("value");
+        });
+        test("should be the provided default value`", () => {
+            expect.soft(not_a_value.unwrap_or("default")).toBe("default");
+        });
+    });
+    describe(".unwrap_or_else()", () => {
+        test("should be the actual value it holds", () => {
+            expect.soft(has_value.unwrap_or_else(() => "calulated default")).toBe("value");
+        });
+        test("should be the return value of the provided function`", () => {
+            expect.soft(not_a_value.unwrap_or_else(() => "calulated default")).toBe("calulated default");
+        });
+    });
+    describe(".map()", () => {
+        test("should be a new instance of Maybe holding the returned value of the provided function", () => {
+            const new_maybe_with_val = has_value.map((val) => val.length);
+            expect.soft(new_maybe_with_val).toBeInstanceOf(Maybe);
+            expect.soft(new_maybe_with_val.unwrap()).toBe(5 /*length*/);
+        });
+        test("should be the a new instance of maybe that holds no value`", () => {
+            const new_maybe_with_no_val = not_a_value.map((val) => val.length);
+            expect.soft(new_maybe_with_no_val).toBeInstanceOf(Maybe);
+            expect.soft(() => {
+                new_maybe_with_no_val.unwrap();
+            }).toThrow();
+        });
+    });
+    describe(".transform()", () => {
+        test("should transform the whole Maybe<T> class to boolean", () => {
+            const tr_maybe_with_val = has_value.transform(val => true);
+            expect.soft(tr_maybe_with_val).toBe(true);
+        });
+        test("should transform the whole Maybe<T> class to Date object", () => {
+            const tr_maybe_with_no_val = not_a_value.transform(val => new Date());
+            expect.soft(tr_maybe_with_no_val).toBeInstanceOf(Date);
+        });
+    });
+});
+//# sourceMappingURL=maybe.test.js.map

package/dist/maybe/maybe.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybe.test.js","sourceRoot":"","sources":["../../src/maybe/maybe.test.ts"],"names":[],"mappings":"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"}

package/dist/result/result.js

@@ -0,0 +1,51 @@
+import Maybe from "../maybe/maybe.js";
+export default class Result {
+    constructor(ok, err) {
+        if (ok === null && err === null) {
+            throw Error(`both \`Ok\` and \'Err\' can't be null at the same time`);
+        }
+        if (ok !== null && err !== null) {
+            throw Error(`both \`Ok\` and \'Err\' can't be other than null at the same time`);
+        }
+        this.ok = new Maybe(ok);
+        this.err = new Maybe(err);
+    }
+    //public interface to construct an instance
+    static Ok(val) {
+        return new Result(val, null);
+    }
+    static Err(err) {
+        return new Result(null, err);
+    }
+    //useful methods
+    is_ok() {
+        return this.ok.is_value();
+    }
+    is_error() {
+        return this.err.is_value();
+    }
+    ok_value() {
+        return this.ok;
+    }
+    err_value() {
+        return this.err;
+    }
+    map(ok_mapper, err_mapper) {
+        if (this.is_ok()) {
+            return Result.Ok(ok_mapper(this.ok_value().unwrap()));
+        }
+        else {
+            return Result.Err(err_mapper(this.err_value().unwrap()));
+        }
+    }
+    map_ok(fn) {
+        return this.map(fn, (err) => err);
+    }
+    map_err(fn) {
+        return this.map((v) => v, fn);
+    }
+    transform(fn) {
+        return fn(this);
+    }
+}
+//# sourceMappingURL=result.js.map

package/dist/result/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/result/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,mBAAmB,CAAC;AAEtC,MAAM,CAAC,OAAO,OAAO,MAAM;IAIzB,YAAoB,EAAY,EAAE,GAAa;QAC7C,IAAI,EAAE,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YAChC,MAAM,KAAK,CAAC,wDAAwD,CAAC,CAAC;QACxE,CAAC;QACD,IAAI,EAAE,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YAChC,MAAM,KAAK,CACT,mEAAmE,CACpE,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,EAAE,GAAG,IAAI,KAAK,CAAI,EAAE,CAAC,CAAC;QAC3B,IAAI,CAAC,GAAG,GAAG,IAAI,KAAK,CAAI,GAAG,CAAC,CAAC;IAC/B,CAAC;IAED,2CAA2C;IACpC,MAAM,CAAC,EAAE,CAAO,GAAM;QAC3B,OAAO,IAAI,MAAM,CAAO,GAAG,EAAE,IAAI,CAAC,CAAC;IACrC,CAAC;IACM,MAAM,CAAC,GAAG,CAAO,GAAM;QAC5B,OAAO,IAAI,MAAM,CAAO,IAAI,EAAE,GAAG,CAAC,CAAC;IACrC,CAAC;IACD,gBAAgB;IACT,KAAK;QACV,OAAO,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC;IAC5B,CAAC;IACM,QAAQ;QACb,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IACM,QAAQ;QACb,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;IACM,SAAS;QACd,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IACM,GAAG,CACR,SAAwB,EACxB,UAAyB;QAEzB,IAAI,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;YACjB,OAAO,MAAM,CAAC,EAAE,CAAO,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAC9D,CAAC;aAAM,CAAC;YACN,OAAO,MAAM,CAAC,GAAG,CAAO,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IACM,MAAM,CAAI,EAAiB;QAChC,OAAO,IAAI,CAAC,GAAG,CAAO,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;IAC1C,CAAC;IACM,OAAO,CAAI,EAAiB;QACjC,OAAO,IAAI,CAAC,GAAG,CAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACtC,CAAC;IACM,SAAS,CAAK,EAA6B;QAChD,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;IAClB,CAAC;CACF"}

package/dist/result/result.test.js

@@ -0,0 +1,101 @@
+import { describe, test, expect } from "vitest";
+import { Maybe, Result } from "@/index.js";
+const ok_variant = Result.Ok({
+    data: "ok data",
+});
+const err_variant = Result.Err({
+    status: 400,
+});
+describe("Result<T, E>", () => {
+    describe(".is_ok()", () => {
+        test("should be true", () => {
+            expect.soft(ok_variant.is_ok()).toBe(true);
+        });
+        test("should be false", () => {
+            expect.soft(err_variant.is_ok()).toBe(false);
+        });
+    });
+    describe(".is_error()", () => {
+        test("should be false", () => {
+            expect.soft(ok_variant.is_error()).toBe(false);
+        });
+        test("should be true", () => {
+            expect.soft(err_variant.is_error()).toBe(true);
+        });
+    });
+    describe(".ok_value()", () => {
+        test("should be an instance of Maybe<T> containing the expected value", () => {
+            const ok_variant_ok_value = ok_variant.ok_value();
+            expect.soft(ok_variant_ok_value).toBeInstanceOf(Maybe);
+            expect.soft(ok_variant_ok_value.unwrap()).toStrictEqual({
+                data: "ok data",
+            });
+        });
+        test("should be an instance of Maybe<T> containing nothing", () => {
+            const err_variant_ok_value = err_variant.ok_value();
+            expect.soft(err_variant_ok_value).toBeInstanceOf(Maybe);
+            expect
+                .soft(() => {
+                err_variant_ok_value.unwrap();
+            })
+                .toThrow();
+        });
+    });
+    describe(".err_value()", () => {
+        test("should be an instance of Maybe<T> containing the nothing", () => {
+            const ok_variant_err_value = ok_variant.err_value();
+            expect.soft(ok_variant_err_value).toBeInstanceOf(Maybe);
+            expect
+                .soft(() => {
+                ok_variant_err_value.unwrap();
+            })
+                .toThrow();
+        });
+    });
+    test("should be an instance of Maybe<T> containing error details", () => {
+        const err_variant_err_value = err_variant.err_value();
+        expect.soft(err_variant_err_value).toBeInstanceOf(Maybe);
+        expect.soft(err_variant_err_value.unwrap()).toStrictEqual({
+            status: 400,
+        });
+    });
+    describe(".map()", () => {
+        test("should be ok variant of another Result with new calulated ok and error value", () => {
+            const mapped_ok_variant = ok_variant.map((ok_data) => "was ok variant", (err_data) => "was error variant");
+            expect.soft(mapped_ok_variant).toBeInstanceOf(Result);
+            expect.soft(mapped_ok_variant.is_ok()).toBe(true);
+            expect.soft(mapped_ok_variant.ok_value().unwrap()).toBe("was ok variant");
+        });
+        test("should be err variant of another Result with new calulated ok and error value", () => {
+            const mapped_err_variant = err_variant.map((ok_data) => "was ok variant", (err_data) => "was error variant");
+            expect.soft(mapped_err_variant).toBeInstanceOf(Result);
+            expect.soft(mapped_err_variant.is_error()).toBe(true);
+            expect.soft(mapped_err_variant.err_value().unwrap()).toBe("was error variant");
+        });
+    });
+    describe(".map_ok()", () => {
+        test("should be ok variant of another Result with new calculated ok value but old error value", () => {
+            const map_ok_of_ok_variant = ok_variant.map_ok((ok_data) => "was ok variant");
+            expect.soft(map_ok_of_ok_variant).toBeInstanceOf(Result);
+            expect.soft(map_ok_of_ok_variant.is_ok()).toBe(true);
+            expect.soft(map_ok_of_ok_variant.ok_value().unwrap()).toBe("was ok variant");
+        });
+        test("should be ok variant of another Result with new calculated error value but old ok value", () => {
+            const map_err_of_err_variant = err_variant.map_err((err_data) => "was error variant");
+            expect.soft(map_err_of_err_variant).toBeInstanceOf(Result);
+            expect.soft(map_err_of_err_variant.is_error()).toBe(true);
+            expect.soft(map_err_of_err_variant.err_value().unwrap()).toBe("was error variant");
+        });
+    });
+    describe(".transform()", () => {
+        test("should transform the whole Result<T, E> class to type string", () => {
+            const tr_maybe_with_val = ok_variant.transform(val => 'success');
+            expect.soft(tr_maybe_with_val).toBe('success');
+        });
+        test("should transform the whole Result<T, E> class to number", () => {
+            const tr_maybe_with_no_val = err_variant.transform(val => 500);
+            expect.soft(tr_maybe_with_no_val).toBe(500);
+        });
+    });
+});
+//# sourceMappingURL=result.test.js.map

package/dist/result/result.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.test.js","sourceRoot":"","sources":["../../src/result/result.test.ts"],"names":[],"mappings":"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"}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+import Maybe from "./maybe/maybe.js";
+import Result from "./result/result.js";
+export { Maybe, Result };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,kBAAkB,CAAC;AACrC,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC"}

package/dist/types/maybe/maybe.d.ts

@@ -0,0 +1,13 @@
+export default class Maybe<T> {
+    private value;
+    constructor(val?: T | null);
+    is_value(): boolean;
+    is_not_a_value(): boolean;
+    expect(msg: string): T;
+    unwrap(): T;
+    unwrap_or(def: T): T;
+    unwrap_or_else(fn: () => T): T;
+    map<U>(fn: (v: T) => U): Maybe<U>;
+    transform<To>(fn: (from: typeof this) => To): To;
+}
+//# sourceMappingURL=maybe.d.ts.map

package/dist/types/maybe/maybe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybe.d.ts","sourceRoot":"","sources":["../../../src/maybe/maybe.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,KAAK,CAAC,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAW;gBAEZ,GAAG,GAAE,CAAC,GAAG,IAAW;IAIzB,QAAQ,IAAI,OAAO;IAOnB,cAAc,IAAI,OAAO;IAGzB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC;IAOtB,MAAM,IAAI,CAAC;IAGX,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;IAOpB,cAAc,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAG9B,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAOjC,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,IAAI,KAAK,EAAE,GAAG,EAAE;CAGxD"}

package/dist/types/maybe/maybe.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=maybe.test.d.ts.map

package/dist/types/maybe/maybe.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybe.test.d.ts","sourceRoot":"","sources":["../../../src/maybe/maybe.test.ts"],"names":[],"mappings":""}

package/dist/types/result/result.d.ts

@@ -0,0 +1,17 @@
+import Maybe from "../maybe/maybe.js";
+export default class Result<T, E> {
+    private ok;
+    private err;
+    private constructor();
+    static Ok<T, E>(val: T): Result<T, E>;
+    static Err<T, E>(err: E): Result<T, E>;
+    is_ok(): boolean;
+    is_error(): boolean;
+    ok_value(): Maybe<T>;
+    err_value(): Maybe<E>;
+    map<U, Q>(ok_mapper: (val: T) => U, err_mapper: (err: E) => Q): Result<U, Q>;
+    map_ok<U>(fn: (val: T) => U): Result<U, E>;
+    map_err<Q>(fn: (val: E) => Q): Result<T, Q>;
+    transform<To>(fn: (from: typeof this) => To): To;
+}
+//# sourceMappingURL=result.d.ts.map

package/dist/types/result/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/result/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,mBAAmB,CAAC;AAEtC,MAAM,CAAC,OAAO,OAAO,MAAM,CAAC,CAAC,EAAE,CAAC;IAC9B,OAAO,CAAC,EAAE,CAAW;IACrB,OAAO,CAAC,GAAG,CAAW;IAEtB,OAAO;WAcO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;WAG9B,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IAItC,KAAK,IAAI,OAAO;IAGhB,QAAQ,IAAI,OAAO;IAGnB,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC;IAGpB,SAAS,IAAI,KAAK,CAAC,CAAC,CAAC;IAGrB,GAAG,CAAC,CAAC,EAAE,CAAC,EACb,SAAS,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EACxB,UAAU,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GACxB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IAOR,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IAG1C,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IAG3C,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,IAAI,KAAK,EAAE,GAAG,EAAE;CAGxD"}

package/dist/types/result/result.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=result.test.d.ts.map

package/dist/types/result/result.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.test.d.ts","sourceRoot":"","sources":["../../../src/result/result.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "ferric-oxide",
+  "version": "1.0.0",
+  "description": "Rust liike utilities for typescript",
+  "homepage": "https://github.com/mr-m1m3/rsts",
+  "bugs": {
+    "url": "https://github.com/mr-m1m3/rsts/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mr-m1m3/rsts.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test:watch": "vitest",
+    "test": "vitest run"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./maybe": {
+      "types": "./dist/types/maybe/maybe.d.ts",
+      "default": "./dist/maybe/maybe.js"
+    },
+    "./result": {
+      "types": "./dist/types/result/result.d.ts",
+      "default": "./dist/result/result.js"
+    }
+  },
+  "files": [
+    "./src",
+    "./dist"
+  ],
+  "keywords": [
+    "rust",
+    "utilities",
+    "result",
+    "option",
+    "enum",
+    "error-handling",
+    "null-handling"
+  ],
+  "author": "@mr-m1m3",
+  "license": "ISC",
+  "packageManager": "pnpm@10.28.1",
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "type": "module"
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import Maybe from "./maybe/maybe.js";
+import Result from "./result/result.js";
+export { Maybe, Result };

package/src/maybe/maybe.test.ts

@@ -0,0 +1,91 @@
+import { describe, test, expect } from "vitest";
+import { Maybe } from "@/index.js";
+
+const has_value = new Maybe("value");
+const not_a_value = new Maybe<string>(null);
+describe("Maybe<T>", () => {
+  describe(".is_value()", () => {
+    test("should be true", () => {
+      expect.soft(has_value.is_value()).toBe(true);
+    });
+    test("should be false", () => {
+      expect.soft(not_a_value.is_value()).toBe(false);
+    });
+  });
+
+  describe(".is_not_a_value()", () => {
+    test("should be false", () => {
+      expect.soft(has_value.is_not_a_value()).toBe(false);
+    });
+    test("should be true", () => {
+      expect.soft(not_a_value.is_not_a_value()).toBe(true);
+    });
+  });
+
+  describe(".expect.soft(msg: string)", () => {
+    test("should be the actual value it holds", () => {
+      expect.soft(has_value.expect("doesn't hold a value")).toBe("value");
+    });
+    test("should throw with the message passed", () => {
+      expect.soft(() => not_a_value.expect("error msg")).toThrow("error msg");
+    });
+  });
+
+  describe(".unwrap()", () => {
+    test("should be the actual value it holds", () => {
+      expect.soft(has_value.unwrap()).toBe("value");
+    });
+    test("should throw with default message: `Expected a value but didnt get one.`", () => {
+      expect.soft(() => {
+        not_a_value.unwrap();
+      }).toThrow("Expected a value but didnt get one.");
+    });
+  });
+
+  describe(".unwrap_or()", () => {
+    test("should be the actual value it holds", () => {
+      expect.soft(has_value.unwrap_or("default")).toBe("value");
+    });
+    test("should be the provided default value`", () => {
+      expect.soft(not_a_value.unwrap_or("default")).toBe("default");
+    });
+  });
+
+  describe(".unwrap_or_else()", () => {
+    test("should be the actual value it holds", () => {
+      expect.soft(has_value.unwrap_or_else(() => "calulated default")).toBe("value");
+    });
+    test("should be the return value of the provided function`", () => {
+      expect.soft(not_a_value.unwrap_or_else(() => "calulated default")).toBe(
+        "calulated default",
+      );
+    });
+  });
+
+  describe(".map()", () => {
+    test("should be a new instance of Maybe holding the returned value of the provided function", () => {
+      const new_maybe_with_val = has_value.map<number>((val) => val.length);
+      expect.soft(new_maybe_with_val).toBeInstanceOf(Maybe);
+      expect.soft(new_maybe_with_val.unwrap()).toBe(5 /*length*/);
+    });
+    test("should be the a new instance of maybe that holds no value`", () => {
+      const new_maybe_with_no_val = not_a_value.map((val) => val.length);
+      expect.soft(new_maybe_with_no_val).toBeInstanceOf(Maybe);
+      expect.soft(() => {
+        new_maybe_with_no_val.unwrap();
+      }).toThrow();
+    });
+  });
+
+  describe(".transform()", () => {
+    test("should transform the whole Maybe<T> class to boolean", () => {
+      const tr_maybe_with_val = has_value.transform(val => true);
+      expect.soft(tr_maybe_with_val).toBe(true);
+    });
+
+    test("should transform the whole Maybe<T> class to Date object", () => {
+      const tr_maybe_with_no_val = not_a_value.transform(val => new Date());
+      expect.soft(tr_maybe_with_no_val).toBeInstanceOf(Date);
+    });
+  });
+});

package/src/maybe/maybe.ts

@@ -0,0 +1,48 @@
+export default class Maybe<T> {
+  private value: T | null;
+
+  constructor(val: T | null = null) {
+    this.value = val;
+  }
+  //useful methods
+  public is_value(): boolean {
+    if (this.value === null) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+  public is_not_a_value(): boolean {
+    return !this.is_value();
+  }
+  public expect(msg: string): T {
+    if (this.is_value()) {
+      return this.value as T;
+    } else {
+      throw new Error(msg);
+    }
+  }
+  public unwrap(): T {
+    return this.expect('Expected a value but didnt get one.')
+  }
+  public unwrap_or(def: T): T {
+    if (this.is_value()) {
+      return this.value as T;
+    } else {
+      return def;
+    }
+  }
+  public unwrap_or_else(fn: () => T): T {
+    return this.unwrap_or(fn())
+  }
+  public map<U>(fn: (v: T) => U): Maybe<U> {
+    if (this.is_value()) {
+      return new Maybe<U>(fn(this.value as T));
+    } else {
+      return new Maybe<U>(null);
+    }
+  }
+  public transform<To>(fn: (from: typeof this) => To): To {
+    return fn(this);
+  }
+}

package/src/result/result.test.ts

@@ -0,0 +1,126 @@
+import { describe, test, expect } from "vitest";
+import { Maybe, Result } from "@/index.js";
+type OkData = {
+  data: string;
+};
+type ErrData = {
+  status: number;
+};
+const ok_variant = Result.Ok<OkData, ErrData>({
+  data: "ok data",
+});
+const err_variant = Result.Err<OkData, ErrData>({
+  status: 400,
+});
+
+describe("Result<T, E>", () => {
+  describe(".is_ok()", () => {
+    test("should be true", () => {
+      expect.soft(ok_variant.is_ok()).toBe(true);
+    });
+    test("should be false", () => {
+      expect.soft(err_variant.is_ok()).toBe(false);
+    });
+  });
+
+  describe(".is_error()", () => {
+    test("should be false", () => {
+      expect.soft(ok_variant.is_error()).toBe(false);
+    });
+    test("should be true", () => {
+      expect.soft(err_variant.is_error()).toBe(true);
+    });
+  });
+
+  describe(".ok_value()", () => {
+    test("should be an instance of Maybe<T> containing the expected value", () => {
+      const ok_variant_ok_value = ok_variant.ok_value();
+      expect.soft(ok_variant_ok_value).toBeInstanceOf(Maybe);
+      expect.soft(ok_variant_ok_value.unwrap()).toStrictEqual({
+        data: "ok data",
+      });
+    });
+    test("should be an instance of Maybe<T> containing nothing", () => {
+      const err_variant_ok_value = err_variant.ok_value();
+      expect.soft(err_variant_ok_value).toBeInstanceOf(Maybe);
+      expect
+        .soft(() => {
+          err_variant_ok_value.unwrap();
+        })
+        .toThrow();
+    });
+  });
+
+  describe(".err_value()", () => {
+    test("should be an instance of Maybe<T> containing the nothing", () => {
+      const ok_variant_err_value = ok_variant.err_value();
+      expect.soft(ok_variant_err_value).toBeInstanceOf(Maybe);
+      expect
+        .soft(() => {
+          ok_variant_err_value.unwrap();
+        })
+        .toThrow();
+    });
+  });
+  test("should be an instance of Maybe<T> containing error details", () => {
+    const err_variant_err_value = err_variant.err_value();
+    expect.soft(err_variant_err_value).toBeInstanceOf(Maybe);
+    expect.soft(err_variant_err_value.unwrap()).toStrictEqual({
+      status: 400,
+    });
+  });
+
+  describe(".map()", () => {
+    test("should be ok variant of another Result with new calulated ok and error value", () => {
+      const mapped_ok_variant = ok_variant.map(
+        (ok_data) => "was ok variant",
+        (err_data) => "was error variant",
+      );
+      expect.soft(mapped_ok_variant).toBeInstanceOf(Result);
+      expect.soft(mapped_ok_variant.is_ok()).toBe(true);
+      expect.soft(mapped_ok_variant.ok_value().unwrap()).toBe("was ok variant")
+    });
+
+    test("should be err variant of another Result with new calulated ok and error value", () => {
+      const mapped_err_variant = err_variant.map(
+        (ok_data) => "was ok variant",
+        (err_data) => "was error variant",
+      );
+      expect.soft(mapped_err_variant).toBeInstanceOf(Result);
+      expect.soft(mapped_err_variant.is_error()).toBe(true);
+      expect.soft(mapped_err_variant.err_value().unwrap()).toBe("was error variant");
+    });
+  });
+
+  describe(".map_ok()", () => {
+    test("should be ok variant of another Result with new calculated ok value but old error value", () => {
+      const map_ok_of_ok_variant = ok_variant.map_ok(
+        (ok_data) => "was ok variant",
+      );
+      expect.soft(map_ok_of_ok_variant).toBeInstanceOf(Result);
+      expect.soft(map_ok_of_ok_variant.is_ok()).toBe(true);
+      expect.soft(map_ok_of_ok_variant.ok_value().unwrap()).toBe("was ok variant");
+    });
+
+    test("should be ok variant of another Result with new calculated error value but old ok value", () => {
+      const map_err_of_err_variant = err_variant.map_err(
+        (err_data) => "was error variant",
+      );
+      expect.soft(map_err_of_err_variant).toBeInstanceOf(Result);
+      expect.soft(map_err_of_err_variant.is_error()).toBe(true);
+      expect.soft(map_err_of_err_variant.err_value().unwrap()).toBe("was error variant");
+    });
+  });
+
+ describe(".transform()", () => {
+    test("should transform the whole Result<T, E> class to type string", () => {
+      const tr_maybe_with_val = ok_variant.transform(val => 'success');
+      expect.soft(tr_maybe_with_val).toBe('success');
+    });
+
+    test("should transform the whole Result<T, E> class to number", () => {
+      const tr_maybe_with_no_val = err_variant.transform(val => 500);
+      expect.soft(tr_maybe_with_no_val).toBe(500);
+    });
+  });
+});

package/src/result/result.ts

@@ -0,0 +1,59 @@
+import Maybe from "../maybe/maybe.js";
+
+export default class Result<T, E> {
+  private ok: Maybe<T>;
+  private err: Maybe<E>;
+
+  private constructor(ok: T | null, err: E | null) {
+    if (ok === null && err === null) {
+      throw Error(`both \`Ok\` and \'Err\' can't be null at the same time`);
+    }
+    if (ok !== null && err !== null) {
+      throw Error(
+        `both \`Ok\` and \'Err\' can't be other than null at the same time`,
+      );
+    }
+    this.ok = new Maybe<T>(ok);
+    this.err = new Maybe<E>(err);
+  }
+
+  //public interface to construct an instance
+  public static Ok<T, E>(val: T): Result<T, E> {
+    return new Result<T, E>(val, null);
+  }
+  public static Err<T, E>(err: E): Result<T, E> {
+    return new Result<T, E>(null, err);
+  }
+  //useful methods
+  public is_ok(): boolean {
+    return this.ok.is_value();
+  }
+  public is_error(): boolean {
+    return this.err.is_value();
+  }
+  public ok_value(): Maybe<T> {
+    return this.ok;
+  }
+  public err_value(): Maybe<E> {
+    return this.err;
+  }
+  public map<U, Q>(
+    ok_mapper: (val: T) => U,
+    err_mapper: (err: E) => Q,
+  ): Result<U, Q> {
+    if (this.is_ok()) {
+      return Result.Ok<U, Q>(ok_mapper(this.ok_value().unwrap()));
+    } else {
+      return Result.Err<U, Q>(err_mapper(this.err_value().unwrap()));
+    }
+  }
+  public map_ok<U>(fn: (val: T) => U): Result<U, E> {
+    return this.map<U, E>(fn, (err) => err);
+  }
+  public map_err<Q>(fn: (val: E) => Q): Result<T, Q> {
+    return this.map<T, Q>((v) => v, fn);
+  }
+  public transform<To>(fn: (from: typeof this) => To): To {
+    return fn(this);
+  }
+}