effect 2.0.0-next.55 → 2.0.0-next.56

package/src/internal/stream/debounceState.ts

@@ -28,13 +28,13 @@ export interface NotStarted {
 }
 
 /** @internal */
-export interface Previous<A> {
+export interface Previous<out A> {
   readonly _tag: OP_PREVIOUS
   readonly fiber: Fiber.Fiber<never, Chunk.Chunk<A>>
 }
 
 /** @internal */
-export interface Current<E, A> {
+export interface Current<out E, out A> {
   readonly _tag: OP_CURRENT
   readonly fiber: Fiber.Fiber<E, HandoffSignal.HandoffSignal<E, A>>
 }

package/src/internal/stream/handoff.ts

@@ -17,7 +17,7 @@ export type HandoffTypeId = typeof HandoffTypeId
  *
  * @internal
  */
-export interface Handoff<A> extends Handoff.Variance<A> {
+export interface Handoff<in out A> extends Handoff.Variance<A> {
   readonly ref: Ref.Ref<Handoff.State<A>>
 }
 
@@ -36,7 +36,7 @@ export type OP_HANDOFF_STATE_FULL = typeof OP_HANDOFF_STATE_FULL
 /** @internal */
 export declare namespace Handoff {
   /** @internal */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [HandoffTypeId]: {
       readonly _A: (_: A) => A
     }
@@ -52,7 +52,7 @@ export declare namespace Handoff {
   }
 
   /** @internal */
-  export interface Full<A> {
+  export interface Full<out A> {
     readonly _tag: OP_HANDOFF_STATE_FULL
     readonly value: A
     readonly notifyProducer: Deferred.Deferred<never, void>

package/src/internal/stream/handoffSignal.ts

@@ -23,13 +23,13 @@ export const OP_END = "End" as const
 /** @internal */
 export type OP_END = typeof OP_END
 
-export interface Emit<A> {
+export interface Emit<out A> {
   readonly _tag: OP_EMIT
   readonly elements: Chunk.Chunk<A>
 }
 
 /** @internal */
-export interface Halt<E> {
+export interface Halt<out E> {
   readonly _tag: OP_HALT
   readonly cause: Cause.Cause<E>
 }

package/src/internal/stream/pull.ts

@@ -7,7 +7,7 @@ import type * as Take from "../../Take.js"
 import * as take from "../take.js"
 
 /** @internal */
-export interface Pull<R, E, A> extends Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>> {}
+export interface Pull<out R, out E, out A> extends Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>> {}
 
 /** @internal */
 export const emit = <A>(value: A): Effect.Effect<never, never, Chunk.Chunk<A>> => Effect.succeed(Chunk.of(value))

package/src/internal/stream.ts

@@ -65,7 +65,7 @@ const streamVariance = {
 }
 
 /** @internal */
-export class StreamImpl<R, E, A> implements Stream.Stream<R, E, A> {
+export class StreamImpl<out R, out E, out A> implements Stream.Stream<R, E, A> {
   readonly [StreamTypeId] = streamVariance
   constructor(
     readonly channel: Channel.Channel<R, unknown, unknown, unknown, E, Chunk.Chunk<A>, unknown>
@@ -2352,16 +2352,15 @@ export const failCauseSync = <E>(evaluate: LazyArg<Cause.Cause<E>>): Stream.Stre
   fromEffect(Effect.failCauseSync(evaluate))
 
 /** @internal */
-export const filter = dual<
-  {
-    <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, B>
-    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>
-  },
-  {
-    <R, E, A, B extends A>(self: Stream.Stream<R, E, A>, refinement: Refinement<A, B>): Stream.Stream<R, E, B>
-    <R, E, A, X extends A>(self: Stream.Stream<R, E, A>, predicate: Predicate<X>): Stream.Stream<R, E, A>
-  }
->(2, <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>) => mapChunks(self, Chunk.filter(predicate)))
+export const filter: {
+  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, B>
+  <A, B extends A>(predicate: Predicate<B>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>
+  <R, E, A, B extends A>(self: Stream.Stream<R, E, A>, refinement: Refinement<A, B>): Stream.Stream<R, E, B>
+  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>): Stream.Stream<R, E, A>
+} = dual(
+  2,
+  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>) => mapChunks(self, Chunk.filter(predicate))
+)
 
 /** @internal */
 export const filterEffect = dual<
@@ -3698,17 +3697,26 @@ export const mapAccumEffect = dual<
 /** @internal */
 export const mapBoth = dual<
   <E, E2, A, A2>(
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ) => <R>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E2, A2>,
   <R, E, E2, A, A2>(
     self: Stream.Stream<R, E, A>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ) => Stream.Stream<R, E2, A2>
 >(
   2,
   <R, E, E2, A, A2>(
     self: Stream.Stream<R, E, A>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ): Stream.Stream<R, E2, A2> => pipe(self, mapError(options.onFailure), map(options.onSuccess))
 )
 
@@ -4370,23 +4378,46 @@ export const peel = dual<
 })
 
 /** @internal */
-export const partition = dual<
+export const partition: {
+  <C extends A, B extends A, A = C>(
+    refinement: Refinement<A, B>,
+    options?: {
+      bufferSize?: number | undefined
+    }
+  ): <R, E>(
+    self: Stream.Stream<R, E, C>
+  ) => Effect.Effect<
+    Scope.Scope | R,
+    E,
+    [excluded: Stream.Stream<never, E, Exclude<C, B>>, satisfying: Stream.Stream<never, E, B>]
+  >
   <A>(
     predicate: Predicate<A>,
     options?: {
       bufferSize?: number | undefined
     }
-  ) => <R, E>(
+  ): <R, E>(
     self: Stream.Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, E, [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]>,
+  ) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream.Stream<never, E, A>, satisfying: Stream.Stream<never, E, A>]>
+  <R, E, C extends A, B extends A, A = C>(
+    self: Stream.Stream<R, E, C>,
+    refinement: Refinement<A, B>,
+    options?: {
+      bufferSize?: number | undefined
+    }
+  ): Effect.Effect<
+    Scope.Scope | R,
+    E,
+    [excluded: Stream.Stream<never, E, Exclude<C, B>>, satisfying: Stream.Stream<never, E, B>]
+  >
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
     predicate: Predicate<A>,
     options?: {
       bufferSize?: number | undefined
     }
-  ) => Effect.Effect<Scope.Scope | R, E, [Stream.Stream<never, E, A>, Stream.Stream<never, E, A>]>
->(
+  ): Effect.Effect<Scope.Scope | R, E, [excluded: Stream.Stream<never, E, A>, satisfying: Stream.Stream<never, E, A>]>
+} = dual(
   (args) => typeof args[1] === "function",
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
@@ -4418,7 +4449,7 @@ export const partitionEither = dual<
   ) => Effect.Effect<
     Scope.Scope | R2 | R,
     E2 | E,
-    [Stream.Stream<never, E2 | E, A2>, Stream.Stream<never, E2 | E, A3>]
+    [left: Stream.Stream<never, E2 | E, A2>, right: Stream.Stream<never, E2 | E, A3>]
   >,
   <R, E, A, R2, E2, A2, A3>(
     self: Stream.Stream<R, E, A>,
@@ -4429,7 +4460,7 @@ export const partitionEither = dual<
   ) => Effect.Effect<
     Scope.Scope | R2 | R,
     E2 | E,
-    [Stream.Stream<never, E2 | E, A2>, Stream.Stream<never, E2 | E, A3>]
+    [left: Stream.Stream<never, E2 | E, A2>, right: Stream.Stream<never, E2 | E, A3>]
   >
 >(
   (args) => typeof args[1] === "function",
@@ -4752,7 +4783,7 @@ const rechunkProcess = <E, A>(
   })
 
 /** @internal */
-class StreamRechunker<E, A> {
+class StreamRechunker<in out E, out A> {
   private builder: Array<A> = []
   private pos = 0
 
@@ -5716,7 +5747,7 @@ export const slidingSize = dual<
   <R, E, A>(self: Stream.Stream<R, E, A>, chunkSize: number, stepSize: number): Stream.Stream<R, E, Chunk.Chunk<A>> => {
     if (chunkSize <= 0 || stepSize <= 0) {
       return die(
-        Cause.IllegalArgumentException("Invalid bounds - `chunkSize` and `stepSize` must be greater than zero")
+        new Cause.IllegalArgumentException("Invalid bounds - `chunkSize` and `stepSize` must be greater than zero")
       )
     }
     return new StreamImpl(core.suspend(() => {
@@ -5965,7 +5996,7 @@ export const take = dual<
   <R, E, A>(self: Stream.Stream<R, E, A>, n: number) => Stream.Stream<R, E, A>
 >(2, <R, E, A>(self: Stream.Stream<R, E, A>, n: number): Stream.Stream<R, E, A> => {
   if (!Number.isInteger(n)) {
-    return die(Cause.IllegalArgumentException(`${n} must be an integer`))
+    return die(new Cause.IllegalArgumentException(`${n} must be an integer`))
   }
   const loop = (n: number): Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> =>
     core.readWith({
@@ -6082,10 +6113,12 @@ export const takeUntilEffect = dual<
 )
 
 /** @internal */
-export const takeWhile = dual<
-  <A, X extends A>(predicate: Predicate<X>) => <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
-  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>) => Stream.Stream<R, E, A>
->(2, <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>): Stream.Stream<R, E, A> => {
+export const takeWhile: {
+  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, B>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream.Stream<R, E, B>) => Stream.Stream<R, E, B>
+  <R, E, A, B extends A>(self: Stream.Stream<R, E, A>, refinement: Refinement<A, B>): Stream.Stream<R, E, B>
+  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>): Stream.Stream<R, E, A>
+} = dual(2, <R, E, A>(self: Stream.Stream<R, E, A>, predicate: Predicate<A>): Stream.Stream<R, E, A> => {
   const loop: Channel.Channel<never, never, Chunk.Chunk<A>, unknown, never, Chunk.Chunk<A>, unknown> = core.readWith({
     onInput: (input: Chunk.Chunk<A>) => {
       const taken = pipe(input, Chunk.takeWhile(predicate))
@@ -6508,7 +6541,7 @@ export const timeoutTo = dual<
     duration: Duration.DurationInput,
     that: Stream.Stream<R2, E2, A2>
   ): Stream.Stream<R | R2, E | E2, A | A2> => {
-    const StreamTimeout = Cause.RuntimeException("Stream Timeout")
+    const StreamTimeout = new Cause.RuntimeException("Stream Timeout")
     return pipe(
       self,
       timeoutFailCause<E | E2>(() => Cause.die(StreamTimeout), duration),
@@ -6835,12 +6868,12 @@ export const updateService = dual<
 
 /** @internal */
 export const when = dual<
-  (predicate: LazyArg<boolean>) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
-  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: LazyArg<boolean>) => Stream.Stream<R, E, A>
+  (test: LazyArg<boolean>) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
+  <R, E, A>(self: Stream.Stream<R, E, A>, test: LazyArg<boolean>) => Stream.Stream<R, E, A>
 >(
   2,
-  <R, E, A>(self: Stream.Stream<R, E, A>, predicate: LazyArg<boolean>): Stream.Stream<R, E, A> =>
-    pipe(self, whenEffect(Effect.sync(predicate)))
+  <R, E, A>(self: Stream.Stream<R, E, A>, test: LazyArg<boolean>): Stream.Stream<R, E, A> =>
+    pipe(self, whenEffect(Effect.sync(test)))
 )
 
 /** @internal */

package/src/internal/subscriptionRef.ts

@@ -20,11 +20,11 @@ export const SubscriptionRefTypeId: SubscriptionRef.SubscriptionRefTypeId = Symb
 
 /** @internal */
 const subscriptionRefVariance = {
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
 /** @internal */
-class SubscriptionRefImpl<A> implements SubscriptionRef.SubscriptionRef<A> {
+class SubscriptionRefImpl<in out A> implements SubscriptionRef.SubscriptionRef<A> {
   readonly [Ref.RefTypeId] = _ref.refVariance
   readonly [Synchronized.SynchronizedRefTypeId] = _circular.synchronizedVariance
   readonly [SubscriptionRefTypeId] = subscriptionRefVariance

package/src/internal/supervisor.ts

@@ -25,7 +25,7 @@ export const supervisorVariance = {
 }
 
 /** @internal */
-export class ProxySupervisor<T> implements Supervisor.Supervisor<T> {
+export class ProxySupervisor<out T> implements Supervisor.Supervisor<T> {
   readonly [SupervisorTypeId] = supervisorVariance
 
   constructor(
@@ -73,7 +73,7 @@ export class ProxySupervisor<T> implements Supervisor.Supervisor<T> {
 }
 
 /** @internal */
-export class Zip<T0, T1> implements Supervisor.Supervisor<readonly [T0, T1]> {
+export class Zip<out T0, out T1> implements Supervisor.Supervisor<readonly [T0, T1]> {
   readonly _tag = "Zip"
   readonly [SupervisorTypeId] = supervisorVariance
 
@@ -181,7 +181,7 @@ export class Track implements Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any
 }
 
 /** @internal */
-export class Const<T> implements Supervisor.Supervisor<T> {
+export class Const<out T> implements Supervisor.Supervisor<T> {
   readonly [SupervisorTypeId] = supervisorVariance
 
   constructor(readonly effect: Effect.Effect<never, never, T>) {

package/src/internal/take.ts

@@ -22,7 +22,7 @@ const takeVariance = {
 }
 
 /** @internal */
-export class TakeImpl<E, A> implements Take.Take<E, A> {
+export class TakeImpl<out E, out A> implements Take.Take<E, A> {
   readonly [TakeTypeId] = takeVariance
   constructor(readonly exit: Exit.Exit<Option.Option<E>, Chunk.Chunk<A>>) {
   }
@@ -39,7 +39,7 @@ export const die = (defect: unknown): Take.Take<never, never> => new TakeImpl(Ex
 
 /** @internal */
 export const dieMessage = (message: string): Take.Take<never, never> =>
-  new TakeImpl(Exit.die(Cause.RuntimeException(message)))
+  new TakeImpl(Exit.die(new Cause.RuntimeException(message)))
 
 /** @internal */
 export const done = <E, A>(self: Take.Take<E, A>): Effect.Effect<never, Option.Option<E>, Chunk.Chunk<A>> =>

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.0.0-next.55"
+export const moduleVersion = "2.0.0-next.56"