@typed/fx 1.6.2 → 1.8.0

package/src/internal/BaseFx.ts

@@ -1,90 +0,0 @@
-import type { Trace } from '@effect/data/Debug'
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Equal from '@effect/data/Equal'
-import * as Hash from '@effect/data/Hash'
-import * as Effect from '@effect/io/Effect'
-import type { Scope } from '@effect/io/Scope'
-
-import * as fx from '@typed/fx/internal/Fx'
-import * as run from '@typed/fx/internal/run/index'
-
-export function isFx(value: unknown): value is fx.Fx<unknown, unknown, unknown> {
-  return isObject(value) && hasRunFunction(value)
-}
-
-const isObject = (value: unknown): value is object => value !== null && typeof value === 'object'
-
-const hasRunFunction = (value: object): value is fx.Fx<unknown, unknown, unknown> =>
-  'run' in value && typeof value['run'] === 'function' && value['run'].length === 1
-
-export abstract class BaseFx<R, E, A> implements fx.Fx<R, E, A> {
-  abstract readonly name: string
-
-  abstract run(sink: fx.Sink<E, A>): Effect.Effect<R | Scope, never, unknown>
-
-  readonly traced: fx.Fx<R, E, A>['traced'] = (trace) => (trace ? new TracedFx(this, trace) : this)
-
-  readonly transform: fx.Fx<R, E, A>['transform'] = methodWithTrace(
-    (trace) => (f) => new TransformedFx(this, f).traced(trace),
-  )
-
-  readonly observe: fx.Fx<R, E, A>['observe'] = methodWithTrace(
-    (trace) => (f) => run.observe(this, f).traced(trace),
-  )
-
-  readonly forkObserve: fx.Fx<R, E, A>['forkObserve'] = methodWithTrace(
-    (trace) => (f) => Effect.forkScoped(this.observe(f)).traced(trace),
-  );
-
-  [Hash.symbol]() {
-    return Hash.random(this)
-  }
-
-  [Equal.symbol](that: Equal.Equal): boolean {
-    return this === that
-  }
-}
-
-export class TransformedFx<R, E, A, R2, E2> extends BaseFx<Exclude<R2, Scope>, E | E2, A> {
-  readonly name = 'Transformed' as const
-
-  constructor(
-    readonly self: fx.Fx<R, E, A>,
-    readonly f: (
-      fx: Effect.Effect<R | Scope, never, unknown>,
-    ) => Effect.Effect<R2 | Scope, E2, unknown>,
-  ) {
-    super()
-  }
-
-  run(sink: fx.Sink<E | E2, A>): Effect.Effect<Scope | Exclude<R2, Scope>, never, unknown> {
-    return Effect.catchAllCause(this.f(this.self.run(sink)), sink.error) as Effect.Effect<
-      Exclude<R2, Scope> | Scope,
-      never,
-      unknown
-    >
-  }
-}
-
-export class TracedFx<R, E, A, R2, E2> extends BaseFx<Exclude<R2, Scope>, E | E2, A> {
-  readonly name = 'Traced' as const
-
-  constructor(readonly self: fx.Fx<R, E, A>, readonly trace: Trace) {
-    super()
-  }
-
-  run(sink: fx.Sink<E | E2, A>) {
-    return this.self.run(fx.Sink.traced(sink, this.trace)).traced(this.trace) as Effect.Effect<
-      Exclude<R2, Scope> | Scope,
-      never,
-      unknown
-    >
-  }
-}
-
-export function make<R, E, A>(run: fx.Fx<R, E, A>['run'], name?: string): fx.Fx<R, E, A> {
-  return new (class Fx extends BaseFx<R, E, A> {
-    readonly name = name || 'Fx'
-    readonly run = run
-  })()
-}

package/src/internal/Fx.ts

@@ -1,163 +0,0 @@
-/**
- * A `Fx` is a push-based reactive data structure that declaratively represents multi-shot Effects.
- * An Fx can call its provided Sink 0 or more times, and then call Sink.error or Sink.end exactly once.
- *
- * With an Fx you can represent workflows that exist over time like RPC, DOM Event, and so much more.
- * You can skip, take, filter, and transform the events of an Fx. You can also easily create your own.
- *
- * @since 1.0.0
- */
-
-import type { Trace } from '@effect/data/Debug'
-import { methodWithTrace } from '@effect/data/Debug'
-import type { Equal } from '@effect/data/Equal'
-import type { TypeLambda } from '@effect/data/HKT'
-import type { Cause } from '@effect/io/Cause'
-import type { Effect } from '@effect/io/Effect'
-import type { Scope } from '@effect/io/Scope'
-
-import type { Fiber } from '@typed/fx/internal/externals'
-
-/**
- * A `Fx` is a push-based reactive data structure that declaratively represents a multi-shot Effects.
- * An Fx can call its provided Sink 0 or more times, and then call Sink.error or Sink.end exactly once.
- *
- * It makes use of Scope to ensure that all resources are properly released including any "nested" Fx
- * being run by higher-order Fx operators like flatMap or switchMap but not limited to.
- *
- * Fx extends the EffectGen interface to allow being yield*ed in a Generator. It is a shortcut
- * to runCollectAll and is mostly useful in tests.
- * @since 1.0.0
- * @category Model
- */
-export interface Fx<out Services, out Errors, out Output> extends Equal {
-  readonly name: string
-
-  /**
-   * The main API for running an Fx.
-   */
-  run(sink: Sink<Errors, Output>): Effect<Services | Scope, never, unknown>
-
-  /**
-   * Add a trace to an Fx
-   */
-
-  traced(trace: Trace): Fx<Services, Errors, Output>
-
-  /**
-   * Transform the output of an Fx.
-   */
-  transform<R2 = never, E2 = never>(
-    f: (effect: Effect<Services | Scope, never, unknown>) => Effect<R2 | Scope, E2, unknown>,
-  ): Fx<Exclude<R2, Scope>, Errors | E2, Output>
-
-  /**
-   * Construct a new Fx by applying a Effectful function to every element of this Fx.
-   */
-  readonly observe: <R2, E2, B>(
-    f: (o: Output) => Effect<R2, E2, B>,
-  ) => Effect<Services | R2, Errors | E2, unknown>
-
-  /**
-   * Construct a new Fx by applying a Effectful function to every element of this Fx
-   * and fork the resulting Effect.
-   */
-  readonly forkObserve: <R2, E2, B>(
-    f: (o: Output) => Effect<R2, E2, B>,
-  ) => Effect<Services | R2 | Scope, never, Fiber.RuntimeFiber<Errors | E2, unknown>>
-}
-
-export namespace Fx {
-  /**
-   * Extract the services of an Fx.
-   * @since 1.0.0
-   * @category Type-level
-   */
-  export type ResourcesOf<T> = T extends Fx<infer Services, any, any> ? Services : never
-
-  /**
-   * Extract the errors of an Fx.
-   * @since 1.0.0
-   * @category Type-level
-   */
-  export type ErrorsOf<T> = T extends Fx<any, infer Errors, any> ? Errors : never
-
-  /**
-   * Extract the output of an Fx.
-   * @since 1.0.0
-   * @category Type-level
-   */
-  export type OutputOf<T> = T extends Fx<any, any, infer Output> ? Output : never
-
-  /**
-   * An Fx which will always succeed with the given value.
-   */
-  export type Succeed<A> = Fx<never, never, A>
-
-  /**
-   * An Fx which will always fail with the given value.
-   */
-  export type Fail<E> = Fx<never, E, never>
-
-  /**
-   * An Fx which has an error and a value but not resources.
-   */
-  export type WithError<E, A> = Fx<never, E, A>
-
-  /**
-   * An Fx which has a resource and a value but not an error.
-   */
-  export type WithService<R, A> = Fx<R, never, A>
-}
-
-/**
- * A `Sink` is receiver of a `Fx`'s events and errors. It describes event and error.
- * @since 1.0.0
- * @category Model
- */
-export interface Sink<in Errors, in Output> {
-  readonly event: (event: Output) => Effect<never, never, unknown>
-  readonly error: (error: Cause<Errors>) => Effect<never, never, unknown>
-  readonly end: () => Effect<never, never, unknown>
-}
-
-/**
- * Construct a Sink.
- * @since 1.0.0
- * @category Constructor
- */
-export function Sink<Errors, Output>(
-  event: Sink<Errors, Output>['event'],
-  error: Sink<Errors, Output>['error'],
-  end: Sink<Errors, Output>['end'],
-): Sink<Errors, Output> {
-  const sink: Sink<Errors, Output> = {
-    event: methodWithTrace((trace, restore) => (a) => restore(event)(a).traced(trace)),
-    error: methodWithTrace((trace, restore) => (e) => restore(error)(e).traced(trace)),
-    end: methodWithTrace((trace, restore) => () => restore(end)().traced(trace)),
-  }
-
-  return sink
-}
-
-export namespace Sink {
-  export function traced<Errors, Output>(
-    sink: Sink<Errors, Output>,
-    trace: Trace,
-  ): Sink<Errors, Output> {
-    return Sink(
-      (a) => sink.event(a).traced(trace),
-      (e) => sink.error(e).traced(trace),
-      () => sink.end().traced(trace),
-    )
-  }
-}
-
-/**
- * TypeLambda for typeclasses using Fx.
- * @since 1.0.0
- * @category Type Lambda
- */
-export interface FxTypeLambda extends TypeLambda {
-  readonly type: Fx<this['Out2'], this['Out1'], this['Target']>
-}

package/src/internal/Mutable.ts

@@ -1,11 +0,0 @@
-export interface Mutable<A> {
-  readonly get: () => A
-  readonly set: (a: A) => A
-}
-
-export function Mutable<A>(value: A): Mutable<A> {
-  return {
-    get: () => value,
-    set: (a: A) => (value = a),
-  }
-}

package/src/internal/RefCounter.ts

@@ -1,95 +0,0 @@
-import { millis } from '@effect/data/Duration'
-import { pipe } from '@effect/data/Function'
-import * as Deferred from '@effect/io/Deferred'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as Ref from '@effect/io/Ref'
-import * as Schedule from '@effect/io/Schedule'
-
-import { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Cause, Context, Scope } from '@typed/fx/internal/externals'
-
-const zero = millis(0)
-export const asap = Schedule.delayed(Schedule.once(), () => zero)
-
-export class RefCounter {
-  protected count = Ref.unsafeMake(this.initial)
-  protected fiber: Fiber.RuntimeFiber<never, void> | undefined
-
-  constructor(readonly initial: number, readonly deferred: Deferred.Deferred<never, void>) {}
-
-  readonly get = Ref.get(this.count)
-
-  readonly increment = pipe(
-    this.count,
-    Ref.updateAndGet((x) => x + 1),
-  )
-
-  readonly decrement = pipe(
-    this.count,
-    Ref.updateAndGet((x) => Math.max(0, x - 1)),
-    Effect.tap(() => this.checkShouldClose),
-  )
-
-  readonly wait = Deferred.await(this.deferred)
-
-  readonly refCounted = <R, E, A, R2, B>(
-    fx: Fx<R, E, A>,
-    sink: Sink<E, A>,
-    onComplete: () => Effect.Effect<R2, never, B>,
-  ): Effect.Effect<R | R2 | Scope.Scope, never, unknown> =>
-    Effect.contextWith((ctx: Context.Context<R | R2 | Scope.Scope>) =>
-      pipe(
-        fx.run(
-          Sink(
-            sink.event,
-            (cause) =>
-              Cause.isInterruptedOnly(cause)
-                ? Effect.provideContext(Effect.zipRight(onComplete(), this.decrement), ctx)
-                : sink.error(cause),
-            () => Effect.provideContext(Effect.zipRight(onComplete(), this.decrement), ctx),
-          ),
-        ),
-      ),
-    )
-
-  private checkShouldClose = Effect.suspend(() => {
-    const interrupt = this.fiber ? Fiber.interrupt(this.fiber) : Effect.unit()
-
-    this.fiber = undefined
-
-    return pipe(
-      interrupt,
-      Effect.zipParRight(Ref.get(this.count)),
-      Effect.flatMap((x) =>
-        x === 0 ? Effect.intoDeferred(Effect.unit(), this.deferred) : Effect.unit(),
-      ),
-      Effect.scheduleForked(asap),
-      Effect.tap((fiber) =>
-        Effect.sync(() => {
-          this.fiber = fiber
-        }),
-      ),
-    )
-  })
-}
-
-export function withRefCounter<R, E, A, R2, E2, B>(
-  initialCount: number,
-  f: (counter: RefCounter, scope: Scope.Scope) => Effect.Effect<R, E, A>,
-  onEnd: () => Effect.Effect<R2, E2, B>,
-): Effect.Effect<R | R2 | Scope.Scope, E | E2, B> {
-  return Effect.gen(function* ($) {
-    const scope = yield* $(Effect.scope())
-    const deferred = yield* $(Deferred.make<never, void>())
-    const counter = new RefCounter(initialCount, deferred)
-
-    const fiber = yield* $(Effect.forkScoped(f(counter, scope)))
-
-    yield* $(counter.wait)
-
-    yield* $(Fiber.interrupt(fiber))
-
-    return yield* $(onEnd())
-  })
-}

package/src/internal/concurrency/index.ts

@@ -1,2 +0,0 @@
-export * from './withParallelism.js'
-export * from './withParallelismUnbounded.js'

package/src/internal/concurrency/withParallelism.ts

@@ -1,14 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const withParallelism: {
-  <R, E, A>(self: Fx<R, E, A>, concurrency: number): Fx<R, E, A>
-  (concurrency: number): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, concurrency: number) =>
-      self.transform(Effect.withParallelism(concurrency)).traced(trace),
-)

package/src/internal/concurrency/withParallelismUnbounded.ts

@@ -1,6 +0,0 @@
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export function withParallelismUnbounded<R, E, A>(self: Fx<R, E, A>): Fx<R, E, A> {
-  return self.transform(Effect.withParallelismUnbounded)
-}

package/src/internal/config/config.ts

@@ -1,13 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type { Config } from '@effect/io/Config'
-import type { ConfigError } from '@effect/io/Config/Error'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const config: <A>(config: Config<A>) => Fx<never, ConfigError, A> = methodWithTrace(
-  (trace) =>
-    <A>(config: Config<A>) =>
-      fromEffect(Effect.config(config)).traced(trace),
-)

package/src/internal/config/configProviderWith.ts

@@ -1,25 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type { ConfigProvider } from '@effect/io/Config/Provider'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const configProviderWith: <R, E, A>(
-  f: (config: ConfigProvider) => Fx<R, E, A>,
-) => Fx<R, E, A> = methodWithTrace(
-  (trace) =>
-    <R, E, A>(f: (config: ConfigProvider) => Fx<R, E, A>) =>
-      new ConfigProviderWithFx(f).traced(trace),
-)
-
-class ConfigProviderWithFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = 'ConfigProviderWith'
-  constructor(readonly f: (config: ConfigProvider) => Fx<R, E, A>) {
-    super()
-  }
-
-  run(sink: Sink<E, A>) {
-    return Effect.configProviderWith((config) => this.f(config).run(sink))
-  }
-}

package/src/internal/config/index.ts

@@ -1,3 +0,0 @@
-export * from './config.js'
-export * from './configProviderWith.js'
-export * from './withConfigProvider.js'

package/src/internal/config/withConfigProvider.ts

@@ -1,15 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type { ConfigProvider } from '@effect/io/Config/Provider'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const withConfigProvider: {
-  <R, E, A>(fx: Fx<R, E, A>, provider: ConfigProvider): Fx<R, E, A>
-  (provider: ConfigProvider): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(fx: Fx<R, E, A>, provider: ConfigProvider) =>
-      fx.transform(Effect.withConfigProvider(provider)).traced(trace),
-)

package/src/internal/constructor/acquireUseRelease.ts

@@ -1,48 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import * as Effect from '@effect/io/Effect'
-import type { Exit } from '@effect/io/Exit'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Scope } from '@typed/fx/internal/externals'
-
-export const acquireUseRelease: {
-  <R, E, A, R2, E2, B, R3, C>(
-    acquire: Effect.Effect<R, E, A>,
-    use: (a: A) => Fx<R2, E2, B>,
-    release: (a: A, exit: Exit<never, unknown>) => Effect.Effect<R3, never, C>,
-  ): Fx<R | R2 | R3, E | E2, B>
-
-  <A, R2, E2, B, R3, C>(
-    use: (a: A) => Fx<R2, E2, B>,
-    release: (a: A, exit: Exit<never, unknown>) => Effect.Effect<R3, never, C>,
-  ): <R, E>(acquire: Effect.Effect<R, E, A>) => Fx<R | R2 | R3, E | E2, B>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A, R2, E2, B, R3, C>(
-      acquire: Effect.Effect<R, E, A>,
-      use: (a: A) => Fx<R2, E2, B>,
-      release: (a: A, exit: Exit<never, unknown>) => Effect.Effect<R3, never, C>,
-    ) =>
-      new AcquireUseReleaseFx(acquire, use, release).traced(trace),
-)
-
-export class AcquireUseReleaseFx<R, E, A, R2, E2, B, R3> extends BaseFx<R | R2 | R3, E | E2, B> {
-  readonly name = 'AcquireUseRelease'
-
-  constructor(
-    readonly acquire: Effect.Effect<R, E, A>,
-    readonly use: (a: A) => Fx<R2, E2, B>,
-    readonly release: (a: A, exit: Exit<never, unknown>) => Effect.Effect<R3, never, unknown>,
-  ) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, B>): Effect.Effect<R | R2 | R3 | Scope.Scope, never, unknown> {
-    return Effect.catchAllCause(
-      Effect.acquireUseRelease(this.acquire, (a) => this.use(a).run(sink), this.release),
-      sink.error,
-    )
-  }
-}

package/src/internal/constructor/async.ts

@@ -1,13 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Effect from '@effect/io/Effect'
-import type * as FiberId from '@effect/io/Fiber/Id'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const async: <R, E, A>(
-  register: (callback: (_: Effect.Effect<R, E, A>) => void) => void,
-  blockingOn?: FiberId.None | FiberId.Runtime | FiberId.Composite | undefined,
-) => Fx<R, E, A> = methodWithTrace(
-  (trace) => (register, blockingOn) => fromEffect(Effect.async(register, blockingOn)).traced(trace),
-)

package/src/internal/constructor/asyncEffect.ts

@@ -1,11 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const asyncEffect: <R, E, A, R2, E2, B>(
-  register: (callback: (_: Effect.Effect<R, E, A>) => void) => Effect.Effect<R2, E2, B>,
-) => Fx<R | R2, E | E2, A> = methodWithTrace(
-  (trace) => (register) => fromEffect(Effect.asyncEffect(register)).traced(trace),
-)

package/src/internal/constructor/asyncInterrupt.ts

@@ -1,18 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import * as Effect from '@effect/io/Effect'
-import type * as FiberId from '@effect/io/Fiber/Id'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const asyncInterrupt: <R, E, A, R2>(
-  register: (callback: (_: Effect.Effect<R, E, A>) => void) => Effect.Effect<R2, never, void>,
-  blockingOn?: FiberId.None | FiberId.Runtime | FiberId.Composite | undefined,
-) => Fx<R | R2, E, A> = methodWithTrace(
-  (trace) =>
-    <R, E, A, R2>(
-      register: (callback: (_: Effect.Effect<R, E, A>) => void) => Effect.Effect<R2, never, void>,
-      blockingOn?: FiberId.None | FiberId.Runtime | FiberId.Composite | undefined,
-    ) =>
-      fromEffect(Effect.asyncInterrupt<R | R2, E, A>(register, blockingOn)).traced(trace),
-)

package/src/internal/constructor/asyncInterruptEither.ts

@@ -1,23 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type * as Either from '@effect/data/Either'
-import * as Effect from '@effect/io/Effect'
-import type * as FiberId from '@effect/io/Fiber/Id'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const asyncInterruptEither: <R, E, A, R2>(
-  register: (
-    callback: (_: Effect.Effect<R, E, A>) => void,
-  ) => Either.Either<Effect.Effect<R2, never, void>, Effect.Effect<R, E, A>>,
-  blockingOn?: FiberId.None | FiberId.Runtime | FiberId.Composite | undefined,
-) => Fx<R | R2, E, A> = methodWithTrace(
-  (trace) =>
-    <R, E, A, R2>(
-      register: (
-        callback: (_: Effect.Effect<R, E, A>) => void,
-      ) => Either.Either<Effect.Effect<R2, never, void>, Effect.Effect<R, E, A>>,
-      blockingOn?: FiberId.None | FiberId.Runtime | FiberId.Composite | undefined,
-    ) =>
-      fromEffect(Effect.asyncInterruptEither<R | R2, E, A>(register, blockingOn)).traced(trace),
-)

package/src/internal/constructor/asyncOption.ts

@@ -1,23 +0,0 @@
-import { methodWithTrace } from '@effect/data/Debug'
-import type * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-import type * as FiberId from '@effect/io/Fiber/Id'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const asyncOption: <R, E, A, R2>(
-  register: (
-    callback: (_: Effect.Effect<R, E, A>) => void,
-  ) => Option.Option<Effect.Effect<R, E, A>>,
-  blockingOn?: FiberId.None | FiberId.Runtime | FiberId.Composite | undefined,
-) => Fx<R | R2, E, A> = methodWithTrace(
-  (trace) =>
-    <R, E, A, R2>(
-      register: (
-        callback: (_: Effect.Effect<R, E, A>) => void,
-      ) => Option.Option<Effect.Effect<R, E, A>>,
-      blockingOn?: FiberId.None | FiberId.Runtime | FiberId.Composite | undefined,
-    ) =>
-      fromEffect(Effect.asyncOption<R | R2, E, A>(register, blockingOn)).traced(trace),
-)

package/src/internal/constructor/at.ts

@@ -1,13 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type { Duration } from '@effect/data/Duration'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-
-export const at: {
-  <A>(value: A, delay: Duration): Fx<never, never, A>
-  (delay: Duration): <A>(value: A) => Fx<never, never, A>
-} = dualWithTrace(2, (trace) => <A>(value: A, delay: Duration): Fx<never, never, A> => {
-  return fromEffect(Effect.as(Effect.sleep(delay), value)).traced(trace)
-})

package/src/internal/constructor/collect.ts

@@ -1,26 +0,0 @@
-import type { Chunk } from '@effect/data/Chunk'
-import { dualWithTrace } from '@effect/data/Debug'
-import type { Option } from '@effect/data/Option'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { fromEffect } from '@typed/fx/internal/conversion/fromEffect'
-import { Effect } from '@typed/fx/internal/externals'
-
-export const collect: {
-  <A, R, E, B>(elements: Iterable<A>, f: (a: A) => Effect.Effect<R, Option<E>, B>): Fx<
-    R,
-    E,
-    Chunk<B>
-  >
-  <A, R, E, B>(f: (a: A) => Effect.Effect<R, Option<E>, B>): (
-    elements: Iterable<A>,
-  ) => Fx<R, E, Chunk<B>>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <A, R, E, B>(
-      elements: Iterable<A>,
-      f: (a: A) => Effect.Effect<R, Option<E>, B>,
-    ): Fx<R, E, Chunk<B>> =>
-      fromEffect(Effect.collect(elements, f)).traced(trace),
-)