effect 2.2.5 → 2.3.1

package/src/TReentrantLock.ts

@@ -69,7 +69,7 @@ export declare namespace TReentrantLock {
  * @since 2.0.0
  * @category mutations
  */
-export const acquireRead: (self: TReentrantLock) => STM.STM<never, never, number> = internal.acquireRead
+export const acquireRead: (self: TReentrantLock) => STM.STM<number> = internal.acquireRead
 
 /**
  * Acquires a write lock. The transaction will suspend until no other fibers
@@ -79,7 +79,7 @@ export const acquireRead: (self: TReentrantLock) => STM.STM<never, never, number
  * @since 2.0.0
  * @category mutations
  */
-export const acquireWrite: (self: TReentrantLock) => STM.STM<never, never, number> = internal.acquireWrite
+export const acquireWrite: (self: TReentrantLock) => STM.STM<number> = internal.acquireWrite
 
 /**
  * Retrieves the number of acquired read locks for this fiber.
@@ -87,7 +87,7 @@ export const acquireWrite: (self: TReentrantLock) => STM.STM<never, never, numbe
  * @since 2.0.0
  * @category mutations
  */
-export const fiberReadLocks: (self: TReentrantLock) => STM.STM<never, never, number> = internal.fiberReadLocks
+export const fiberReadLocks: (self: TReentrantLock) => STM.STM<number> = internal.fiberReadLocks
 
 /**
  * Retrieves the number of acquired write locks for this fiber.
@@ -95,7 +95,7 @@ export const fiberReadLocks: (self: TReentrantLock) => STM.STM<never, never, num
  * @since 2.0.0
  * @category mutations
  */
-export const fiberWriteLocks: (self: TReentrantLock) => STM.STM<never, never, number> = internal.fiberWriteLocks
+export const fiberWriteLocks: (self: TReentrantLock) => STM.STM<number> = internal.fiberWriteLocks
 
 /**
  * Just a convenience method for applications that only need reentrant locks,
@@ -106,7 +106,7 @@ export const fiberWriteLocks: (self: TReentrantLock) => STM.STM<never, never, nu
  * @since 2.0.0
  * @category mutations
  */
-export const lock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, never, number> = internal.lock
+export const lock: (self: TReentrantLock) => Effect.Effect<number, never, Scope.Scope> = internal.lock
 
 /**
  * Determines if any fiber has a read or write lock.
@@ -114,7 +114,7 @@ export const lock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, never, n
  * @since 2.0.0
  * @category mutations
  */
-export const locked: (self: TReentrantLock) => STM.STM<never, never, boolean> = internal.locked
+export const locked: (self: TReentrantLock) => STM.STM<boolean> = internal.locked
 
 /**
  * Makes a new reentrant read/write lock.
@@ -122,7 +122,7 @@ export const locked: (self: TReentrantLock) => STM.STM<never, never, boolean> =
  * @since 2.0.0
  * @category constructors
  */
-export const make: STM.STM<never, never, TReentrantLock> = internal.make
+export const make: STM.STM<TReentrantLock> = internal.make
 
 /**
  * Obtains a read lock in a scoped context.
@@ -130,7 +130,7 @@ export const make: STM.STM<never, never, TReentrantLock> = internal.make
  * @since 2.0.0
  * @category mutations
  */
-export const readLock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, never, number> = internal.readLock
+export const readLock: (self: TReentrantLock) => Effect.Effect<number, never, Scope.Scope> = internal.readLock
 
 /**
  * Retrieves the total number of acquired read locks.
@@ -138,7 +138,7 @@ export const readLock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, neve
  * @since 2.0.0
  * @category mutations
  */
-export const readLocks: (self: TReentrantLock) => STM.STM<never, never, number> = internal.readLocks
+export const readLocks: (self: TReentrantLock) => STM.STM<number> = internal.readLocks
 
 /**
  * Determines if any fiber has a read lock.
@@ -146,7 +146,7 @@ export const readLocks: (self: TReentrantLock) => STM.STM<never, never, number>
  * @since 2.0.0
  * @category mutations
  */
-export const readLocked: (self: TReentrantLock) => STM.STM<never, never, boolean> = internal.readLocked
+export const readLocked: (self: TReentrantLock) => STM.STM<boolean> = internal.readLocked
 
 /**
  * Releases a read lock held by this fiber. Succeeds with the outstanding
@@ -155,7 +155,7 @@ export const readLocked: (self: TReentrantLock) => STM.STM<never, never, boolean
  * @since 2.0.0
  * @category mutations
  */
-export const releaseRead: (self: TReentrantLock) => STM.STM<never, never, number> = internal.releaseRead
+export const releaseRead: (self: TReentrantLock) => STM.STM<number> = internal.releaseRead
 
 /**
  * Releases a write lock held by this fiber. Succeeds with the outstanding
@@ -164,7 +164,7 @@ export const releaseRead: (self: TReentrantLock) => STM.STM<never, never, number
  * @since 2.0.0
  * @category mutations
  */
-export const releaseWrite: (self: TReentrantLock) => STM.STM<never, never, number> = internal.releaseWrite
+export const releaseWrite: (self: TReentrantLock) => STM.STM<number> = internal.releaseWrite
 
 /**
  * Runs the specified workflow with a lock.
@@ -173,8 +173,8 @@ export const releaseWrite: (self: TReentrantLock) => STM.STM<never, never, numbe
  * @category mutations
  */
 export const withLock: {
-  (self: 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): Effect.Effect<R, E, A>
+  (self: 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): Effect.Effect<A, E, R>
 } = internal.withLock
 
 /**
@@ -184,8 +184,8 @@ export const withLock: {
  * @category mutations
  */
 export const withReadLock: {
-  (self: 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): Effect.Effect<R, E, A>
+  (self: 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): Effect.Effect<A, E, R>
 } = internal.withReadLock
 
 /**
@@ -195,8 +195,8 @@ export const withReadLock: {
  * @category mutations
  */
 export const withWriteLock: {
-  (self: 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): Effect.Effect<R, E, A>
+  (self: 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): Effect.Effect<A, E, R>
 } = internal.withWriteLock
 
 /**
@@ -205,7 +205,7 @@ export const withWriteLock: {
  * @since 2.0.0
  * @category mutations
  */
-export const writeLock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, never, number> = internal.writeLock
+export const writeLock: (self: TReentrantLock) => Effect.Effect<number, never, Scope.Scope> = internal.writeLock
 
 /**
  * Determines if a write lock is held by some fiber.
@@ -213,7 +213,7 @@ export const writeLock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, nev
  * @since 2.0.0
  * @category mutations
  */
-export const writeLocked: (self: TReentrantLock) => STM.STM<never, never, boolean> = internal.writeLocked
+export const writeLocked: (self: TReentrantLock) => STM.STM<boolean> = internal.writeLocked
 
 /**
  * Computes the number of write locks held by fibers.
@@ -221,4 +221,4 @@ export const writeLocked: (self: TReentrantLock) => STM.STM<never, never, boolea
  * @since 2.0.0
  * @category mutations
  */
-export const writeLocks: (self: TReentrantLock) => STM.STM<never, never, number> = internal.writeLocks
+export const writeLocks: (self: TReentrantLock) => STM.STM<number> = internal.writeLocks

package/src/TRef.ts

@@ -38,7 +38,7 @@ export interface TRef<in out A> extends TRef.Variance<A> {
   /**
    * Note: the method is unbound, exposed only for potential extensions.
    */
-  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<never, never, B>
+  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<B>
 }
 /**
  * @internal
@@ -69,15 +69,15 @@ export declare namespace TRef {
  * @since 2.0.0
  * @category mutations
  */
-export const get: <A>(self: TRef<A>) => STM.STM<never, never, A> = internal.get
+export const get: <A>(self: TRef<A>) => STM.STM<A> = internal.get
 
 /**
  * @since 2.0.0
  * @category mutations
  */
 export const getAndSet: {
-  <A>(value: A): (self: TRef<A>) => STM.STM<never, never, A>
-  <A>(self: TRef<A>, value: A): STM.STM<never, never, A>
+  <A>(value: A): (self: TRef<A>) => STM.STM<A>
+  <A>(self: TRef<A>, value: A): STM.STM<A>
 } = internal.getAndSet
 
 /**
@@ -85,8 +85,8 @@ export const getAndSet: {
  * @category mutations
  */
 export const getAndUpdate: {
-  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<never, never, A>
-  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<never, never, A>
+  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<A>
+  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<A>
 } = internal.getAndUpdate
 
 /**
@@ -94,23 +94,23 @@ export const getAndUpdate: {
  * @category mutations
  */
 export const getAndUpdateSome: {
-  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<never, never, A>
-  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<never, never, A>
+  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<A>
+  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<A>
 } = internal.getAndUpdateSome
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const make: <A>(value: A) => STM.STM<never, never, TRef<A>> = internal.make
+export const make: <A>(value: A) => STM.STM<TRef<A>> = internal.make
 
 /**
  * @since 2.0.0
  * @category mutations
  */
 export const modify: {
-  <A, B>(f: (a: A) => readonly [B, A]): (self: TRef<A>) => STM.STM<never, never, B>
-  <A, B>(self: TRef<A>, f: (a: A) => readonly [B, A]): STM.STM<never, never, B>
+  <A, B>(f: (a: A) => readonly [B, A]): (self: TRef<A>) => STM.STM<B>
+  <A, B>(self: TRef<A>, f: (a: A) => readonly [B, A]): STM.STM<B>
 } = internal.modify
 
 /**
@@ -118,8 +118,8 @@ export const modify: {
  * @category mutations
  */
 export const modifySome: {
-  <A, B>(fallback: B, f: (a: A) => Option.Option<readonly [B, A]>): (self: TRef<A>) => STM.STM<never, never, B>
-  <A, B>(self: 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<A>) => STM.STM<B>
+  <A, B>(self: TRef<A>, fallback: B, f: (a: A) => Option.Option<readonly [B, A]>): STM.STM<B>
 } = internal.modifySome
 
 /**
@@ -127,8 +127,8 @@ export const modifySome: {
  * @category mutations
  */
 export const set: {
-  <A>(value: A): (self: TRef<A>) => STM.STM<never, never, void>
-  <A>(self: TRef<A>, value: A): STM.STM<never, never, void>
+  <A>(value: A): (self: TRef<A>) => STM.STM<void>
+  <A>(self: TRef<A>, value: A): STM.STM<void>
 } = internal.set
 
 /**
@@ -136,8 +136,8 @@ export const set: {
  * @category mutations
  */
 export const setAndGet: {
-  <A>(value: A): (self: TRef<A>) => STM.STM<never, never, A>
-  <A>(self: TRef<A>, value: A): STM.STM<never, never, A>
+  <A>(value: A): (self: TRef<A>) => STM.STM<A>
+  <A>(self: TRef<A>, value: A): STM.STM<A>
 } = internal.setAndGet
 
 /**
@@ -145,8 +145,8 @@ export const setAndGet: {
  * @category mutations
  */
 export const update: {
-  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<never, never, void>
-  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<never, never, void>
+  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<void>
+  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<void>
 } = internal.update
 
 /**
@@ -154,8 +154,8 @@ export const update: {
  * @category mutations
  */
 export const updateAndGet: {
-  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<never, never, A>
-  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<never, never, A>
+  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<A>
+  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<A>
 } = internal.updateAndGet
 
 /**
@@ -163,8 +163,8 @@ export const updateAndGet: {
  * @category mutations
  */
 export const updateSome: {
-  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<never, never, void>
-  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<never, never, void>
+  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<void>
+  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<void>
 } = internal.updateSome
 
 /**
@@ -172,6 +172,6 @@ export const updateSome: {
  * @category mutations
  */
 export const updateSomeAndGet: {
-  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<never, never, A>
-  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<never, never, A>
+  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<A>
+  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<A>
 } = internal.updateSomeAndGet

package/src/TSemaphore.ts

@@ -51,42 +51,42 @@ export declare namespace TSemaphore {
  * @since 2.0.0
  * @category mutations
  */
-export const acquire: (self: TSemaphore) => STM.STM<never, never, void> = internal.acquire
+export const acquire: (self: TSemaphore) => STM.STM<void> = internal.acquire
 
 /**
  * @since 2.0.0
  * @category mutations
  */
 export const acquireN: {
-  (n: number): (self: TSemaphore) => STM.STM<never, never, void>
-  (self: TSemaphore, n: number): STM.STM<never, never, void>
+  (n: number): (self: TSemaphore) => STM.STM<void>
+  (self: TSemaphore, n: number): STM.STM<void>
 } = internal.acquireN
 
 /**
  * @since 2.0.0
  * @category getters
  */
-export const available: (self: TSemaphore) => STM.STM<never, never, number> = internal.available
+export const available: (self: TSemaphore) => STM.STM<number> = internal.available
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const make: (permits: number) => STM.STM<never, never, TSemaphore> = internal.make
+export const make: (permits: number) => STM.STM<TSemaphore> = internal.make
 
 /**
  * @since 2.0.0
  * @category mutations
  */
-export const release: (self: TSemaphore) => STM.STM<never, never, void> = internal.release
+export const release: (self: TSemaphore) => STM.STM<void> = internal.release
 
 /**
  * @since 2.0.0
  * @category mutations
  */
 export const releaseN: {
-  (n: number): (self: TSemaphore) => STM.STM<never, never, void>
-  (self: TSemaphore, n: number): STM.STM<never, never, void>
+  (n: number): (self: TSemaphore) => STM.STM<void>
+  (self: TSemaphore, n: number): STM.STM<void>
 } = internal.releaseN
 
 /**
@@ -94,8 +94,8 @@ export const releaseN: {
  * @category mutations
  */
 export const withPermit: {
-  (semaphore: 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): Effect.Effect<R, E, A>
+  (semaphore: 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): Effect.Effect<A, E, R>
 } = internal.withPermit
 
 /**
@@ -103,23 +103,23 @@ export const withPermit: {
  * @category mutations
  */
 export const withPermits: {
-  (semaphore: 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>, semaphore: TSemaphore, permits: number): Effect.Effect<R, E, A>
+  (semaphore: TSemaphore, permits: number): <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, permits: number): Effect.Effect<A, E, R>
 } = internal.withPermits
 
 /**
  * @since 2.0.0
  * @category mutations
  */
-export const withPermitScoped: (self: TSemaphore) => Effect.Effect<Scope.Scope, never, void> = internal.withPermitScoped
+export const withPermitScoped: (self: TSemaphore) => Effect.Effect<void, never, Scope.Scope> = internal.withPermitScoped
 
 /**
  * @since 2.0.0
  * @category mutations
  */
 export const withPermitsScoped: {
-  (permits: number): (self: TSemaphore) => Effect.Effect<Scope.Scope, never, void>
-  (self: TSemaphore, permits: number): Effect.Effect<Scope.Scope, never, void>
+  (permits: number): (self: TSemaphore) => Effect.Effect<void, never, Scope.Scope>
+  (self: TSemaphore, permits: number): Effect.Effect<void, never, Scope.Scope>
 } = internal.withPermitsScoped
 
 /**