@typed/fx 0.0.9 → 0.0.12

package/src/observe.ts

@@ -1,24 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { Fiber } from '@effect/core/io/Fiber'
-
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-
-export function observeNow<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Effect.Effect<R | R2, E | E1 | E2, void> =>
-    fx.run(Sink<E, A, R | R2, E | E1 | E2, void>(f, Effect.failCause, Effect.unit))
-}
-
-export function observe<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
-  return <R, E, E1>(
-    fx: Fx<R, E, A, E1>,
-  ): Effect.Effect<R | R2, never, Fiber.Runtime<E | E1 | E2, void>> =>
-    Effect.fork(observeNow(f)(fx))
-}
-
-export function observeDaemon<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
-  return <R, E, E1>(
-    fx: Fx<R, E, A, E1>,
-  ): Effect.Effect<R | R2, never, Fiber.Runtime<E | E1 | E2, void>> =>
-    Effect.forkDaemon(observeNow(f)(fx))
-}

package/src/reduce.ts

@@ -1,81 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { makeRef } from '@effect/core/io/Ref'
-import { pipe } from '@fp-ts/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { FilterMapFx, MapFx } from './map.js'
-
-export function reduceFilterMap<R, E, A, E1, B>(seed: B, f: (b: B, a: A) => Maybe.Maybe<B>) {
-  return (fx: Fx<R, E, A, E1>): Effect.Effect<R, E1 | E, B> => {
-    return reduceFilterMap_(fx, seed, f)
-  }
-}
-
-export function reduce<B, A>(seed: B, f: (b: B, a: A) => B) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Effect.Effect<R, E | E1, B> => {
-    if (fx instanceof FilterMapFx) {
-      return pipe(
-        fx.fx,
-        reduceFilterMap(seed, (b, a) =>
-          pipe(
-            a,
-            fx.f,
-            Maybe.map((a2) => f(b, a2)),
-          ),
-        ),
-      )
-    }
-
-    if (fx instanceof MapFx) {
-      return pipe(
-        fx.fx,
-        reduce(seed, (b, a) => f(b, fx.f(a))),
-      )
-    }
-
-    return reduce_(fx, seed, f)
-  }
-}
-
-export function collectAll<R, E, A, E1>(
-  fx: Fx<R, E, A, E1>,
-): Effect.Effect<R, E | E1, readonly A[]> {
-  return reduce_(fx, [] as readonly A[], (b, a) => b.concat([a]))
-}
-
-function reduce_<R, E, A, E1, B>(fx: Fx<R, E, A, E1>, seed: B, f: (b: B, a: A) => B) {
-  return pipe(
-    makeRef<B>(() => seed),
-    Effect.flatMap((ref) =>
-      fx.run(Sink((a) => ref.update((b) => f(b, a)), Effect.failCause, ref.get)),
-    ),
-  )
-}
-
-function reduceFilterMap_<R, E, A, E1, B>(
-  fx: Fx<R, E, A, E1>,
-  seed: B,
-  f: (b: B, a: A) => Maybe.Maybe<B>,
-) {
-  return pipe(
-    makeRef<B>(() => seed),
-    Effect.flatMap((ref) =>
-      fx.run(
-        Sink(
-          (a) =>
-            ref.modify((b) => [
-              null,
-              pipe(
-                f(b, a),
-                Maybe.getOrElse(() => b),
-              ),
-            ]),
-          Effect.failCause,
-          ref.get,
-        ),
-      ),
-    ),
-  )
-}

package/src/takeUntil.ts

@@ -1,29 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Exit from '@effect/core/io/Exit'
-import { pipe } from '@fp-ts/data/Function'
-import { Predicate } from '@fp-ts/data/Predicate'
-
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { deferredCallback } from './_internal.js'
-
-export function takeUntil<A>(predicate: Predicate<A>) {
-  return <R, E, 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) => {
-        return fx.run({
-          ...sink,
-          event: (a) => {
-            if (!predicate(a)) {
-              return sink.event(a)
-            }
-
-            return pipe(
-              sink.end,
-              Effect.tap((b) => cb(Exit.succeed(b))),
-            )
-          },
-        })
-      }),
-    )
-}

package/src/tap.ts

@@ -1,48 +0,0 @@
-import * as Cause from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import { flow, pipe } from '@fp-ts/data/Function'
-import * as Either from '@tsplus/stdlib/data/Either'
-
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { map } from './map.js'
-
-export function tap<A, B>(f: (a: A) => B) {
-  return map((a: A) => (f(a), a))
-}
-
-export function tapEffect<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A, E1 | E2> =>
-    Fx((sink) =>
-      fx.run(Sink((a) => pipe(a, f, Effect.zipRight(sink.event(a))), sink.error, sink.end)),
-    )
-}
-
-export function tapCauseEffect<E, R2, E2, B>(f: (e: Cause.Cause<E>) => Effect.Effect<R2, E2, B>) {
-  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A, E1 | E2> =>
-    Fx((sink) =>
-      fx.run(Sink(sink.event, (e) => pipe(e, f, Effect.zipRight(sink.error(e))), sink.end)),
-    )
-}
-
-export function tapErrorEffect<E, R2, E2, B>(f: (e: E) => Effect.Effect<R2, E2, B>) {
-  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A, E1 | E2> =>
-    Fx((sink) =>
-      fx.run(
-        Sink(
-          sink.event,
-          (e) =>
-            pipe(
-              Cause.failureOrCause(e),
-              Either.fold(flow(f, Effect.zipRight(sink.error(e))), sink.error),
-            ),
-          sink.end,
-        ),
-      ),
-    )
-}
-
-export function tapEndEffect<R2, E2, B>(effect: Effect.Effect<R2, E2, B>) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A, E1 | E2> =>
-    Fx((sink) => fx.run(Sink(sink.event, sink.error, Effect.zipRight(sink.end)(effect))))
-}

package/src/zipItems.test.ts

@@ -1,21 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { unsafeRunPromise } from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-
-import { periodic } from './periodic.js'
-import { collectAll } from './reduce.js'
-import { withItems } from './zipItems.js'
-
-describe(import.meta.url, () => {
-  describe('withItems', () => {
-    it('zips together an Fx with an Array', async () => {
-      const values = [1, 2, 3]
-      const test = pipe(periodic(Duration.millis(10)), withItems(values))
-      const events = await pipe(test, collectAll, unsafeRunPromise)
-
-      deepStrictEqual(events, values)
-    })
-  })
-})

package/src/zipItems.ts

@@ -1,41 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Exit from '@effect/core/io/Exit'
-import { flow, pipe } from '@fp-ts/data/Function'
-import { identity } from '@tsplus/stdlib/data/Function'
-
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { deferredCallback } from './_internal.js'
-
-export function zipItems<A, B, C>(array: ReadonlyArray<A>, f: (a: A, b: B) => C) {
-  return <R, E, E1>(fx: Fx<R, E, B, E1>): Fx<R, E, C, E1> =>
-    Fx(<R2, E2, D>(sink: Sink<E, C, R2, E2, D>) =>
-      deferredCallback<E1 | E2, D, R | R2, E1 | E2>((cb) => {
-        let i = 0
-
-        return fx.run(
-          Sink(
-            (b) => {
-              const a = array[i++]
-              const c = f(a, b)
-
-              return pipe(
-                sink.event(c),
-                Effect.flatMap((x) =>
-                  i === array.length
-                    ? pipe(sink.end, Effect.flatMap(flow(Exit.succeed, cb)))
-                    : Effect.succeed(x),
-                ),
-              )
-            },
-            sink.error,
-            sink.end,
-          ),
-        )
-      }),
-    )
-}
-
-export function withItems<A>(array: ReadonlyArray<A>) {
-  return <R, E, B, E1>(fx: Fx<R, E, B, E1>): Fx<R, E, A, E1> => pipe(fx, zipItems(array, identity))
-}