@typed/fx 1.6.2 → 1.8.0

package/src/internal/slicing/since.ts

@@ -1,47 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Effect, pipe, Scope } from '@typed/fx/internal/externals'
-import { filter } from '@typed/fx/internal/operator/filterMap'
-
-export const since: {
-  <R2, E2, B>(signal: Fx<R2, E2, B>): <R, E, A>(self: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, signal: Fx<R2, E2, B>): Fx<R | R2, E | E2, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(self: Fx<R, E, A>, signal: Fx<R2, E2, B>) =>
-      new SinceFx(self, signal).traced(trace),
-)
-
-export class SinceFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, A> {
-  readonly name = 'Since' as const
-
-  constructor(readonly self: Fx<R, E, A>, readonly signal: Fx<R2, E2, B>) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, A>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
-    const { self, signal } = this
-
-    return Effect.gen(function* ($) {
-      let shouldRun = false
-
-      yield* $(
-        pipe(
-          signal.observe(() =>
-            Effect.flatMap(
-              Effect.sync(() => (shouldRun = true)),
-              Effect.interrupt,
-            ),
-          ),
-          Effect.matchCauseEffect(sink.error, Effect.unit),
-          Effect.forkScoped,
-        ),
-      )
-
-      return yield* $(filter(self, () => shouldRun).run(sink))
-    })
-  }
-}

package/src/internal/slicing/skip.ts

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

package/src/internal/slicing/skipAfter.ts

@@ -1,51 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import type { Predicate } from '@effect/data/Predicate'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Effect, Scope } from '@typed/fx/internal/externals'
-
-export const skipAfter: {
-  <R, E, A>(self: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-  <A>(predicate: Predicate<A>): <R, E>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, predicate: Predicate<A>) =>
-      new SkipAfterFx(self, predicate).traced(trace),
-)
-
-export class SkipAfterFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = 'SkipAfter' as const
-
-  constructor(readonly self: Fx<R, E, A>, readonly prediate: Predicate<A>) {
-    super()
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return Effect.suspend(() => this.self.run(new SkipAfterSink(sink, this.prediate)))
-  }
-}
-
-export class SkipAfterSink<E, A> implements Sink<E, A> {
-  protected running = true
-
-  constructor(readonly sink: Sink<E, A>, readonly predicate: Predicate<A>) {}
-
-  event = (a: A) => {
-    const passed = this.predicate(a)
-
-    if (this.running) {
-      if (passed) {
-        this.running = false
-      } else {
-        return this.sink.event(a)
-      }
-    }
-
-    return Effect.unit()
-  }
-
-  error: Sink<E, A>['error'] = this.sink.error
-  end = this.sink.end
-}

package/src/internal/slicing/skipUntil.ts

@@ -1,15 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import { not } from '@effect/data/Predicate'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { skipWhile } from '@typed/fx/internal/slicing/skipWhile'
-
-export const skipUntil: {
-  <R, E, A>(self: Fx<R, E, A>, predicate: (value: A) => boolean): Fx<R, E, A>
-  <A>(predicate: (value: A) => boolean): <R, E>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, predicate: (value: A) => boolean) =>
-      skipWhile(self, not(predicate)).traced(trace),
-)

package/src/internal/slicing/skipWhile.ts

@@ -1,44 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Effect, Scope } from '@typed/fx/internal/externals'
-
-export const skipWhile: {
-  <R, E, A>(self: Fx<R, E, A>, predicate: (value: A) => boolean): Fx<R, E, A>
-  <A>(predicate: (value: A) => boolean): <R, E>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, predicate: (value: A) => boolean) =>
-      new SkipWhileFx(self, predicate).traced(trace),
-)
-
-export class SkipWhileFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = 'SkipWhile'
-
-  constructor(readonly self: Fx<R, E, A>, readonly predicate: (value: A) => boolean) {
-    super()
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return Effect.suspend(() => this.self.run(new SkipWhileSink(sink, this.predicate)))
-  }
-}
-
-export class SkipWhileSink<E, A> implements Sink<E, A> {
-  protected skip = true
-
-  constructor(readonly sink: Sink<E, A>, readonly predicate: (value: A) => boolean) {}
-
-  event(value: A) {
-    if (this.skip && this.skip === this.predicate(value)) {
-      return Effect.unit()
-    }
-
-    return this.sink.event(value)
-  }
-
-  error: Sink<E, A>['error'] = this.sink.error
-  end = this.sink.end
-}

package/src/internal/slicing/slice.ts

@@ -1,66 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { withEarlyExit } from '../withEarlyExit.js'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Effect, Scope } from '@typed/fx/internal/externals'
-
-export const slice: {
-  <R, E, A>(self: Fx<R, E, A>, skip: number, take: number): Fx<R, E, A>
-  (skip: number, take: number): <R, E, A>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  3,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, skip: number, take: number) =>
-      new SliceFx(self, skip, take).traced(trace),
-)
-
-export class SliceFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = 'SliceFx'
-
-  constructor(readonly self: Fx<R, E, A>, readonly skip: number, readonly take: number) {
-    super()
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return withEarlyExit((earlyExit) =>
-      this.self.run(new SliceSink(sink, this.skip, this.take, earlyExit)),
-    )
-  }
-}
-
-export class SliceSink<E, A> implements Sink<E, A> {
-  protected toSkip = this.skip
-  protected toTake = this.take
-
-  constructor(
-    readonly sink: Sink<E, A>,
-    readonly skip: number,
-    readonly take: number,
-    readonly earlyExit: Effect.Effect<never, never, never>,
-  ) {}
-
-  event(value: A) {
-    return Effect.suspend(() => {
-      if (this.toSkip > 0) {
-        this.toSkip -= 1
-
-        return Effect.unit()
-      }
-
-      if (this.toTake > 0) {
-        this.toTake -= 1
-
-        return Effect.flatMap(this.sink.event(value), () =>
-          this.toTake === 0 ? this.earlyExit : Effect.unit(),
-        )
-      }
-
-      return this.earlyExit
-    })
-  }
-
-  error: Sink<E, A>['error'] = this.sink.error
-  end = this.sink.end
-}

package/src/internal/slicing/take.ts

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

package/src/internal/slicing/takeUntil.ts

@@ -1,15 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-import { not } from '@effect/data/Predicate'
-
-import type { Fx } from '@typed/fx/internal/Fx'
-import { takeWhile } from '@typed/fx/internal/slicing/takeWhile'
-
-export const takeUntil: {
-  <R, E, A>(self: Fx<R, E, A>, predicate: (value: A) => boolean): Fx<R, E, A>
-  <A>(predicate: (value: A) => boolean): <R, E>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, predicate: (value: A) => boolean) =>
-      takeWhile(self, not(predicate)).traced(trace),
-)

package/src/internal/slicing/takeWhile.ts

@@ -1,42 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Effect, Scope } from '@typed/fx/internal/externals'
-
-export const takeWhile: {
-  <R, E, A>(self: Fx<R, E, A>, predicate: (value: A) => boolean): Fx<R, E, A>
-  <A>(predicate: (value: A) => boolean): <R, E>(self: Fx<R, E, A>) => Fx<R, E, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A>(self: Fx<R, E, A>, predicate: (value: A) => boolean) =>
-      new TakeWhileFx(self, predicate).traced(trace),
-)
-
-export class TakeWhileFx<R, E, A> extends BaseFx<R, E, A> {
-  readonly name = 'TakeWhile'
-
-  constructor(readonly self: Fx<R, E, A>, readonly predicate: (value: A) => boolean) {
-    super()
-  }
-
-  run(sink: Sink<E, A>): Effect.Effect<R | Scope.Scope, never, unknown> {
-    return Effect.suspend(() => this.self.run(new TakeWhileSink(sink, this.predicate)))
-  }
-}
-
-export class TakeWhileSink<E, A> implements Sink<E, A> {
-  constructor(readonly sink: Sink<E, A>, readonly predicate: (value: A) => boolean) {}
-
-  event(value: A) {
-    if (this.predicate(value)) {
-      return this.sink.event(value)
-    }
-
-    return this.sink.end()
-  }
-
-  error: Sink<E, A>['error'] = this.sink.error
-  end = this.sink.end
-}

package/src/internal/slicing/until.ts

@@ -1,40 +0,0 @@
-import { dualWithTrace } from '@effect/data/Debug'
-
-import { BaseFx } from '@typed/fx/internal/BaseFx'
-import type { Fx, Sink } from '@typed/fx/internal/Fx'
-import { Effect, Fiber, pipe, Scope } from '@typed/fx/internal/externals'
-
-export const until: {
-  <R2, E2, B>(signal: Fx<R2, E2, B>): <R, E, A>(self: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
-  <R, E, A, R2, E2, B>(self: Fx<R, E, A>, signal: Fx<R2, E2, B>): Fx<R | R2, E | E2, A>
-} = dualWithTrace(
-  2,
-  (trace) =>
-    <R, E, A, R2, E2, B>(self: Fx<R, E, A>, signal: Fx<R2, E2, B>) =>
-      new UntilFx(self, signal).traced(trace),
-)
-
-export class UntilFx<R, E, A, R2, E2, B> extends BaseFx<R | R2, E | E2, A> {
-  readonly name = 'Until' as const
-
-  constructor(readonly self: Fx<R, E, A>, readonly signal: Fx<R2, E2, B>) {
-    super()
-  }
-
-  run(sink: Sink<E | E2, A>): Effect.Effect<R | R2 | Scope.Scope, never, unknown> {
-    const { self, signal } = this
-
-    return Effect.gen(function* ($) {
-      const fiber = yield* $(Effect.forkScoped(self.run(sink)))
-      const signalFiber = yield* $(
-        pipe(
-          signal.observe(() => Effect.interrupt()),
-          Effect.matchCauseEffect(sink.error, Effect.unit),
-          Effect.forkScoped,
-        ),
-      )
-
-      yield* $(Fiber.joinAll([fiber, signalFiber]))
-    })
-  }
-}

package/src/internal/subject/HoldSubject.ts

@@ -1,45 +0,0 @@
-import { Mutable } from '@typed/fx/internal/Mutable'
-import { never } from '@typed/fx/internal/constructor/never'
-import type { Scope } from '@typed/fx/internal/externals'
-import { Effect, Option } from '@typed/fx/internal/externals'
-import { HoldFx } from '@typed/fx/internal/operator/hold'
-import type { Subject } from '@typed/fx/internal/subject/Subject'
-
-export interface HoldSubject<in out E, in out A> extends Subject<E, A> {
-  readonly current: Mutable<Option.Option<A>>
-}
-
-export function makeHoldSubject<E, A>(): Effect.Effect<never, never, HoldSubject<E, A>> {
-  return Effect.sync(() => HoldSubject.unsafeMake(Mutable(Option.none<A>())))
-}
-
-export function makeScopedHoldSubject<E, A>(): Effect.Effect<
-  Scope.Scope,
-  never,
-  HoldSubject<E, A>
-> {
-  return Effect.gen(function* ($) {
-    const subject = yield* $(makeHoldSubject<E, A>())
-
-    yield* $(Effect.addFinalizer(subject.end))
-
-    return subject
-  })
-}
-
-export namespace HoldSubject {
-  export const unsafeMake = <E, A>(current: Mutable<Option.Option<A>>): HoldSubject<E, A> =>
-    new HoldSubjectImpl<E, A, 'HoldSubject'>(current, 'HoldSubject')
-}
-
-/**
- * @internal
- */
-export class HoldSubjectImpl<E, A, Tag extends string>
-  extends HoldFx<never, E, A, Tag>
-  implements HoldSubject<E, A>
-{
-  constructor(current: Mutable<Option.Option<A>>, tag: Tag) {
-    super(never, current, tag, true)
-  }
-}