@typed/fx 1.22.2 → 1.23.0

package/src/RefArray.ts

@@ -28,18 +28,18 @@ export interface RefArray<out R, in out E, in out A> extends RefSubject.RefSubje
  * @category constructors
  */
 export function make<R, E, A>(
-  initial: Effect.Effect<R, E, ReadonlyArray<A>>,
+  initial: Effect.Effect<ReadonlyArray<A>, E, R>,
   eq?: Equivalence<A>
-): Effect.Effect<R | Scope.Scope, never, RefArray<never, E, A>>
+): Effect.Effect<RefArray<never, E, A>, never, R | Scope.Scope>
 export function make<R, E, A>(
   initial: Fx.Fx<R, E, ReadonlyArray<A>>,
   eq?: Equivalence<A>
-): Effect.Effect<R | Scope.Scope, never, RefArray<never, E, A>>
+): Effect.Effect<RefArray<never, E, A>, never, R | Scope.Scope>
 
 export function make<R, E, A>(
-  initial: Effect.Effect<R, E, ReadonlyArray<A>> | Fx.Fx<R, E, ReadonlyArray<A>>,
+  initial: Effect.Effect<ReadonlyArray<A>, E, R> | Fx.Fx<R, E, ReadonlyArray<A>>,
   eq: Equivalence<A> = equals
-): Effect.Effect<R | Scope.Scope, never, RefArray<never, E, A>> {
+): Effect.Effect<RefArray<never, E, A>, never, R | Scope.Scope> {
   return RefSubject.make(
     initial,
     {
@@ -91,8 +91,8 @@ export function tagged(): {
  * @category combinators
  */
 export const prepend: {
-  <A>(value: A): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, value: A): Effect.Effect<R, E, ReadonlyArray<A>>
+  <A>(value: A): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, value: A): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function prepend<R, E, A>(ref: RefArray<R, E, A>, value: A) {
   return RefSubject.update(ref, ReadonlyArray.prepend(value))
 })
@@ -103,8 +103,8 @@ export const prepend: {
  * @category combinators
  */
 export const prependAll: {
-  <A>(value: Iterable<A>): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, value: Iterable<A>): Effect.Effect<R, E, ReadonlyArray<A>>
+  <A>(value: Iterable<A>): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, value: Iterable<A>): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(
   2,
   function prependAll<R, E, A>(ref: RefArray<R, E, A>, value: Iterable<A>) {
@@ -118,8 +118,8 @@ export const prependAll: {
  * @category combinators
  */
 export const append: {
-  <A>(value: A): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, value: A): Effect.Effect<R, E, ReadonlyArray<A>>
+  <A>(value: A): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, value: A): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function append<R, E, A>(ref: RefArray<R, E, A>, value: A) {
   return RefSubject.update(ref, ReadonlyArray.append(value))
 })
@@ -132,8 +132,8 @@ export const append: {
 export const appendAll: {
   <A>(
     value: Iterable<A>
-  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, value: Iterable<A>): Effect.Effect<R, E, ReadonlyArray<A>>
+  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, value: Iterable<A>): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function appendAll<R, E, A>(ref: RefArray<R, E, A>, value: Iterable<A>) {
   return RefSubject.update(ref, ReadonlyArray.appendAll(value))
 })
@@ -144,8 +144,8 @@ export const appendAll: {
  * @category combinators
  */
 export const drop: {
-  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<R, E, ReadonlyArray<A>>
+  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function drop<R, E, A>(ref: RefArray<R, E, A>, n: number) {
   return RefSubject.update(ref, ReadonlyArray.drop(n))
 })
@@ -156,8 +156,8 @@ export const drop: {
  * @category combinators
  */
 export const dropRight: {
-  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<R, E, ReadonlyArray<A>>
+  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function dropRight<R, E, A>(ref: RefArray<R, E, A>, n: number) {
   return RefSubject.update(ref, ReadonlyArray.dropRight(n))
 })
@@ -170,11 +170,11 @@ export const dropRight: {
 export const dropWhile: {
   <A>(
     predicate: (a: A) => boolean
-  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
+  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
   <R, E, A>(
     ref: RefArray<R, E, A>,
     predicate: (a: unknown) => boolean
-  ): Effect.Effect<R, E, ReadonlyArray<A>>
+  ): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(
   2,
   function dropWhile<R, E, A>(ref: RefArray<R, E, A>, predicate: (a: unknown) => boolean) {
@@ -239,12 +239,12 @@ export const insertAt: {
   <A>(
     index: number,
     a: A
-  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
+  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
   <R, E, A>(
     ref: RefArray<R, E, A>,
     index: number,
     a: A
-  ): Effect.Effect<R, E, ReadonlyArray<A>>
+  ): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(3, function insertAt<R, E, A>(ref: RefArray<R, E, A>, index: number, a: A) {
   return RefSubject.update(ref, (as) => Option.getOrElse(ReadonlyArray.insertAt(as, index, a), () => [...as, a]))
 })
@@ -320,12 +320,12 @@ export const modifyAt: {
   <A>(
     index: number,
     f: (a: A) => A
-  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
+  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
   <R, E, A>(
     ref: RefArray<R, E, A>,
     index: number,
     f: (a: A) => A
-  ): Effect.Effect<R, E, ReadonlyArray<A>>
+  ): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(3, function modifyAt<R, E, A>(ref: RefArray<R, E, A>, index: number, f: (a: A) => A) {
   return RefSubject.update(ref, ReadonlyArray.modify(index, f))
 })
@@ -407,12 +407,12 @@ export const replaceAt: {
   <A>(
     index: number,
     a: A
-  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
+  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
   <R, E, A>(
     ref: RefArray<R, E, A>,
     index: number,
     a: A
-  ): Effect.Effect<R, E, ReadonlyArray<A>>
+  ): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(3, function replaceAt<R, E, A>(ref: RefArray<R, E, A>, index: number, a: A) {
   return RefSubject.update(ref, ReadonlyArray.replace(index, a))
 })
@@ -423,8 +423,8 @@ export const replaceAt: {
  * @category combinators
  */
 export const rotate: {
-  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<R, E, ReadonlyArray<A>>
+  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function rotate<R, E, A>(ref: RefArray<R, E, A>, n: number) {
   return RefSubject.update(ref, ReadonlyArray.rotate(n))
 })
@@ -437,11 +437,11 @@ export const rotate: {
 export const sortBy: {
   <A>(
     orders: Iterable<Order.Order<A>>
-  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
+  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
   <R, E, A>(
     ref: RefArray<R, E, A>,
     orders: Iterable<Order.Order<A>>
-  ): Effect.Effect<R, E, ReadonlyArray<A>>
+  ): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function sortBy<R, E, A>(ref: RefArray<R, E, A>, orders: Iterable<Order.Order<A>>) {
   return RefSubject.update(ref, ReadonlyArray.sortBy(...orders))
 })
@@ -452,8 +452,8 @@ export const sortBy: {
  * @category combinators
  */
 export const take: {
-  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<R, E, ReadonlyArray<A>>
+  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function take<R, E, A>(ref: RefArray<R, E, A>, n: number) {
   return RefSubject.update(ref, ReadonlyArray.take(n))
 })
@@ -464,8 +464,8 @@ export const take: {
  * @category combinators
  */
 export const takeRight: {
-  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
-  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<R, E, ReadonlyArray<A>>
+  (n: number): <R, E, A>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
+  <R, E, A>(ref: RefArray<R, E, A>, n: number): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(2, function takeRight<R, E, A>(ref: RefArray<R, E, A>, n: number) {
   return RefSubject.update(ref, ReadonlyArray.takeRight(n))
 })
@@ -478,11 +478,11 @@ export const takeRight: {
 export const takeWhile: {
   <A>(
     predicate: (a: A) => boolean
-  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<R, E, ReadonlyArray<A>>
+  ): <R, E>(ref: RefArray<R, E, A>) => Effect.Effect<ReadonlyArray<A>, E, R>
   <R, E, A>(
     ref: RefArray<R, E, A>,
     predicate: (a: unknown) => boolean
-  ): Effect.Effect<R, E, ReadonlyArray<A>>
+  ): Effect.Effect<ReadonlyArray<A>, E, R>
 } = dual(
   2,
   function takeWhile<R, E, A>(ref: RefArray<R, E, A>, predicate: (a: unknown) => boolean) {
@@ -496,7 +496,7 @@ export const takeWhile: {
  * @category combinators
  */
 export const dedupeWith =
-  <A>(valueEq: Equivalence<A>) => <R, E>(ref: RefArray<R, E, A>): Effect.Effect<R, E, ReadonlyArray<A>> =>
+  <A>(valueEq: Equivalence<A>) => <R, E>(ref: RefArray<R, E, A>): Effect.Effect<ReadonlyArray<A>, E, R> =>
     RefSubject.update(ref, ReadonlyArray.dedupeWith(valueEq))
 
 /**

package/src/RefChunk.ts

@@ -26,18 +26,18 @@ export interface RefChunk<out R, in out E, in out A> extends RefSubject.RefSubje
  * @category constructors
  */
 export function make<R, E, A>(
-  initial: Effect.Effect<R, E, Chunk.Chunk<A>>,
+  initial: Effect.Effect<Chunk.Chunk<A>, E, R>,
   eq?: Equivalence<A>
-): Effect.Effect<R | Scope.Scope, never, RefChunk<never, E, A>>
+): Effect.Effect<RefChunk<never, E, A>, never, R | Scope.Scope>
 export function make<R, E, A>(
   initial: Fx.Fx<R, E, Chunk.Chunk<A>>,
   eq?: Equivalence<A>
-): Effect.Effect<R | Scope.Scope, never, RefChunk<never, E, A>>
+): Effect.Effect<RefChunk<never, E, A>, never, R | Scope.Scope>
 
 export function make<R, E, A>(
-  initial: Fx.Fx<R, E, Chunk.Chunk<A>> | Effect.Effect<R, E, Chunk.Chunk<A>>,
+  initial: Fx.Fx<R, E, Chunk.Chunk<A>> | Effect.Effect<Chunk.Chunk<A>, E, R>,
   eq: Equivalence<A> = equals
-): Effect.Effect<R | Scope.Scope, never, RefChunk<never, E, A>> {
+): Effect.Effect<RefChunk<never, E, A>, never, R | Scope.Scope> {
   return RefSubject.make(
     initial,
     {
@@ -65,8 +65,8 @@ export const tagged: <A>() => {
  * @category combinators
  */
 export const prepend: {
-  <A>(value: A): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
-  <R, E, A>(ref: RefChunk<R, E, A>, value: A): Effect.Effect<R, E, Chunk.Chunk<A>>
+  <A>(value: A): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
+  <R, E, A>(ref: RefChunk<R, E, A>, value: A): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(2, function prepend<R, E, A>(ref: RefChunk<R, E, A>, value: A) {
   return RefSubject.update(ref, Chunk.prepend(value))
 })
@@ -77,8 +77,8 @@ export const prepend: {
  * @category combinators
  */
 export const prependAll: {
-  <A>(value: Iterable<A>): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
-  <R, E, A>(ref: RefChunk<R, E, A>, value: Iterable<A>): Effect.Effect<R, E, Chunk.Chunk<A>>
+  <A>(value: Iterable<A>): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
+  <R, E, A>(ref: RefChunk<R, E, A>, value: Iterable<A>): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(
   2,
   function prependAll<R, E, A>(ref: RefChunk<R, E, A>, value: Iterable<A>) {
@@ -92,8 +92,8 @@ export const prependAll: {
  * @category combinators
  */
 export const append: {
-  <A>(value: A): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
-  <R, E, A>(ref: RefChunk<R, E, A>, value: A): Effect.Effect<R, E, Chunk.Chunk<A>>
+  <A>(value: A): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
+  <R, E, A>(ref: RefChunk<R, E, A>, value: A): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(2, function append<R, E, A>(ref: RefChunk<R, E, A>, value: A) {
   return RefSubject.update(ref, Chunk.append(value))
 })
@@ -106,8 +106,8 @@ export const append: {
 export const appendAll: {
   <A>(
     value: Iterable<A>
-  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
-  <R, E, A>(ref: RefChunk<R, E, A>, value: Iterable<A>): Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
+  <R, E, A>(ref: RefChunk<R, E, A>, value: Iterable<A>): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(2, function appendAll<R, E, A>(ref: RefChunk<R, E, A>, value: Iterable<A>) {
   return RefSubject.update(ref, Chunk.appendAll(Chunk.fromIterable(value)))
 })
@@ -118,8 +118,8 @@ export const appendAll: {
  * @category combinators
  */
 export const drop: {
-  (n: number): <R, E, A>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
-  <R, E, A>(ref: RefChunk<R, E, A>, n: number): Effect.Effect<R, E, Chunk.Chunk<A>>
+  (n: number): <R, E, A>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
+  <R, E, A>(ref: RefChunk<R, E, A>, n: number): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(2, function drop<R, E, A>(ref: RefChunk<R, E, A>, n: number) {
   return RefSubject.update(ref, Chunk.drop(n))
 })
@@ -130,8 +130,8 @@ export const drop: {
  * @category combinators
  */
 export const dropRight: {
-  (n: number): <R, E, A>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
-  <R, E, A>(ref: RefChunk<R, E, A>, n: number): Effect.Effect<R, E, Chunk.Chunk<A>>
+  (n: number): <R, E, A>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
+  <R, E, A>(ref: RefChunk<R, E, A>, n: number): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(2, function dropRight<R, E, A>(ref: RefChunk<R, E, A>, n: number) {
   return RefSubject.update(ref, Chunk.dropRight(n))
 })
@@ -144,11 +144,11 @@ export const dropRight: {
 export const dropWhile: {
   <A>(
     predicate: (a: A) => boolean
-  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
   <R, E, A>(
     ref: RefChunk<R, E, A>,
     predicate: (a: A) => boolean
-  ): Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(
   2,
   function dropWhile<R, E, A>(ref: RefChunk<R, E, A>, predicate: (a: A) => boolean) {
@@ -256,12 +256,12 @@ export const modifyAt: {
   <A>(
     index: number,
     f: (a: A) => A
-  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
   <R, E, A>(
     ref: RefChunk<R, E, A>,
     index: number,
     f: (a: A) => A
-  ): Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(3, function modifyAt<R, E, A>(ref: RefChunk<R, E, A>, index: number, f: (a: A) => A) {
   return RefSubject.update(ref, Chunk.modify(index, f))
 })
@@ -343,12 +343,12 @@ export const replaceAt: {
   <A>(
     index: number,
     a: A
-  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
   <R, E, A>(
     ref: RefChunk<R, E, A>,
     index: number,
     a: A
-  ): Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(3, function replaceAt<R, E, A>(ref: RefChunk<R, E, A>, index: number, a: A) {
   return RefSubject.update(ref, Chunk.replace(index, a))
 })
@@ -359,8 +359,8 @@ export const replaceAt: {
  * @category combinators
  */
 export const take: {
-  (n: number): <R, E, A>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
-  <R, E, A>(ref: RefChunk<R, E, A>, n: number): Effect.Effect<R, E, Chunk.Chunk<A>>
+  (n: number): <R, E, A>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
+  <R, E, A>(ref: RefChunk<R, E, A>, n: number): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(2, function take<R, E, A>(ref: RefChunk<R, E, A>, n: number) {
   return RefSubject.update(ref, Chunk.take(n))
 })
@@ -371,8 +371,8 @@ export const take: {
  * @category combinators
  */
 export const takeRight: {
-  (n: number): <R, E, A>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
-  <R, E, A>(ref: RefChunk<R, E, A>, n: number): Effect.Effect<R, E, Chunk.Chunk<A>>
+  (n: number): <R, E, A>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
+  <R, E, A>(ref: RefChunk<R, E, A>, n: number): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(2, function takeRight<R, E, A>(ref: RefChunk<R, E, A>, n: number) {
   return RefSubject.update(ref, Chunk.takeRight(n))
 })
@@ -385,11 +385,11 @@ export const takeRight: {
 export const takeWhile: {
   <A>(
     predicate: (a: A) => boolean
-  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): <R, E>(ref: RefChunk<R, E, A>) => Effect.Effect<Chunk.Chunk<A>, E, R>
   <R, E, A>(
     ref: RefChunk<R, E, A>,
     predicate: (a: A) => boolean
-  ): Effect.Effect<R, E, Chunk.Chunk<A>>
+  ): Effect.Effect<Chunk.Chunk<A>, E, R>
 } = dual(
   2,
   function takeWhile<R, E, A>(ref: RefChunk<R, E, A>, predicate: (a: A) => boolean) {
@@ -402,5 +402,5 @@ export const takeWhile: {
  * @since 1.18.0
  * @category combinators
  */
-export const dedupe = <R, E, A>(ref: RefChunk<R, E, A>): Effect.Effect<R, E, Chunk.Chunk<A>> =>
+export const dedupe = <R, E, A>(ref: RefChunk<R, E, A>): Effect.Effect<Chunk.Chunk<A>, E, R> =>
   RefSubject.update(ref, Chunk.dedupe)

package/src/RefHashMap.ts

@@ -27,15 +27,15 @@ export interface RefHashMap<out R, in out E, in out K, in out V>
  * @category constructors
  */
 export function make<R, E, K, V>(
-  initial: Effect.Effect<R, E, HashMap.HashMap<K, V>>
-): Effect.Effect<R | Scope.Scope, never, RefHashMap<never, E, K, V>>
+  initial: Effect.Effect<HashMap.HashMap<K, V>, E, R>
+): Effect.Effect<RefHashMap<never, E, K, V>, never, R | Scope.Scope>
 export function make<R, E, K, V>(
   initial: Fx.Fx<R, E, HashMap.HashMap<K, V>>
-): Effect.Effect<R | Scope.Scope, never, RefHashMap<never, E, K, V>>
+): Effect.Effect<RefHashMap<never, E, K, V>, never, R | Scope.Scope>
 
 export function make<R, E, K, V>(
-  initial: Effect.Effect<R, E, HashMap.HashMap<K, V>> | Fx.Fx<R, E, HashMap.HashMap<K, V>>
-): Effect.Effect<R | Scope.Scope, never, RefHashMap<never, E, K, V>> {
+  initial: Effect.Effect<HashMap.HashMap<K, V>, E, R> | Fx.Fx<R, E, HashMap.HashMap<K, V>>
+): Effect.Effect<RefHashMap<never, E, K, V>, never, R | Scope.Scope> {
   return RefSubject.make(initial)
 }
 
@@ -59,7 +59,7 @@ export const tagged: <K, V>() => {
  */
 export function of<K, V>(
   map: HashMap.HashMap<K, V>
-): Effect.Effect<Scope.Scope, never, RefHashMap<never, never, K, V>> {
+): Effect.Effect<RefHashMap<never, never, K, V>, never, Scope.Scope> {
   return make(Effect.succeed(map))
 }
 
@@ -129,12 +129,12 @@ export function keys<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>): RefSubject
 export const map: {
   <K, V>(
     f: (v: V, k: K) => V
-  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
-  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, f: (v: V, k: K) => V): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<HashMap.HashMap<K, V>, E, R>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, f: (v: V, k: K) => V): Effect.Effect<HashMap.HashMap<K, V>, E, R>
 } = dual(2, function map<R, E, K, V>(
   refHashMap: RefHashMap<R, E, K, V>,
   f: (v: V, k: K) => V
-): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
+): Effect.Effect<HashMap.HashMap<K, V>, E, R> {
   return RefSubject.update(refHashMap, HashMap.map(f))
 })
 
@@ -147,17 +147,17 @@ export const modify: {
   <K, V>(
     key: K,
     f: (v: V) => V
-  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<HashMap.HashMap<K, V>, E, R>
   <R, E, K, V>(
     refHashMap: RefHashMap<R, E, K, V>,
     key: K,
     f: (v: V) => V
-  ): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  ): Effect.Effect<HashMap.HashMap<K, V>, E, R>
 } = dual(3, function map<R, E, K, V>(
   refHashMap: RefHashMap<R, E, K, V>,
   key: K,
   f: (v: V) => V
-): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
+): Effect.Effect<HashMap.HashMap<K, V>, E, R> {
   return RefSubject.update(refHashMap, HashMap.modify(key, f))
 })
 
@@ -170,17 +170,17 @@ export const modifyAt: {
   <K, V>(
     key: K,
     f: HashMap.HashMap.UpdateFn<V>
-  ): <R, E>(self: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  ): <R, E>(self: RefHashMap<R, E, K, V>) => Effect.Effect<HashMap.HashMap<K, V>, E, R>
   <R, E, K, V>(
     self: RefHashMap<R, E, K, V>,
     key: K,
     f: HashMap.HashMap.UpdateFn<V>
-  ): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  ): Effect.Effect<HashMap.HashMap<K, V>, E, R>
 } = dual(3, function modifyAt<R, E, K, V>(
   self: RefHashMap<R, E, K, V>,
   key: K,
   f: HashMap.HashMap.UpdateFn<V>
-): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
+): Effect.Effect<HashMap.HashMap<K, V>, E, R> {
   return RefSubject.update(self, HashMap.modifyAt(key, f))
 })
 
@@ -194,19 +194,19 @@ export const modifyHash: {
     key: K,
     hash: number,
     f: HashMap.HashMap.UpdateFn<V>
-  ): <R, E>(self: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  ): <R, E>(self: RefHashMap<R, E, K, V>) => Effect.Effect<HashMap.HashMap<K, V>, E, R>
   <R, E, K, V>(
     self: RefHashMap<R, E, K, V>,
     key: K,
     hash: number,
     f: HashMap.HashMap.UpdateFn<V>
-  ): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  ): Effect.Effect<HashMap.HashMap<K, V>, E, R>
 } = dual(4, function modifyAt<R, E, K, V>(
   self: RefHashMap<R, E, K, V>,
   key: K,
   hash: number,
   f: HashMap.HashMap.UpdateFn<V>
-): Effect.Effect<R, E, HashMap.HashMap<K, V>> {
+): Effect.Effect<HashMap.HashMap<K, V>, E, R> {
   return RefSubject.update(self, HashMap.modifyHash(key, hash, f))
 })
 
@@ -239,8 +239,8 @@ export const reduce: {
  * @category combinators
  */
 export const remove: {
-  <K>(key: K): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
-  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <K>(key: K): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<HashMap.HashMap<K, V>, E, R>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K): Effect.Effect<HashMap.HashMap<K, V>, E, R>
 } = dual(2, function remove<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K) {
   return RefSubject.update(refHashMap, HashMap.remove(key))
 })
@@ -251,8 +251,8 @@ export const remove: {
  * @category combinators
  */
 export const removeMany: {
-  <K>(key: Iterable<K>): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
-  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: Iterable<K>): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  <K>(key: Iterable<K>): <R, E, V>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<HashMap.HashMap<K, V>, E, R>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: Iterable<K>): Effect.Effect<HashMap.HashMap<K, V>, E, R>
 } = dual(2, function removeMany<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: Iterable<K>) {
   return RefSubject.update(refHashMap, HashMap.removeMany(key))
 })
@@ -266,8 +266,8 @@ export const set: {
   <K, V>(
     key: K,
     value: V
-  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<R, E, HashMap.HashMap<K, V>>
-  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, value: V): Effect.Effect<R, E, HashMap.HashMap<K, V>>
+  ): <R, E>(refHashMap: RefHashMap<R, E, K, V>) => Effect.Effect<HashMap.HashMap<K, V>, E, R>
+  <R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, value: V): Effect.Effect<HashMap.HashMap<K, V>, E, R>
 } = dual(3, function set<R, E, K, V>(refHashMap: RefHashMap<R, E, K, V>, key: K, value: V) {
   return RefSubject.update(refHashMap, HashMap.set(key, value))
 })

package/src/RefHashSet.ts

@@ -22,8 +22,8 @@ export interface RefHashSet<out R, in out E, in out A> extends RefSubject.RefSub
  * @since 1.18.0
  */
 export function make<R, E, A>(
-  initial: Effect.Effect<R, E, HashSet.HashSet<A>> | Fx.Fx<R, E, HashSet.HashSet<A>>
-): Effect.Effect<R | Scope.Scope, never, RefHashSet<never, E, A>> {
+  initial: Effect.Effect<HashSet.HashSet<A>, E, R> | Fx.Fx<R, E, HashSet.HashSet<A>>
+): Effect.Effect<RefHashSet<never, E, A>, never, R | Scope.Scope> {
   return RefSubject.make(
     initial
   )
@@ -48,8 +48,8 @@ export const tagged: <A>() => {
  * @category combinators
  */
 export const add: {
-  <A>(value: A): <R, E>(ref: RefHashSet<R, E, A>) => Effect.Effect<R, E, HashSet.HashSet<A>>
-  <R, E, A>(ref: RefHashSet<R, E, A>, value: A): Effect.Effect<R, E, HashSet.HashSet<A>>
+  <A>(value: A): <R, E>(ref: RefHashSet<R, E, A>) => Effect.Effect<HashSet.HashSet<A>, E, R>
+  <R, E, A>(ref: RefHashSet<R, E, A>, value: A): Effect.Effect<HashSet.HashSet<A>, E, R>
 } = dual(2, function add<R, E, A>(ref: RefHashSet<R, E, A>, value: A) {
   return RefSubject.update(ref, HashSet.add(value))
 })
@@ -62,8 +62,8 @@ export const add: {
 export const appendAll: {
   <A>(
     value: Iterable<A>
-  ): <R, E>(ref: RefHashSet<R, E, A>) => Effect.Effect<R, E, HashSet.HashSet<A>>
-  <R, E, A>(ref: RefHashSet<R, E, A>, value: Iterable<A>): Effect.Effect<R, E, HashSet.HashSet<A>>
+  ): <R, E>(ref: RefHashSet<R, E, A>) => Effect.Effect<HashSet.HashSet<A>, E, R>
+  <R, E, A>(ref: RefHashSet<R, E, A>, value: Iterable<A>): Effect.Effect<HashSet.HashSet<A>, E, R>
 } = dual(2, function appendAll<R, E, A>(ref: RefHashSet<R, E, A>, value: Iterable<A>) {
   return RefSubject.update(ref, (set) =>
     HashSet.mutate(set, (set) => {