rsult 1.0.2 → 1.2.0

package/deno.json

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

package/package.json

@@ -1,19 +1,19 @@
 {
-  "name": "rsult",
-  "version": "1.0.2",
-  "description": "",
-  "main": "src/lib.ts",
-  "repository": "https://github.com/indicium-ag/rsult",
-  "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"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  }
+    "name": "rsult",
+    "version": "1.2.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.ts';
-export * from './option.ts';
+export * from './result';
+export * from './option';

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));

package/src/result.ts

@@ -1,4 +1,4 @@
-import { Option, None, Some } from './option.ts';
+import { Option, None, Some } from './option';
 
 export type Result<T, E> =
     ResultOk<T, E> | ResultErr<T, E>;
@@ -121,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> {
@@ -324,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.
@@ -472,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;
@@ -493,6 +500,10 @@ 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> {
@@ -602,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 {
@@ -617,6 +624,10 @@ export class ResultErr<T, E> implements IResult<T, E> {
     into_err(): E {
         return this.value;
     }
+
+    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>;

package/tsconfig.json

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