src/lib/util/basic/either.ts

@@ -14,55 +14,15 @@ export const right = <A>(a: A): Either<A, never> => ({
 
 // Operations
 export const eitherMap =
-  <A, B, E>(f: (a: A) => B) => (fa: Either<A, E>): Either<B, E> =>
+  <E, A, B>(f: (a: A) => B) => (fa: Either<A, E>): Either<B, E> =>
     fa._tag === 'Right' ? right(f(fa.right)) : fa
 
 export const eitherChain =
-  <A, B, E>(f: (a: A) => Either<B, E>) => (fa: Either<A, E>): Either<B, E> =>
+  <E, A, B>(f: (a: A) => Either<B, E>) =>
+  (fa: Either<A, E>): Either<B, E> =>
     fa._tag === 'Right' ? f(fa.right) : fa
 
 export const fold =
   <A, B, E>(onLeft: (e: E) => B, onRight: (a: A) => B) =>
   (fa: Either<A, E>): B =>
     fa._tag === 'Left' ? onLeft(fa.left) : onRight(fa.right)
-
-// Do notation
-export class DoEither<T extends Record<string, unknown>, E> {
-  constructor(private readonly either: Either<T, E>) {}
-
-  bind<K extends string, A>(
-    key: K,
-    fa: Either<A, E>,
-  ): DoEither<T & Record<K, A>, E> {
-    const newEither = eitherChain<T, T & Record<K, A>, E>((scope: T) =>
-      eitherMap<A, T & Record<K, A>, E>((a: A) => ({...scope, [key]: a}))(fa)
-    )(this.either)
-    return new DoEither(newEither)
-  }
-
-  return<B>(f: (scope: T) => B): Either<B, E> {
-    return eitherMap<T, B, E>(f)(this.either)
-  }
-
-  done(): Either<T, E> {
-    return this.either
-  }
-
-  do(fa: Either<unknown, E>): DoEither<T, E> {
-    const newEither = eitherChain<T, T, E>((scope: T) =>
-      eitherMap<unknown, T, E>(() => scope)(fa)
-    )(this.either)
-    return new DoEither(newEither)
-  }
-
-  doL(f: (scope: T) => Either<unknown, E>): DoEither<T, E> {
-    const newEither = eitherChain<T, T, E>((scope: T) =>
-      eitherMap<unknown, T, E>(() => scope)(f(scope))
-    )(this.either)
-    return new DoEither(newEither)
-  }
-
-  static start<E>(): DoEither<{}, E> {
-    return new DoEither(right({}))
-  }
-}

src/lib/util/basic/option.ts

@@ -10,8 +10,9 @@ export const some = <A>(value: A): Option<A> => ({
 })
 
 // Operations
-export const map = <A, B>(f: (a: A) => B) => (fa: Option<A>): Option<B> =>
+export const map =
-  fa._tag === 'Some' ? some(f(fa.value)) : none
+  <A, B>(f: (a: A) => B) => (fa: Option<A>): Option<B> =>
+    fa._tag === 'Some' ? some(f(fa.value)) : none
 
 export const chain =
   <A, B>(f: (a: A) => Option<B>) => (fa: Option<A>): Option<B> =>
@@ -19,37 +20,3 @@ export const chain =
 
 export const getOrElse = <A>(defaultValue: A) => (fa: Option<A>): A =>
   fa._tag === 'Some' ? fa.value : defaultValue
-
-export class DoOption<T extends Record<string, unknown>> {
-  constructor(private readonly option: Option<T>) {}
-
-  bind<K extends string, A>(key: K, fa: Option<A>): DoOption<T & Record<K, A>> {
-    const newOption = chain((scope: T) =>
-      map((a: A) => ({...scope, [key]: a}))(fa)
-    )(this.option)
-    return new DoOption(newOption as Option<T & Record<K, A>>)
-  }
-
-  return<B>(f: (scope: T) => B): Option<B> {
-    return map(f)(this.option)
-  }
-
-  done(): Option<T> {
-    return this.option
-  }
-  do(fa: Option<unknown>): DoOption<T> {
-    const newOption = chain((scope: T) => map(() => scope)(fa))(this.option)
-    return new DoOption(newOption)
-  }
-
-  doL(f: (scope: T) => Option<unknown>): DoOption<T> {
-    const newOption = chain((scope: T) => map(() => scope)(f(scope)))(
-      this.option,
-    )
-    return new DoOption(newOption)
-  }
-
-  static start(): DoOption<{}> {
-    return new DoOption(some({}))
-  }
-}

src/lib/util/basic/utility.ts

@@ -2,11 +2,14 @@ import { type Either, left, right } from './either'
 import { none, type Option, some } from './option'
 
 // Pipe function for composition
-export const pipe = <A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C =>
+export const pipe = <A, B, C>(
-  bc(ab(a))
+  a: A,
+  ab: (a: A) => B,
+  bc: (b: B) => C,
+): C => bc(ab(a))
 
 // TryCatch helper using Either
-export const tryCatch = <A>(f: () => A): Either<A, Error> => {
+export const tryCatch = <A>(f: () => A): Either<Error, A> => {
   try {
     return right(f())
   } catch (e) {