@typed/fx 0.0.9 → 0.0.12

package/src/scheduled.ts

@@ -4,59 +4,61 @@ import * as Schedule from '@effect/core/io/Schedule'
 import { millis } from '@tsplus/stdlib/data/Duration'
 import { isRight } from '@tsplus/stdlib/data/Either'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
+import { Emitter, Fx } from './Fx.js'
 
 /**
- * Schedules an Effect to run, emitting the result of the Effect to the sink.
+ * Schedules an Effect to run, emitting the result of the Effect to the emmiter
  */
 export function scheduled<S, R2, Out>(schedule: Schedule.Schedule<S, R2, any, Out>) {
   return <R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R | R2, E, A> =>
-    Fx(<R3, E3, B>(sink: Sink<E, A, R3, E3, B>) =>
-      Effect.gen(function* ($) {
-        const clock = yield* $(Effect.clock)
+    Fx(
+      <R3>(emitter: Emitter<R3, E, A>): Effect.Effect<R | R2 | R3, never, unknown> =>
+        Effect.gen(function* ($) {
+          const clock = yield* $(Effect.clock)
 
-        let now = yield* $(clock.currentTime)
-        let [s, , decision] = yield* $(schedule.step(now, undefined, schedule.initial))
+          let now = yield* $(clock.currentTime)
+          let [s, , decision] = yield* $(schedule.step(now, undefined, schedule.initial))
 
-        while (decision._tag === 'Continue') {
-          yield* $(clock.sleep(millis((Schedule.Intervals.start(decision.intervals) - now) as any)))
+          while (decision._tag === 'Continue') {
+            yield* $(
+              clock.sleep(millis((Schedule.Intervals.start(decision.intervals) - now) as any)),
+            )
 
-          const exit = yield* $(Effect.exit(effect))
+            const exit = yield* $(Effect.exit(effect))
 
-          if (Exit.isFailure(exit)) {
-            return yield* $(sink.error(exit.cause))
-          }
+            if (Exit.isFailure(exit)) {
+              return yield* $(emitter.failCause(exit.cause))
+            }
 
-          yield* $(sink.event(exit.value))
+            yield* $(emitter.emit(exit.value))
 
-          now = yield* $(clock.currentTime)
-          const [s2, , decision2] = yield* $(schedule.step(now, exit.value, s))
+            now = yield* $(clock.currentTime)
+            const [s2, , decision2] = yield* $(schedule.step(now, exit.value, s))
 
-          s = s2
-          decision = decision2
-        }
+            s = s2
+            decision = decision2
+          }
 
-        return yield* $(sink.end)
-      }),
+          return yield* $(emitter.end)
+        }),
     )
 }
 
 /**
- * Schedules an Effect to run, emitting the result of the Schedule to the sink.
+ * Schedules an Effect to run, emitting the result of the Schedule to the emmiter
  *
  * TODO: Needs a better name
  */
 export function scheduledOut<S, R2, A, Out>(schedule: Schedule.Schedule<S, R2, A, Out>) {
   return <R, E>(effect: Effect.Effect<R, E, A>): Fx<R | R2, E, Out> =>
-    Fx(<R3, E3, B>(sink: Sink<E, Out, R3, E3, B>) =>
+    Fx(<R3>(sink: Emitter<R3, E, Out>) =>
       Effect.gen(function* ($) {
         const d = yield* $(Schedule.driver(schedule))
 
         let inputExit = yield* $(Effect.exit(effect))
 
         if (Exit.isFailure(inputExit)) {
-          return yield* $(sink.error(inputExit.cause))
+          return yield* $(sink.failCause(inputExit.cause))
         }
 
         let outputEither = yield* $(Effect.either(d.next(inputExit.value)))
@@ -65,7 +67,7 @@ export function scheduledOut<S, R2, A, Out>(schedule: Schedule.Schedule<S, R2, A
           inputExit = yield* $(Effect.exit(effect))
 
           if (Exit.isFailure(inputExit)) {
-            return yield* $(sink.error(inputExit.cause))
+            return yield* $(sink.failCause(inputExit.cause))
           }
 
           outputEither = yield* $(Effect.either(d.next(inputExit.value)))

package/src/since.test.ts

@@ -0,0 +1,40 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import * as Fiber from '@effect/core/io/Fiber'
+import * as TestClock from '@effect/core/testing/TestClock'
+import { TestEnvironment } from '@effect/core/testing/TestEnvironment'
+import { pipe } from '@fp-ts/data/Function'
+import { millis } from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.since.name, () => {
+    it('runs a stream since a signal is emitted to stop', async () => {
+      const sut = Effect.gen(function* ($) {
+        const fiber = yield* $(
+          pipe(
+            Fx.periodic(millis(10)),
+            Fx.scan(0, (x) => x + 1),
+            Fx.since(Fx.at(millis(100))(null)),
+            Fx.take(5),
+            Fx.runCollect,
+            Effect.fork,
+          ),
+        )
+
+        for (let i = 0; i < 15; i++) {
+          yield* $(TestClock.adjust(millis(10)))
+        }
+
+        return yield* $(Fiber.join(fiber))
+      })
+
+      const test = pipe(sut, Effect.provideLayer(TestEnvironment))
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [11, 12, 13, 14, 15])
+    })
+  })
+})

package/src/since.ts

@@ -1,47 +1,30 @@
 import * as Effect from '@effect/core/io/Effect'
-import { makeRef } from '@effect/core/io/Ref'
-import { flow, pipe } from '@fp-ts/data/Function'
+import { pipe } from '@fp-ts/data/Function'
+import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { exitEarly, onEarlyExitFailure } from './_internal.js'
 
-export function since<R2, E2, B, E3>(signal: Fx<R2, E2, B, E3>) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E, A, E1 | E2 | E3> =>
-    Fx(<R4, E4, C>(sink: Sink<E, A, R4, E4, C>) =>
-      Effect.gen(function* ($) {
-        const ref = yield* $(makeRef(() => false))
-        const deferred = yield* $(refCountDeferred<E1 | E2 | E3 | E4, C>(true))
-
-        yield* $(
-          Effect.fork(
-            signal.run(
-              Sink(
-                () => ref.set(true),
-                flow(Effect.failCause, deferred.error),
-                deferred.endIfComplete(sink.end),
-              ),
-            ),
-          ),
-        )
-
-        yield* $(
-          Effect.fork(
-            fx.run(
-              Sink(
-                (a) =>
-                  pipe(
-                    ref.get,
-                    Effect.flatMap((started) => (started ? sink.event(a) : Effect.unit)),
-                  ),
-                flow(sink.error, deferred.error),
-                deferred.endIfComplete(sink.end),
-              ),
-            ),
-          ),
-        )
+export function since<R2, E2, B>(signal: Fx<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> => since_(fx, signal)
+}
 
-        return yield* $(deferred.await)
-      }),
-    )
+function since_<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, signal: Fx<R2, E2, B>): Fx<R | R2, E | E2, A> {
+  return Fx((emitter) =>
+    pipe(
+      Effect.sync(() => new AtomicReference(false)),
+      Effect.tap((ref) =>
+        pipe(
+          signal.run(Emitter(() => exitEarly, emitter.failCause, Effect.unit)),
+          onEarlyExitFailure(Effect.sync(() => ref.set(true))),
+          Effect.forkScoped,
+        ),
+      ),
+      Effect.flatMap((ref) =>
+        fx.run(
+          Emitter((a) => (ref.get ? emitter.emit(a) : Effect.unit), emitter.failCause, emitter.end),
+        ),
+      ),
+    ),
+  )
 }

package/src/skipRepeats.test.ts

@@ -0,0 +1,28 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Equivalence from '@tsplus/stdlib/prelude/Equivalence'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.skipRepeats.name, () => {
+    it('skips repeating values', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2, 3]),
+            Fx.flatMap((n) => Fx.fromIterable([n, n, n])),
+            Fx.skipRepeats(Equivalence.strict<number>()),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [1, 2, 3])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/skipRepeats.ts

@@ -4,27 +4,26 @@ import { pipe } from '@fp-ts/data/Function'
 import * as Maybe from '@tsplus/stdlib/data/Maybe'
 import { Equivalence } from '@tsplus/stdlib/prelude/Equivalence'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
+import { Emitter, Fx } from './Fx.js'
 
 export function skipRepeats<A>(E: Equivalence<A>) {
   const equals = Maybe.getEquivalence(E).equals
 
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> =>
     Fx((sink) =>
       pipe(
         makeRef<Maybe.Maybe<A>>(() => Maybe.none),
         Effect.flatMap((ref) =>
           fx.run(
-            Sink(
+            Emitter(
               (a) =>
                 Effect.flatten(
-                  ref.modify((m) => [
-                    equals(m, Maybe.some(a)) ? Effect.unit : sink.event(a),
-                    Maybe.some(a),
-                  ]),
+                  ref.modify((m) => {
+                    const m2 = Maybe.some(a)
+                    return [equals(m, m2) ? Effect.unit : sink.emit(a), m2]
+                  }),
                 ),
-              sink.error,
+              sink.failCause,
               sink.end,
             ),
           ),

package/src/skipWhile.test.ts

@@ -0,0 +1,44 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.skipWhile.name, () => {
+    it('skips all values until a predicate is reached', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2, 3, 4, 3, 2, 1]),
+            Fx.skipWhile((x) => x < 4),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [4, 3, 2, 1])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+
+  describe(Fx.skipUntil.name, () => {
+    it('skips values until a predicate is matched', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2, 3, 4, 3, 2, 1]),
+            Fx.skipUntil((x) => x > 3),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [4, 3, 2, 1])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/skipWhile.ts

@@ -1,31 +1,45 @@
 import * as Effect from '@effect/core/io/Effect'
+import * as Ref from '@effect/core/io/Ref'
 import { pipe } from '@fp-ts/data/Function'
-import { Predicate, not } from '@fp-ts/data/Predicate'
+import { Predicate, not } from '@tsplus/stdlib/data/Predicate'
 
-import { Fx } from './Fx.js'
+import { Emitter, Fx } from './Fx.js'
+import { onEarlyExitFailure } from './_internal.js'
 
 export function skipWhile<A>(predicate: Predicate<A>) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
-    Fx((sink) =>
-      Effect.suspendSucceed(() => {
-        let started = false
-
-        return fx.run({
-          ...sink,
-          event: (a) => {
-            if (!started && predicate(a)) {
-              return Effect.unit
-            }
-
-            started = true
-
-            return sink.event(a)
-          },
-        })
-      }),
-    )
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => skipWhile_(fx, predicate)
 }
 
 export function skipUntil<A>(predicate: Predicate<A>) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> => pipe(fx, skipWhile(not(predicate)))
+  return skipWhile(not(predicate))
+}
+
+function skipWhile_<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return Fx((emitter) =>
+    pipe(
+      Ref.makeRef<boolean>(() => false),
+      Effect.flatMap((ref) =>
+        pipe(
+          fx.run(
+            Emitter(
+              (a) =>
+                pipe(
+                  ref.get,
+                  Effect.flatMap((started) =>
+                    started
+                      ? emitter.emit(a)
+                      : predicate(a)
+                      ? Effect.unit
+                      : pipe(ref.set(true), Effect.zipRight(emitter.emit(a))),
+                  ),
+                ),
+              emitter.failCause,
+              emitter.end,
+            ),
+          ),
+        ),
+      ),
+      onEarlyExitFailure(emitter.end),
+    ),
+  )
 }

package/src/slice.test.ts

@@ -1,19 +1,21 @@
 import { deepStrictEqual } from 'assert'
 
-import { unsafeRunPromise } from '@effect/core/io/Effect'
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
 
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
-import { slice } from './slice.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
-  describe('slice', () => {
-    it('skips and takes a set amount of values', async () => {
-      const values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-      const test = collectAll(slice(2, 4)(from(values)))
-      const events = await unsafeRunPromise(test)
+  describe(Fx.slice.name, () => {
+    it('skips/takes values from a Fx', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+        Fx.slice(3, 4),
+        Fx.runCollect,
+        Effect.unsafeRunPromise,
+      )
 
-      deepStrictEqual(events, [3, 4, 5, 6])
+      deepStrictEqual(result, [4, 5, 6, 7])
     })
   })
 })

package/src/slice.ts

@@ -1,53 +1,47 @@
 import * as Effect from '@effect/core/io/Effect'
-import * as Exit from '@effect/core/io/Exit'
 import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { deferredCallback } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { exitEarly, onEarlyExitFailure } from './_internal.js'
 
-export function slice(skip: number, take: number) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
-    Fx(<R2, E2, B>(sink: Sink<E, A, R2, E2, B>) =>
-      deferredCallback<E1 | E2, B, R | R2, E1 | E2>((cb) => {
-        let toSkip = skip
-        let toTake = take
-
-        return fx.run({
-          ...sink,
-          event: (a) => {
-            if (toSkip > 0) {
-              toSkip -= 1
-              return Effect.unit
-            }
-
-            if (toTake === 0) {
-              return Effect.unit
-            }
+// TODO: Commutation with map
+// TODO: Fusion with other slices
 
-            toTake -= 1
-
-            return pipe(
-              sink.event(a),
-              Effect.flatMap(() =>
-                toTake === 0
-                  ? pipe(
-                      sink.end,
-                      Effect.tap((b) => cb(Exit.succeed(b))),
-                    )
-                  : Effect.unit,
-              ),
-            )
-          },
-        })
-      }),
+export function slice(skip: number, take: number) {
+  return <R, E, A>(push: Fx<R, E, A>): Fx<R, E, A> =>
+    Fx((emitter) =>
+      pipe(
+        Effect.suspendSucceed(() => {
+          let toSkip = skip
+          let toTake = take
+
+          return push.run(
+            Emitter(
+              (a) => {
+                if (toSkip > 0) {
+                  --toSkip
+                  return Effect.unit
+                }
+
+                return pipe(
+                  emitter.emit(a),
+                  Effect.flatMap(() => (--toTake === 0 ? exitEarly : Effect.unit)),
+                )
+              },
+              emitter.failCause,
+              emitter.end,
+            ),
+          )
+        }),
+        onEarlyExitFailure(emitter.end),
+      ),
     )
 }
 
-export function skip(skip: number) {
-  return slice(skip, Infinity)
+export function skip(n: number) {
+  return slice(n, Infinity)
 }
 
-export function take(take: number) {
-  return slice(0, take)
+export function take(n: number) {
+  return slice(0, n)
 }

package/src/snapshot.test.ts

@@ -0,0 +1,51 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.snapshot.name, () => {
+    it('provides a service to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2, 3]),
+            Fx.delay(Duration.millis(10)),
+            Fx.snapshot(Fx.succeed(10), (x, y) => x * y),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [10, 20, 30])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+
+  describe(Fx.sample.name, () => {
+    it('provides a service to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2, 3]),
+            Fx.delay(Duration.millis(10)),
+            Fx.sample(Fx.succeed(1)),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [
+          [1, 1],
+          [2, 1],
+          [3, 1],
+        ])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/snapshot.ts

@@ -1,47 +1,58 @@
 import * as Effect from '@effect/core/io/Effect'
-import * as Ref from '@effect/core/io/Ref'
-import { flow, pipe } from '@fp-ts/data/Function'
+import { pipe } from '@fp-ts/data/Function'
+import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
 import * as Maybe from '@tsplus/stdlib/data/Maybe'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
+import { Emitter, Fx } from './Fx.js'
 
-export function snapshot<R2, E2, B, E3, A, C>(sampled: Fx<R2, E2, B, E3>, f: (a: A, b: B) => C) {
-  return <R, E, E1>(sampler: Fx<R, E, A, E1>): Fx<R | R2, E | E2, C, E1 | E3> =>
-    Fx((sink) =>
-      Effect.gen(function* ($) {
-        const ref = yield* $(Ref.makeRef<Maybe.Maybe<B>>(() => Maybe.none))
-
-        yield* $(
-          Effect.fork(sampled.run(Sink(flow(Maybe.some, ref.set), Effect.failCause, Effect.unit))),
-        )
-
-        return yield* $(
-          sampler.run(
-            Sink(
-              (a) =>
-                pipe(
-                  ref.get,
-                  Effect.flatMap(
-                    Maybe.fold(
-                      () => Effect.unit,
-                      (b) => sink.event(f(a, b)),
-                    ),
-                  ),
-                ),
-              sink.error,
-              sink.end,
-            ),
-          ),
-        )
-      }),
-    )
+export function snapshot<R2, E2, B, A, R3, E3, C>(sampled: Fx<R2, E2, B>, f: (b: B, a: A) => C) {
+  return <R, E>(sampler: Fx<R, E, A>): Fx<R & R2 & R3, E | E2 | E3, C> =>
+    snapshot_(sampler, sampled, f)
 }
 
-export function sample<R2, E2, B, E3>(sampled: Fx<R2, E2, B, E3>) {
-  return <R, E, A, E1>(sampler: Fx<R, E, A, E1>): Fx<R | R2, E | E2, B, E1 | E3> =>
+export function sample<R2, E2, B>(sampled: Fx<R2, E2, B>) {
+  return <R, E, A>(sampler: Fx<R, E, A>): Fx<R | R2, E | E2, readonly [A, B]> =>
     pipe(
       sampler,
-      snapshot(sampled, (_, b) => b),
+      snapshot(sampled, (b, a) => [a, b]),
     )
 }
+
+function snapshot_<R, E, A, R2, E2, B, R3, E3, C>(
+  sampler: Fx<R, E, A>,
+  sampled: Fx<R2, E2, B>,
+  f: (b: B, a: A) => C,
+): Fx<R | R2 | R3, E | E2 | E3, C> {
+  return Fx((emitter) =>
+    pipe(
+      Effect.sync(() => new AtomicReference<Maybe.Maybe<B>>(Maybe.none)),
+      Effect.tap((ref) =>
+        Effect.forkScoped(
+          sampled.run(
+            Emitter(
+              (a) => Effect.sync(() => ref.set(Maybe.some(a))),
+              emitter.failCause,
+              Effect.unit,
+            ),
+          ),
+        ),
+      ),
+      Effect.flatMap((ref) =>
+        sampler.run(
+          Emitter(
+            (a) =>
+              pipe(
+                ref.get,
+                Maybe.fold(
+                  () => Effect.unit,
+                  (b) => emitter.emit(f(b, a)),
+                ),
+              ),
+            emitter.failCause,
+            emitter.end,
+          ),
+        ),
+      ),
+    ),
+  )
+}

package/src/suspendSucceed.ts

@@ -1,7 +1,5 @@
-import * as Effect from '@effect/core/io/Effect'
-
 import { Fx } from './Fx.js'
 
-export function suspendSucceed<R, E, A, E1>(f: () => Fx<R, E, A, E1>): Fx<R, E, A, E1> {
-  return Fx((sink) => Effect.suspendSucceed(() => f().run(sink)))
+export function suspendSucceed<R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A> {
+  return Fx((emitter) => f().run(emitter))
 }