rsult 1.0.1 → 1.1.0

package/deno.json

@@ -0,0 +1,5 @@
+{
+    "name": "@int/rsult",
+    "version": "1.1.0",
+    "exports": "./src/lib.ts"
+}

package/package.json

@@ -1,19 +1,19 @@
 {
-  "name": "rsult",
-  "version": "1.0.1",
-  "description": "",
-  "main": "src/lib.ts",
-  "repository": "https://github.com/indicium-ag/rsult",
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "devDependencies": {
-    "@swc/core": "^1.4.12",
-    "@swc/jest": "^0.2.36",
-    "@types/jest": "^29.5.12",
-    "jest": "^29.7.0"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  }
+    "name": "rsult",
+    "version": "1.1.0",
+    "description": "",
+    "main": "src/lib.ts",
+    "repository": "https://github.com/indicium-ag/rsult",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [],
+    "author": "Kenan Sulayman <kenan@sly.mn>",
+    "license": "MIT",
+    "devDependencies": {
+        "@swc/core": "^1.4.12",
+        "@swc/jest": "^0.2.36",
+        "@types/jest": "^29.5.12",
+        "jest": "^29.7.0"
+    }
 }

package/readme.md

@@ -276,6 +276,7 @@ console.log(result); // "Parsed content: {"parsed":"Resource content"}"
 #### Conversion Methods
 - `into_ok()`: Converts from `IResultCore<T, E>` to `T`.
 - `into_err()`: Converts from `IResultCore<T, E>` to `E`.
+- `transmute()`: Changes the type of `Result<T, E>` to `Result<T, never>` or `Result<never, E>`, respectively. This is particularly useful when trying to forward a `ResultErr` returned by a function whose error type overlaps with the returned error type of the current function, but whose value type does not.
 
 #### Checking and Transforming Methods
 - `is_ok_and(f: (value: T) => boolean)`: Checks if the result is Ok and the contained value passes a specified condition.
@@ -301,7 +302,6 @@ console.log(result); // "Parsed content: {"parsed":"Resource content"}"
 
 #### Iteration and Flattening Methods
 - `iter()`: Returns an iterator over the potentially contained value.
-- `transpose()`: Attempts to transpose a `Result` of a `Promise` into a `Promise` of a `Result`.
 - `flatten()`: Flattens a nested `Result` if the contained value is itself a `Result`.
 
 ## Contributing

package/src/lib.ts

@@ -1,2 +1,2 @@
-export * from './result';
-export * from './option';
+export * from './result.ts';
+export * from './option.ts';

package/src/option.ts

@@ -1,4 +1,5 @@
-export type Option<T> = OptionSome<T> | OptionNone<T>;
+export type Option<T> =
+    OptionSome<T> | OptionNone<T>;
 
 export interface IOptionCheck<T> {
     /**
@@ -178,7 +179,7 @@ export interface IOptionUtility<T> {
      * const myOption is None<number>();
      * const value = myOption.unwrap_or_default(); // 0
      */
-    unwrap_or_default(): T;
+    unwrap_or_default(): T | null;
 }
 
 export interface IOptionMutate<T> {
@@ -280,7 +281,8 @@ export interface IOption<T> extends
 
 export class OptionSome<T> implements IOption<T> {
     readonly _tag = 'Some' as const;
-    readonly _T!: T;
+    // @ts-ignore
+    readonly _T: T;
 
     constructor(readonly value: T) { }
 
@@ -352,7 +354,7 @@ export class OptionSome<T> implements IOption<T> {
         return this.value;
     }
 
-    unwrap_or_default(): T {
+    unwrap_or_default(): T | null {
         return this.value;
     }
 
@@ -408,7 +410,8 @@ export class OptionSome<T> implements IOption<T> {
 
 export class OptionNone<T> implements IOption<T> {
     private readonly _tag: 'None' = 'None';
-    private readonly _T!: T;
+    // @ts-ignore
+    private readonly _T: T;
 
     is_some(): this is never {
         return false;
@@ -470,7 +473,7 @@ export class OptionNone<T> implements IOption<T> {
         return fn();
     }
 
-    unwrap_or_default() {
+    unwrap_or_default(): T | null {
         return null as any;
     }
 
@@ -499,11 +502,11 @@ export class OptionNone<T> implements IOption<T> {
     }
 }
 
-export const Some = <T>(val: T) => {
+export const Some = <T>(val: T): Option<T> => {
     return new OptionSome<T>(val);
 };
 
-export const None = <T>() => {
+export const None = <T>(): Option<T> => {
     return new OptionNone<T>();
 };
 

package/src/result.test.ts

@@ -341,20 +341,6 @@ describe('Result', () => {
             });
         });
 
-        describe('transpose', () => {
-            it('returns ResultOk<number, _> for Result<number, _>', () => {
-                const resultPromise = Ok(5);
-                const transposed = resultPromise.transpose();
-                expect(transposed).toEqual(Ok(5));
-            });
-
-            it('returns ResultErr<_, Error> for Result<_, Error>', () => {
-                const resultPromise = Err(new Error("Error"));
-                const transposed = resultPromise.transpose();
-                expect(transposed).toEqual(Err(new Error("Error")));
-            });
-        });
-
         describe('flatten', () => {
             it('flattens nested Ok Result', () => {
                 const nestedOk = Ok(Ok(5));
@@ -452,7 +438,7 @@ describe('Result', () => {
                 const promise = Promise.reject(new Error(errorMsg));
                 const result = await result_from_promise(promise);
                 expect(result.is_err()).toBe(true);
-                expect((await result.unwrap_err()).message).toBe(errorMsg);
+                expect(result.unwrap_err().message).toBe(errorMsg);
             });
         });
     });

package/src/result.ts

@@ -1,6 +1,7 @@
-import { Option, None, Some } from './option';
+import { Option, None, Some } from './option.ts';
 
-export type Result<T, E> = ResultOk<T, E> | ResultErr<T, E>;
+export type Result<T, E> =
+    ResultOk<T, E> | ResultErr<T, E>;
 
 export interface IResultCore<T, E> {
     /**
@@ -120,6 +121,30 @@ export interface IResultCore<T, E> {
      * console.log(result.into_err());
      */
     into_err(): E;
+
+    /**
+     * Converts between different forms of `Result`, allowing the error type to be widened.
+     * 
+     * If called on a `ResultOk<T, E>`, it will return a `Result<T, never>`, effectively discarding 
+     * the error type. This is useful when you want to use the `Result` in a context that expects
+     * a `Result` with a specific error type, but you know that the `Result` is an `Ok` variant.
+     *
+     * If called on a `ResultErr<T, E>`, it will return a `Result<never, E>`, effectively discarding 
+     * the value type. This is useful when you want to use the `Result` in a context that expects
+     * a `Result` with a specific value type, but you know that the `Result` is an `Err` variant. 
+     * 
+     * This is particularly useful when trying to forward a ResultErr returned by a function whose
+     * error type overlaps with the returned error type of the current function, but whose value type
+     * does not.
+     *
+     * Usage Example:
+     * const result: Result<number, Error> = Ok<number, Error>(5);
+     * const transmuted: Result<number, never> = result.transmute();
+     *
+     * const result: Result<number, Error> = Err<number, Error>(new Error("Failure"));
+     * const transmuted: Result<never, Error> = result.transmute();
+     */
+    transmute(): Result<T, never> | Result<never, E>;
 }
 
 export interface IResultExt<T, E> extends IResultCore<T, E> {
@@ -323,19 +348,6 @@ export interface IResultIteration<T, E> extends IResultCore<T, E> {
      */
     iter(): IterableIterator<T>;
 
-    /**
-     * Attempts to transpose a `Result` of a `Promise` into a `Promise` of a `Result`.
-     * @returns A Promise of a Result if the inner value is a Promise, null otherwise.
-     *
-     * Usage Example:
-     * async function example() {
-     *   const resultPromise = Ok(Promise.resolve(5));
-     *   const transposed = resultPromise.transpose(); // Result<Promise<5>, E> -> Promise<Result<5, E>> | null
-     *   console.log(await transposed); // Prints Ok(5) if the promise resolves successfully.
-     * }
-     */
-    transpose(): Result<T, E>;
-
     /**
      * Flattens a nested `Result` if the contained value is itself a `Result`.
      * @returns A single-layer `Result`, by stripping one layer of `Result` container.
@@ -365,8 +377,10 @@ export const isResultErr = <T, E>(val: any): val is ResultErr<T, E> => {
 
 export class ResultOk<T, E> implements IResult<T, E> {
     private readonly _tag = 'Ok' as const;
-    private readonly _T!: T;
-    private readonly _E!: E;
+    // @ts-ignore
+    private readonly _T: T;
+    // @ts-ignore
+    private readonly _E: E;
 
     constructor(readonly value: T) {
     }
@@ -469,10 +483,6 @@ export class ResultOk<T, E> implements IResult<T, E> {
         return this.value;
     }
 
-    transpose(): Result<T, E> {
-        return new ResultOk<T, E>(this.value);
-    }
-
     flatten(): Result<UnwrapResult<T>, E> {
         if (this.value instanceof ResultOk || this.value instanceof ResultErr) {
             return this.value;
@@ -490,12 +500,18 @@ export class ResultOk<T, E> implements IResult<T, E> {
     into_err(): never {
         throw new Error('Called Result.into_err() on an Ok value: ' + this.value);
     }
+
+    transmute(): Result<T, never> {
+        return this as any;
+    }
 }
 
 export class ResultErr<T, E> implements IResult<T, E> {
     private readonly _tag: 'Err' = 'Err';
-    private readonly _T!: T;
-    private readonly _E!: E;
+    // @ts-ignore
+    private readonly _T: T;
+    // @ts-ignore
+    private readonly _E: E;
 
     constructor(readonly value: E) {
     }
@@ -597,12 +613,8 @@ export class ResultErr<T, E> implements IResult<T, E> {
         return fn(this.value);
     }
 
-    transpose(): Result<T, E> {
-        return new ResultErr<T, E>(this.value);
-    }
-
     flatten(): Result<UnwrapResult<T>, E> {
-        return this.transpose() as Result<never, E>;
+        return new ResultErr(this.value) as Result<never, E>;
     }
 
     into_ok(): T {
@@ -612,13 +624,16 @@ export class ResultErr<T, E> implements IResult<T, E> {
     into_err(): E {
         return this.value;
     }
-}
 
-export const Ok = <T, E>(val: T) => {
+    transmute(): Result<never, E> {
+        return this as any;
+    }
+}
+export const Ok = <T, E>(val: T): Result<T, never> => {
     return new ResultOk<T, E>(val) as Result<T, never>;
 };
 
-export const Err = <T, E>(val: E) => {
+export const Err = <T, E>(val: E): Result<never, E> => {
     return new ResultErr<T, E>(val) as Result<never, E>;
 };
 

package/tsconfig.json

@@ -2,6 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "target": "es2020",
+        "outDir": "./dist",
         "lib": [
             "es6",
             "es7",
@@ -10,6 +11,8 @@
         "allowJs": false,
         "moduleResolution": "node",
         "forceConsistentCasingInFileNames": true,
+        "allowImportingTsExtensions": true,
+        "emitDeclarationOnly": true,
         "noImplicitReturns": true,
         "noImplicitThis": true,
         "noImplicitAny": true,
@@ -29,6 +32,8 @@
         "src/*.ts"
     ],
     "exclude": [
-        "node_modules/"
+        "node_modules/",
+        "src/**/*.test.ts",
+        "src/*.test.ts"
     ]
 }