@typed/fx 1.22.2 → 1.24.0

package/src/Stream.ts

@@ -19,8 +19,8 @@ import * as Sink from "./Sink.js"
  * @since 1.18.0
  * @category conversions
  */
-export function toStream<R, E, A>(fx: Fx.Fx<R, E, A>): Stream.Stream<R, E, A> {
-  return Stream.asyncScoped<R | Scope.Scope, E, A>((emit) =>
+export function toStream<A, E, R>(fx: Fx.Fx<A, E, R>): Stream.Stream<A, E, R> {
+  return Stream.asyncScoped<A, E, R | Scope.Scope>((emit) =>
     fx.run(
       Sink.make(
         (cause) => Effect.promise(() => emit(Effect.failCause(Cause.map(cause, Option.some)))),
@@ -42,17 +42,17 @@ export function toStream<R, E, A>(fx: Fx.Fx<R, E, A>): Stream.Stream<R, E, A> {
  */
 export const toStreamQueued: {
   <E, A, R2, E2>(
-    make: Effect.Effect<R2, E2, Queue.Queue<Exit.Exit<Option.Option<E>, A>>>
-  ): <R>(fx: Fx.Fx<R, E, A>) => Stream.Stream<R | R2, E | E2, A>
+    make: Effect.Effect<Queue.Queue<Exit.Exit<A, Option.Option<E>>>, E2, R2>
+  ): <R>(fx: Fx.Fx<A, E, R>) => Stream.Stream<A, E | E2, R | R2>
 
-  <R, E, A, R2, E2>(
-    fx: Fx.Fx<R, E, A>,
-    make: Effect.Effect<R2, E2, Queue.Queue<Exit.Exit<Option.Option<E>, A>>>
-  ): Stream.Stream<R | R2, E | E2, A>
-} = dual(2, function toStreamQueued<R, E, A, R2, E2>(
-  fx: Fx.Fx<R, E, A>,
-  make: Effect.Effect<R2, E2, Queue.Queue<Exit.Exit<Option.Option<E>, A>>>
-): Stream.Stream<R | R2, E | E2, A> {
+  <A, E, R, R2, E2>(
+    fx: Fx.Fx<A, E, R>,
+    make: Effect.Effect<Queue.Queue<Exit.Exit<A, Option.Option<E>>>, E2, R2>
+  ): Stream.Stream<A, E | E2, R | R2>
+} = dual(2, function toStreamQueued<A, E, R, R2, E2>(
+  fx: Fx.Fx<A, E, R>,
+  make: Effect.Effect<Queue.Queue<Exit.Exit<A, Option.Option<E>>>, E2, R2>
+): Stream.Stream<A, E | E2, R | R2> {
   return make.pipe(
     Effect.tap((queue) =>
       fx.pipe(
@@ -76,11 +76,11 @@ export const toStreamQueued: {
  * @category conversions
  */
 export const toStreamSliding: {
-  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<R, E, A>
-  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A>
+  (capacity: number): <A, E, R>(fx: Fx.Fx<A, E, R>) => Stream.Stream<A, E, R>
+  <A, E, R>(fx: Fx.Fx<A, E, R>, capacity: number): Stream.Stream<A, E, R>
 } = dual(
   2,
-  function toStreamSliding<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A> {
+  function toStreamSliding<A, E, R>(fx: Fx.Fx<A, E, R>, capacity: number): Stream.Stream<A, E, R> {
     return toStreamQueued(fx, Queue.sliding(capacity))
   }
 )
@@ -92,11 +92,11 @@ export const toStreamSliding: {
  * @category conversions
  */
 export const toStreamDropping: {
-  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<R, E, A>
-  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A>
+  (capacity: number): <A, E, R>(fx: Fx.Fx<A, E, R>) => Stream.Stream<A, E, R>
+  <A, E, R>(fx: Fx.Fx<A, E, R>, capacity: number): Stream.Stream<A, E, R>
 } = dual(
   2,
-  function toStreamDropping<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A> {
+  function toStreamDropping<A, E, R>(fx: Fx.Fx<A, E, R>, capacity: number): Stream.Stream<A, E, R> {
     return toStreamQueued(fx, Queue.dropping(capacity))
   }
 )
@@ -108,11 +108,11 @@ export const toStreamDropping: {
  * @category conversions
  */
 export const toStreamBounded: {
-  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<R, E, A>
-  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A>
+  (capacity: number): <A, E, R>(fx: Fx.Fx<A, E, R>) => Stream.Stream<A, E, R>
+  <A, E, R>(fx: Fx.Fx<A, E, R>, capacity: number): Stream.Stream<A, E, R>
 } = dual(
   2,
-  function toStreamBounded<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A> {
+  function toStreamBounded<A, E, R>(fx: Fx.Fx<A, E, R>, capacity: number): Stream.Stream<A, E, R> {
     return toStreamQueued(fx, Queue.bounded(capacity))
   }
 )
@@ -122,10 +122,10 @@ export const toStreamBounded: {
  * @since 1.18.0
  * @category conversions
  */
-export function fromStream<R, E, A>(
-  stream: Stream.Stream<R, E, A>
-): Fx.Fx<R, E, A> {
-  return Fx.make<R, E, A>((sink) => Effect.catchAllCause(Stream.runForEach(stream, sink.onSuccess), sink.onFailure))
+export function fromStream<A, E, R>(
+  stream: Stream.Stream<A, E, R>
+): Fx.Fx<A, E, R> {
+  return Fx.make<A, E, R>((sink) => Effect.catchAllCause(Stream.runForEach(stream, sink.onSuccess), sink.onFailure))
 }
 
 /**
@@ -133,8 +133,8 @@ export function fromStream<R, E, A>(
  * @since 1.18.0
  * @category conversions
  */
-export function fromStreamChunked<R, E, A>(stream: Stream.Stream<R, E, A>): Fx.Fx<R, E, Chunk.Chunk<A>> {
-  return Fx.make<R, E, Chunk.Chunk<A>>((sink) =>
+export function fromStreamChunked<A, E, R>(stream: Stream.Stream<A, E, R>): Fx.Fx<Chunk.Chunk<A>, E, R> {
+  return Fx.make<Chunk.Chunk<A>, E, R>((sink) =>
     Effect.catchAllCause(Stream.runForEachChunk(stream, sink.onSuccess), sink.onFailure)
   )
 }

package/src/Subject.ts

@@ -26,9 +26,11 @@ import { TypeId } from "./TypeId.js"
  * Subject is an Fx type which can also be imperatively pushed into.
  * @since 1.20.0
  */
-export interface Subject<out R, in out E, in out A> extends Push<R, E, A, R | Scope.Scope, E, A>, Pipeable.Pipeable {
-  readonly subscriberCount: Effect.Effect<R, never, number>
-  readonly interrupt: Effect.Effect<R, never, void>
+export interface Subject<in out A, in out E = never, out R = never>
+  extends Push<A, E, R, A, E, R | Scope.Scope>, Pipeable.Pipeable
+{
+  readonly subscriberCount: Effect.Effect<number, never, R>
+  readonly interrupt: Effect.Effect<void, never, R>
 }
 
 /**
@@ -38,10 +40,10 @@ export namespace Subject {
   /**
    * @since 1.20.0
    */
-  export interface Tagged<I, E, A> extends Subject<I, E, A> {
-    readonly tag: C.Tagged<I, Subject<never, E, A>>
+  export interface Tagged<A, E, I> extends Subject<A, E, I> {
+    readonly tag: C.Tagged<I, Subject<A, E>>
 
-    readonly make: (replay?: number) => Layer.Layer<never, never, I>
+    readonly make: (replay?: number) => Layer.Layer<I>
     readonly provide: Provide<I>
   }
 
@@ -62,11 +64,11 @@ export namespace Subject {
     ...args: Args
   ) => Args extends readonly [infer _ extends number] ? <T extends Fx<any, any, any> | Effect.Effect<any, any, any>>(
       fxOrEffect: T
-    ) => [T] extends [Fx<infer R2, infer E2, infer B>] ? Fx<Exclude<R2, I>, E2, B>
-      : [T] extends [Effect.Effect<infer R2, infer E2, infer B>] ? Effect.Effect<Exclude<R2, I>, E2, B>
+    ) => [T] extends [Fx<infer B, infer E2, infer R2>] ? Fx<B, E2, Exclude<R2, I>>
+      : [T] extends [Effect.Effect<infer B, infer E2, infer R2>] ? Effect.Effect<B, E2, Exclude<R2, I>>
       : never
-    : Args extends readonly [Fx<infer R2, infer E2, infer B>] ? Fx<Exclude<R2, I>, E2, B>
-    : Args extends readonly [Effect.Effect<infer R2, infer E2, infer B>] ? Effect.Effect<Exclude<R2, I>, E2, B>
+    : Args extends readonly [Fx<infer B, infer E2, infer R2>] ? Fx<B, E2, Exclude<R2, I>>
+    : Args extends readonly [Effect.Effect<infer B, infer E2, infer R2>] ? Effect.Effect<B, E2, Exclude<R2, I>>
     : never
 }
 
@@ -75,8 +77,8 @@ const DISCARD = { discard: true } as const
 /**
  * @internal
  */
-export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subject<never, E, A> {
-  protected sinks: Set<readonly [Sink<any, E, A>, Context.Context<any>]> = new Set()
+export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subject<A, E> {
+  protected sinks: Set<readonly [Sink<A, E, any>, Context.Context<any>]> = new Set()
   protected scopes: Set<Scope.CloseableScope> = new Set()
 
   constructor() {
@@ -85,7 +87,7 @@ export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subj
     this.onSuccess = this.onSuccess.bind(this)
   }
 
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink<A, E, R2>): Effect.Effect<unknown, never, R2 | Scope.Scope> {
     return this.addSink(sink, awaitScopeClose)
   }
 
@@ -110,9 +112,9 @@ export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subj
   )
 
   protected addSink<R, R2, B>(
-    sink: Sink<R, E, A>,
-    f: (scope: Scope.Scope) => Effect.Effect<R2, never, B>
-  ): Effect.Effect<R2 | Scope.Scope, never, B> {
+    sink: Sink<A, E, R>,
+    f: (scope: Scope.Scope) => Effect.Effect<B, never, R2>
+  ): Effect.Effect<B, never, R2 | Scope.Scope> {
     return withScope(
       (innerScope) =>
         Effect.contextWithEffect((ctx) => {
@@ -135,7 +137,7 @@ export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subj
     )
   }
 
-  readonly subscriberCount: Effect.Effect<never, never, number> = Effect.sync(() => this.sinks.size)
+  readonly subscriberCount: Effect.Effect<number> = Effect.sync(() => this.sinks.size)
 
   protected onEvent(a: A) {
     if (this.sinks.size === 0) return Effect.unit
@@ -156,7 +158,7 @@ export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subj
 /**
  * @internal
  */
-export class HoldSubjectImpl<E, A> extends SubjectImpl<E, A> implements Subject<never, E, A> {
+export class HoldSubjectImpl<A, E> extends SubjectImpl<A, E> implements Subject<A, E> {
   private lastValue: MutableRef.MutableRef<Option.Option<A>> = MutableRef.make(Option.none())
 
   // Emit an event to all sinks
@@ -167,7 +169,7 @@ export class HoldSubjectImpl<E, A> extends SubjectImpl<E, A> implements Subject<
       return this.onEvent(a)
     })
 
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink<A, E, R2>): Effect.Effect<unknown, never, R2 | Scope.Scope> {
     return this.addSink(sink, (scope) =>
       Option.match(MutableRef.get(this.lastValue), {
         onNone: () => awaitScopeClose(scope),
@@ -186,7 +188,7 @@ export class HoldSubjectImpl<E, A> extends SubjectImpl<E, A> implements Subject<
 /**
  * @internal
  */
-export class ReplaySubjectImpl<E, A> extends SubjectImpl<E, A> {
+export class ReplaySubjectImpl<A, E> extends SubjectImpl<A, E> {
   constructor(readonly buffer: RingBuffer<A>) {
     super()
   }
@@ -199,7 +201,7 @@ export class ReplaySubjectImpl<E, A> extends SubjectImpl<E, A> {
       return this.onEvent(a)
     })
 
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink<A, E, R2>): Effect.Effect<unknown, never, R2 | Scope.Scope> {
     return this.addSink(
       sink,
       (scope) => Effect.zipRight(this.buffer.forEach((a) => sink.onSuccess(a)), awaitScopeClose(scope))
@@ -217,39 +219,39 @@ export class ReplaySubjectImpl<E, A> extends SubjectImpl<E, A> {
 /**
  * @since 1.20.0
  */
-export function unsafeMake<E, A>(replay: number = 0): Subject<never, E, A> {
+export function unsafeMake<A, E = never>(replay: number = 0): Subject<A, E> {
   replay = Math.max(0, replay)
 
   if (replay === 0) {
-    return new SubjectImpl<E, A>()
+    return new SubjectImpl<A, E>()
   } else if (replay === 1) {
-    return new HoldSubjectImpl<E, A>()
+    return new HoldSubjectImpl<A, E>()
   } else {
-    return new ReplaySubjectImpl<E, A>(new RingBuffer(replay))
+    return new ReplaySubjectImpl<A, E>(new RingBuffer(replay))
   }
 }
 
 /**
  * @since 1.20.0
  */
-export function make<E, A>(replay?: number): Effect.Effect<Scope.Scope, never, Subject<never, E, A>> {
+export function make<A, E>(replay?: number): Effect.Effect<Subject<A, E>, never, Scope.Scope> {
   return Effect.acquireRelease(Effect.sync(() => unsafeMake(replay)), (subject) => subject.interrupt)
 }
 
 /**
  * @since 1.20.0
  */
-export function fromTag<I, S, R, E, A>(tag: C.Tag<I, S>, f: (s: S) => Subject<R, E, A>): Subject<I | R, E, A> {
+export function fromTag<I, S, A, E, R>(tag: C.Tag<I, S>, f: (s: S) => Subject<A, E, R>): Subject<A, E, I | R> {
   return new FromTag(tag, f)
 }
 
-class FromTag<I, S, R, E, A> extends FxBase<I | R | Scope.Scope, E, A> implements Subject<I | R, E, A> {
-  private get: Effect.Effect<I, never, Subject<R, E, A>>
+class FromTag<I, S, A, E, R> extends FxBase<A, E, I | R | Scope.Scope> implements Subject<A, E, I | R> {
+  private get: Effect.Effect<Subject<A, E, R>, never, I>
 
-  readonly subscriberCount: Effect.Effect<I | R, never, number>
-  readonly interrupt: Effect.Effect<I | R, never, void>
+  readonly subscriberCount: Effect.Effect<number, never, I | R>
+  readonly interrupt: Effect.Effect<void, never, I | R>
 
-  constructor(readonly tag: C.Tag<I, S>, readonly f: (s: S) => Subject<R, E, A>) {
+  constructor(readonly tag: C.Tag<I, S>, readonly f: (s: S) => Subject<A, E, R>) {
     super()
 
     this.get = Effect.map(tag, f)
@@ -257,15 +259,15 @@ class FromTag<I, S, R, E, A> extends FxBase<I | R | Scope.Scope, E, A> implement
     this.interrupt = Effect.flatMap(this.get, (subject) => subject.interrupt)
   }
 
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<I | R | R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink<A, E, R2>): Effect.Effect<unknown, never, I | R | R2 | Scope.Scope> {
     return Effect.flatMap(this.get, (subject) => subject.run(sink))
   }
 
-  onFailure(cause: Cause.Cause<E>): Effect.Effect<I | R, never, unknown> {
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, I | R> {
     return Effect.flatMap(this.get, (subject) => subject.onFailure(cause))
   }
 
-  onSuccess(value: A): Effect.Effect<I | R, never, unknown> {
+  onSuccess(value: A): Effect.Effect<unknown, never, I | R> {
     return Effect.flatMap(this.get, (subject) => subject.onSuccess(value))
   }
 }
@@ -273,32 +275,32 @@ class FromTag<I, S, R, E, A> extends FxBase<I | R | Scope.Scope, E, A> implement
 /**
  * @since 1.20.0
  */
-export function tagged<E, A>(): {
-  <const I extends C.IdentifierFactory<any>>(identifier: I): Subject.Tagged<C.IdentifierOf<I>, E, A>
-  <const I>(identifier: I): Subject.Tagged<C.IdentifierOf<I>, E, A>
+export function tagged<A, E = never>(): {
+  <const I extends C.IdentifierFactory<any>>(identifier: I): Subject.Tagged<A, E, C.IdentifierOf<I>>
+  <const I>(identifier: I): Subject.Tagged<A, E, C.IdentifierOf<I>>
 } {
-  return <const I>(identifier: I) => new TaggedImpl(C.Tagged<I, Subject<never, E, A>>(identifier))
+  return <const I>(identifier: I) => new TaggedImpl(C.Tagged<I, Subject<A, E>>(identifier))
 }
 
 const isDataFirst = (args: IArguments): boolean =>
   args.length === 2 || Effect.isEffect(args[0]) || hasProperty(args[0], TypeId)
 
-class TaggedImpl<I, E, A> extends FromTag<I, Subject<never, E, A>, never, E, A> implements Subject.Tagged<I, E, A> {
-  readonly provide: Subject.Tagged<I, E, A>["provide"]
+class TaggedImpl<A, E, I> extends FromTag<I, Subject<A, E>, A, E, never> implements Subject.Tagged<A, E, I> {
+  readonly provide: Subject.Tagged<A, E, I>["provide"]
 
-  constructor(readonly tag: C.Tagged<I, Subject<never, E, A>>) {
+  constructor(readonly tag: C.Tagged<I, Subject<A, E>>) {
     super(tag, identity)
 
     this.provide = dual(
       isDataFirst,
-      <R2, E2, B>(fxOrEffect: Fx<R2, E2, B> | Effect.Effect<R2, E2, B>, replay?: number) => {
-        if (TypeId in fxOrEffect) return provide(fxOrEffect as Fx<Exclude<R2, I>, E2, B>, this.make(replay))
-        else return Effect.provide(fxOrEffect as Effect.Effect<R2, E2, B>, this.make(replay))
+      <B, E2, R2>(fxOrEffect: Fx<B, E2, R2> | Effect.Effect<B, E2, R2>, replay?: number) => {
+        if (TypeId in fxOrEffect) return provide(fxOrEffect as Fx<B, E2, Exclude<R2, I>>, this.make(replay))
+        else return Effect.provide(fxOrEffect as Effect.Effect<B, E2, R2>, this.make(replay))
       }
     )
   }
 
-  make(replay?: number): Layer.Layer<never, never, I> {
+  make(replay?: number): Layer.Layer<I> {
     return this.tag.scoped(make(replay))
   }
 }

package/src/Typeclass.ts

@@ -33,7 +33,7 @@ import { multicast } from "./internal/share.js"
  * @category TypeLambda
  */
 export interface FxTypeLambda extends HKT.TypeLambda {
-  readonly type: Fx.Fx<this["Out2"], this["Out1"], this["Target"]>
+  readonly type: Fx.Fx<this["Target"], this["Out1"], this["Out2"]>
 }
 
 /**
@@ -302,7 +302,7 @@ export const Applicative: App.Applicative<FxTypeLambda> = {
  * @category Filterable
  */
 export const Filterable: Filter.Filterable<FxTypeLambda> = {
-  partitionMap: dual(2, <R, E, A, B, C>(self: Fx.Fx<R, E, A>, f: (a: A) => Either<B, C>) => {
+  partitionMap: dual(2, <A, E, R, B, C>(self: Fx.Fx<A, E, R>, f: (a: A) => Either<B, C>) => {
     const m = multicast(Fx.map(self, f))
 
     return [