@typed/fx 1.5.9 → 1.6.2

package/src/subject/RefSubject.ts

@@ -1,336 +0,0 @@
-import { equals } from '@effect/data/Equal'
-import { identity, pipe, dual, flow } from '@effect/data/Function'
-import * as Option from '@effect/data/Option'
-import * as ReadonlyArray from '@effect/data/ReadonlyArray'
-import * as ReadonlyRecord from '@effect/data/ReadonlyRecord'
-import * as Equivalence from '@effect/data/typeclass/Equivalence'
-import type * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import type * as Exit from '@effect/io/Exit'
-import * as Ref from '@effect/io/Ref'
-import type * as Scope from '@effect/io/Scope'
-
-import { Fx, Sink } from '../Fx.js'
-import { Mutable } from '../_internal/Mutable.js'
-import { flatMapEffect } from '../operator/flatMapEffect.js'
-import { skipWhile } from '../operator/skipWhile.js'
-import { observe } from '../run/observe.js'
-
-import { HoldSubject, isHoldSubject } from './HoldSubject.js'
-import { Subject } from './Subject.js'
-
-export interface RefSubject<A> extends HoldSubject<never, A>, Ref.Ref<A> {
-  readonly eq: Equivalence.Equivalence<A>
-  readonly get: Effect.Effect<never, never, A>
-  readonly set: (a: A) => Effect.Effect<never, never, A>
-  readonly update: (f: (a: A) => A) => Effect.Effect<never, never, A>
-  readonly delete: Effect.Effect<never, Cause.NoSuchElementException, A>
-  readonly compute: <R, E, B>(
-    f: (a: A) => Effect.Effect<R, E, B>,
-  ) => Effect.Effect<R | Scope.Scope, never, Computed<E, B>>
-  readonly computeSync: <B>(f: (a: A) => B) => Effect.Effect<Scope.Scope, never, Computed<never, B>>
-}
-
-export function makeRef<A>(
-  initial: () => A,
-  eq: Equivalence.Equivalence<A> = equals,
-): Effect.Effect<never, never, RefSubject<A>> {
-  return Effect.sync(() => RefSubject.unsafeMake(initial, eq))
-}
-
-export namespace RefSubject {
-  export type ValueOf<T> = T extends RefSubject<infer A> ? A : never
-
-  export function unsafeMake<A>(
-    initial: () => A,
-    eq: Equivalence.Equivalence<A> = equals,
-    current: Mutable<Option.Option<A>> = Mutable(Option.some(initial())),
-  ): RefSubject<A> {
-    const subject = HoldSubject.unsafeMake<never, A>(current)
-
-    const getValue = () =>
-      pipe(
-        current.get(),
-        Option.getOrElse(() => {
-          const a = initial()
-          current.set(Option.some(a))
-          return a
-        }),
-      )
-
-    const modify = <B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> =>
-      Effect.suspend(() => {
-        const currentValue = getValue()
-        const [b, a] = f(currentValue)
-
-        current.set(Option.some(a))
-
-        if (eq(currentValue, a)) {
-          return Effect.succeed(b)
-        }
-
-        return pipe(subject.event(a), Effect.as(b))
-      })
-
-    const refSubject: RefSubject<A> = {
-      [Fx.TypeId]: subject[Fx.TypeId],
-      [Subject.TypeId]: subject[Subject.TypeId],
-      [HoldSubject.TypeId]: subject[HoldSubject.TypeId],
-      [Ref.RefTypeId]: {
-        _A: identity,
-      },
-      run: subject.run.bind(subject),
-      event: subject.event.bind(subject),
-      error: subject.error.bind(subject),
-      end: subject.end,
-      value: subject.value,
-      current: subject.current,
-      eq,
-      modify,
-      ...makeDerivations(modify, Effect.sync(getValue)),
-      delete: Effect.suspend(() => {
-        const option = current.get()
-
-        current.set(Option.none())
-
-        return option
-      }),
-      compute: (f) => makeComputed(refSubject, f),
-      computeSync: (f) => makeComputed(refSubject, (a) => Effect.sync(() => f(a))),
-    }
-
-    return refSubject
-  }
-
-  export function tuple<Subjects extends ReadonlyArray.NonEmptyReadonlyArray<RefSubject<any>>>(
-    ...subjects: Subjects
-  ): Effect.Effect<
-    Scope.Scope,
-    never,
-    RefSubject<{ readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }>
-  > {
-    type Val = { readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }
-    const length = subjects.length
-
-    const getUnderlyingValues = Effect.all(
-      ...ReadonlyArray.mapNonEmpty(subjects, (s) => s.get),
-    ) as Effect.Effect<never, never, Val>
-
-    const eq = Equivalence.tuple(
-      ...ReadonlyArray.mapNonEmpty(subjects, (s) => s.eq),
-    ) as Equivalence.Equivalence<Val>
-
-    return Effect.gen(function* ($) {
-      const initial = yield* $(getUnderlyingValues)
-      const refSubject = unsafeMake(() => initial, eq)
-
-      const updateAtIndex =
-        <I extends keyof Val & number>(i: I) =>
-        (a: Val[I]) =>
-          Effect.gen(function* ($) {
-            const current = yield* $(refSubject.get)
-            const next = current.slice()
-            next[i] = a
-
-            yield* $(refSubject.set(next as Val))
-          })
-
-      // Override event to replicate events into underlying subjects
-      const event = (val: Val) =>
-        Effect.all(...ReadonlyArray.mapNonEmpty(subjects, (s, i) => s.event(val[i])))
-
-      // Override modify to replicate events into underlying subjects
-      const modify = <B>(f: (a: Val) => readonly [B, Val]): Effect.Effect<never, never, B> =>
-        Effect.gen(function* ($) {
-          const current = yield* $(getUnderlyingValues)
-          const [b, a] = f(current)
-
-          if (!eq(current, a)) {
-            // Will update this RefSubject using observe below
-            yield* $(event(a))
-          }
-
-          return b
-        })
-
-      // Listen to changes to each subject and update the derived subject
-      for (let i = 0; i < length; i++) {
-        yield* $(Effect.forkScoped(observe(updateAtIndex(i))(subjects[i])))
-      }
-
-      // Allow underlying subscriptions to start
-      yield* $(Effect.yieldNow())
-
-      const derived: RefSubject<Val> = {
-        ...refSubject,
-        event,
-        modify,
-        ...makeDerivations(modify, refSubject.get),
-        compute: (f) => makeComputed(derived, f),
-      }
-
-      return derived
-    })
-  }
-
-  export function struct<Subjects extends Readonly<Record<string, RefSubject<any>>>>(
-    subjects: Subjects,
-  ): Effect.Effect<
-    Scope.Scope,
-    never,
-    RefSubject<{ readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }>
-  > {
-    type Val = { readonly [K in keyof Subjects]: ValueOf<Subjects[K]> }
-
-    const getUnderlyingValues = Effect.all(
-      ReadonlyRecord.map(subjects, (s) => s.get),
-    ) as Effect.Effect<never, never, Val>
-
-    const eq = Equivalence.struct(
-      ReadonlyRecord.map(subjects, (s) => s.eq),
-    ) as Equivalence.Equivalence<Val>
-
-    return Effect.gen(function* ($) {
-      const initial = yield* $(getUnderlyingValues)
-      const refSubject = unsafeMake(() => initial, eq)
-
-      const updateAtKey =
-        <I extends keyof Val & string>(i: I) =>
-        (a: Val[I]) =>
-          Effect.gen(function* ($) {
-            const current = yield* $(refSubject.get)
-            const next = { ...current, [i]: a }
-
-            yield* $(refSubject.set(next as Val))
-          })
-
-      // Override event to replicate events into underlying subjects
-      const event = (val: Val) =>
-        Effect.all(ReadonlyRecord.map(subjects, (s, i) => s.event(val[i])))
-
-      // Override modify to replicate events into underlying subjects
-      const modify = <B>(f: (a: Val) => readonly [B, Val]): Effect.Effect<never, never, B> =>
-        Effect.gen(function* ($) {
-          const current = yield* $(getUnderlyingValues)
-          const [b, a] = f(current)
-
-          if (!eq(current, a)) {
-            // Will update this RefSubject using observe below
-            yield* $(event(a))
-          }
-
-          return b
-        })
-
-      // Listen to changes to each subject and update the derived subject
-      for (const i in subjects) {
-        yield* $(Effect.forkScoped(observe(updateAtKey(i))(subjects[i])))
-      }
-
-      // Allow underlying subscriptions to start
-      yield* $(Effect.yieldNow())
-
-      const derived: RefSubject<Val> = {
-        ...refSubject,
-        event,
-        modify,
-        ...makeDerivations(modify, refSubject.get),
-        compute: (f) => makeComputed(derived, f),
-      }
-
-      return derived
-    })
-  }
-
-  const makeDerivations = <A>(
-    modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<never, never, B>,
-    getValue: Effect.Effect<never, never, A>,
-  ) => {
-    return {
-      get: getValue,
-      set(a: A) {
-        return modify(() => [a, a])
-      },
-      update(f: (a: A) => A) {
-        return modify((a) => {
-          const a2 = f(a)
-          return [a2, a2]
-        })
-      },
-    }
-  }
-}
-
-export function isRefSubject<A>(u: unknown): u is RefSubject<A> {
-  return isHoldSubject(u) && Ref.RefTypeId in u
-}
-
-export interface Computed<E, A> extends Fx<never, E, A> {
-  readonly get: Effect.Effect<never, E, A>
-
-  readonly compute: <R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, B>,
-  ) => Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>>
-
-  readonly computeSync: <B>(f: (a: A) => B) => Effect.Effect<Scope.Scope, never, Computed<E, B>>
-}
-
-export namespace Computed {
-  export function make<A, R, E, B>(
-    input: RefSubject<A>,
-    compute: (a: A) => Effect.Effect<R, E, B>,
-  ): Effect.Effect<R | Scope.Scope, never, Computed<E, B>> {
-    return Effect.gen(function* ($) {
-      const compute_ = flow(compute, Effect.exit)
-      const initialInput = yield* $(input.get)
-      const initial = yield* $(compute_(initialInput))
-      const refSubject = yield* $(makeRef(() => initial))
-
-      yield* $(
-        pipe(
-          input,
-          skipWhile((x) => input.eq(x, initialInput)), // We already have the initial value, don't waste downstream resources
-          observe((a) => Effect.flatMap(compute_(a), refSubject.set)),
-          Effect.forkScoped,
-        ),
-      )
-
-      // Allow subscription to finalize as HoldFx under the hood of RefSubject schedules the start of the Fx.
-      yield* $(Effect.yieldNow())
-
-      return new ComputedImpl(refSubject)
-    })
-  }
-
-  class ComputedImpl<E, A> extends Fx.Variance<never, E, A> implements Computed<E, A> {
-    constructor(readonly input: RefSubject<Exit.Exit<E, A>>) {
-      super()
-    }
-
-    run<R3>(sink: Sink<R3, E, A>) {
-      return pipe(this.input, flatMapEffect(Effect.done)).run(sink)
-    }
-
-    readonly get = Effect.flatMap(this.input.get, Effect.done)
-
-    readonly compute = <R2, E2, B>(
-      f: (a: A) => Effect.Effect<R2, E2, B>,
-    ): Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>> =>
-      Effect.tap(this.input.compute(Effect.flatMap(f)), Effect.yieldNow)
-
-    readonly computeSync = <B>(f: (a: A) => B): Effect.Effect<Scope.Scope, never, Computed<E, B>> =>
-      Effect.tap(this.input.compute(Effect.map(f)), Effect.yieldNow)
-  }
-}
-
-export const makeComputed: {
-  <A, R, E, B>(input: RefSubject<A>, compute: (a: A) => Effect.Effect<R, E, B>): Effect.Effect<
-    R | Scope.Scope,
-    never,
-    Computed<E, B>
-  >
-
-  <A, R, E, B>(compute: (a: A) => Effect.Effect<R, E, B>): (
-    input: RefSubject<A>,
-  ) => Effect.Effect<R | Scope.Scope, never, Computed<E, B>>
-} = dual(2, Computed.make)

package/src/subject/Subject.test.ts

@@ -1,37 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import { describe, it } from 'vitest'
-
-import { collectAll } from '../run/collectAll.js'
-
-import { Subject } from './Subject.js'
-
-describe(import.meta.url, () => {
-  describe('Subject', () => {
-    it('allows broadcastig values directly to observers', async () => {
-      const test = Effect.gen(function* ($) {
-        const subject = Subject.unsafeMake<never, number>()
-
-        const fiber1 = yield* $(Effect.fork(collectAll(subject)))
-        const fiber2 = yield* $(Effect.fork(collectAll(subject)))
-
-        yield* $(Effect.yieldNow())
-
-        yield* $(subject.event(1))
-        yield* $(subject.event(2))
-        yield* $(subject.event(3))
-        yield* $(subject.end)
-
-        const events1 = yield* $(Fiber.join(fiber1))
-        const events2 = yield* $(Fiber.join(fiber2))
-
-        deepStrictEqual(events1, [1, 2, 3])
-        deepStrictEqual(events1, events2)
-      })
-
-      await Effect.runPromise(test)
-    })
-  })
-})

package/src/subject/Subject.ts

@@ -1,47 +0,0 @@
-import { identity } from '@effect/data/Function'
-
-import { Fx, isFx, Sink } from '../Fx.js'
-import { never } from '../constructor/never.js'
-import { MulticastFx } from '../operator/multicast.js'
-
-export interface Subject<E, A> extends Fx<never, E, A>, Sink<never, E, A>, Subject.Variance<E, A> {}
-
-export namespace Subject {
-  export const TypeId = Symbol.for('@typed/fx/Subject')
-  export type TypeId = typeof TypeId
-
-  export abstract class Variance<E, A> extends Fx.Variance<never, E, A> {
-    readonly [TypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
-    } = {
-      _E: identity,
-      _A: identity,
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  export type ErrorsOf<T> = [T] extends [Variance<infer E, infer _A>] ? E : never
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  export type OutputsOf<T> = [T] extends [Variance<infer _E, infer A>] ? A : never
-
-  export function unsafeMake<E, A>(): Subject<E, A> {
-    return new SubjectImpl()
-  }
-
-  class SubjectImpl<E, A> extends MulticastFx<never, E, A> implements Subject<E, A> {
-    readonly [TypeId]: Subject.Variance<E, A>[TypeId] = {
-      _E: identity,
-      _A: identity,
-    }
-
-    constructor() {
-      super(never)
-    }
-  }
-}
-
-export function isSubject<E, A>(u: unknown): u is Subject<E, A> {
-  return isFx(u) && Subject.TypeId in u
-}

package/src/subject/SynchronizedSubject.ts

@@ -1,118 +0,0 @@
-import { equals } from '@effect/data/Equal'
-import { identity, pipe } from '@effect/data/Function'
-import * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-import * as Ref from '@effect/io/Ref'
-import * as Synchronized from '@effect/io/Ref/Synchronized'
-
-import { Fx } from '../Fx.js'
-import { Mutable } from '../_internal/Mutable.js'
-
-import { HoldSubject } from './HoldSubject.js'
-import { Computed, isRefSubject, RefSubject } from './RefSubject.js'
-import { Subject } from './Subject.js'
-
-export interface SynchronizedSubject<A> extends RefSubject<A>, Synchronized.Synchronized<A> {
-  readonly updateEffect: <R2, E2>(f: (a: A) => Effect.Effect<R2, E2, A>) => Effect.Effect<R2, E2, A>
-}
-
-export function makeSynchronized<A>(
-  initial: () => A,
-  eq: (a: A, b: A) => boolean = equals,
-): Effect.Effect<never, never, SynchronizedSubject<A>> {
-  return Effect.sync(() => SynchronizedSubject.unsafeMake(initial, eq))
-}
-
-export namespace SynchronizedSubject {
-  export function unsafeMake<A>(
-    initial: () => A,
-    eq: (a: A, b: A) => boolean = equals,
-  ): SynchronizedSubject<A> {
-    const current = Mutable(Option.some(initial()))
-    const subject = HoldSubject.unsafeMake<never, A>(current)
-    const locked = Effect.unsafeMakeSemaphore(1).withPermits(1)
-
-    const getValue = () =>
-      pipe(
-        current.get(),
-        Option.getOrElse(() => {
-          const a = initial()
-
-          current.set(Option.some(a))
-
-          return a
-        }),
-      )
-
-    const modifyEffect = <B, R2, E2>(
-      f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>,
-    ): Effect.Effect<R2, E2, B> =>
-      locked(
-        Effect.gen(function* ($) {
-          const next = getValue()
-          const [b, a] = yield* $(f(next))
-
-          if (eq(next, a)) {
-            return b
-          }
-
-          current.set(Option.some(a))
-
-          yield* $(subject.event(a))
-
-          return b
-        }),
-      )
-
-    const modify = <B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> =>
-      modifyEffect((a) => Effect.sync(() => f(a)))
-
-    const synchronizedSubject: SynchronizedSubject<A> = {
-      [Fx.TypeId]: subject[Fx.TypeId],
-      [Subject.TypeId]: subject[Subject.TypeId],
-      [HoldSubject.TypeId]: subject[HoldSubject.TypeId],
-      [Ref.RefTypeId]: {
-        _A: identity,
-      },
-      [Synchronized.SynchronizedTypeId]: {
-        _A: identity,
-      },
-      run: subject.run.bind(subject),
-      event: subject.event.bind(subject),
-      error: subject.error.bind(subject),
-      end: subject.end,
-      value: subject.value,
-      current,
-      eq,
-      modify,
-      modifyEffect,
-      get get() {
-        return Synchronized.get(synchronizedSubject)
-      },
-      set(a: A) {
-        return Ref.updateAndGet(() => a)(synchronizedSubject)
-      },
-      update(f: (a: A) => A) {
-        return Ref.updateAndGet(f)(synchronizedSubject)
-      },
-      updateEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, A>) {
-        return Synchronized.updateAndGetEffect(f)(synchronizedSubject)
-      },
-      delete: Effect.sync(() => {
-        const value = getValue()
-
-        current.set(Option.some(value))
-
-        return value
-      }),
-      compute: (f) => Computed.make(synchronizedSubject, f),
-      computeSync: (f) => Computed.make(synchronizedSubject, (a) => Effect.sync(() => f(a))),
-    }
-
-    return synchronizedSubject
-  }
-}
-
-export function isSynchronizedSubject<A>(u: unknown): u is SynchronizedSubject<A> {
-  return isRefSubject(u) && Synchronized.SynchronizedTypeId in u
-}

package/src/subject/index.ts

@@ -1,4 +0,0 @@
-export * from './HoldSubject.js'
-export * from './RefSubject.js'
-export * from './Subject.js'
-export * from './SynchronizedSubject.js'

package/src/typeclass/Alternative.ts

@@ -1,15 +0,0 @@
-import type * as A from '@effect/data/typeclass/Alternative'
-
-import { CoproductRace, CoproductOrElse } from './Coproduct.js'
-import { SemiAlternativeRace, SemiAlternativeOrElse } from './SemiAlternative.js'
-import type { FxTypeLambda } from './TypeLambda.js'
-
-export const ApplicativeRace: A.Alternative<FxTypeLambda> = {
-  ...SemiAlternativeRace,
-  ...CoproductRace,
-}
-
-export const ApplicativeOrElse: A.Alternative<FxTypeLambda> = {
-  ...SemiAlternativeOrElse,
-  ...CoproductOrElse,
-}

package/src/typeclass/Applicative.ts

@@ -1,15 +0,0 @@
-import type * as A from '@effect/data/typeclass/Applicative'
-
-import type { Fx } from '../Fx.js'
-import { combineAll } from '../operator/combine.js'
-
-import { Of } from './Of.js'
-import { SemiApplicative } from './SemiApplicative.js'
-import type { FxTypeLambda } from './TypeLambda.js'
-
-export const Applicative: A.Applicative<FxTypeLambda> = {
-  ...SemiApplicative,
-  ...Of,
-  productAll: (<R, E, A>(collection: Iterable<Fx<R, E, A>>) =>
-    combineAll<readonly Fx<R, E, A>[]>(...collection)) as A.Applicative<FxTypeLambda>['productAll'],
-}

package/src/typeclass/Bicovariant.ts

@@ -1,21 +0,0 @@
-import { dual, pipe } from '@effect/data/Function'
-import * as B from '@effect/data/typeclass/Bicovariant'
-
-import type { Fx } from '../Fx.js'
-import { map } from '../operator/map.js'
-import { mapError } from '../operator/mapError.js'
-
-import type { FxTypeLambda } from './TypeLambda.js'
-
-export const bimap: B.Bicovariant<FxTypeLambda>['bimap'] = dual(
-  3,
-  <R, E, A, E2, B>(self: Fx<R, E, A>, f: (e: E) => E2, g: (a: A) => B) =>
-    pipe(self, mapError(f), map(g)),
-)
-
-export const Bicovariant: B.Bicovariant<FxTypeLambda> = {
-  bimap,
-}
-
-export const mapLeft: <E1, E2>(f: (e: E1) => E2) => <R, A>(self: Fx<R, E1, A>) => Fx<R, E2, A> =
-  B.mapLeft(Bicovariant)

package/src/typeclass/Chainable.ts

@@ -1,20 +0,0 @@
-import type * as C from '@effect/data/typeclass/Chainable'
-
-import { Covariant } from './Covariant.js'
-import { FlatMap, SwitchMap, ExhaustMap } from './FlatMap.js'
-import type { FxTypeLambda } from './TypeLambda.js'
-
-export const Chainable: C.Chainable<FxTypeLambda> = {
-  ...FlatMap,
-  ...Covariant,
-}
-
-export const Switchable: C.Chainable<FxTypeLambda> = {
-  ...SwitchMap,
-  ...Covariant,
-}
-
-export const Exhaustable: C.Chainable<FxTypeLambda> = {
-  ...ExhaustMap,
-  ...Covariant,
-}

package/src/typeclass/Coproduct.ts

@@ -1,25 +0,0 @@
-import type * as CP from '@effect/data/typeclass/Coproduct'
-import * as Cause from '@effect/io/Cause'
-
-import type { Fx } from '../Fx.js'
-import { failCause } from '../constructor/failCause.js'
-import { never } from '../constructor/never.js'
-import { orElse } from '../operator/orElse.js'
-import { raceAll } from '../operator/race.js'
-
-import { SemiCoproductRace, SemiCoproductOrElse } from './SemiCoproduct.js'
-import type { FxTypeLambda } from './TypeLambda.js'
-
-export const CoproductRace: CP.Coproduct<FxTypeLambda> = {
-  ...SemiCoproductRace,
-  zero: () => never,
-  coproductAll: <R, E, A>(collection: Iterable<Fx<R, E, A>>) =>
-    raceAll<readonly Fx<R, E, A>[]>(...collection),
-}
-
-export const CoproductOrElse: CP.Coproduct<FxTypeLambda> = {
-  ...SemiCoproductOrElse,
-  zero: () => failCause(Cause.empty),
-  coproductAll: <R, E, A>(collection: Iterable<Fx<R, E, A>>) =>
-    Array.from(collection).reduce((acc, fx) => orElse(fx)(acc), CoproductOrElse.zero()),
-}

package/src/typeclass/Covariant.ts

@@ -1,28 +0,0 @@
-import * as C from '@effect/data/typeclass/Covariant'
-
-import type { Fx } from '../Fx.js'
-import { map } from '../operator/map.js'
-
-import type { FxTypeLambda } from './TypeLambda.js'
-
-export const Covariant: C.Covariant<FxTypeLambda> = {
-  map,
-  imap: C.imap<FxTypeLambda>(map),
-}
-
-export const flap: <A>(a: A) => <R, E, B>(self: Fx<R, E, (a: A) => B>) => Fx<R, E, B> =
-  C.flap(Covariant)
-
-export const imap: <A, B>(
-  to: (a: A) => B,
-  from: (b: B) => A,
-) => <R, E>(self: Fx<R, E, A>) => Fx<R, E, B> = C.imap<FxTypeLambda>(Covariant.map)
-
-const let_: <N extends string, A extends object, B>(
-  name: Exclude<N, keyof A>,
-  f: (a: A) => B,
-) => <R, E>(
-  self: Fx<R, E, A>,
-) => Fx<R, E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }> = C.let(Covariant)
-
-export { let_ as let }