@typed/fx 1.23.0 → 1.24.1

package/src/internal/share.ts

@@ -10,10 +10,10 @@ import * as Subject from "../Subject.js"
 import { withScopedFork } from "./helpers.js"
 import { FxBase } from "./protos.js"
 
-export function share<R, E, A, R2>(
-  fx: Fx<R, E, A>,
-  subject: Subject.Subject<R2, E, A>
-): Fx<R | R2 | Scope.Scope, E, A> {
+export function share<A, E, R, R2>(
+  fx: Fx<A, E, R>,
+  subject: Subject.Subject<A, E, R2>
+): Fx<A, E, R | R2 | Scope.Scope> {
   return new Share(fx, subject)
 }
 
@@ -29,18 +29,18 @@ class RefCounter {
   }
 }
 
-export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
+export class Share<A, E, R, R2> extends FxBase<A, E, R | R2 | Scope.Scope> {
   _FxFiber: MutableRef.MutableRef<Option.Option<Fiber.Fiber<unknown>>> = MutableRef.make(Option.none())
   _RefCount = new RefCounter()
 
   constructor(
-    readonly i0: Fx<R, E, A>,
-    readonly i1: Subject.Subject<R2, E, A>
+    readonly i0: Fx<A, E, R>,
+    readonly i1: Subject.Subject<A, E, R2>
   ) {
     super()
   }
 
-  run<R3>(sink: Sink<R3, E, A>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope> {
+  run<R3>(sink: Sink<A, E, R3>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope> {
     return withScopedFork(
       (fork) =>
         Effect.flatMap(
@@ -89,24 +89,24 @@ export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
   }
 }
 
-export function multicast<R, E, A>(
-  fx: Fx<R, E, A>
-): Fx<R | Scope.Scope, E, A> {
-  return new Share(fx, Subject.unsafeMake<E, A>(0))
+export function multicast<A, E, R>(
+  fx: Fx<A, E, R>
+): Fx<A, E, R | Scope.Scope> {
+  return new Share(fx, Subject.unsafeMake<A, E>(0))
 }
 
-export function hold<R, E, A>(
-  fx: Fx<R, E, A>
-): Fx<R | Scope.Scope, E, A> {
-  return new Share(fx, Subject.unsafeMake<E, A>(1))
+export function hold<A, E, R>(
+  fx: Fx<A, E, R>
+): Fx<A, E, R | Scope.Scope> {
+  return new Share(fx, Subject.unsafeMake<A, E>(1))
 }
 
 export const replay: {
-  (capacity: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
-  <R, E, A>(fx: Fx<R, E, A>, capacity: number): Fx<R, E, A>
-} = dual(2, function replay<R, E, A>(
-  fx: Fx<R, E, A>,
+  (capacity: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>
+  <A, E, R>(fx: Fx<A, E, R>, capacity: number): Fx<A, E, R>
+} = dual(2, function replay<A, E, R>(
+  fx: Fx<A, E, R>,
   capacity: number
-): Fx<R | Scope.Scope, E, A> {
-  return new Share(fx, Subject.unsafeMake<E, A>(capacity))
+): Fx<A, E, R | Scope.Scope> {
+  return new Share(fx, Subject.unsafeMake<A, E>(capacity))
 })

package/src/internal/sync-operator.ts

@@ -80,8 +80,8 @@ export function matchSyncOperator<A>(operator: SyncOperator, matchers: {
 
 export function compileSyncOperatorSink<R>(
   operator: SyncOperator,
-  sink: Sink.Sink<R, any, any>
-): Sink.Sink<R, any, any> {
+  sink: Sink.Sink<any, any, R>
+): Sink.Sink<any, any, R> {
   return matchSyncOperator(operator, {
     Map: (op) => Sink.map(sink, op.f),
     Filter: (op) => Sink.filter(sink, op.f),
@@ -91,8 +91,8 @@ export function compileSyncOperatorSink<R>(
 
 export function compileCauseSyncOperatorSink<R>(
   operator: SyncOperator,
-  sink: Sink.Sink<R, any, any>
-): Sink.Sink<R, any, any> {
+  sink: Sink.Sink<any, any, R>
+): Sink.Sink<any, any, R> {
   return matchSyncOperator(operator, {
     Map: (op) => Sink.make((a) => sink.onFailure(op.f(a)), sink.onSuccess),
     Filter: (op) => Sink.make((a) => op.f(a) ? sink.onFailure(a) : Effect.unit, sink.onSuccess),

package/src/internal/sync-producer.ts

@@ -47,7 +47,7 @@ export const matchSyncProducer = <A, R>(
 
 export function runSink<A, R, E>(
   producer: SyncProducer<A>,
-  sink: Sink<R, E, A>
+  sink: Sink<A, E, R>
 ): Effect.Effect<unknown, never, R> {
   return matchSyncProducer(producer, {
     Success: (a) => sink.onSuccess(a),
@@ -70,7 +70,7 @@ export function runReduce<A, B>(
   })
 }
 
-export function runReduceEffect<A, R2, E2, B>(
+export function runReduceEffect<A, B, E2, R2>(
   producer: SyncProducer<A>,
   initial: B,
   f: (b: B, a: any) => Effect.Effect<B, E2, R2>
@@ -83,7 +83,7 @@ export function runReduceEffect<A, R2, E2, B>(
   })
 }
 
-function arrayToSink<A, R2>(array: ReadonlyArray<A>, sink: Sink<R2, never, A>): Effect.Effect<unknown, never, R2> {
+function arrayToSink<A, R2>(array: ReadonlyArray<A>, sink: Sink<A, never, R2>): Effect.Effect<unknown, never, R2> {
   if (array.length === 0) return Effect.unit
   else if (array.length === 1) return sink.onSuccess(array[0])
   else {
@@ -96,7 +96,7 @@ function arrayToSink<A, R2>(array: ReadonlyArray<A>, sink: Sink<R2, never, A>):
   }
 }
 
-function iterableToSink<A, R2>(array: Iterable<A>, sink: Sink<R2, never, A>): Effect.Effect<unknown, never, R2> {
+function iterableToSink<A, R2>(array: Iterable<A>, sink: Sink<A, never, R2>): Effect.Effect<unknown, never, R2> {
   let effect: Effect.Effect<any, never, R2> = Effect.unit
 
   for (const item of array) {
@@ -121,7 +121,7 @@ export const syncOnce = <A>(f: () => A): Effect.Effect<A> => {
   return Effect.sync(get)
 }
 
-export const effectOnce = <R, E, A>(f: () => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => {
+export const effectOnce = <A, E, R>(f: () => Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => {
   let memoized: Option.Option<A> = Option.none()
 
   return Effect.suspend(() => {
@@ -133,7 +133,7 @@ export const effectOnce = <R, E, A>(f: () => Effect.Effect<A, E, R>): Effect.Eff
   })
 }
 
-export function runEffect<A, R2, E2, B>(
+export function runEffect<A, B, E2, R2>(
   producer: SyncProducer<A>,
   f: (a: A) => Effect.Effect<B, E2, R2>
 ): Effect.Effect<void, E2, R2> {

package/src/internal/withKey.ts

@@ -9,28 +9,28 @@ import * as Sink from "../Sink.js"
 import { withSwitchFork } from "./helpers.js"
 import { FxBase } from "./protos.js"
 
-export function withKey<R, E, A, B extends PropertyKey, R2, E2, C>(
-  fx: Fx<R, E, A>,
-  options: WithKeyOptions<A, B, R2, E2, C>
-): Fx<R | R2 | Scope.Scope, E | E2, C> {
+export function withKey<A, E, R, B extends PropertyKey, C, E2, R2>(
+  fx: Fx<A, E, R>,
+  options: WithKeyOptions<A, B, C, E2, R2>
+): Fx<C, E | E2, R | R2 | Scope.Scope> {
   return new WithKey(fx, options)
 }
 
-class WithKey<R, E, A, B extends PropertyKey, R2, E2, C> extends FxBase<R | R2 | Scope.Scope, E | E2, C> {
-  constructor(readonly fx: Fx<R, E, A>, readonly options: WithKeyOptions<A, B, R2, E2, C>) {
+class WithKey<A, E, R, B extends PropertyKey, C, E2, R2> extends FxBase<C, E | E2, R | R2 | Scope.Scope> {
+  constructor(readonly fx: Fx<A, E, R>, readonly options: WithKeyOptions<A, B, C, E2, R2>) {
     super()
   }
 
-  run<R3>(sink: Sink.Sink<R3, E | E2, C>) {
+  run<R3>(sink: Sink.Sink<C, E | E2, R3>) {
     return runWithKey(this.fx, this.options, sink)
   }
 }
 
-function runWithKey<R, E, A, B extends PropertyKey, R2, E2, C, R3>(
-  fx: Fx<R, E, A>,
-  options: WithKeyOptions<A, B, R2, E2, C>,
-  sink: Sink.Sink<R3, E | E2, C>
-) {
+function runWithKey<A, E, R, B extends PropertyKey, C, E2, R2, R3>(
+  fx: Fx<A, E, R>,
+  options: WithKeyOptions<A, B, C, E2, R2>,
+  sink: Sink.Sink<C, E | E2, R3>
+): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope> {
   return withSwitchFork((fork) => {
     let previous: Option.Option<WithKeyState<A, B>> = Option.none()
 
@@ -78,5 +78,5 @@ function runWithKey<R, E, A, B extends PropertyKey, R2, E2, C, R3>(
 type WithKeyState<A, B> = {
   value: A
   key: B
-  ref: RefSubject.RefSubject<never, never, A>
+  ref: RefSubject.RefSubject<A>
 }