Added bimap to maybe

src/either/either.test.ts

@@ -141,7 +141,7 @@ describe('Either', () => {
 			it('maps right type', () => {
 				const expected = 'right'
 
-				const actual = adt.bimap(() => 'left', () => 'right')
+				const actual = adt.bimap(() => 'left', () => expected)
 
 				expect(actual).toBeRight(expected)
 			})

src/jest-matchers.ts

@@ -49,7 +49,7 @@ const getReportHeader = (fnName: string, pass: boolean) => `${matcherHint(
 
 const getExpectedMessage = (values: TestValues) => printExpected(`${values.side}(${values.expected.fold()})`)
 
-const getReceivedMessage = (values: TestValues) => `Received: ${printReceived(values.received)}`
+const getReceivedMessage = (values: TestValues) => `Received: ${printReceived(values.received.fold())}`
 
 const getExpectedValueMessage = (pass: boolean, values: TestValues) =>
 	`Expected value${pass ? ' not ' : ' '}to be: ${getExpectedMessage(values)}`

src/maybe/maybe.test.ts

@@ -176,6 +176,16 @@ describe('Maybe', () => {
 				expect(actual).toBeRight(value)
 			})
 		})
+
+		describe('bimap', () => {
+			it('maps just type', () => {
+				const expected = 'just'
+
+				const actual = adt.bimap(() => 'none', () => expected)
+
+				expect(actual).toBeJust(expected)
+			})
+		})
 	})
 
 	describe('none', () => {
@@ -309,6 +319,16 @@ describe('Maybe', () => {
 				expect(actual).toBeLeft(expected)
 			})
 		})
+
+		describe('bimap', () => {
+			it('maps none type', () => {
+				const expected = 'none'
+
+				const actual = adt.bimap(() => expected, () => 'just')
+
+				expect(actual).toBeJust(expected)
+			})
+		})
 	})
 
 	describe('maybe', () => {

src/maybe/maybe.ts

@@ -22,6 +22,7 @@ export const just = <A>(value: NonNullable<ValueOrMaybe<A>>): Maybe<A> =>
 			flatMap: (ifJust) => maybe(ifJust(data)),
 			mapIf: (predicate, ifTrue) => (predicate(data) ? maybe(ifTrue(data)) : maybe(data)),
 			orElse: () => maybe(data),
+			bimap: (_, ifJust) => maybe(ifJust(data)),
 			toEither: () => right(data),
 		})
 	)
@@ -45,6 +46,7 @@ export const none = once(
 				mapIf: <B>() => none<B>(),
 				orElse: (ifNone) => maybe(ifNone()),
 				fold: <B>(ifNone?: () => B) => (ifNone ? ifNone() : NONE_VALUE),
+				bimap: (ifNone) => maybe(ifNone()),
 				toEither: (ifNone) => left(ifNone())
 			})
 		)

src/maybe/maybe.types.ts

@@ -1,20 +1,27 @@
-import { Serializer } from "../utils/serializer";
-import { Either, LeftValueOrEither } from "../either/either.types";
+import { Serializer } from '../utils/serializer'
+import { Either, LeftValueOrEither } from '../either/either.types'
 
 export type AnyMaybe = Maybe<any>
 
 export type ValueOrMaybe<A> = A | Maybe<A> | undefined | null
 
 interface MaybeProto<A> extends Serializer {
 	equals(value: AnyMaybe): boolean
+
 	flatMap<B>(ifJust: (just: A) => ValueOrMaybe<B>): Maybe<B>
+
 	mapIf(predicate: (just: A) => boolean, ifTrue: (just: A) => ValueOrMaybe<A>): Maybe<A>
+
 	orElse(ifNone: () => ValueOrMaybe<A>): Maybe<A>
+
+	bimap<B>(ifNone: () => ValueOrMaybe<B>, ifJust: (just: A) => ValueOrMaybe<B>): Maybe<B>
+
 	toEither<E>(ifNone: () => LeftValueOrEither<E>): Either<E, A>
 }
 
 interface Fold<A, T> {
 	fold(): T
+
 	fold<B>(ifNone: () => B, ifJust: (just: A) => B): B
 }