refactor: get rid of curry

src/types.ts

@@ -1,6 +1,5 @@
 export type { Result, Failure, Success } from '~/utils/adt/result'
 export type { Just, Maybe, Nothing } from '~/utils/adt/maybe'
-export type { Curry } from '~/utils/composition/curry'
 export type { Compose } from '~/utils/composition/compose'
 export type { Reduce } from '~/utils/typeclass/foldable'
 export type { Pipe } from '~/utils/composition/pipe'

src/utils/composition/compose.ts

@@ -4,14 +4,14 @@
  * @module compose
  */
 
-import { curry } from '~/utils/composition/curry'
-import { reduce } from '~/utils/typeclass/foldable'
+/** To pattern match values. */
+import { match } from '~/utils/control-flow/match'
 
-/** @typeParam T */
-type Fn<T> = (a: T) => T
+/** Function that takes a value of type A and returns a value of type A. */
+type Fn<A> = (a: A) => A
 
-/** @template T */
-export type Fx<T> = ReadonlyArray<Fn<T>>
+/** An array of functions {@link Fn}. */
+export type Fx<A> = ReadonlyArray<Fn<A>>
 
 /**
  * @template T
@@ -33,7 +33,10 @@ export type Compose = <T>(a: Fx<T>) => (b: T) => T
  *   types do not match/. That needs to be fixed.
  */
 export const compose: Compose = <T>(fx: Fx<T>): ((x: T) => T) => {
-  const fn = (g: T, f: Fn<T>) => f(g)
-  const reducer = curry(reduce)(fn)
-  return (x: T) => reducer(x)(fx)
+  return match(fx.length)
+    .with(0, () => (x: T) => x)
+    .otherwise(() => {
+      const [head, ...tail] = fx
+      return (x: T) => compose(tail)(head(x))
+    })
 }