adds overload to Result.gen and Result.genCatching for passing the this-context to the callback fn

Author: everweij

package.json

@@ -1,7 +1,7 @@
 {
 	"private": false,
 	"name": "typescript-result",
-	"version": "3.3.0-beta.1",
+	"version": "3.3.0-beta.2",
 	"description": "A Result type inspired by Rust and Kotlin that leverages TypeScript's powerful type system to simplify error handling and make your code more readable and maintainable.",
 	"keywords": [
 		"result",

readme.md

@@ -1455,6 +1455,7 @@ Executes the given `fn` (async) generator function and encapsulates the returned
 This method is often used once as entry point to run a specific flow. The reason for this is that nested generator functions or calls to other functions that return results are supported.
 
 #### Parameters
+- `self` optional `this` context to bind the generator function to.
 - `fn` (async) generator function to execute.
 
 **returns** a new [`AsyncResult`](#asyncresult) or `Result` instance depending on the provided callback fn.
@@ -1470,6 +1471,22 @@ const result = Result.gen(async function* () {
 }); // AsyncResult<string, NotFoundError | InvalidOrderStatusError>;
 ```
 
+#### Example
+With 'this' context
+
+```ts
+class MyClass {
+  someValue = 12;
+  
+  someMethod() {
+    return Result.gen(this, function* () {
+      const otherValue = yield* Result.ok(8);
+      return `The sum is ${this.someValue + otherValue}`;
+    });
+  }
+}
+```
+
 ### Result.genCatching()
 
 Similar to [`Result.gen()`](#resultgen) this method transforms the given generator function into a `Result` or [`AsyncResult`](#asyncresult) depending on whether the generator function contains async operations or not.

src/result.test.ts

@@ -1097,6 +1097,23 @@ describe("Result", () => {
 			const result = await asyncResult;
 			expect(result).toEqual(Result.ok(10));
 		});
+
+		it("allows to to pass the 'this' context", () => {
+			class MyClass {
+				constructor(public someValue: number) {}
+
+				methodA() {
+					return Result.gen(this, function* () {
+						return this.someValue;
+					});
+				}
+			}
+
+			const result = new MyClass(42).methodA();
+			expectTypeOf(result).toEqualTypeOf<Result<number, never>>();
+			Result.assertOk(result);
+			expect(result.value).toBe(42);
+		});
 	});
 
 	describe("Result.genCatching", () => {
@@ -1219,6 +1236,23 @@ describe("Result", () => {
 			Result.assertError(result);
 			expect(result.error).toEqual(new Error("Boom!"));
 		});
+
+		it("allows to to pass the 'this' context", () => {
+			class MyClass {
+				constructor(public someValue: number) {}
+
+				methodA() {
+					return Result.genCatching(this, function* () {
+						return this.someValue;
+					});
+				}
+			}
+
+			const result = new MyClass(42).methodA();
+			expectTypeOf(result).toEqualTypeOf<Result<number, Error>>();
+			Result.assertOk(result);
+			expect(result.value).toBe(42);
+		});
 	});
 
 	describe("instance methods and getters", () => {

src/result.ts

@@ -1987,6 +1987,7 @@ export class Result<Value, Err> {
 	 * Executes the given {@linkcode fn} (async) generator function and encapsulates the returned value or error as a Result.
 	 * This method is often used once as entry point to run a specific flow. The reason for this is that nested generator functions or calls to other functions that return results are supported.
 	 *
+	 * @param self optional `this` context to bind the generator function to.
 	 * @param fn generator function with code to execute. Can be synchronous or asynchronous.
 	 * @returns a new {@linkcode Result} or {@linkcode AsyncResult} instance depending on the provided callback fn.
 	 *
@@ -2001,14 +2002,43 @@ export class Result<Value, Err> {
 	 * }); // AsyncResult<string, NotFoundError | InvalidOrderStatusError>;
 	 * ```
 	 *
+	 * @example
+	 * this context
+	 * ```ts
+	 * class MyClass {
+	 *   someValue = 12;
+	 *
+	 *   someMethod() {
+	 *     return Result.gen(this, function* () {
+	 *       const otherValue = yield* Result.ok(8);
+	 *       return `The sum is ${this.someValue + otherValue}`;
+	 *     });
+	 *   }
+	 * }
+	 * ```
 	 */
-	static gen<T extends Generator | AsyncGenerator>(fn: () => T) {
-		const it = fn();
-		return Result.handleGenerator(it) as IfGeneratorAsync<
-			T,
-			AsyncResult<InferGeneratorReturn<T>, InferGeneratorError<T>>,
-			Result<InferGeneratorReturn<T>, InferGeneratorError<T>>
-		>;
+	static gen<T extends Generator | AsyncGenerator>(
+		fn: () => T,
+	): IfGeneratorAsync<
+		T,
+		AsyncResult<InferGeneratorReturn<T>, InferGeneratorError<T>>,
+		Result<InferGeneratorReturn<T>, InferGeneratorError<T>>
+	>;
+	static gen<T extends Generator | AsyncGenerator, This>(
+		self: This,
+		fn: (this: This) => T,
+	): IfGeneratorAsync<
+		T,
+		AsyncResult<InferGeneratorReturn<T>, InferGeneratorError<T>>,
+		Result<InferGeneratorReturn<T>, InferGeneratorError<T>>
+	>;
+	static gen<T extends Generator | AsyncGenerator>(
+		selfOrFn: unknown,
+		fn?: () => T,
+	) {
+		const it =
+			typeof selfOrFn === "function" ? selfOrFn() : fn?.apply(selfOrFn);
+		return Result.handleGenerator(it);
 	}
 
 	/**
@@ -2026,20 +2056,44 @@ export class Result<Value, Err> {
 		T,
 		AsyncResult<InferGeneratorReturn<T>, InferGeneratorError<T> | ErrorType>,
 		Result<InferGeneratorReturn<T>, InferGeneratorError<T> | ErrorType>
-	> {
+	>;
+	static genCatching<
+		T extends Generator | AsyncGenerator,
+		This,
+		ErrorType = NativeError,
+	>(
+		self: This,
+		fn: (this: This) => T,
+		transformError?: (error: unknown) => ErrorType,
+	): IfGeneratorAsync<
+		T,
+		AsyncResult<InferGeneratorReturn<T>, InferGeneratorError<T> | ErrorType>,
+		Result<InferGeneratorReturn<T>, InferGeneratorError<T> | ErrorType>
+	>;
+	static genCatching(
+		selfOrFn: unknown,
+		transformValueOrError?: Function,
+		transformError?: Function,
+	) {
+		const self = typeof selfOrFn === "function" ? undefined : selfOrFn;
+		const tValue =
+			typeof selfOrFn === "function" ? selfOrFn : transformValueOrError!;
+		const tError =
+			typeof selfOrFn === "function" ? transformValueOrError : transformError;
+
 		try {
-			const it = fn();
+			const it = self ? tValue.apply(selfOrFn) : tValue();
 			const result = Result.handleGenerator(it);
 
 			if (Result.isAsyncResult(result)) {
 				return result.catch((error) =>
-					AsyncResult.error(transformError?.(error) ?? error),
+					AsyncResult.error(tError?.(error) ?? error),
 				) as any;
 			}
 
 			return result as any;
 		} catch (error: unknown) {
-			return Result.error(transformError?.(error) ?? error) as any;
+			return Result.error(tError?.(error) ?? error) as any;
 		}
 	}