@typed/fx 1.6.2 → 1.8.0

package/src/internal/subject/RefSubject.ts

@@ -1,448 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import { equals } from '@effect/data/Equal'
-import type * as RA from '@effect/data/ReadonlyArray'
-import * as RR from '@effect/data/ReadonlyRecord'
-import * as Equivalence from '@effect/data/typeclass/Equivalence'
-import type { RuntimeFiber } from '@effect/io/Fiber'
-
-import { isFx } from '../BaseFx.js'
-
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Mutable } from '@typed/fx/internal/Mutable'
-import { Effect, Fiber, Option, pipe } from '@typed/fx/internal/externals'
-import type { Context, Scope } from '@typed/fx/internal/externals'
-import type { HoldSubject } from '@typed/fx/internal/subject/HoldSubject'
-import { HoldSubjectImpl } from '@typed/fx/internal/subject/HoldSubject'
-
-/**
- * A RefSubject is a lazily-instantiated Reference to a value. It also
- * implements
- */
-export interface RefSubject<in out E, in out A> extends HoldSubject<E, A> {
-  readonly [RefSubject.TypeId]: RefSubject.TypeId
-
-  readonly eq: Equivalence.Equivalence<A>
-
-  // Ref methods
-
-  /**
-   * Get the current value of the Ref. The value will be initialized if it hasn't
-   * been already.
-   */
-  readonly get: Effect.Effect<never, E, A>
-
-  /**
-   * Set the current value of the Ref. Cannot fail because no value needs
-   * to be initialized.
-   */
-  readonly set: (a: A) => Effect.Effect<never, never, A>
-
-  /**
-   * Modify the current value of the Ref with the specified effectful function.
-   * The current value will be initialized if it hasn't been already.
-   */
-  readonly modifyEffect: <R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>,
-  ) => Effect.Effect<R2, E | E2, B>
-
-  /**
-   * Modify the current value of the Ref with the specified function. The current
-   * value will be initialized if it hasn't been already.
-   */
-  readonly modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<never, E, B>
-
-  /**
-   * Update the current value of the Ref with the specified effectful function.
-   * The current value will be initialized if it hasn't been already.
-   */
-  readonly updateEffect: <R2, E2>(
-    f: (a: A) => Effect.Effect<R2, E2, A>,
-  ) => Effect.Effect<R2, E | E2, A>
-
-  /**
-   * Update the current value of the Ref with the specified function. The current
-   * value will be initialized if it hasn't been already.
-   */
-  readonly update: (f: (a: A) => A) => Effect.Effect<never, E, A>
-
-  /**
-   * Delete the current value of the Ref. Option.none() will be returned if the
-   * has not been initialized yet. Option.some(a) will be returned if the Ref
-   * has been initialized previously.
-   */
-  readonly delete: Effect.Effect<never, never, Option.Option<A>>
-
-  // Computed methods
-
-  /**
-   * Compute a value from the current value of the Ref with an Effect.
-   */
-  readonly mapEffect: <R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, B>,
-    eq?: Equivalence.Equivalence<B>,
-  ) => Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>>
-
-  /**
-   * Compute a value from the current value of the Ref.
-   */
-  readonly map: <B>(
-    f: (a: A) => B,
-    eq?: Equivalence.Equivalence<B>,
-  ) => Effect.Effect<Scope.Scope, never, Computed<E, B>>
-}
-
-export function makeRef<R, E, A>(
-  initialize: Effect.Effect<R, E, A>,
-  eq: Equivalence.Equivalence<A> = equals,
-): Effect.Effect<R, never, RefSubject<E, A>> {
-  return Effect.contextWith((ctx: Context.Context<R>) =>
-    RefSubject.unsafeMake(Effect.provideContext(initialize, ctx), eq),
-  )
-}
-
-export function makeScopedRef<R, E, A>(
-  initialize: Effect.Effect<R, E, A>,
-  eq: Equivalence.Equivalence<A> = equals,
-): Effect.Effect<R | Scope.Scope, never, RefSubject<E, A>> {
-  return Effect.gen(function* ($) {
-    const subject = yield* $(makeRef(initialize, eq))
-
-    yield* $(Effect.addFinalizer(subject.end))
-
-    return subject
-  })
-}
-
-export namespace RefSubject {
-  export const TypeId = Symbol.for('@typed/fx/RefSubject')
-  export type TypeId = typeof TypeId
-
-  export type Any =
-    | RefSubject<any, any>
-    | RefSubject<never, any>
-    | Computed<any, any>
-    | Computed<never, any>
-
-  export function unsafeMake<E, A>(
-    initialize: Effect.Effect<never, E, A>,
-    eq: Equivalence.Equivalence<A> = equals,
-  ): RefSubject<E, A> {
-    return new RefSubjectImpl<E, A>(initialize, eq, Mutable(Option.none<A>()))
-  }
-
-  export function all<const P extends RA.NonEmptyReadonlyArray<Any>>(
-    properties: P,
-  ): RefSubject<Fx.ErrorsOf<P[number]>, { readonly [K in keyof P]: Fx.OutputOf<P[K]> }>
-
-  export function all<const P extends Readonly<Record<string, Any>>>(
-    properties: P,
-  ): RefSubject<Fx.ErrorsOf<P[string]>, { readonly [K in keyof P]: Fx.OutputOf<P[K]> }>
-
-  export function all<
-    const P extends Readonly<Record<string, Any>> | RA.NonEmptyReadonlyArray<Any>,
-  >(properties: P) {
-    return Array.isArray(properties) ? tuple(...(properties as any)) : struct(properties as any)
-  }
-
-  export function struct<P extends Readonly<Record<string, Any>>>(
-    properties: P,
-  ): RefSubject<Fx.ErrorsOf<P[string]>, { readonly [K in keyof P]: Fx.OutputOf<P[K]> }> {
-    return new StructRefSubject(properties)
-  }
-
-  export function tuple<P extends RA.NonEmptyReadonlyArray<Any>>(
-    ...properties: P
-  ): RefSubject<Fx.ErrorsOf<P[number]>, { readonly [K in keyof P]: Fx.OutputOf<P[K]> }> {
-    return new TupleRefSubject(properties)
-  }
-
-  class RefSubjectImpl<E, A>
-    extends HoldSubjectImpl<E, A, 'RefSubject'>
-    implements RefSubject<E, A>
-  {
-    readonly [TypeId]: TypeId = TypeId
-
-    // Ensure all modifications happen in FIFO order
-    protected lock = Effect.unsafeMakeSemaphore(1).withPermits(1)
-    // Ensure only one fiber is initializing the value
-    protected initFiber = Mutable<RuntimeFiber<E, A> | null>(null)
-
-    constructor(
-      readonly initialize: Effect.Effect<never, E, A>,
-      readonly eq: Equivalence.Equivalence<A>,
-      readonly current: Mutable<Option.Option<A>>,
-    ) {
-      super(current, 'RefSubject')
-
-      this.event = this.event.bind(this)
-      this.error = this.error.bind(this)
-      this.end = this.end.bind(this)
-      this.set = this.set.bind(this)
-      this.mapEffect = this.mapEffect.bind(this)
-      this.map = this.map.bind(this)
-    }
-
-    run(sink: Sink<E, A>) {
-      return pipe(
-        // Ensure Ref is initialized
-        Effect.catchAllCause(this.get, sink.error),
-        Effect.zipRight(super.run(sink)),
-      )
-    }
-
-    event(a: A) {
-      return this.set(a)
-    }
-
-    readonly get: Effect.Effect<never, E, A> = Effect.suspend(() => {
-      const current = this.current.get()
-
-      if (Option.isSome(current)) {
-        return Effect.succeed(current.value)
-      }
-
-      const fiberOrNull = this.initFiber.get()
-
-      if (fiberOrNull) {
-        return Fiber.join<E, A>(fiberOrNull)
-      }
-
-      return this.lock(
-        Effect.flatMap(Effect.fork(this.initialize), (actualFiber) => {
-          this.initFiber.set(actualFiber)
-
-          return pipe(
-            Fiber.join(actualFiber),
-            Effect.ensuring(Effect.sync(() => this.initFiber.set(null))),
-            Effect.tap((a) => Effect.sync(() => this.current.set(Option.some(a)))),
-          )
-        }),
-      )
-    })
-
-    modifyEffect<R2, E2, B>(
-      f: (a: A) => Effect.Effect<R2, E2, readonly [B, A]>,
-    ): Effect.Effect<R2, E | E2, B> {
-      return Effect.flatMap(this.get, (currentValue) =>
-        this.lock(Effect.flatMap(f(currentValue), ([b, a]) => Effect.as(this.setAndSend(a), b))),
-      )
-    }
-
-    modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, E, B> {
-      return this.modifyEffect((a) => Effect.sync(() => f(a)))
-    }
-
-    set(a: A): Effect.Effect<never, never, A> {
-      return this.lock(Effect.flatMap(this.setValue(a), (a) => Effect.as(super.event(a), a)))
-    }
-
-    updateEffect<R2, E2>(f: (a: A) => Effect.Effect<R2, E2, A>): Effect.Effect<R2, E | E2, A> {
-      return this.modifyEffect((a) => Effect.map(f(a), (a) => [a, a]))
-    }
-
-    update(f: (a: A) => A): Effect.Effect<never, E, A> {
-      return this.updateEffect((a) => Effect.sync(() => f(a)))
-    }
-
-    get delete() {
-      return this.lock(
-        Effect.sync(() => {
-          const option = this.current.get()
-
-          this.current.set(Option.none<A>())
-
-          return option
-        }),
-      )
-    }
-
-    mapEffect<R2, E2, B>(
-      f: (a: A) => Effect.Effect<R2, E2, B>,
-      eq?: Equivalence.Equivalence<B>,
-    ): Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>> {
-      return makeComputed(this, f, eq)
-    }
-
-    map<B>(
-      f: (a: A) => B,
-      eq?: Equivalence.Equivalence<B>,
-    ): Effect.Effect<Scope.Scope, never, Computed<E, B>> {
-      return this.mapEffect((a) => Effect.sync(() => f(a)), eq)
-    }
-
-    protected setValue(a: A): Effect.Effect<never, never, A> {
-      return Effect.sync(() => {
-        const current = this.current.get()
-
-        if (Option.isSome(current) && this.eq(current.value, a)) {
-          return current.value
-        }
-
-        this.current.set(Option.some(a))
-
-        return a
-      })
-    }
-
-    protected setAndSend(a: A) {
-      return Effect.flatMap(this.setValue(a), (a) => Effect.as(super.event(a), a))
-    }
-  }
-
-  type TupleErrors<Members extends ReadonlyArray<Any>> = Fx.ErrorsOf<Members[number]>
-  type TupleOutput<Members extends ReadonlyArray<Any>> = {
-    readonly [_ in keyof Members]: Fx.OutputOf<Members[_]>
-  }
-
-  class TupleRefSubject<Members extends ReadonlyArray<Any>>
-    extends RefSubjectImpl<TupleErrors<Members>, TupleOutput<Members>>
-    implements RefSubject<TupleErrors<Members>, TupleOutput<Members>>
-  {
-    constructor(readonly members: Members) {
-      const current: Mutable<Option.Option<TupleOutput<Members>>> = {
-        get: () =>
-          Option.all(members.map((m) => m.current.get())) as Option.Option<TupleOutput<Members>>,
-        set: (a) =>
-          pipe(
-            a,
-            Option.match(
-              () => {
-                members.forEach((m) => m.current.set(Option.none()))
-                return Option.none()
-              },
-              (a) => Option.all(a.map((a, i) => members[i].current.set(Option.some(a)))),
-            ),
-          ) as Option.Option<TupleOutput<Members>>,
-      }
-
-      super(
-        Effect.allPar(members.map((m) => m.get)) as Effect.Effect<
-          never,
-          TupleErrors<Members>,
-          TupleOutput<Members>
-        >,
-        Equivalence.tuple(...members.map((m) => m.eq)) as Equivalence.Equivalence<
-          TupleOutput<Members>
-        >,
-        current,
-      )
-    }
-  }
-
-  type StructErrors<Members extends Readonly<Record<string, Any>>> = Fx.ErrorsOf<Members[string]>
-  type StructOutput<Members extends Readonly<Record<string, Any>>> = {
-    readonly [_ in keyof Members]: Fx.OutputOf<Members[_]>
-  }
-
-  class StructRefSubject<Members extends Readonly<Record<string, Any>>>
-    extends RefSubjectImpl<StructErrors<Members>, StructOutput<Members>>
-    implements RefSubject<StructErrors<Members>, StructOutput<Members>>
-  {
-    constructor(readonly members: Members) {
-      const keys = Object.keys(members) as ReadonlyArray<keyof Members>
-
-      const current: Mutable<Option.Option<StructOutput<Members>>> = {
-        get: () =>
-          Option.struct(RR.map(members, (m) => m.current.get())) as Option.Option<
-            StructOutput<Members>
-          >,
-        set: (a) =>
-          pipe(
-            a,
-            Option.match(
-              () => {
-                keys.forEach((k) => members[k].current.set(Option.none()))
-                return Option.none()
-              },
-              (a) => Option.struct(RR.map(a, (a, i) => members[i].current.set(Option.some(a)))),
-            ),
-          ) as Option.Option<StructOutput<Members>>,
-      }
-
-      super(
-        Effect.allPar(RR.map(members, (m) => m.get)) as Effect.Effect<
-          never,
-          StructErrors<Members>,
-          StructOutput<Members>
-        >,
-        Equivalence.struct(RR.map(members, (m) => m.eq)) as Equivalence.Equivalence<
-          StructOutput<Members>
-        >,
-        current,
-      )
-    }
-  }
-}
-
-/**
- * A Computed is a readonly view of a current value that is computed from
- * the current value of a RefSubject.
- */
-export interface Computed<E, A> extends Fx<never, E, A> {
-  /**
-   * The current value of the Computed.
-   */
-  readonly get: Effect.Effect<never, E, A>
-
-  /**
-   * Compute a new value from the current value of the Computed with an Effect.
-   */
-  readonly mapEffect: <R2, E2, B>(
-    f: (a: A) => Effect.Effect<R2, E2, B>,
-  ) => Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>>
-
-  /**
-   * Compute a new value from the current value of the Computed.
-   */
-  readonly map: <B>(f: (a: A) => B) => Effect.Effect<Scope.Scope, never, Computed<E, B>>
-
-  /**
-   * @internal
-   */
-  readonly current: Mutable<Option.Option<A>>
-
-  /**
-   * @internal
-   */
-  readonly eq: Equivalence.Equivalence<A>
-}
-
-export const makeComputed: {
-  <E, A, R2, E2, B>(
-    ref: RefSubject<E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, B>,
-    eq?: Equivalence.Equivalence<B>,
-  ): Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>>
-
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>, eq?: Equivalence.Equivalence<B>): <E>(
-    ref: RefSubject<E, A>,
-  ) => Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    function makeComputed<E, A, R2, E2, B>(
-      ref: RefSubject<E, A>,
-      f: (a: A) => Effect.Effect<R2, E2, B>,
-      eq?: Equivalence.Equivalence<B>,
-    ): Effect.Effect<R2 | Scope.Scope, never, Computed<E | E2, B>> {
-      return Effect.gen(function* ($) {
-        const computed = yield* $(makeRef(Effect.flatMap(ref.get, f), eq))
-
-        yield* $(
-          Effect.forkScoped(
-            Effect.matchCauseEffect(
-              ref.observe((a) => computed.updateEffect(() => f(a))),
-              computed.error,
-              computed.end,
-            ),
-          ),
-        )
-
-        return computed
-      }).traced(trace)
-    },
-)
-
-export function isRefSubject<E, A>(u: unknown): u is RefSubject<E, A> {
-  return isFx(u) && RefSubject.TypeId in u
-}

package/src/internal/subject/Subject.ts

@@ -1,31 +0,0 @@
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { never } from '@typed/fx/internal/constructor/never'
-import type { Scope } from '@typed/fx/internal/externals'
-import { Effect } from '@typed/fx/internal/externals'
-import { MulticastFx } from '@typed/fx/internal/operator/multicast'
-
-export interface Subject<in out E, in out A> extends Fx<never, E, A>, Sink<E, A> {}
-
-export function makeSubject<E, A>(): Effect.Effect<never, never, Subject<E, A>> {
-  return Effect.sync(() => new SubjectImpl())
-}
-
-export function makeScopedSubject<E, A>(): Effect.Effect<Scope.Scope, never, Subject<E, A>> {
-  return Effect.gen(function* ($) {
-    const subject = yield* $(makeSubject<E, A>())
-
-    yield* $(Effect.addFinalizer(subject.end))
-
-    return subject
-  })
-}
-
-export namespace Subject {
-  export const unsafeMake = <E, A>() => new SubjectImpl<E, A>()
-}
-
-class SubjectImpl<E, A> extends MulticastFx<never, E, A, 'Subject'> implements Subject<E, A> {
-  constructor() {
-    super(never, 'Subject', true)
-  }
-}

package/src/internal/subject/index.ts

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

package/src/internal/typeclass/Applicative.ts

@@ -1,13 +0,0 @@
-import * as A from '@effect/data/typeclass/Applicative'
-import type { Monoid } from '@effect/data/typeclass/Monoid'
-
-import type { Fx, FxTypeLambda } from '@typed/fx/internal/Fx'
-import { Product } from '@typed/fx/internal/typeclass/Product'
-import { SemiApplicative } from '@typed/fx/internal/typeclass/SemiApplicative'
-
-export const Applicative: A.Applicative<FxTypeLambda> = {
-  ...SemiApplicative,
-  ...Product,
-}
-
-export const getMonoid: <R, E, A>(M: Monoid<A>) => Monoid<Fx<R, E, A>> = A.getMonoid(Applicative)

package/src/internal/typeclass/Bicovariant.ts

@@ -1,8 +0,0 @@
-import * as BC from '@effect/data/typeclass/Bicovariant'
-
-import type { FxTypeLambda } from '@typed/fx/internal/Fx'
-import { mapBoth } from '@typed/fx/internal/operator/mapBoth'
-
-export const Bicovariant: BC.Bicovariant<FxTypeLambda> = {
-  bimap: mapBoth,
-}

package/src/internal/typeclass/Chainable.ts

@@ -1,16 +0,0 @@
-import * as C from '@effect/data/typeclass/Chainable'
-
-import type { Fx, FxTypeLambda } from '@typed/fx/internal/Fx'
-import { Covariant } from '@typed/fx/internal/typeclass/Covariant'
-import { FlatMap } from '@typed/fx/internal/typeclass/FlatMap'
-
-export const Chainable: C.Chainable<FxTypeLambda> = {
-  ...Covariant,
-  ...FlatMap,
-}
-
-export const zipLeft: {
-  <R2, E2, _>(that: Fx<R2, E2, _>): <R1, E1, A>(self: Fx<R1, E1, A>) => Fx<R2 | R1, E2 | E1, A>
-
-  <R1, E1, A, R2, E2, _>(self: Fx<R1, E1, A>, that: Fx<R2, E2, _>): Fx<R2 | R1, E2 | E1, A>
-} = C.zipLeft(Chainable)

package/src/internal/typeclass/Covariant.ts

@@ -1,28 +0,0 @@
-import type { Kind, TypeLambda } from '@effect/data/HKT'
-import * as C from '@effect/data/typeclass/Covariant'
-
-import type { Fx, FxTypeLambda } from '@typed/fx/internal/Fx'
-import { map } from '@typed/fx/internal/operator/map'
-
-export const imap = C.imap<FxTypeLambda>(map)
-
-export const Covariant: C.Covariant<FxTypeLambda> = {
-  map,
-  imap,
-}
-
-export const as = C.as(Covariant)
-export const asUnit = C.asUnit(Covariant)
-export const flap = C.flap(Covariant)
-
-const let_ = C.let(Covariant)
-
-export { let_ as let }
-
-export const mapComposition: <T extends TypeLambda>(
-  other: C.Covariant<T>,
-) => <R, E, GR, GO, GE, A, B>(
-  self: Fx<R, E, Kind<T, GR, GO, GE, A>>,
-  f: (a: A) => B,
-) => Fx<R, E, Kind<T, GR, GO, GE, B>> = <T extends TypeLambda>(other: C.Covariant<T>) =>
-  C.mapComposition(Covariant, other)

package/src/internal/typeclass/FlatMap.ts

@@ -1,23 +0,0 @@
-import * as F from '@effect/data/typeclass/FlatMap'
-
-import type { Fx, FxTypeLambda } from '@typed/fx/internal/Fx'
-import { flatMap } from '@typed/fx/internal/operator/flatMap'
-
-export const FlatMap: F.FlatMap<FxTypeLambda> = {
-  flatMap,
-}
-
-export const zipRight: {
-  <R2, E2, B>(that: Fx<R2, E2, B>): <R1, E1, _>(self: Fx<R1, E1, _>) => Fx<R2 | R1, E2 | E1, B>
-  <R1, E1, A, R2, E2, B>(self: Fx<R1, E1, A>, that: Fx<R2, E2, B>): Fx<R1 | R2, E1 | E2, B>
-} = F.zipRight(FlatMap)
-
-export const composeK: {
-  <B, R2, E2, C>(bfc: (b: B) => Fx<R2, E2, C>): <A, R1, E1>(
-    afb: (a: A) => Fx<R1, E1, B>,
-  ) => (a: A) => Fx<R2 | R1, E2 | E1, C>
-
-  <A, R1, E1, B, R2, E2, C>(afb: (a: A) => Fx<R1, E1, B>, bfc: (b: B) => Fx<R2, E2, C>): (
-    a: A,
-  ) => Fx<R2 | R1, E2 | E1, C>
-} = F.composeK(FlatMap)

package/src/internal/typeclass/Monad.ts

@@ -1,10 +0,0 @@
-import type * as M from '@effect/data/typeclass/Monad'
-
-import type { FxTypeLambda } from '@typed/fx/internal/Fx'
-import { FlatMap } from '@typed/fx/internal/typeclass/FlatMap'
-import { Pointed } from '@typed/fx/internal/typeclass/Pointed'
-
-export const Monad: M.Monad<FxTypeLambda> = {
-  ...Pointed,
-  ...FlatMap,
-}

package/src/internal/typeclass/Of.ts

@@ -1,10 +0,0 @@
-import * as O from '@effect/data/typeclass/Of'
-
-import type { Fx, FxTypeLambda } from '@typed/fx/internal/Fx'
-import { succeed } from '@typed/fx/internal/constructor/succeed'
-
-export const Of: O.Of<FxTypeLambda> = {
-  of: succeed,
-}
-
-export const unit: Fx.Succeed<void> = O.unit(Of)<never, never, void>()

package/src/internal/typeclass/Pointed.ts

@@ -1,10 +0,0 @@
-import type * as P from '@effect/data/typeclass/Pointed'
-
-import type { FxTypeLambda } from '@typed/fx/internal/Fx'
-import { Covariant } from '@typed/fx/internal/typeclass/Covariant'
-import { Of } from '@typed/fx/internal/typeclass/Of'
-
-export const Pointed: P.Pointed<FxTypeLambda> = {
-  ...Of,
-  ...Covariant,
-}

package/src/internal/typeclass/Product.ts

@@ -1,45 +0,0 @@
-import * as P from '@effect/data/typeclass/Product'
-
-import type { Fx, FxTypeLambda } from '@typed/fx/internal/Fx'
-import { collectAll } from '@typed/fx/internal/constructor/collectAll'
-import { map } from '@typed/fx/internal/operator/map'
-import { Of } from '@typed/fx/internal/typeclass/Of'
-import { SemiProduct } from '@typed/fx/internal/typeclass/SemiProduct'
-
-export const Product: P.Product<FxTypeLambda> = {
-  ...SemiProduct,
-  ...Of,
-  productAll: (iterable) => map(collectAll(iterable), (a) => Array.from(a)),
-}
-
-export const struct: <const R extends Readonly<Record<string, Fx<any, any, any>>>>(
-  fields: R,
-) => Fx<
-  Fx.ResourcesOf<R[string]>,
-  Fx.ErrorsOf<R[string]>,
-  { readonly [K in keyof R]: Fx.OutputOf<R[K]> }
-> = P.struct(Product) as <R extends Readonly<Record<string, Fx<any, any, any>>>>(
-  fields: R,
-) => Fx<
-  Fx.ResourcesOf<R[string]>,
-  Fx.ErrorsOf<R[string]>,
-  {
-    readonly [K in keyof R]: Fx.OutputOf<R[K]>
-  }
->
-
-export const tuple: <const R extends ReadonlyArray<Fx<any, any, any>>>(
-  ...elements: R
-) => Fx<
-  Fx.ResourcesOf<R[number]>,
-  Fx.ErrorsOf<R[number]>,
-  { readonly [K in keyof R]: Fx.OutputOf<R[K]> }
-> = P.tuple(Product) as <R extends ReadonlyArray<Fx<any, any, any>>>(
-  ...elements: R
-) => Fx<
-  Fx.ResourcesOf<R[number]>,
-  Fx.ErrorsOf<R[number]>,
-  {
-    readonly [K in keyof R]: Fx.OutputOf<R[K]>
-  }
->