@typed/fx 1.22.2 → 1.24.0

package/src/internal/loop-operator.ts

@@ -216,14 +216,14 @@ export function fuseLoopOperators<A, B, C, D, E>(
   })
 }
 
-export function compileLoopOperatorSink<R>(operator: SyncLoopOperator, sink: Sink.Sink<R, any, any>) {
+export function compileLoopOperatorSink<R>(operator: SyncLoopOperator, sink: Sink.Sink<any, any, R>) {
   return matchSyncLoopOperator(operator, {
     Loop: (op) => Sink.loop(sink, op.seed, op.f),
     FilterMapLoop: (op) => Sink.filterMapLoop(sink, op.seed, op.f)
   })
 }
 
-export function compileCauseLoopOperatorSink<R>(operator: SyncLoopOperator, sink: Sink.Sink<R, any, any>) {
+export function compileCauseLoopOperatorSink<R>(operator: SyncLoopOperator, sink: Sink.Sink<any, any, R>) {
   return matchSyncLoopOperator(operator, {
     Loop: (op) => Sink.loopCause(sink, op.seed, op.f),
     FilterMapLoop: (op) => Sink.filterMapLoopCause(sink, op.seed, op.f)

package/src/internal/operator.ts

@@ -68,7 +68,7 @@ export function fuseOperators(first: Operator, second: Operator): Operator {
   })
 }
 
-export function compileOperatorSink<R, R2>(operator: Operator, sink: Sink<R, any, any>): Sink<R | R2, any, any> {
+export function compileOperatorSink<R, R2>(operator: Operator, sink: Sink<any, any, R>): Sink<any, any, R | R2> {
   return matchOperator(operator, {
     SyncOperator: (op) => SyncOp.compileSyncOperatorSink(op, sink),
     EffectOperator: (op) => EffectOp.compileEffectOperatorSink(op, sink),
@@ -77,7 +77,7 @@ export function compileOperatorSink<R, R2>(operator: Operator, sink: Sink<R, any
   })
 }
 
-export function compileOperatorSinkCause<R, R2>(operator: Operator, sink: Sink<R, any, any>): Sink<R | R2, any, any> {
+export function compileOperatorSinkCause<R, R2>(operator: Operator, sink: Sink<any, any, R>): Sink<any, any, R | R2> {
   return matchOperator(operator, {
     SyncOperator: (op) => SyncOp.compileCauseSyncOperatorSink(op, sink),
     EffectOperator: (op) => EffectOp.compileCauseEffectOperatorSink(op, sink),

package/src/internal/protos.ts

@@ -12,27 +12,27 @@ const Variance: Fx.Variance<never, never, never> = {
   _A: identity
 }
 
-export abstract class FxBase<R, E, A> implements Fx<R, E, A> {
-  readonly [TypeId]: Fx.Variance<R, E, A> = Variance
+export abstract class FxBase<A, E, R> implements Fx<A, E, R> {
+  readonly [TypeId]: Fx.Variance<A, E, R> = Variance
 
-  abstract run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown>
+  abstract run<R2>(sink: Sink<A, E, R2>): Effect.Effect<unknown, never, R | R2>
 
   pipe() {
     return pipeArguments(this, arguments)
   }
 }
 
-export abstract class FxEffectBase<R, E, A, R2, E2, B> extends Effectable.StructuralClass<R2, E2, B>
-  implements Fx<R, E, A>, Effect.Effect<R2, E2, B>
+export abstract class FxEffectBase<A, E, R, B, E2, R2> extends Effectable.StructuralClass<B, E2, R2>
+  implements Fx<A, E, R>, Effect.Effect<B, E2, R2>
 {
-  readonly [TypeId]: Fx.Variance<R, E, A> = Variance
+  readonly [TypeId]: Fx.Variance<A, E, R> = Variance
 
-  abstract run<R3>(sink: Sink<R3, E, A>): Effect.Effect<R | R3, never, unknown>
+  abstract run<R3>(sink: Sink<A, E, R3>): Effect.Effect<unknown, never, R | R3>
 
-  abstract toEffect(): Effect.Effect<R2, E2, B>
+  abstract toEffect(): Effect.Effect<B, E2, R2>
 
-  protected _effect: Effect.Effect<R2, E2, B> | undefined
-  commit(): Effect.Effect<R2, E2, B> {
+  protected _effect: Effect.Effect<B, E2, R2> | undefined
+  commit(): Effect.Effect<B, E2, R2> {
     if (this._effect === undefined) {
       return (this._effect = this.toEffect())
     } else {
@@ -41,13 +41,13 @@ export abstract class FxEffectBase<R, E, A, R2, E2, B> extends Effectable.Struct
   }
 }
 
-export abstract class EffectBase<R, E, A> extends Effectable.StructuralClass<R, E, A>
-  implements Effect.Effect<R, E, A>
+export abstract class EffectBase<A, E, R> extends Effectable.StructuralClass<A, E, R>
+  implements Effect.Effect<A, E, R>
 {
-  abstract toEffect(): Effect.Effect<R, E, A>
+  abstract toEffect(): Effect.Effect<A, E, R>
 
-  private _effect: Effect.Effect<R, E, A> | undefined
-  commit(): Effect.Effect<R, E, A> {
+  private _effect: Effect.Effect<A, E, R> | undefined
+  commit(): Effect.Effect<A, E, R> {
     if (this._effect === undefined) {
       return (this._effect = this.toEffect())
     } else {

package/src/internal/provide.ts

@@ -6,12 +6,12 @@ import * as Runtime from "effect/Runtime"
 import * as RuntimeFlags from "effect/RuntimeFlags"
 import type * as Scope from "effect/Scope"
 
-export type Provide<R, E, A> =
+export type Provide<A, E, R> =
   | ProvideContext<A>
-  | ProvideLayer<R, E, A>
+  | ProvideLayer<A, E, R>
   | ProvideRuntime<A>
   | ProvideService<A, any>
-  | ProvideServiceEffect<R, E, A, any>
+  | ProvideServiceEffect<A, any, E, R>
 
 export interface ProvideContext<A> {
   readonly _tag: "ProvideContext"
@@ -23,12 +23,12 @@ export const ProvideContext = <A>(i0: Context.Context<A>): ProvideContext<A> =>
   i0
 })
 
-export interface ProvideLayer<R, E, A> {
+export interface ProvideLayer<A, E, R> {
   readonly _tag: "ProvideLayer"
-  readonly i0: Layer.Layer<R, E, A>
+  readonly i0: Layer.Layer<A, E, R>
 }
 
-export const ProvideLayer = <R, E, A>(i0: Layer.Layer<R, E, A>): ProvideLayer<R, E, A> => ({
+export const ProvideLayer = <A, E, R>(i0: Layer.Layer<A, E, R>): ProvideLayer<A, E, R> => ({
   _tag: "ProvideLayer",
   i0
 })
@@ -45,16 +45,16 @@ export const ProvideService = <I, S>(i0: Context.Tag<I, S>, i1: S): ProvideServi
   i1
 })
 
-export interface ProvideServiceEffect<R, E, I, S> {
+export interface ProvideServiceEffect<I, S, E, R> {
   readonly _tag: "ProvideServiceEffect"
   readonly i0: Context.Tag<I, S>
-  readonly i1: Effect.Effect<R, E, S>
+  readonly i1: Effect.Effect<S, E, R>
 }
 
-export const ProvideServiceEffect = <R, E, I, S>(
+export const ProvideServiceEffect = <I, S, E, R>(
   i0: Context.Tag<I, S>,
-  i1: Effect.Effect<R, E, S>
-): ProvideServiceEffect<R, E, I, S> => ({
+  i1: Effect.Effect<S, E, R>
+): ProvideServiceEffect<I, S, E, R> => ({
   _tag: "ProvideServiceEffect",
   i0,
   i1
@@ -70,34 +70,34 @@ export const ProvideRuntime = <A>(i0: Runtime.Runtime<A>): ProvideRuntime<A> =>
   i0
 })
 
-export function matchProvide<R = never, E = never, A = never, B = never>(
-  self: Provide<R, E, A>,
+export function matchProvide<A, E, R, B>(
+  self: Provide<A, E, R>,
   matchers: {
     readonly ProvideContext: (i0: Context.Context<A>) => B
     readonly ProvideRuntime: (i0: Runtime.Runtime<A>) => B
-    readonly ProvideLayer: (i0: Layer.Layer<R, E, A>) => B
+    readonly ProvideLayer: (i0: Layer.Layer<A, E, R>) => B
     readonly ProvideService: (tag: Context.Tag<A, any>, service: any) => B
-    readonly ProvideServiceEffect: (tag: Context.Tag<A, any>, service: Effect.Effect<R, E, any>) => B
+    readonly ProvideServiceEffect: (tag: Context.Tag<A, any>, service: Effect.Effect<any, E, R>) => B
   }
 ): B {
   return matchers[self._tag](self.i0 as any, (self as any).i1)
 }
 
-export function merge<R = never, E = never, A = never, R2 = never, E2 = never, B = never>(
-  self: Provide<R, E, A>,
-  that: Provide<R2, E2, B>
-): Provide<Exclude<R, B> | R2, E | E2, A | B> {
+export function merge<A, E, R, B, E2, R2>(
+  self: Provide<A, E, R>,
+  that: Provide<B, E2, R2>
+): Provide<A | B, E | E2, Exclude<R, B> | R2> {
   return ProvideLayer(Layer.provideMerge(toLayer(self), toLayer(that)))
 }
 
-export function buildWithScope<R, E, A>(
-  provide: Provide<R, E, A>,
+export function buildWithScope<A, E, R>(
+  provide: Provide<A, E, R>,
   scope: Scope.Scope
 ) {
   return Layer.buildWithScope(toLayer(provide), scope)
 }
 
-export function toLayer<R, E, A>(provide: Provide<R, E, A>): Layer.Layer<R, E, A> {
+export function toLayer<A, E, R>(provide: Provide<A, E, R>): Layer.Layer<A, E, R> {
   switch (provide._tag) {
     case "ProvideContext":
       return Layer.succeedContext(provide.i0)
@@ -112,14 +112,14 @@ export function toLayer<R, E, A>(provide: Provide<R, E, A>): Layer.Layer<R, E, A
   }
 }
 
-export function provideToEffect<R, E, A, R2 = never, E2 = never, S = never>(
-  effect: Effect.Effect<R, E, A>,
-  provide: Provide<R2, E2, S>
-): Effect.Effect<Exclude<R, S> | R2, E | E2, A> {
+export function provideToEffect<A, E, R, R2 = never, E2 = never, S = never>(
+  effect: Effect.Effect<A, E, R>,
+  provide: Provide<S, E, R2>
+): Effect.Effect<A, E | E2, Exclude<R, S> | R2> {
   return Effect.provide(effect, toLayer(provide))
 }
 
-export function runtimeToLayer<R>(runtime: Runtime.Runtime<R>): Layer.Layer<never, never, R> {
+export function runtimeToLayer<R>(runtime: Runtime.Runtime<R>): Layer.Layer<R> {
   // Calculate patch
   const patchRefs = FiberRefsPatch.diff(Runtime.defaultRuntime.fiberRefs, runtime.fiberRefs)
   const patchFlags = RuntimeFlags.diff(Runtime.defaultRuntime.runtimeFlags, runtime.runtimeFlags)

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> {
-  _FxFiber: MutableRef.MutableRef<Option.Option<Fiber.Fiber<never, unknown>>> = MutableRef.make(Option.none())
+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<R | R2 | R3 | Scope.Scope, never, unknown> {
+  run<R3>(sink: Sink<A, E, R3>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope> {
     return withScopedFork(
       (fork) =>
         Effect.flatMap(
@@ -53,7 +53,7 @@ export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
     )
   }
 
-  private initialize(): Effect.Effect<R | R2, never, unknown> {
+  private initialize(): Effect.Effect<unknown, never, R | R2> {
     return Effect.suspend(() => {
       if (this._RefCount.increment() === 1) {
         return this.i0.run(this.i1).pipe(
@@ -80,7 +80,7 @@ export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
     })
   }
 
-  private interrupt(): Effect.Effect<R | R2, never, void> {
+  private interrupt(): Effect.Effect<void, never, R | R2> {
     return Effect.suspend(() => {
       const fiber = Option.getOrNull(MutableRef.getAndSet(this._FxFiber, Option.none()))
 
@@ -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,8 +47,8 @@ export const matchSyncProducer = <A, R>(
 
 export function runSink<A, R, E>(
   producer: SyncProducer<A>,
-  sink: Sink<R, E, A>
-): Effect.Effect<R, never, unknown> {
+  sink: Sink<A, E, R>
+): Effect.Effect<unknown, never, R> {
   return matchSyncProducer(producer, {
     Success: (a) => sink.onSuccess(a),
     FromSync: (a) => Effect.suspend(() => sink.onSuccess(a())),
@@ -61,7 +61,7 @@ export function runReduce<A, B>(
   producer: SyncProducer<A>,
   initial: B,
   f: (b: B, a: any) => B
-): Effect.Effect<never, never, B> {
+): Effect.Effect<B> {
   return matchSyncProducer(producer, {
     Success: (a) => syncOnce(() => f(initial, a)),
     FromSync: (a) => syncOnce(() => f(initial, a())),
@@ -70,11 +70,11 @@ 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<R2, E2, B>
-): Effect.Effect<R2, E2, B> {
+  f: (b: B, a: any) => Effect.Effect<B, E2, R2>
+): Effect.Effect<B, E2, R2> {
   return matchSyncProducer(producer, {
     Success: (a) => effectOnce(() => f(initial, a)),
     FromSync: (a) => Effect.suspend(() => f(initial, a())),
@@ -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<R2, never, unknown> {
+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,8 +96,8 @@ 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<R2, never, unknown> {
-  let effect: Effect.Effect<R2, never, any> = Effect.unit
+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) {
     effect = Effect.zipRight(effect, sink.onSuccess(item))
@@ -106,7 +106,7 @@ function iterableToSink<A, R2>(array: Iterable<A>, sink: Sink<R2, never, A>): Ef
   return effect
 }
 
-export const syncOnce = <A>(f: () => A): Effect.Effect<never, never, A> => {
+export const syncOnce = <A>(f: () => A): Effect.Effect<A> => {
   let memoized: Option.Option<A> = Option.none()
   const get = () => {
     if (Option.isSome(memoized)) {
@@ -121,7 +121,7 @@ export const syncOnce = <A>(f: () => A): Effect.Effect<never, never, A> => {
   return Effect.sync(get)
 }
 
-export const effectOnce = <R, E, A>(f: () => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> => {
+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,12 +133,12 @@ export const effectOnce = <R, E, A>(f: () => Effect.Effect<R, E, A>): Effect.Eff
   })
 }
 
-export function runEffect<A, R2, E2, B>(
+export function runEffect<A, B, E2, R2>(
   producer: SyncProducer<A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>
-): Effect.Effect<R2, E2, void> {
+  f: (a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<void, E2, R2> {
   return matchSyncProducer(producer, {
-    Success: (a): Effect.Effect<R2, E2, void> => f(a),
+    Success: (a): Effect.Effect<void, E2, R2> => f(a),
     FromSync: (a) => Effect.suspend(() => f(a())),
     FromArray: (a) => Effect.forEach(a, f, DISCARD),
     FromIterable: (a) => Effect.forEach(a, f, DISCARD)

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>
 }