feat: add maybe map

src/types.ts

@@ -14,3 +14,4 @@ export type { PostalAddress } from '~/stores/PostalAddressStore'
 export type { GeoCoordinates } from '~/stores/GeoCoordinatesStore'
 export type { IsString } from '~/utils/types/string'
 export type { IsNumber } from '~/utils/types/number'
+export type { Map } from '~/utils/typeclass/functor'

src/utils/adt/maybe.ts

@@ -88,3 +88,23 @@ export const match: Match = (onNothing, onJust) => (x) =>
     .with({ _tag: 'Nothing' }, onNothing)
     .with({ _tag: 'Just' }, ({ value }) => onJust(value))
     .exhaustive()
+
+/**
+ * Maybe functor to wrap/unwrap a function.
+ *
+ * @param {Function} f The mapping function that transforms the input value.
+ * @returns {Function} A new function that takes a `Maybe` container and applies
+ *   the mapping function to its value.
+ */
+export type Map = <A, B>(f: (x: A) => B) => (Fx: Maybe<A>) => Maybe<B>
+
+/**
+ * Maybe functor to wrap/unwrap a function.
+ *
+ * @todo Add support for curried functions.
+ */
+export const map: Map = (f) =>
+  match(
+    () => nothing,
+    (a) => just(f(a))
+  )

src/utils/typeclass/functor.ts

@@ -3,3 +3,5 @@
  *
  * @module functor
  */
+
+export type { Map } from '~/utils/adt/maybe'

test/unit/utils/adt/maybe.test.ts

@@ -3,7 +3,7 @@ import type { Matcher } from '~/utils/adt/maybe'
 
 import { describe, expect, expectTypeOf, test } from 'vitest'
 
-import { isJust, isNothing, just, match, nothing } from '~/utils/adt/maybe'
+import { isJust, isNothing, just, map, match, nothing } from '~/utils/adt/maybe'
 
 describe('Maybe', () => {
   describe('Given a value or the absence thereof', () => {
@@ -98,3 +98,23 @@ describe('match/2', () => {
     })
   })
 })
+
+describe('map/1', () => {
+  describe('Given a function', () => {
+    type Inc<A> = (a: A) => A
+    const inc: Inc<number> = (a) => a + 1
+
+    type MaybeAdd<A> = (a: Maybe<A>) => Maybe<A>
+    const maybeAdd: MaybeAdd<number> = map(inc)
+
+    test('When lifting it with "just"', () => {
+      const result = maybeAdd(just(1))
+      expect(result).toStrictEqual(just(2))
+    })
+
+    test('When lifting it with "nothing"', () => {
+      const result = maybeAdd(nothing)
+      expect(result).toBe(nothing)
+    })
+  })
+})