effect 2.2.5 → 2.3.1

package/src/internal/stm/tReentrantLock.ts

@@ -153,7 +153,7 @@ const adjustReadLock = (readLock: ReadLock, fiberId: FiberId.FiberId, adjustment
   return new ReadLock(HashMap.set(readLock.readers, fiberId, newTotal))
 }
 
-const adjustRead = (self: TReentrantLock.TReentrantLock, delta: number): STM.STM<never, never, number> =>
+const adjustRead = (self: TReentrantLock.TReentrantLock, delta: number): STM.STM<number> =>
   core.withSTMRuntime((runtime) => {
     const lock = tRef.unsafeGet(self.state, runtime.journal)
     if (isReadLock(lock)) {
@@ -181,10 +181,10 @@ const adjustRead = (self: TReentrantLock.TReentrantLock, delta: number): STM.STM
   })
 
 /** @internal */
-export const acquireRead = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, number> => adjustRead(self, 1)
+export const acquireRead = (self: TReentrantLock.TReentrantLock): STM.STM<number> => adjustRead(self, 1)
 
 /** @internal */
-export const acquireWrite = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, number> =>
+export const acquireWrite = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
   core.withSTMRuntime((runtime) => {
     const lock = tRef.unsafeGet(self.state, runtime.journal)
     if (isReadLock(lock) && noOtherHolder(lock, runtime.fiberId)) {
@@ -207,7 +207,7 @@ export const acquireWrite = (self: TReentrantLock.TReentrantLock): STM.STM<never
   })
 
 /** @internal */
-export const fiberReadLocks = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, number> =>
+export const fiberReadLocks = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
   core.effect<never, number>((journal, fiberId) =>
     tRef.unsafeGet(
       self.state,
@@ -216,7 +216,7 @@ export const fiberReadLocks = (self: TReentrantLock.TReentrantLock): STM.STM<nev
   )
 
 /** @internal */
-export const fiberWriteLocks = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, number> =>
+export const fiberWriteLocks = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
   core.effect<never, number>((journal, fiberId) =>
     tRef.unsafeGet(
       self.state,
@@ -225,10 +225,10 @@ export const fiberWriteLocks = (self: TReentrantLock.TReentrantLock): STM.STM<ne
   )
 
 /** @internal */
-export const lock = (self: TReentrantLock.TReentrantLock): Effect.Effect<Scope.Scope, never, number> => writeLock(self)
+export const lock = (self: TReentrantLock.TReentrantLock): Effect.Effect<number, never, Scope.Scope> => writeLock(self)
 
 /** @internal */
-export const locked = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, boolean> =>
+export const locked = (self: TReentrantLock.TReentrantLock): STM.STM<boolean> =>
   core.zipWith(
     readLocked(self),
     writeLocked(self),
@@ -236,37 +236,37 @@ export const locked = (self: TReentrantLock.TReentrantLock): STM.STM<never, neve
   )
 
 /** @internal */
-export const make: STM.STM<never, never, TReentrantLock.TReentrantLock> = core.map(
+export const make: STM.STM<TReentrantLock.TReentrantLock> = core.map(
   tRef.make<LockState>(emptyReadLock),
   (readLock) => new TReentranLockImpl(readLock)
 )
 
 /** @internal */
-export const readLock = (self: TReentrantLock.TReentrantLock): Effect.Effect<Scope.Scope, never, number> =>
+export const readLock = (self: TReentrantLock.TReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
   Effect.acquireRelease(
     core.commit(acquireRead(self)),
     () => core.commit(releaseRead(self))
   )
 
 /** @internal */
-export const readLocks = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, number> =>
+export const readLocks = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
   core.map(
     tRef.get(self.state),
     (state) => state.readLocks
   )
 
 /** @internal */
-export const readLocked = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, boolean> =>
+export const readLocked = (self: TReentrantLock.TReentrantLock): STM.STM<boolean> =>
   core.map(
     tRef.get(self.state),
     (state) => state.readLocks > 0
   )
 
 /** @internal */
-export const releaseRead = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, number> => adjustRead(self, -1)
+export const releaseRead = (self: TReentrantLock.TReentrantLock): STM.STM<number> => adjustRead(self, -1)
 
 /** @internal */
-export const releaseWrite = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, number> =>
+export const releaseWrite = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
   core.withSTMRuntime((runtime) => {
     const lock = tRef.unsafeGet(self.state, runtime.journal)
     if (isWriteLock(lock) && lock.writeLocks === 1 && Equal.equals(runtime.fiberId)(lock.fiberId)) {
@@ -288,22 +288,22 @@ export const releaseWrite = (self: TReentrantLock.TReentrantLock): STM.STM<never
 export const withLock = dual<
   (
     self: TReentrantLock.TReentrantLock
-  ) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(
-    effect: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
     self: TReentrantLock.TReentrantLock
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(2, (effect, self) => withWriteLock(effect, self))
 
 /** @internal */
 export const withReadLock = dual<
-  (self: TReentrantLock.TReentrantLock) => <R, E, A>(
-    effect: Effect.Effect<R, E, A>
-  ) => Effect.Effect<R, E, A>,
-  <R, E, A>(
-    effect: Effect.Effect<R, E, A>,
+  (self: TReentrantLock.TReentrantLock) => <A, E, R>(
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, R>,
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
     self: TReentrantLock.TReentrantLock
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(2, (effect, self) =>
   Effect.uninterruptibleMask((restore) =>
     Effect.zipRight(
@@ -317,8 +317,8 @@ export const withReadLock = dual<
 
 /** @internal */
 export const withWriteLock = dual<
-  (self: TReentrantLock.TReentrantLock) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(effect: Effect.Effect<R, E, A>, self: TReentrantLock.TReentrantLock) => Effect.Effect<R, E, A>
+  (self: TReentrantLock.TReentrantLock) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, self: TReentrantLock.TReentrantLock) => Effect.Effect<A, E, R>
 >(2, (effect, self) =>
   Effect.uninterruptibleMask((restore) =>
     Effect.zipRight(
@@ -331,21 +331,21 @@ export const withWriteLock = dual<
   ))
 
 /** @internal */
-export const writeLock = (self: TReentrantLock.TReentrantLock): Effect.Effect<Scope.Scope, never, number> =>
+export const writeLock = (self: TReentrantLock.TReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
   Effect.acquireRelease(
     core.commit(acquireWrite(self)),
     () => core.commit(releaseWrite(self))
   )
 
 /** @internal */
-export const writeLocked = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, boolean> =>
+export const writeLocked = (self: TReentrantLock.TReentrantLock): STM.STM<boolean> =>
   core.map(
     tRef.get(self.state),
     (state) => state.writeLocks > 0
   )
 
 /** @internal */
-export const writeLocks = (self: TReentrantLock.TReentrantLock): STM.STM<never, never, number> =>
+export const writeLocks = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
   core.map(
     tRef.get(self.state),
     (state) => state.writeLocks

package/src/internal/stm/tRef.ts

@@ -32,7 +32,7 @@ export class TRefImpl<in out A> implements TRef.TRef<A> {
     this.versioned = new Versioned.Versioned(value)
     this.todos = new Map()
   }
-  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<never, never, B> {
+  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<B> {
     return core.effect<never, B>((journal) => {
       const entry = getOrMakeEntry(this, journal)
       const [retValue, newValue] = f(Entry.unsafeGet(entry) as A)
@@ -43,7 +43,7 @@ export class TRefImpl<in out A> implements TRef.TRef<A> {
 }
 
 /** @internal */
-export const make = <A>(value: A): STM.STM<never, never, TRef.TRef<A>> =>
+export const make = <A>(value: A): STM.STM<TRef.TRef<A>> =>
   core.effect<never, TRef.TRef<A>>((journal) => {
     const ref = new TRefImpl(value)
     journal.set(ref, Entry.make(ref, true))
@@ -55,29 +55,29 @@ export const get = <A>(self: TRef.TRef<A>) => self.modify((a) => [a, a])
 
 /** @internal */
 export const set = dual<
-  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<never, never, void>,
-  <A>(self: TRef.TRef<A>, value: A) => STM.STM<never, never, void>
+  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<void>,
+  <A>(self: TRef.TRef<A>, value: A) => STM.STM<void>
 >(
   2,
-  <A>(self: TRef.TRef<A>, value: A): STM.STM<never, never, void> => self.modify((): [void, A] => [void 0, value])
+  <A>(self: TRef.TRef<A>, value: A): STM.STM<void> => self.modify((): [void, A] => [void 0, value])
 )
 
 /** @internal */
 export const getAndSet = dual<
-  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<never, never, A>,
-  <A>(self: TRef.TRef<A>, value: A) => STM.STM<never, never, A>
+  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<A>,
+  <A>(self: TRef.TRef<A>, value: A) => STM.STM<A>
 >(2, (self, value) => self.modify((a) => [a, value]))
 
 /** @internal */
 export const getAndUpdate = dual<
-  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<never, never, A>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<never, never, A>
+  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<A>,
+  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<A>
 >(2, (self, f) => self.modify((a) => [a, f(a)]))
 
 /** @internal */
 export const getAndUpdateSome = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<never, never, A>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<never, never, A>
+  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<A>,
+  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
 >(2, (self, f) =>
   self.modify((a) =>
     Option.match(f(a), {
@@ -88,20 +88,20 @@ export const getAndUpdateSome = dual<
 
 /** @internal */
 export const setAndGet = dual<
-  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<never, never, A>,
-  <A>(self: TRef.TRef<A>, value: A) => STM.STM<never, never, A>
+  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<A>,
+  <A>(self: TRef.TRef<A>, value: A) => STM.STM<A>
 >(2, (self, value) => self.modify(() => [value, value]))
 
 /** @internal */
 export const modify = dual<
-  <A, B>(f: (a: A) => readonly [B, A]) => (self: TRef.TRef<A>) => STM.STM<never, never, B>,
-  <A, B>(self: TRef.TRef<A>, f: (a: A) => readonly [B, A]) => STM.STM<never, never, B>
+  <A, B>(f: (a: A) => readonly [B, A]) => (self: TRef.TRef<A>) => STM.STM<B>,
+  <A, B>(self: TRef.TRef<A>, f: (a: A) => readonly [B, A]) => STM.STM<B>
 >(2, (self, f) => self.modify(f))
 
 /** @internal */
 export const modifySome = dual<
-  <A, B>(fallback: B, f: (a: A) => Option.Option<readonly [B, A]>) => (self: TRef.TRef<A>) => STM.STM<never, never, B>,
-  <A, B>(self: TRef.TRef<A>, fallback: B, f: (a: A) => Option.Option<readonly [B, A]>) => STM.STM<never, never, B>
+  <A, B>(fallback: B, f: (a: A) => Option.Option<readonly [B, A]>) => (self: TRef.TRef<A>) => STM.STM<B>,
+  <A, B>(self: TRef.TRef<A>, fallback: B, f: (a: A) => Option.Option<readonly [B, A]>) => STM.STM<B>
 >(3, (self, fallback, f) =>
   self.modify((a) =>
     Option.match(f(a), {
@@ -112,14 +112,14 @@ export const modifySome = dual<
 
 /** @internal */
 export const update = dual<
-  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<never, never, void>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<never, never, void>
+  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<void>,
+  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<void>
 >(2, (self, f) => self.modify((a) => [void 0, f(a)]))
 
 /** @internal */
 export const updateAndGet = dual<
-  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<never, never, A>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<never, never, A>
+  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<A>,
+  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<A>
 >(2, (self, f) =>
   self.modify((a) => {
     const b = f(a)
@@ -128,8 +128,8 @@ export const updateAndGet = dual<
 
 /** @internal */
 export const updateSome = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<never, never, void>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<never, never, void>
+  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<void>,
+  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<void>
 >(
   2,
   (self, f) =>
@@ -144,8 +144,8 @@ export const updateSome = dual<
 
 /** @internal */
 export const updateSomeAndGet = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<never, never, A>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<never, never, A>
+  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<A>,
+  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
 >(
   2,
   (self, f) =>

package/src/internal/stm/tSemaphore.ts

@@ -23,16 +23,16 @@ class TSemaphoreImpl implements TSemaphore.TSemaphore {
 }
 
 /** @internal */
-export const make = (permits: number): STM.STM<never, never, TSemaphore.TSemaphore> =>
+export const make = (permits: number): STM.STM<TSemaphore.TSemaphore> =>
   STM.map(tRef.make(permits), (permits) => new TSemaphoreImpl(permits))
 
 /** @internal */
-export const acquire = (self: TSemaphore.TSemaphore): STM.STM<never, never, void> => acquireN(self, 1)
+export const acquire = (self: TSemaphore.TSemaphore): STM.STM<void> => acquireN(self, 1)
 
 /** @internal */
 export const acquireN = dual<
-  (n: number) => (self: TSemaphore.TSemaphore) => STM.STM<never, never, void>,
-  (self: TSemaphore.TSemaphore, n: number) => STM.STM<never, never, void>
+  (n: number) => (self: TSemaphore.TSemaphore) => STM.STM<void>,
+  (self: TSemaphore.TSemaphore, n: number) => STM.STM<void>
 >(2, (self, n) =>
   core.withSTMRuntime((driver) => {
     if (n < 0) {
@@ -50,12 +50,12 @@ export const acquireN = dual<
 export const available = (self: TSemaphore.TSemaphore) => tRef.get(self.permits)
 
 /** @internal */
-export const release = (self: TSemaphore.TSemaphore): STM.STM<never, never, void> => releaseN(self, 1)
+export const release = (self: TSemaphore.TSemaphore): STM.STM<void> => releaseN(self, 1)
 
 /** @internal */
 export const releaseN = dual<
-  (n: number) => (self: TSemaphore.TSemaphore) => STM.STM<never, never, void>,
-  (self: TSemaphore.TSemaphore, n: number) => STM.STM<never, never, void>
+  (n: number) => (self: TSemaphore.TSemaphore) => STM.STM<void>,
+  (self: TSemaphore.TSemaphore, n: number) => STM.STM<void>
 >(2, (self, n) =>
   core.withSTMRuntime((driver) => {
     if (n < 0) {
@@ -67,8 +67,8 @@ export const releaseN = dual<
 
 /** @internal */
 export const withPermit = dual<
-  (semaphore: TSemaphore.TSemaphore) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, semaphore: TSemaphore.TSemaphore) => Effect.Effect<R, E, A>
+  (semaphore: TSemaphore.TSemaphore) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(self: Effect.Effect<A, E, R>, semaphore: TSemaphore.TSemaphore) => Effect.Effect<A, E, R>
 >(2, (self, semaphore) => withPermits(self, semaphore, 1))
 
 /** @internal */
@@ -76,12 +76,12 @@ export const withPermits = dual<
   (
     semaphore: TSemaphore.TSemaphore,
     permits: number
-  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
     semaphore: TSemaphore.TSemaphore,
     permits: number
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(3, (self, semaphore, permits) =>
   Effect.uninterruptibleMask((restore) =>
     Effect.zipRight(
@@ -94,13 +94,13 @@ export const withPermits = dual<
   ))
 
 /** @internal */
-export const withPermitScoped = (self: TSemaphore.TSemaphore): Effect.Effect<Scope.Scope, never, void> =>
+export const withPermitScoped = (self: TSemaphore.TSemaphore): Effect.Effect<void, never, Scope.Scope> =>
   withPermitsScoped(self, 1)
 
 /** @internal */
 export const withPermitsScoped = dual<
-  (permits: number) => (self: TSemaphore.TSemaphore) => Effect.Effect<Scope.Scope, never, void>,
-  (self: TSemaphore.TSemaphore, permits: number) => Effect.Effect<Scope.Scope, never, void>
+  (permits: number) => (self: TSemaphore.TSemaphore) => Effect.Effect<void, never, Scope.Scope>,
+  (self: TSemaphore.TSemaphore, permits: number) => Effect.Effect<void, never, Scope.Scope>
 >(2, (self, permits) =>
   Effect.acquireReleaseInterruptible(
     core.commit(acquireN(self, permits)),

package/src/internal/stm/tSet.ts

@@ -33,14 +33,14 @@ const isTSet = (u: unknown) => hasProperty(u, TSetTypeId)
 
 /** @internal */
 export const add = dual<
-  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
-  <A>(self: TSet.TSet<A>, value: A) => STM.STM<never, never, void>
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<void>
 >(2, (self, value) => tMap.set(self.tMap, value, void 0 as void))
 
 /** @internal */
 export const difference = dual<
-  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
-  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<never, never, void>
+  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
 >(2, (self, other) =>
   core.flatMap(
     toHashSet(other),
@@ -48,16 +48,16 @@ export const difference = dual<
   ))
 
 /** @internal */
-export const empty = <A>(): STM.STM<never, never, TSet.TSet<A>> => fromIterable<A>([])
+export const empty = <A>(): STM.STM<TSet.TSet<A>> => fromIterable<A>([])
 
 /** @internal */
 export const forEach = dual<
-  <A, R, E>(f: (value: A) => STM.STM<R, E, void>) => (self: TSet.TSet<A>) => STM.STM<R, E, void>,
-  <A, R, E>(self: TSet.TSet<A>, f: (value: A) => STM.STM<R, E, void>) => STM.STM<R, E, void>
+  <A, R, E>(f: (value: A) => STM.STM<void, E, R>) => (self: TSet.TSet<A>) => STM.STM<void, E, R>,
+  <A, R, E>(self: TSet.TSet<A>, f: (value: A) => STM.STM<void, E, R>) => STM.STM<void, E, R>
 >(2, (self, f) => reduceSTM(self, void 0 as void, (_, value) => f(value)))
 
 /** @internal */
-export const fromIterable = <A>(iterable: Iterable<A>): STM.STM<never, never, TSet.TSet<A>> =>
+export const fromIterable = <A>(iterable: Iterable<A>): STM.STM<TSet.TSet<A>> =>
   core.map(
     tMap.fromIterable(Array.from(iterable).map((a): [A, void] => [a, void 0])),
     (tMap) => new TSetImpl(tMap)
@@ -65,14 +65,14 @@ export const fromIterable = <A>(iterable: Iterable<A>): STM.STM<never, never, TS
 
 /** @internal */
 export const has = dual<
-  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<never, never, boolean>,
-  <A>(self: TSet.TSet<A>, value: A) => STM.STM<never, never, boolean>
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<boolean>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<boolean>
 >(2, (self, value) => tMap.has(self.tMap, value))
 
 /** @internal */
 export const intersection = dual<
-  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
-  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<never, never, void>
+  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
 >(2, (self, other) =>
   core.flatMap(
     toHashSet(other),
@@ -80,17 +80,17 @@ export const intersection = dual<
   ))
 
 /** @internal */
-export const isEmpty = <A>(self: TSet.TSet<A>): STM.STM<never, never, boolean> => tMap.isEmpty(self.tMap)
+export const isEmpty = <A>(self: TSet.TSet<A>): STM.STM<boolean> => tMap.isEmpty(self.tMap)
 
 /** @internal */
 export const make = <Elements extends Array<any>>(
   ...elements: Elements
-): STM.STM<never, never, TSet.TSet<Elements[number]>> => fromIterable(elements)
+): STM.STM<TSet.TSet<Elements[number]>> => fromIterable(elements)
 
 /** @internal */
 export const reduce = dual<
-  <Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: TSet.TSet<A>) => STM.STM<never, never, Z>,
-  <Z, A>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => STM.STM<never, never, Z>
+  <Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: TSet.TSet<A>) => STM.STM<Z>,
+  <Z, A>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => STM.STM<Z>
 >(3, (self, zero, f) =>
   tMap.reduce(
     self.tMap,
@@ -100,8 +100,8 @@ export const reduce = dual<
 
 /** @internal */
 export const reduceSTM = dual<
-  <Z, A, R, E>(zero: Z, f: (accumulator: Z, value: A) => STM.STM<R, E, Z>) => (self: TSet.TSet<A>) => STM.STM<R, E, Z>,
-  <Z, A, R, E>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<R, E, Z>) => STM.STM<R, E, Z>
+  <Z, A, R, E>(zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>) => (self: TSet.TSet<A>) => STM.STM<Z, E, R>,
+  <Z, A, R, E>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>) => STM.STM<Z, E, R>
 >(3, (self, zero, f) =>
   tMap.reduceSTM(
     self.tMap,
@@ -111,37 +111,37 @@ export const reduceSTM = dual<
 
 /** @internal */
 export const remove = dual<
-  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
-  <A>(self: TSet.TSet<A>, value: A) => STM.STM<never, never, void>
+  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, value: A) => STM.STM<void>
 >(2, (self, value) => tMap.remove(self.tMap, value))
 
 /** @internal */
 export const removeAll = dual<
-  <A>(iterable: Iterable<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
-  <A>(self: TSet.TSet<A>, iterable: Iterable<A>) => STM.STM<never, never, void>
+  <A>(iterable: Iterable<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, iterable: Iterable<A>) => STM.STM<void>
 >(2, (self, iterable) => tMap.removeAll(self.tMap, iterable))
 
 /** @internal */
 export const removeIf: {
   <A>(predicate: Predicate<A>, options: {
     readonly discard: true
-  }): (self: TSet.TSet<A>) => STM.STM<never, never, void>
+  }): (self: TSet.TSet<A>) => STM.STM<void>
   <A>(
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
-  ): (self: TSet.TSet<A>) => STM.STM<never, never, Array<A>>
+  ): (self: TSet.TSet<A>) => STM.STM<Array<A>>
   <A>(self: TSet.TSet<A>, predicate: Predicate<A>, options: {
     readonly discard: true
-  }): STM.STM<never, never, void>
+  }): STM.STM<void>
   <A>(
     self: TSet.TSet<A>,
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
-  ): STM.STM<never, never, Array<A>>
+  ): STM.STM<Array<A>>
 } = dual(
   (args) => isTSet(args[0]),
   (self, predicate, options) =>
@@ -155,23 +155,23 @@ export const removeIf: {
 export const retainIf: {
   <A>(predicate: Predicate<A>, options: {
     readonly discard: true
-  }): (self: TSet.TSet<A>) => STM.STM<never, never, void>
+  }): (self: TSet.TSet<A>) => STM.STM<void>
   <A>(
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
-  ): (self: TSet.TSet<A>) => STM.STM<never, never, Array<A>>
+  ): (self: TSet.TSet<A>) => STM.STM<Array<A>>
   <A>(self: TSet.TSet<A>, predicate: Predicate<A>, options: {
     readonly discard: true
-  }): STM.STM<never, never, void>
+  }): STM.STM<void>
   <A>(
     self: TSet.TSet<A>,
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
-  ): STM.STM<never, never, Array<A>>
+  ): STM.STM<Array<A>>
 } = dual((args) => isTSet(args[0]), (self, predicate, options) =>
   options?.discard === true ?
     tMap.retainIf(self.tMap, (key) => predicate(key), { discard: true }) :
@@ -181,44 +181,43 @@ export const retainIf: {
     ))
 
 /** @internal */
-export const size = <A>(self: TSet.TSet<A>): STM.STM<never, never, number> =>
-  core.map(toChunk(self), (chunk) => chunk.length)
+export const size = <A>(self: TSet.TSet<A>): STM.STM<number> => core.map(toChunk(self), (chunk) => chunk.length)
 
 /** @internal */
 export const takeFirst = dual<
-  <A, B>(pf: (a: A) => Option.Option<B>) => (self: TSet.TSet<A>) => STM.STM<never, never, B>,
-  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<never, never, B>
+  <A, B>(pf: (a: A) => Option.Option<B>) => (self: TSet.TSet<A>) => STM.STM<B>,
+  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<B>
 >(2, (self, pf) => tMap.takeFirst(self.tMap, (key) => pf(key)))
 
 /** @internal */
 export const takeFirstSTM = dual<
-  <A, R, E, B>(pf: (a: A) => STM.STM<R, Option.Option<E>, B>) => (self: TSet.TSet<A>) => STM.STM<R, E, B>,
-  <A, R, E, B>(self: TSet.TSet<A>, pf: (a: A) => STM.STM<R, Option.Option<E>, B>) => STM.STM<R, E, B>
+  <A, R, E, B>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => (self: TSet.TSet<A>) => STM.STM<B, E, R>,
+  <A, R, E, B>(self: TSet.TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => STM.STM<B, E, R>
 >(2, (self, pf) => tMap.takeFirstSTM(self.tMap, (key) => pf(key)))
 
 /** @internal */
 export const takeSome = dual<
-  <A, B>(pf: (a: A) => Option.Option<B>) => (self: TSet.TSet<A>) => STM.STM<never, never, RA.NonEmptyArray<B>>,
-  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<never, never, RA.NonEmptyArray<B>>
+  <A, B>(pf: (a: A) => Option.Option<B>) => (self: TSet.TSet<A>) => STM.STM<RA.NonEmptyArray<B>>,
+  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<RA.NonEmptyArray<B>>
 >(2, (self, pf) => tMap.takeSome(self.tMap, (key) => pf(key)))
 
 /** @internal */
 export const takeSomeSTM = dual<
   <A, R, E, B>(
-    pf: (a: A) => STM.STM<R, Option.Option<E>, B>
-  ) => (self: TSet.TSet<A>) => STM.STM<R, E, RA.NonEmptyArray<B>>,
+    pf: (a: A) => STM.STM<B, Option.Option<E>, R>
+  ) => (self: TSet.TSet<A>) => STM.STM<RA.NonEmptyArray<B>, E, R>,
   <A, R, E, B>(
     self: TSet.TSet<A>,
-    pf: (a: A) => STM.STM<R, Option.Option<E>, B>
-  ) => STM.STM<R, E, RA.NonEmptyArray<B>>
+    pf: (a: A) => STM.STM<B, Option.Option<E>, R>
+  ) => STM.STM<RA.NonEmptyArray<B>, E, R>
 >(2, (self, pf) => tMap.takeSomeSTM(self.tMap, (key) => pf(key)))
 
 /** @internal */
-export const toChunk = <A>(self: TSet.TSet<A>): STM.STM<never, never, Chunk.Chunk<A>> =>
+export const toChunk = <A>(self: TSet.TSet<A>): STM.STM<Chunk.Chunk<A>> =>
   tMap.keys(self.tMap).pipe(STM.map(Chunk.unsafeFromArray))
 
 /** @internal */
-export const toHashSet = <A>(self: TSet.TSet<A>): STM.STM<never, never, HashSet.HashSet<A>> =>
+export const toHashSet = <A>(self: TSet.TSet<A>): STM.STM<HashSet.HashSet<A>> =>
   reduce(
     self,
     HashSet.empty<A>(),
@@ -226,7 +225,7 @@ export const toHashSet = <A>(self: TSet.TSet<A>): STM.STM<never, never, HashSet.
   )
 
 /** @internal */
-export const toArray = <A>(self: TSet.TSet<A>): STM.STM<never, never, Array<A>> =>
+export const toArray = <A>(self: TSet.TSet<A>): STM.STM<Array<A>> =>
   reduce<Array<A>, A>(
     self,
     [],
@@ -234,19 +233,19 @@ export const toArray = <A>(self: TSet.TSet<A>): STM.STM<never, never, Array<A>>
   )
 
 /** @internal */
-export const toReadonlySet = <A>(self: TSet.TSet<A>): STM.STM<never, never, ReadonlySet<A>> =>
+export const toReadonlySet = <A>(self: TSet.TSet<A>): STM.STM<ReadonlySet<A>> =>
   core.map(toArray(self), (values) => new Set(values))
 
 /** @internal */
 export const transform = dual<
-  <A>(f: (a: A) => A) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
-  <A>(self: TSet.TSet<A>, f: (a: A) => A) => STM.STM<never, never, void>
+  <A>(f: (a: A) => A) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, f: (a: A) => A) => STM.STM<void>
 >(2, (self, f) => tMap.transform(self.tMap, (key, value) => [f(key), value]))
 
 /** @internal */
 export const transformSTM = dual<
-  <A, R, E>(f: (a: A) => STM.STM<R, E, A>) => (self: TSet.TSet<A>) => STM.STM<R, E, void>,
-  <A, R, E>(self: TSet.TSet<A>, f: (a: A) => STM.STM<R, E, A>) => STM.STM<R, E, void>
+  <A, R, E>(f: (a: A) => STM.STM<A, E, R>) => (self: TSet.TSet<A>) => STM.STM<void, E, R>,
+  <A, R, E>(self: TSet.TSet<A>, f: (a: A) => STM.STM<A, E, R>) => STM.STM<void, E, R>
 >(2, (self, f) =>
   tMap.transformSTM(
     self.tMap,
@@ -255,6 +254,6 @@ export const transformSTM = dual<
 
 /** @internal */
 export const union = dual<
-  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<never, never, void>,
-  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<never, never, void>
+  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
+  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
 >(2, (self, other) => forEach(other, (value) => add(self, value)))