effect 2.2.5 → 2.3.1

package/src/FiberSet.ts

@@ -26,34 +26,34 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @categories models
  */
-export interface FiberSet<E = unknown, A = unknown>
-  extends Pipeable, Inspectable.Inspectable, Iterable<Fiber.RuntimeFiber<E, A>>
+export interface FiberSet<out A, out E = never>
+  extends Pipeable, Inspectable.Inspectable, Iterable<Fiber.RuntimeFiber<A, E>>
 {
   readonly [TypeId]: TypeId
-  readonly backing: Set<Fiber.RuntimeFiber<E, A>>
+  readonly backing: Set<Fiber.RuntimeFiber<A, E>>
 }
 
 /**
  * @since 2.0.0
  * @categories refinements
  */
-export const isFiberSet = (u: unknown): u is FiberSet<unknown> => Predicate.hasProperty(u, TypeId)
+export const isFiberSet = (u: unknown): u is FiberSet<unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
 const Proto = {
   [TypeId]: TypeId,
-  [Symbol.iterator](this: FiberSet) {
+  [Symbol.iterator](this: FiberSet<unknown, unknown>) {
     return this.backing[Symbol.iterator]()
   },
-  toString(this: FiberSet) {
+  toString(this: FiberSet<unknown, unknown>) {
     return Inspectable.format(this.toJSON())
   },
-  toJSON(this: FiberSet) {
+  toJSON(this: FiberSet<unknown, unknown>) {
     return {
       _id: "FiberMap",
       backing: Inspectable.toJSON(Array.from(this.backing))
     }
   },
-  [Inspectable.NodeInspectSymbol](this: FiberSet) {
+  [Inspectable.NodeInspectSymbol](this: FiberSet<unknown, unknown>) {
     return this.toJSON()
   },
   pipe() {
@@ -61,7 +61,7 @@ const Proto = {
   }
 }
 
-const unsafeMake = <E = unknown, A = unknown>(): FiberSet<E, A> => {
+const unsafeMake = <A, E>(): FiberSet<A, E> => {
   const self = Object.create(Proto)
   self.backing = new Set()
   return self
@@ -92,8 +92,8 @@ const unsafeMake = <E = unknown, A = unknown>(): FiberSet<E, A> => {
  * @since 2.0.0
  * @categories constructors
  */
-export const make = <E = unknown, A = unknown>(): Effect.Effect<Scope.Scope, never, FiberSet<E, A>> =>
-  Effect.acquireRelease(Effect.sync(() => unsafeMake<E, A>()), clear)
+export const make = <A, E = never>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope> =>
+  Effect.acquireRelease(Effect.sync(() => unsafeMake<A, E>()), clear)
 
 /**
  * Create an Effect run function that is backed by a FiberSet.
@@ -101,16 +101,16 @@ export const make = <E = unknown, A = unknown>(): Effect.Effect<Scope.Scope, nev
  * @since 2.0.0
  * @categories constructors
  */
-export const makeRuntime = <R, E = unknown, A = unknown>(): Effect.Effect<
-  Scope.Scope | R,
-  never,
+export const makeRuntime = <A, E = never, R = never>(): Effect.Effect<
   <XE extends E, XA extends A>(
-    effect: Effect.Effect<R, XE, XA>,
+    effect: Effect.Effect<XA, XE, R>,
     options?: Runtime.RunForkOptions | undefined
-  ) => Fiber.RuntimeFiber<XE, XA>
+  ) => Fiber.RuntimeFiber<XA, XE>,
+  never,
+  Scope.Scope | R
 > =>
   Effect.flatMap(
-    make<E, A>(),
+    make<A, E>(),
     (self) => runtime(self)<R>()
   )
 
@@ -121,15 +121,15 @@ export const makeRuntime = <R, E = unknown, A = unknown>(): Effect.Effect<
  * @categories combinators
  */
 export const unsafeAdd: {
-  <E, A, XE extends E, XA extends A>(fiber: Fiber.RuntimeFiber<XE, XA>): (self: FiberSet<E, A>) => void
-  <E, A, XE extends E, XA extends A>(self: FiberSet<E, A>, fiber: Fiber.RuntimeFiber<XE, XA>): void
+  <A, E, XE extends E, XA extends A>(fiber: Fiber.RuntimeFiber<XA, XE>): (self: FiberSet<A, E>) => void
+  <A, E, XE extends E, XA extends A>(self: FiberSet<A, E>, fiber: Fiber.RuntimeFiber<XA, XE>): void
 } = dual<
-  <E, A, XE extends E, XA extends A>(
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ) => (self: FiberSet<E, A>) => void,
-  <E, A, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
-    fiber: Fiber.RuntimeFiber<XE, XA>
+  <A, E, XE extends E, XA extends A>(
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ) => (self: FiberSet<A, E>) => void,
+  <A, E, XE extends E, XA extends A>(
+    self: FiberSet<A, E>,
+    fiber: Fiber.RuntimeFiber<XA, XE>
   ) => void
 >(2, (self, fiber) => {
   if (self.backing.has(fiber)) {
@@ -148,28 +148,28 @@ export const unsafeAdd: {
  * @categories combinators
  */
 export const add: {
-  <E, A, XE extends E, XA extends A>(
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ): (self: FiberSet<E, A>) => Effect.Effect<never, never, void>
-  <E, A, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ): Effect.Effect<never, never, void>
+  <A, E, XE extends E, XA extends A>(
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ): (self: FiberSet<A, E>) => Effect.Effect<void>
+  <A, E, XE extends E, XA extends A>(
+    self: FiberSet<A, E>,
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ): Effect.Effect<void>
 } = dual<
-  <E, A, XE extends E, XA extends A>(
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ) => (self: FiberSet<E, A>) => Effect.Effect<never, never, void>,
-  <E, A, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ) => Effect.Effect<never, never, void>
+  <A, E, XE extends E, XA extends A>(
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ) => (self: FiberSet<A, E>) => Effect.Effect<void>,
+  <A, E, XE extends E, XA extends A>(
+    self: FiberSet<A, E>,
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ) => Effect.Effect<void>
 >(2, (self, fiber) => Effect.sync(() => unsafeAdd(self, fiber)))
 
 /**
  * @since 2.0.0
  * @categories combinators
  */
-export const clear = <E, A>(self: FiberSet<E, A>): Effect.Effect<never, never, void> =>
+export const clear = <A, E>(self: FiberSet<A, E>): Effect.Effect<void> =>
   Effect.zipRight(
     Effect.forEach(self.backing, (fiber) => Fiber.interrupt(fiber)),
     Effect.sync(() => {
@@ -185,15 +185,15 @@ export const clear = <E, A>(self: FiberSet<E, A>): Effect.Effect<never, never, v
  * @categories combinators
  */
 export const run: {
-  <E, A>(self: FiberSet<E, A>): <R, XE extends E, XA extends A>(
-    effect: Effect.Effect<R, XE, XA>
-  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
-  <E, A, R, XE extends E, XA extends A>(
-    self: FiberSet<E, A>,
-    effect: Effect.Effect<R, XE, XA>
-  ): Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
+  <A, E>(self: FiberSet<A, E>): <R, XE extends E, XA extends A>(
+    effect: Effect.Effect<XA, XE, R>
+  ) => Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
+  <A, E, R, XE extends E, XA extends A>(
+    self: FiberSet<A, E>,
+    effect: Effect.Effect<XA, XE, R>
+  ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
 } = function() {
-  const self = arguments[0] as FiberSet<any>
+  const self = arguments[0] as FiberSet<any, any>
   if (arguments.length === 1) {
     return (effect: Effect.Effect<any, any, any>) =>
       Effect.tap(
@@ -217,9 +217,9 @@ export const run: {
  * interface Users {
  *   readonly _: unique symbol
  * }
- * const Users = Context.Tag<Users, {
- *    getAll: Effect.Effect<never, never, Array<unknown>>
- * }>()
+ * const Users = Context.GenericTag<Users, {
+ *    getAll: Effect.Effect<Array<unknown>>
+ * }>("Users")
  *
  * Effect.gen(function*(_) {
  *   const set = yield* _(FiberSet.make())
@@ -234,22 +234,22 @@ export const run: {
  * @since 2.0.0
  * @categories combinators
  */
-export const runtime: <E, A>(
-  self: FiberSet<E, A>
-) => <R>() => Effect.Effect<
-  R,
-  never,
+export const runtime: <A, E = never>(
+  self: FiberSet<A, E>
+) => <R = never>() => Effect.Effect<
   <XE extends E, XA extends A>(
-    effect: Effect.Effect<R, XE, XA>,
+    effect: Effect.Effect<XA, XE, R>,
     options?: Runtime.RunForkOptions | undefined
-  ) => Fiber.RuntimeFiber<XE, XA>
-> = <E, A>(self: FiberSet<E, A>) => <R>() =>
+  ) => Fiber.RuntimeFiber<XA, XE>,
+  never,
+  R
+> = <A, E>(self: FiberSet<A, E>) => <R>() =>
   Effect.map(
     Effect.runtime<R>(),
     (runtime) => {
       const runFork = Runtime.runFork(runtime)
       return <XE extends E, XA extends A>(
-        effect: Effect.Effect<R, XE, XA>,
+        effect: Effect.Effect<XA, XE, R>,
         options?: Runtime.RunForkOptions | undefined
       ) => {
         const fiber = runFork(effect, options)
@@ -263,5 +263,4 @@ export const runtime: <E, A>(
  * @since 2.0.0
  * @categories combinators
  */
-export const size = <E, A>(self: FiberSet<E, A>): Effect.Effect<never, never, number> =>
-  Effect.sync(() => self.backing.size)
+export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> => Effect.sync(() => self.backing.size)

package/src/GroupBy.ts

@@ -30,7 +30,7 @@ export type GroupByTypeId = typeof GroupByTypeId
  * @category models
  */
 export interface GroupBy<out R, out E, out K, out V> extends GroupBy.Variance<R, E, K, V>, Pipeable {
-  readonly grouped: Stream.Stream<R, E, readonly [K, Queue.Dequeue<Take.Take<E, V>>]>
+  readonly grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
 }
 
 /**
@@ -60,18 +60,14 @@ export declare namespace GroupBy {
  */
 export const evaluate: {
   <K, E, V, R2, E2, A>(
-    f: (key: K, stream: Stream.Stream<never, E, V>) => Stream.Stream<R2, E2, A>,
-    options?: {
-      readonly bufferSize?: number | undefined
-    }
-  ): <R>(self: GroupBy<R, E, K, V>) => Stream.Stream<R2 | R, E | E2, A>
+    f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
+    options?: { readonly bufferSize?: number | undefined } | undefined
+  ): <R>(self: GroupBy<R, E, K, V>) => Stream.Stream<A, E | E2, R2 | R>
   <R, K, E, V, R2, E2, A>(
     self: GroupBy<R, E, K, V>,
-    f: (key: K, stream: Stream.Stream<never, E, V>) => Stream.Stream<R2, E2, A>,
-    options?: {
-      readonly bufferSize?: number | undefined
-    }
-  ): Stream.Stream<R | R2, E | E2, A>
+    f: (key: K, stream: Stream.Stream<V, E>) => Stream.Stream<A, E2, R2>,
+    options?: { readonly bufferSize?: number | undefined } | undefined
+  ): Stream.Stream<A, E | E2, R | R2>
 } = internal.evaluate
 
 /**
@@ -103,5 +99,5 @@ export const first: {
  * @category constructors
  */
 export const make: <R, E, K, V>(
-  grouped: Stream.Stream<R, E, readonly [K, Queue.Dequeue<Take.Take<E, V>>]>
+  grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
 ) => GroupBy<R, E, K, V> = internal.make

package/src/KeyedPool.ts

@@ -21,27 +21,27 @@ export const KeyedPoolTypeId: unique symbol = internal.KeyedPoolTypeId
 export type KeyedPoolTypeId = typeof KeyedPoolTypeId
 
 /**
- * A `KeyedPool<K, E, A>` is a pool of `Pool`s of items of type `A`. Each pool
+ * A `KeyedPool<K, A, E>` is a pool of `Pool`s of items of type `A`. Each pool
  * in the `KeyedPool` is associated with a key of type `K`.
  *
  * @since 2.0.0
  * @category models
  */
-export interface KeyedPool<in K, out E, in out A> extends KeyedPool.Variance<K, E, A>, Pipeable {
+export interface KeyedPool<in K, in out A, out E = never> extends KeyedPool.Variance<K, A, E>, Pipeable {
   /**
    * Retrieves an item from the pool belonging to the given key in a scoped
    * effect. Note that if acquisition fails, then the returned effect will fail
    * for that same reason. Retrying a failed acquisition attempt will repeat the
    * acquisition attempt.
    */
-  get(key: K): Effect.Effect<Scope.Scope, E, A>
+  get(key: K): Effect.Effect<A, E, Scope.Scope>
 
   /**
    * Invalidates the specified item. This will cause the pool to eventually
    * reallocate the item, although this reallocation may occur lazily rather
    * than eagerly.
    */
-  invalidate(item: A): Effect.Effect<never, never, void>
+  invalidate(item: A): Effect.Effect<void>
 }
 
 /**
@@ -52,11 +52,11 @@ export declare namespace KeyedPool {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<in K, out E, in out A> {
+  export interface Variance<in K, in out A, out E> {
     readonly [KeyedPoolTypeId]: {
       readonly _K: Types.Contravariant<K>
-      readonly _E: Types.Covariant<E>
       readonly _A: Types.Invariant<A>
+      readonly _E: Types.Covariant<E>
     }
   }
 }
@@ -70,12 +70,12 @@ export declare namespace KeyedPool {
  * @since 2.0.0
  * @category constructors
  */
-export const make: <K, R, E, A>(
+export const make: <K, A, E, R>(
   options: {
-    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly acquire: (key: K) => Effect.Effect<A, E, R>
     readonly size: number
   }
-) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.make
+) => Effect.Effect<KeyedPool<K, A, E>, never, Scope.Scope | R> = internal.make
 
 /**
  * Makes a new pool of the specified fixed size. The pool is returned in a
@@ -88,12 +88,12 @@ export const make: <K, R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWith: <K, R, E, A>(
+export const makeWith: <K, A, E, R>(
   options: {
-    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly acquire: (key: K) => Effect.Effect<A, E, R>
     readonly size: (key: K) => number
   }
-) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.makeWith
+) => Effect.Effect<KeyedPool<K, A, E>, never, Scope.Scope | R> = internal.makeWith
 
 /**
  * Makes a new pool with the specified minimum and maximum sizes and time to
@@ -108,14 +108,14 @@ export const makeWith: <K, R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWithTTL: <K, R, E, A>(
+export const makeWithTTL: <K, A, E, R>(
   options: {
-    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly acquire: (key: K) => Effect.Effect<A, E, R>
     readonly min: (key: K) => number
     readonly max: (key: K) => number
     readonly timeToLive: Duration.DurationInput
   }
-) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.makeWithTTL
+) => Effect.Effect<KeyedPool<K, A, E>, never, Scope.Scope | R> = internal.makeWithTTL
 
 /**
  * Makes a new pool with the specified minimum and maximum sizes and time to
@@ -130,14 +130,14 @@ export const makeWithTTL: <K, R, E, A>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWithTTLBy: <K, R, E, A>(
+export const makeWithTTLBy: <K, A, E, R>(
   options: {
-    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly acquire: (key: K) => Effect.Effect<A, E, R>
     readonly min: (key: K) => number
     readonly max: (key: K) => number
     readonly timeToLive: (key: K) => Duration.DurationInput
   }
-) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.makeWithTTLBy
+) => Effect.Effect<KeyedPool<K, A, E>, never, Scope.Scope | R> = internal.makeWithTTLBy
 
 /**
  * Retrieves an item from the pool belonging to the given key in a scoped
@@ -149,8 +149,8 @@ export const makeWithTTLBy: <K, R, E, A>(
  * @category combinators
  */
 export const get: {
-  <K>(key: K): <E, A>(self: KeyedPool<K, E, A>) => Effect.Effect<Scope.Scope, E, A>
-  <K, E, A>(self: KeyedPool<K, E, A>, key: K): Effect.Effect<Scope.Scope, E, A>
+  <K>(key: K): <A, E>(self: KeyedPool<K, A, E>) => Effect.Effect<A, E, Scope.Scope>
+  <K, A, E>(self: KeyedPool<K, A, E>, key: K): Effect.Effect<A, E, Scope.Scope>
 } = internal.get
 
 /**
@@ -162,6 +162,6 @@ export const get: {
  * @category combinators
  */
 export const invalidate: {
-  <A>(item: A): <K, E>(self: KeyedPool<K, E, A>) => Effect.Effect<never, never, void>
-  <K, E, A>(self: KeyedPool<K, E, A>, item: A): Effect.Effect<never, never, void>
+  <A>(item: A): <K, E>(self: KeyedPool<K, A, E>) => Effect.Effect<void>
+  <K, A, E>(self: KeyedPool<K, A, E>, item: A): Effect.Effect<void>
 } = internal.invalidate