effect 2.2.5 → 2.3.1

package/src/FiberMap.ts

@@ -31,11 +31,11 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @categories models
  */
-export interface FiberMap<K, E = unknown, A = unknown>
-  extends Pipeable, Inspectable.Inspectable, Iterable<[K, Fiber.RuntimeFiber<E, A>]>
+export interface FiberMap<K, A = unknown, E = unknown>
+  extends Pipeable, Inspectable.Inspectable, Iterable<[K, Fiber.RuntimeFiber<A, E>]>
 {
   readonly [TypeId]: TypeId
-  readonly backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<E, A>>
+  readonly backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<A, E>>
 }
 
 /**
@@ -66,7 +66,7 @@ const Proto = {
   }
 }
 
-const unsafeMake = <K, E = unknown, A = unknown>(): FiberMap<K, E, A> => {
+const unsafeMake = <K, A = unknown, E = unknown>(): FiberMap<K, A, E> => {
   const self = Object.create(Proto)
   self.backing = MutableHashMap.empty()
   return self
@@ -97,8 +97,8 @@ const unsafeMake = <K, E = unknown, A = unknown>(): FiberMap<K, E, A> => {
  * @since 2.0.0
  * @categories constructors
  */
-export const make = <K, E = unknown, A = unknown>(): Effect.Effect<Scope.Scope, never, FiberMap<K, E, A>> =>
-  Effect.acquireRelease(Effect.sync(() => unsafeMake<K, E, A>()), clear)
+export const make = <K, A = unknown, E = unknown>(): Effect.Effect<FiberMap<K, A, E>, never, Scope.Scope> =>
+  Effect.acquireRelease(Effect.sync(() => unsafeMake<K, A, E>()), clear)
 
 /**
  * Create an Effect run function that is backed by a FiberMap.
@@ -107,16 +107,16 @@ export const make = <K, E = unknown, A = unknown>(): Effect.Effect<Scope.Scope,
  * @categories constructors
  */
 export const makeRuntime = <R, K, E = unknown, A = unknown>(): Effect.Effect<
-  Scope.Scope | R,
-  never,
   <XE extends E, XA extends A>(
     key: K,
-    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<K, E, A>(),
+    make<K, A, E>(),
     (self) => runtime(self)<R>()
   )
 
@@ -128,27 +128,27 @@ export const makeRuntime = <R, K, E = unknown, A = unknown>(): Effect.Effect<
  * @categories combinators
  */
 export const unsafeSet: {
-  <K, E, A, XE extends E, XA extends A>(
+  <K, A, E, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
     interruptAs?: FiberId.FiberId
-  ): (self: FiberMap<K, E, A>) => void
-  <K, E, A, XE extends E, XA extends A>(
-    self: FiberMap<K, E, A>,
+  ): (self: FiberMap<K, A, E>) => void
+  <K, A, E, XE extends E, XA extends A>(
+    self: FiberMap<K, A, E>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
     interruptAs?: FiberId.FiberId
   ): void
 } = dual<
-  <K, E, A, XE extends E, XA extends A>(
+  <K, A, E, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
     interruptAs?: FiberId.FiberId
-  ) => (self: FiberMap<K, E, A>) => void,
-  <K, E, A, XE extends E, XA extends A>(
-    self: FiberMap<K, E, A>,
+  ) => (self: FiberMap<K, A, E>) => void,
+  <K, A, E, XE extends E, XA extends A>(
+    self: FiberMap<K, A, E>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
     interruptAs?: FiberId.FiberId
   ) => void
 >((args) => isFiberMap(args[0]), (self, key, fiber, interruptAs) => {
@@ -176,25 +176,25 @@ export const unsafeSet: {
  * @categories combinators
  */
 export const set: {
-  <K, E, A, XE extends E, XA extends A>(
+  <K, A, E, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ): (self: FiberMap<K, E, A>) => Effect.Effect<never, never, void>
-  <K, E, A, XE extends E, XA extends A>(
-    self: FiberMap<K, E, A>,
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ): (self: FiberMap<K, A, E>) => Effect.Effect<void>
+  <K, A, E, XE extends E, XA extends A>(
+    self: FiberMap<K, A, E>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ): Effect.Effect<never, never, void>
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ): Effect.Effect<void>
 } = dual<
-  <K, E, A, XE extends E, XA extends A>(
+  <K, A, E, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ) => (self: FiberMap<K, E, A>) => Effect.Effect<never, never, void>,
-  <K, E, A, XE extends E, XA extends A>(
-    self: FiberMap<K, E, A>,
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ) => (self: FiberMap<K, A, E>) => Effect.Effect<void>,
+  <K, A, E, XE extends E, XA extends A>(
+    self: FiberMap<K, A, E>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XE, XA>
-  ) => Effect.Effect<never, never, void>
+    fiber: Fiber.RuntimeFiber<XA, XE>
+  ) => Effect.Effect<void>
 >(3, (self, key, fiber) =>
   Effect.fiberIdWith(
     (fiberId) => Effect.sync(() => unsafeSet(self, key, fiber, fiberId))
@@ -207,16 +207,16 @@ export const set: {
  * @categories combinators
  */
 export const unsafeGet: {
-  <K>(key: K): <E, A>(self: FiberMap<K, E, A>) => Option.Option<Fiber.RuntimeFiber<E, A>>
-  <K, E, A>(self: FiberMap<K, E, A>, key: K): Option.Option<Fiber.RuntimeFiber<E, A>>
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Option.Option<Fiber.RuntimeFiber<A, E>>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Option.Option<Fiber.RuntimeFiber<A, E>>
 } = dual<
   <K>(
     key: K
-  ) => <E, A>(self: FiberMap<K, E, A>) => Option.Option<Fiber.RuntimeFiber<E, A>>,
-  <K, E, A>(
-    self: FiberMap<K, E, A>,
+  ) => <A, E>(self: FiberMap<K, A, E>) => Option.Option<Fiber.RuntimeFiber<A, E>>,
+  <K, A, E>(
+    self: FiberMap<K, A, E>,
     key: K
-  ) => Option.Option<Fiber.RuntimeFiber<E, A>>
+  ) => Option.Option<Fiber.RuntimeFiber<A, E>>
 >(2, (self, key) => MutableHashMap.get(self.backing, key))
 
 /**
@@ -226,16 +226,16 @@ export const unsafeGet: {
  * @categories combinators
  */
 export const get: {
-  <K>(key: K): <E, A>(self: FiberMap<K, E, A>) => Effect.Effect<never, NoSuchElementException, Fiber.RuntimeFiber<E, A>>
-  <K, E, A>(self: FiberMap<K, E, A>, key: K): Effect.Effect<never, NoSuchElementException, Fiber.RuntimeFiber<E, A>>
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>
 } = dual<
   <K>(
     key: K
-  ) => <E, A>(self: FiberMap<K, E, A>) => Effect.Effect<never, NoSuchElementException, Fiber.RuntimeFiber<E, A>>,
-  <K, E, A>(
-    self: FiberMap<K, E, A>,
+  ) => <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>,
+  <K, A, E>(
+    self: FiberMap<K, A, E>,
     key: K
-  ) => Effect.Effect<never, NoSuchElementException, Fiber.RuntimeFiber<E, A>>
+  ) => Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>
 >(2, (self, key) => Effect.suspend(() => MutableHashMap.get(self.backing, key)))
 
 /**
@@ -245,16 +245,16 @@ export const get: {
  * @categories combinators
  */
 export const remove: {
-  <K>(key: K): <E, A>(self: FiberMap<K, E, A>) => Effect.Effect<never, never, void>
-  <K, E, A>(self: FiberMap<K, E, A>, key: K): Effect.Effect<never, never, void>
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<void>
 } = dual<
   <K>(
     key: K
-  ) => <E, A>(self: FiberMap<K, E, A>) => Effect.Effect<never, never, void>,
-  <K, E, A>(
-    self: FiberMap<K, E, A>,
+  ) => <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>,
+  <K, A, E>(
+    self: FiberMap<K, A, E>,
     key: K
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 >(2, (self, key) =>
   Effect.suspend(() => {
     const fiber = MutableHashMap.get(self.backing, key)
@@ -269,7 +269,7 @@ export const remove: {
  * @since 2.0.0
  * @categories combinators
  */
-export const clear = <K, E, A>(self: FiberMap<K, E, A>): Effect.Effect<never, never, void> =>
+export const clear = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<void> =>
   Effect.zipRight(
     Effect.forEach(self.backing, ([_, fiber]) => Fiber.interrupt(fiber)),
     Effect.sync(() => {
@@ -285,17 +285,17 @@ export const clear = <K, E, A>(self: FiberMap<K, E, A>): Effect.Effect<never, ne
  * @categories combinators
  */
 export const run: {
-  <K, E, A>(
-    self: FiberMap<K, E, A>,
+  <K, A, E>(
+    self: FiberMap<K, A, E>,
     key: K
   ): <R, XE extends E, XA extends A>(
-    effect: Effect.Effect<R, XE, XA>
-  ) => Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
-  <K, E, A, R, XE extends E, XA extends A>(
-    self: FiberMap<K, E, A>,
+    effect: Effect.Effect<XA, XE, R>
+  ) => Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
+  <K, A, E, R, XE extends E, XA extends A>(
+    self: FiberMap<K, A, E>,
     key: K,
-    effect: Effect.Effect<R, XE, XA>
-  ): Effect.Effect<R, never, Fiber.RuntimeFiber<XE, XA>>
+    effect: Effect.Effect<XA, XE, R>
+  ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
 } = function() {
   if (arguments.length === 2) {
     const self = arguments[0] as FiberMap<any>
@@ -324,9 +324,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 map = yield* _(FiberMap.make<string>())
@@ -342,24 +342,24 @@ export const run: {
  * @since 2.0.0
  * @categories combinators
  */
-export const runtime: <K, E, A>(
-  self: FiberMap<K, E, A>
-) => <R>() => Effect.Effect<
-  R,
-  never,
+export const runtime: <K, A, E>(
+  self: FiberMap<K, A, E>
+) => <R = never>() => Effect.Effect<
   <XE extends E, XA extends A>(
     key: K,
-    effect: Effect.Effect<R, XE, XA>,
+    effect: Effect.Effect<XA, XE, R>,
     options?: Runtime.RunForkOptions | undefined
-  ) => Fiber.RuntimeFiber<XE, XA>
-> = <K, E, A>(self: FiberMap<K, E, A>) => <R>() =>
+  ) => Fiber.RuntimeFiber<XA, XE>,
+  never,
+  R
+> = <K, A, E>(self: FiberMap<K, A, E>) => <R>() =>
   Effect.map(
     Effect.runtime<R>(),
     (runtime) => {
       const runFork = Runtime.runFork(runtime)
       return <XE extends E, XA extends A>(
         key: K,
-        effect: Effect.Effect<R, XE, XA>,
+        effect: Effect.Effect<XA, XE, R>,
         options?: Runtime.RunForkOptions | undefined
       ) => {
         const fiber = runFork(effect, options)
@@ -373,5 +373,5 @@ export const runtime: <K, E, A>(
  * @since 2.0.0
  * @categories combinators
  */
-export const size = <K, E, A>(self: FiberMap<K, E, A>): Effect.Effect<never, never, number> =>
+export const size = <K, E, A>(self: FiberMap<K, E, A>): Effect.Effect<number> =>
   Effect.sync(() => MutableHashMap.size(self.backing))

package/src/FiberRef.ts

@@ -78,13 +78,13 @@ export const make: <A>(
     readonly fork?: ((a: A) => A) | undefined
     readonly join?: ((left: A, right: A) => A) | undefined
   }
-) => Effect.Effect<Scope.Scope, never, FiberRef<A>> = fiberRuntime.fiberRefMake
+) => Effect.Effect<FiberRef<A>, never, Scope.Scope> = fiberRuntime.fiberRefMake
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const makeWith: <Value>(ref: LazyArg<FiberRef<Value>>) => Effect.Effect<Scope.Scope, never, FiberRef<Value>> =
+export const makeWith: <Value>(ref: LazyArg<FiberRef<Value>>) => Effect.Effect<FiberRef<Value>, never, Scope.Scope> =
   fiberRuntime.fiberRefMakeWith
 
 /**
@@ -93,7 +93,7 @@ export const makeWith: <Value>(ref: LazyArg<FiberRef<Value>>) => Effect.Effect<S
  */
 export const makeContext: <A>(
   initial: Context.Context<A>
-) => Effect.Effect<Scope.Scope, never, FiberRef<Context.Context<A>>> = fiberRuntime.fiberRefMakeContext
+) => Effect.Effect<FiberRef<Context.Context<A>>, never, Scope.Scope> = fiberRuntime.fiberRefMakeContext
 
 /**
  * @since 2.0.0
@@ -101,7 +101,7 @@ export const makeContext: <A>(
  */
 export const makeRuntimeFlags: (
   initial: RuntimeFlags.RuntimeFlags
-) => Effect.Effect<Scope.Scope, never, FiberRef<RuntimeFlags.RuntimeFlags>> = fiberRuntime.fiberRefMakeRuntimeFlags
+) => Effect.Effect<FiberRef<RuntimeFlags.RuntimeFlags>, never, Scope.Scope> = fiberRuntime.fiberRefMakeRuntimeFlags
 
 /**
  * @since 2.0.0
@@ -153,15 +153,15 @@ export const unsafeMakePatch: <Value, Patch>(
  * @since 2.0.0
  * @category getters
  */
-export const get: <A>(self: FiberRef<A>) => Effect.Effect<never, never, A> = core.fiberRefGet
+export const get: <A>(self: FiberRef<A>) => Effect.Effect<A> = core.fiberRefGet
 
 /**
  * @since 2.0.0
  * @category utils
  */
 export const getAndSet: {
-  <A>(value: A): (self: FiberRef<A>) => Effect.Effect<never, never, A>
-  <A>(self: FiberRef<A>, value: A): Effect.Effect<never, never, A>
+  <A>(value: A): (self: FiberRef<A>) => Effect.Effect<A>
+  <A>(self: FiberRef<A>, value: A): Effect.Effect<A>
 } = core.fiberRefGetAndSet
 
 /**
@@ -169,8 +169,8 @@ export const getAndSet: {
  * @category utils
  */
 export const getAndUpdate: {
-  <A>(f: (a: A) => A): (self: FiberRef<A>) => Effect.Effect<never, never, A>
-  <A>(self: FiberRef<A>, f: (a: A) => A): Effect.Effect<never, never, A>
+  <A>(f: (a: A) => A): (self: FiberRef<A>) => Effect.Effect<A>
+  <A>(self: FiberRef<A>, f: (a: A) => A): Effect.Effect<A>
 } = core.fiberRefGetAndUpdate
 
 /**
@@ -178,8 +178,8 @@ export const getAndUpdate: {
  * @category utils
  */
 export const getAndUpdateSome: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: FiberRef<A>) => Effect.Effect<never, never, A>
-  <A>(self: FiberRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
+  <A>(pf: (a: A) => Option.Option<A>): (self: FiberRef<A>) => Effect.Effect<A>
+  <A>(self: FiberRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
 } = core.fiberRefGetAndUpdateSome
 
 /**
@@ -187,8 +187,8 @@ export const getAndUpdateSome: {
  * @category utils
  */
 export const getWith: {
-  <A, R, E, B>(f: (a: A) => Effect.Effect<R, E, B>): (self: FiberRef<A>) => Effect.Effect<R, E, B>
-  <A, R, E, B>(self: FiberRef<A>, f: (a: A) => Effect.Effect<R, E, B>): Effect.Effect<R, E, B>
+  <A, B, E, R>(f: (a: A) => Effect.Effect<B, E, R>): (self: FiberRef<A>) => Effect.Effect<B, E, R>
+  <A, B, E, R>(self: FiberRef<A>, f: (a: A) => Effect.Effect<B, E, R>): Effect.Effect<B, E, R>
 } = core.fiberRefGetWith
 
 /**
@@ -196,11 +196,11 @@ export const getWith: {
  * @category utils
  */
 export const set: {
-  <A>(value: A): (self: FiberRef<A>) => Effect.Effect<never, never, void>
-  <A>(self: FiberRef<A>, value: A): Effect.Effect<never, never, void>
+  <A>(value: A): (self: FiberRef<A>) => Effect.Effect<void>
+  <A>(self: FiberRef<A>, value: A): Effect.Effect<void>
 } = core.fiberRefSet
 
-const _delete: <A>(self: FiberRef<A>) => Effect.Effect<never, never, void> = core.fiberRefDelete
+const _delete: <A>(self: FiberRef<A>) => Effect.Effect<void> = core.fiberRefDelete
 
 export {
   /**
@@ -214,15 +214,15 @@ export {
  * @since 2.0.0
  * @category utils
  */
-export const reset: <A>(self: FiberRef<A>) => Effect.Effect<never, never, void> = core.fiberRefReset
+export const reset: <A>(self: FiberRef<A>) => Effect.Effect<void> = core.fiberRefReset
 
 /**
  * @since 2.0.0
  * @category utils
  */
 export const modify: {
-  <A, B>(f: (a: A) => readonly [B, A]): (self: FiberRef<A>) => Effect.Effect<never, never, B>
-  <A, B>(self: FiberRef<A>, f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B>
+  <A, B>(f: (a: A) => readonly [B, A]): (self: FiberRef<A>) => Effect.Effect<B>
+  <A, B>(self: FiberRef<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>
 } = core.fiberRefModify
 
 /**
@@ -233,15 +233,15 @@ export const modifySome: <A, B>(
   self: FiberRef<A>,
   def: B,
   f: (a: A) => Option.Option<readonly [B, A]>
-) => Effect.Effect<never, never, B> = core.fiberRefModifySome
+) => Effect.Effect<B> = core.fiberRefModifySome
 
 /**
  * @since 2.0.0
  * @category utils
  */
 export const update: {
-  <A>(f: (a: A) => A): (self: FiberRef<A>) => Effect.Effect<never, never, void>
-  <A>(self: FiberRef<A>, f: (a: A) => A): Effect.Effect<never, never, void>
+  <A>(f: (a: A) => A): (self: FiberRef<A>) => Effect.Effect<void>
+  <A>(self: FiberRef<A>, f: (a: A) => A): Effect.Effect<void>
 } = core.fiberRefUpdate
 
 /**
@@ -249,8 +249,8 @@ export const update: {
  * @category utils
  */
 export const updateSome: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: FiberRef<A>) => Effect.Effect<never, never, void>
-  <A>(self: FiberRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, void>
+  <A>(pf: (a: A) => Option.Option<A>): (self: FiberRef<A>) => Effect.Effect<void>
+  <A>(self: FiberRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<void>
 } = core.fiberRefUpdateSome
 
 /**
@@ -258,8 +258,8 @@ export const updateSome: {
  * @category utils
  */
 export const updateAndGet: {
-  <A>(f: (a: A) => A): (self: FiberRef<A>) => Effect.Effect<never, never, A>
-  <A>(self: FiberRef<A>, f: (a: A) => A): Effect.Effect<never, never, A>
+  <A>(f: (a: A) => A): (self: FiberRef<A>) => Effect.Effect<A>
+  <A>(self: FiberRef<A>, f: (a: A) => A): Effect.Effect<A>
 } = core.fiberRefUpdateAndGet
 
 /**
@@ -267,8 +267,8 @@ export const updateAndGet: {
  * @category utils
  */
 export const updateSomeAndGet: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: FiberRef<A>) => Effect.Effect<never, never, A>
-  <A>(self: FiberRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
+  <A>(pf: (a: A) => Option.Option<A>): (self: FiberRef<A>) => Effect.Effect<A>
+  <A>(self: FiberRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
 } = core.fiberRefUpdateSomeAndGet
 
 /**

package/src/FiberRefs.ts

@@ -115,7 +115,7 @@ export const joinAs: {
  * @since 2.0.0
  * @category utils
  */
-export const setAll: (self: FiberRefs) => Effect.Effect<never, never, void> = internal.setAll
+export const setAll: (self: FiberRefs) => Effect.Effect<void> = internal.setAll
 
 /**
  * Updates the value of the specified `FiberRef` using the provided `FiberId`