@typed/fx 1.13.0 → 1.15.0

package/src/skipRepeats.ts

@@ -1,7 +1,7 @@
-import { equals } from '@effect/data/Equal'
 import * as Option from '@effect/data/Option'
-import type { Equivalence } from '@effect/data/typeclass/Equivalence'
+import type { Equivalence } from '@effect/data/Equivalence'
 import * as Effect from '@effect/io/Effect'
+import fastDeepEqual from 'fast-deep-equal/es6'
 
 import { Fx, Sink } from './Fx.js'
 
@@ -9,15 +9,13 @@ export function skipRepeatsWith<R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): F
   return Fx((sink) =>
     Effect.suspend(() => {
       let previous: Option.Option<A> = Option.none()
-      const isPrevious = Option.contains(eq)
+      const isPrevious = Option.containsWith(eq)
 
       return fx.run(
         Sink(
           (a) =>
             Effect.suspend(() =>
-              isPrevious(previous, a)
-                ? Effect.unit()
-                : sink.event(((previous = Option.some(a)), a)),
+              isPrevious(previous, a) ? Effect.unit : sink.event(((previous = Option.some(a)), a)),
             ),
           sink.error,
         ),
@@ -27,5 +25,5 @@ export function skipRepeatsWith<R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): F
 }
 
 export function skipRepeats<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
-  return skipRepeatsWith(fx, equals)
+  return skipRepeatsWith(fx, fastDeepEqual)
 }

package/src/skipWhile.ts

@@ -14,7 +14,7 @@ export function skipWhile<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx
           (a) =>
             Effect.suspend(() => {
               if (skipping) {
-                return predicate(a) ? Effect.unit() : sink.event(((skipping = false), a))
+                return predicate(a) ? Effect.unit : sink.event(((skipping = false), a))
               }
 
               return sink.event(a)

package/src/slice.ts

@@ -15,17 +15,17 @@ export function slice<R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<
               Effect.suspend(() => {
                 if (toSkip > 0) {
                   toSkip -= 1
-                  return Effect.unit()
+                  return Effect.unit
                 }
 
                 if (toTake > 0) {
                   toTake -= 1
                   return Effect.tap(sink.event(a), () =>
-                    Effect.sync(() => toTake === 0 && cb(Effect.unit())),
+                    Effect.sync(() => toTake === 0 && cb(Effect.unit)),
                   )
                 }
 
-                return Effect.sync(() => cb(Effect.unit()))
+                return Effect.sync(() => cb(Effect.unit))
               }),
             sink.error,
           ),

package/src/struct.ts

@@ -0,0 +1,18 @@
+import { Fx } from './Fx.js'
+import { combineAll } from './combineAll.js'
+import { map } from './map.js'
+
+export function struct<FXS extends Readonly<Record<string, Fx<any, any, any>>>>(
+  fx: FXS,
+): Fx<
+  Fx.ResourcesOf<FXS[string]>,
+  Fx.ErrorsOf<FXS[string]>,
+  {
+    readonly [K in keyof FXS]: Fx.OutputOf<FXS[K]>
+  }
+> {
+  return map(
+    combineAll(...Object.entries(fx).map(([key, value]) => map(value, (x) => [key, x] as const))),
+    Object.fromEntries,
+  )
+}

package/src/switchMapCause.ts

@@ -1,3 +1,4 @@
+import * as Chunk from '@effect/data/Chunk'
 import * as Either from '@effect/data/Either'
 import { pipe } from '@effect/data/Function'
 import * as Cause from '@effect/io/Cause'
@@ -29,7 +30,7 @@ export function switchMapError<R, E, A, R2, E2, B>(
   f: (e: E) => Fx<R2, E2, B>,
 ): Fx<R | R2, E2, A | B> {
   return switchMapCause(fx, (cause) =>
-    pipe(cause, Cause.failureOrCause, Either.match(f, failCause)),
+    pipe(cause, Cause.failureOrCause, Either.match({ onLeft: f, onRight: failCause })),
   )
 }
 
@@ -39,3 +40,18 @@ export function switchMapErrorEffect<R, E, A, R2, E2, B>(
 ): Fx<R | R2, E2, A | B> {
   return switchMapError(fx, (a) => fromEffect(f(a)))
 }
+
+export function switchMapDefect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: unknown) => Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, A | B> {
+  return switchMapCause(fx, (cause): Fx<R | R2, E | E2, A | B> => {
+    const defects = Cause.defects(cause)
+
+    if (Chunk.size(defects) > 0) {
+      return f(Chunk.unsafeHead(defects))
+    }
+
+    return failCause(cause)
+  })
+}

package/src/switchMatch.ts

@@ -32,7 +32,7 @@ export function switchMatch<R, E, A, R2, E2, B, R3, E3, C>(
 ): Fx<R | R2 | R3, E2 | E3, B | C> {
   return switchMatchCause(
     fx,
-    (cause) => pipe(cause, Cause.failureOrCause, Either.match(f, failCause)),
+    (cause) => pipe(cause, Cause.failureOrCause, Either.match({ onLeft: f, onRight: failCause })),
     g,
   )
 }

package/src/takeWhile.ts

@@ -7,7 +7,7 @@ import { Fx, Sink } from './Fx.js'
 export function takeWhile<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
   return Fx(<R2>(sink: Sink<R2, E, A>) =>
     Effect.asyncEffect<never, never, void, R | R2, never, void>((cb) => {
-      const exit = Effect.sync(() => cb(Effect.unit()))
+      const exit = Effect.sync(() => cb(Effect.unit))
 
       return Effect.tap(
         fx.run(

package/src/tap.ts

@@ -8,7 +8,11 @@ export function tap<R, E, A, R2, E2, B>(
 ): Fx<R | R2, E | E2, A> {
   return Fx(<R3>(sink: Sink<R3, E | E2, A>) =>
     fx.run<R2 | R3>(
-      Sink((a: A) => Effect.matchCauseEffect(f(a), sink.error, () => sink.event(a)), sink.error),
+      Sink(
+        (a: A) =>
+          Effect.matchCauseEffect(f(a), { onFailure: sink.error, onSuccess: () => sink.event(a) }),
+        sink.error,
+      ),
     ),
   )
 }

package/src/tapCause.ts

@@ -11,11 +11,10 @@ export function tapCause<R, E, A, R2, E2, B>(
   return Fx((sink) =>
     fx.run(
       Sink(sink.event, (cause) =>
-        Effect.matchCauseEffect(
-          f(cause),
-          (cause2) => sink.error(Cause.sequential(cause, cause2)),
-          () => sink.error(cause),
-        ),
+        Effect.matchCauseEffect(f(cause), {
+          onFailure: (cause2) => sink.error(Cause.sequential(cause, cause2)),
+          onSuccess: () => sink.error(cause),
+        }),
       ),
     ),
   )
@@ -33,7 +32,10 @@ export function tapError<R, E, A, R2, E2, B>(
   f: (error: E) => Effect.Effect<R, E2, B>,
 ): Fx<R | R2, E | E2, A> {
   return tapCause(fx, (cause) =>
-    pipe(Cause.failureOrCause(cause), Effect.matchEffect(f, Effect.failCause)),
+    pipe(
+      Cause.failureOrCause(cause),
+      Effect.matchEffect({ onFailure: f, onSuccess: Effect.failCause }),
+    ),
   )
 }
 

package/src/test-utils.ts

@@ -13,7 +13,7 @@ export function testCollectAll<E = never, A = never>(
   fx: Fx<never, E, A>,
   expected: ReadonlyArray<A>,
 ) {
-  it(name, async () => {
+  it.concurrent(name, async () => {
     const test = Effect.scoped(
       Effect.gen(function* ($) {
         const values: Array<A> = []
@@ -30,7 +30,7 @@ export function testCollectAll<E = never, A = never>(
 
 export function testCause<E, A>(name: string, fx: Fx<never, E, A>, expected: Cause.Cause<E>) {
   it(name, async () => {
-    const exit = await Effect.runPromiseExit(Effect.scoped(observe(fx, () => Effect.unit())))
+    const exit = await Effect.runPromiseExit(Effect.scoped(observe(fx, () => Effect.unit)))
 
     ok(Exit.isFailure(exit))
     expect(Cause.unannotate(exit.cause)).toEqual(expected)

package/src/toArray.ts

@@ -5,11 +5,12 @@ import type { Fx } from './Fx.js'
 import { observe } from './observe.js'
 
 export function toArray<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, Array<A>> {
-  return Effect.gen(function* ($) {
+  return Effect.suspend(() => {
     const array: Array<A> = []
 
-    yield* $(observe(fx, (a) => Effect.sync(() => array.push(a))))
-
-    return array
+    return Effect.map(
+      observe(fx, (a) => Effect.sync(() => array.push(a))),
+      () => array,
+    )
   })
 }

package/src/toEnqueue.ts

@@ -0,0 +1,13 @@
+import * as Effect from '@effect/io/Effect'
+import * as Q from '@effect/io/Queue'
+import * as Scope from '@effect/io/Scope'
+
+import { Fx } from './Fx.js'
+import { observe } from './observe.js'
+
+export function toEnqueue<R, E, A>(
+  fx: Fx<R, E, A>,
+  enqueue: Q.Enqueue<A>,
+): Effect.Effect<R | Scope.Scope, E, void> {
+  return observe(fx, enqueue.offer)
+}

package/tsconfig.build.json

@@ -2,6 +2,7 @@
   "extends": "./tsconfig.json",
   "exclude": [
     "src/**/*.test.ts",
+    "src/**/*.test-d.ts",
     "dist"
   ]
-}
+}