Merge pull request #8 from web-pacotes/7-feat-foldright-foldleft

feat(monad): implement leftMap and leftRight

src/error/call.test.ts

@@ -5,14 +5,14 @@ import {
 	safeAsyncThrowCall,
 	safeThrowCall
 } from './call';
-import { fold, isRight, Right } from '../monad';
+import { Either, fold, isRight, Right } from '../monad';
 import { isTypedError, TypedError } from './typed';
 import { UnknownError } from './unknown';
 
 describe('call', () => {
 	describe('safeThrowCall', () => {
 		test('returns callback result if no error is thrown', () => {
-			const callback = () => Right(2 + 2);
+			const callback = () => Right(2 + 2) satisfies Either<TypedError, number>;
 
 			const result = safeThrowCall(callback);
 			const isRightHanded = isRight(result);
@@ -58,7 +58,8 @@ describe('call', () => {
 
 	describe('safeAsyncThrowCall', () => {
 		test('returns callback result if no error is thrown', async () => {
-			const callback = async () => Right(2 + 2);
+			const callback = async () =>
+				Right(2 + 2) satisfies Either<TypedError, unknown>;
 
 			const result = await safeAsyncThrowCall(callback);
 			const isRightHanded = isRight(result);

src/monad/either.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, test } from '@jest/globals';
-import { fold, isLeft, isRight, Left, Right } from './either';
+import {
+	Either,
+	fold,
+	isLeft,
+	isRight,
+	Left,
+	leftMap,
+	Right,
+	rightMap
+} from './either';
 
 describe('either', () => {
 	describe('isLeft', () => {
@@ -65,4 +74,44 @@ describe('either', () => {
 			expect(result).toBe(value - 1);
 		});
 	});
+
+	describe('leftMap', () => {
+		test('computes left callback if monad is left-handed', () => {
+			const value = 0;
+			const monad = Left(value);
+
+			const result = leftMap(monad, (l) => l + 1);
+
+			expect(result).toStrictEqual(Left(value + 1));
+		});
+
+		test('does not compute left callback if monad is right-handed', () => {
+			const value = 0;
+			const monad = Right(value) satisfies Either<number, number>;
+
+			const result = leftMap(monad, (l) => l + 1);
+
+			expect(result).toStrictEqual(Right(value));
+		});
+	});
+
+	describe('rightMap', () => {
+		test('computes right callback if monad is right-handed', () => {
+			const value = 0;
+			const monad = Right(value);
+
+			const result = rightMap(monad, (r) => r + 1);
+
+			expect(result).toStrictEqual(Right(value + 1));
+		});
+
+		test('does not compute right callback if monad is left-handed', () => {
+			const value = 0;
+			const monad = Left(value) satisfies Either<number, number>;
+
+			const result = rightMap(monad, (l) => l + 1);
+
+			expect(result).toStrictEqual(Left(value));
+		});
+	});
 });

src/monad/either.ts

@@ -24,7 +24,7 @@ export type Either<L, R> = Left<L> | Right<R>;
  *
  * @param value - the value that represents the left hand
  */
-export const Left = <L, R>(value: L) => {
+export const Left = <L, R>(value: L): Either<L, R> => {
 	return {
 		tag: 'left',
 		left: value
@@ -36,7 +36,7 @@ export const Left = <L, R>(value: L) => {
  *
  * @param value - the value that represents the right hand
  */
-export const Right = <L, R>(value: R) => {
+export const Right = <L, R>(value: R): Either<L, R> => {
 	return {
 		tag: 'right',
 		right: value
@@ -79,3 +79,26 @@ export const fold = <L, R, F>(
 			return right(value.right);
 	}
 };
+
+/**
+ * Transforms an [Either] monad by mapping the left hand to a new value, if left-handed.
+ *
+ * @param value - the monad value to fold
+ * @param left - callback for mapping the left-hand
+ * @returns - an [Either] monad in which the left callback is applied to the left hand.
+ */
+export const leftMap = <L1, L2, R>(value: Either<L1, R>, left: (l: L1) => L2) =>
+	(isLeft(value) ? Left(left(value.left)) : value) satisfies Either<L2, R>;
+
+/**
+ * Transforms an [Either] monad by mapping the right hand to a new value, if right-handed.
+ *
+ * @param value - the monad value to fold
+ * @param left - callback for mapping the right-hand
+ * @returns - an [Either] monad in which the right callback is applied to the right hand.
+ */
+export const rightMap = <L, R1, R2>(
+	value: Either<L, R1>,
+	right: (r: R1) => R2
+) =>
+	(isRight(value) ? Right(right(value.right)) : value) satisfies Either<L, R2>;