effect 4.0.0-beta.41 → 4.0.0-beta.42

package/src/TxPriorityQueue.ts

@@ -109,7 +109,7 @@ const insertSorted = <A>(chunk: Chunk<A>, value: A, ord: Order<A>): Chunk<A> =>
  * @since 4.0.0
  * @category constructors
  */
-export const empty = <A>(order: Order<A>): Effect.Effect<TxPriorityQueue<A>, never, Effect.Transaction> =>
+export const empty = <A>(order: Order<A>): Effect.Effect<TxPriorityQueue<A>> =>
   Effect.map(TxRef.make<Chunk<A>>(C.empty()), (ref) => makeTxPriorityQueue(ref, order))
 
 /**
@@ -147,7 +147,7 @@ export const fromIterable: {
    * @since 4.0.0
    * @category constructors
    */
-  <A>(order: Order<A>): (iterable: Iterable<A>) => Effect.Effect<TxPriorityQueue<A>, never, Effect.Transaction>
+  <A>(order: Order<A>): (iterable: Iterable<A>) => Effect.Effect<TxPriorityQueue<A>>
   /**
    * Creates a `TxPriorityQueue` from an iterable of elements.
    *
@@ -165,10 +165,10 @@ export const fromIterable: {
    * @since 4.0.0
    * @category constructors
    */
-  <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>, never, Effect.Transaction>
+  <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>>
 } = dual(
   2,
-  <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>, never, Effect.Transaction> => {
+  <A>(order: Order<A>, iterable: Iterable<A>): Effect.Effect<TxPriorityQueue<A>> => {
     const arr = Array.from(iterable).sort((a, b) => order(a, b))
     return Effect.map(
       TxRef.make</**
@@ -211,9 +211,8 @@ export const fromIterable: {
  * @since 4.0.0
  * @category constructors
  */
-export const make =
-  <A>(order: Order<A>) => (...elements: Array<A>): Effect.Effect<TxPriorityQueue<A>, never, Effect.Transaction> =>
-    fromIterable(order, elements)
+export const make = <A>(order: Order<A>) => (...elements: Array<A>): Effect.Effect<TxPriorityQueue<A>> =>
+  fromIterable(order, elements)
 
 /**
  * Returns the number of elements in the queue.
@@ -232,8 +231,7 @@ export const make =
  * @since 4.0.0
  * @category getters
  */
-export const size = <A>(self: TxPriorityQueue<A>): Effect.Effect<number, never, Effect.Transaction> =>
-  Effect.map(TxRef.get(self.ref), C.size)
+export const size = <A>(self: TxPriorityQueue<A>): Effect.Effect<number> => Effect.map(TxRef.get(self.ref), C.size)
 
 /**
  * Returns `true` if the queue is empty.
@@ -252,8 +250,7 @@ export const size = <A>(self: TxPriorityQueue<A>): Effect.Effect<number, never,
  * @since 4.0.0
  * @category getters
  */
-export const isEmpty = <A>(self: TxPriorityQueue<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
-  Effect.map(size(self), (n) => n === 0)
+export const isEmpty = <A>(self: TxPriorityQueue<A>): Effect.Effect<boolean> => Effect.map(size(self), (n) => n === 0)
 
 /**
  * Returns `true` if the queue has at least one element.
@@ -272,8 +269,7 @@ export const isEmpty = <A>(self: TxPriorityQueue<A>): Effect.Effect<boolean, nev
  * @since 4.0.0
  * @category getters
  */
-export const isNonEmpty = <A>(self: TxPriorityQueue<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
-  Effect.map(size(self), (n) => n > 0)
+export const isNonEmpty = <A>(self: TxPriorityQueue<A>): Effect.Effect<boolean> => Effect.map(size(self), (n) => n > 0)
 
 /**
  * Observes the smallest element without removing it. Retries if the queue is
@@ -293,15 +289,15 @@ export const isNonEmpty = <A>(self: TxPriorityQueue<A>): Effect.Effect<boolean,
  * @since 4.0.0
  * @category getters
  */
-export const peek = <A>(self: TxPriorityQueue<A>): Effect.Effect<A, never, Effect.Transaction> =>
+export const peek = <A>(self: TxPriorityQueue<A>): Effect.Effect<A> =>
   Effect.gen(function*() {
     const chunk = yield* TxRef.get(self.ref)
     const head = C.head(chunk)
     if (O.isNone(head)) {
-      return yield* Effect.retryTransaction
+      return yield* Effect.txRetry
     }
     return head.value
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Observes the smallest element without removing it. Returns `None` if the
@@ -321,7 +317,7 @@ export const peek = <A>(self: TxPriorityQueue<A>): Effect.Effect<A, never, Effec
  * @since 4.0.0
  * @category getters
  */
-export const peekOption = <A>(self: TxPriorityQueue<A>): Effect.Effect<Option<A>, never, Effect.Transaction> =>
+export const peekOption = <A>(self: TxPriorityQueue<A>): Effect.Effect<Option<A>> =>
   Effect.map(TxRef.get(self.ref), C.head)
 
 /**
@@ -363,7 +359,7 @@ export const offer: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(value: A): (self: TxPriorityQueue<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(value: A): (self: TxPriorityQueue<A>) => Effect.Effect<void>
   /**
    * Inserts an element into the queue in sorted position.
    *
@@ -383,10 +379,10 @@ export const offer: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxPriorityQueue<A>, value: A): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxPriorityQueue<A>, value: A): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxPriorityQueue<A>, value: A): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxPriorityQueue<A>, value: A): Effect.Effect<void> =>
     TxRef.update(self.ref, (chunk) => insertSorted(chunk, value, self.ord))
 )
 
@@ -427,7 +423,7 @@ export const offerAll: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(values: Iterable<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(values: Iterable<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void>
   /**
    * Inserts all elements from an iterable into the queue.
    *
@@ -446,10 +442,10 @@ export const offerAll: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxPriorityQueue<A>, values: Iterable<A>): Effect.Effect<void> =>
     TxRef.update(self.ref, (chunk) => {
       const arr = [...C.toArray(chunk), ...values].sort((a, b) => self.ord(a, b))
       return C.fromIterable(arr)
@@ -473,16 +469,16 @@ export const offerAll: {
  * @since 4.0.0
  * @category mutations
  */
-export const take = <A>(self: TxPriorityQueue<A>): Effect.Effect<A, never, Effect.Transaction> =>
+export const take = <A>(self: TxPriorityQueue<A>): Effect.Effect<A> =>
   Effect.gen(function*() {
     const chunk = yield* TxRef.get(self.ref)
     const head = C.head(chunk)
     if (O.isNone(head)) {
-      return yield* Effect.retryTransaction
+      return yield* Effect.txRetry
     }
     yield* TxRef.set(self.ref, C.drop(chunk, 1))
     return head.value
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Takes all elements from the queue, returning them in priority order.
@@ -501,7 +497,7 @@ export const take = <A>(self: TxPriorityQueue<A>): Effect.Effect<A, never, Effec
  * @since 4.0.0
  * @category mutations
  */
-export const takeAll = <A>(self: TxPriorityQueue<A>): Effect.Effect<Array<A>, never, Effect.Transaction> =>
+export const takeAll = <A>(self: TxPriorityQueue<A>): Effect.Effect<Array<A>> =>
   Effect.map(
     TxRef.modify(self.ref, (chunk) => [chunk, C.empty()]),
     C.toArray
@@ -524,7 +520,7 @@ export const takeAll = <A>(self: TxPriorityQueue<A>): Effect.Effect<Array<A>, ne
  * @since 4.0.0
  * @category mutations
  */
-export const takeOption = <A>(self: TxPriorityQueue<A>): Effect.Effect<Option<A>, never, Effect.Transaction> =>
+export const takeOption = <A>(self: TxPriorityQueue<A>): Effect.Effect<Option<A>> =>
   TxRef.modify(self.ref, (chunk) => {
     const head = C.head(chunk)
     if (O.isNone(head)) {
@@ -568,7 +564,7 @@ export const takeUpTo: {
    * @since 4.0.0
    * @category mutations
    */
-  (n: number): <A>(self: TxPriorityQueue<A>) => Effect.Effect<Array<A>, never, Effect.Transaction>
+  (n: number): <A>(self: TxPriorityQueue<A>) => Effect.Effect<Array<A>>
   /**
    * Takes up to `n` elements from the queue in priority order.
    *
@@ -586,10 +582,10 @@ export const takeUpTo: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxPriorityQueue<A>, n: number): Effect.Effect<Array<A>, never, Effect.Transaction>
+  <A>(self: TxPriorityQueue<A>, n: number): Effect.Effect<Array<A>>
 } = dual(
   2,
-  <A>(self: TxPriorityQueue<A>, n: number): Effect.Effect<Array<A>, never, Effect.Transaction> =>
+  <A>(self: TxPriorityQueue<A>, n: number): Effect.Effect<Array<A>> =>
     Effect.map(
       TxRef.modify(self.ref, (chunk) => {
         const taken = C.take(chunk, n)
@@ -637,7 +633,7 @@ export const removeIf: {
    * @since 4.0.0
    * @category filtering
    */
-  <A>(predicate: Predicate<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(predicate: Predicate<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void>
   /**
    * Removes elements matching the predicate.
    *
@@ -656,10 +652,10 @@ export const removeIf: {
    * @since 4.0.0
    * @category filtering
    */
-  <A>(self: TxPriorityQueue<A>, predicate: Predicate<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxPriorityQueue<A>, predicate: Predicate<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxPriorityQueue<A>, predicate: Predicate<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxPriorityQueue<A>, predicate: Predicate<A>): Effect.Effect<void> =>
     TxRef.update(self.ref, (chunk) => C.filter(chunk, (a) => !predicate(a)))
 )
 
@@ -700,7 +696,7 @@ export const retainIf: {
    * @since 4.0.0
    * @category filtering
    */
-  <A>(predicate: Predicate<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void, never, Effect.Transaction>
+  <A>(predicate: Predicate<A>): (self: TxPriorityQueue<A>) => Effect.Effect<void>
   /**
    * Retains only elements matching the predicate.
    *
@@ -719,10 +715,10 @@ export const retainIf: {
    * @since 4.0.0
    * @category filtering
    */
-  <A>(self: TxPriorityQueue<A>, predicate: Predicate<A>): Effect.Effect<void, never, Effect.Transaction>
+  <A>(self: TxPriorityQueue<A>, predicate: Predicate<A>): Effect.Effect<void>
 } = dual(
   2,
-  <A>(self: TxPriorityQueue<A>, predicate: Predicate<A>): Effect.Effect<void, never, Effect.Transaction> =>
+  <A>(self: TxPriorityQueue<A>, predicate: Predicate<A>): Effect.Effect<void> =>
     TxRef.update(self.ref, (chunk) => C.filter(chunk, predicate))
 )
 
@@ -743,7 +739,7 @@ export const retainIf: {
  * @since 4.0.0
  * @category conversions
  */
-export const toArray = <A>(self: TxPriorityQueue<A>): Effect.Effect<Array<A>, never, Effect.Transaction> =>
+export const toArray = <A>(self: TxPriorityQueue<A>): Effect.Effect<Array<A>> =>
   Effect.map(TxRef.get(self.ref), C.toArray)
 
 /**

package/src/TxPubSub.ts

@@ -118,12 +118,12 @@ const makeTxPubSub = <A>(
  * @since 4.0.0
  * @category constructors
  */
-export const bounded = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>, never, Effect.Transaction> =>
+export const bounded = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>> =>
   Effect.gen(function*() {
     const subscribersRef = yield* TxRef.make<Array<TxQueue.TxQueue<A>>>([])
     const shutdownRef = yield* TxRef.make(false)
     return makeTxPubSub(subscribersRef, shutdownRef, "bounded", capacity)
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Creates a dropping TxPubSub with the specified capacity. When a subscriber's
@@ -153,12 +153,12 @@ export const bounded = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>,
  * @since 4.0.0
  * @category constructors
  */
-export const dropping = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>, never, Effect.Transaction> =>
+export const dropping = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>> =>
   Effect.gen(function*() {
     const subscribersRef = yield* TxRef.make<Array<TxQueue.TxQueue<A>>>([])
     const shutdownRef = yield* TxRef.make(false)
     return makeTxPubSub(subscribersRef, shutdownRef, "dropping", capacity)
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Creates a sliding TxPubSub with the specified capacity. When a subscriber's
@@ -187,12 +187,12 @@ export const dropping = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>
  * @since 4.0.0
  * @category constructors
  */
-export const sliding = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>, never, Effect.Transaction> =>
+export const sliding = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>> =>
   Effect.gen(function*() {
     const subscribersRef = yield* TxRef.make<Array<TxQueue.TxQueue<A>>>([])
     const shutdownRef = yield* TxRef.make(false)
     return makeTxPubSub(subscribersRef, shutdownRef, "sliding", capacity)
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Creates an unbounded TxPubSub with unlimited capacity. Messages are always accepted.
@@ -218,12 +218,12 @@ export const sliding = <A = never>(capacity: number): Effect.Effect<TxPubSub<A>,
  * @since 4.0.0
  * @category constructors
  */
-export const unbounded = <A = never>(): Effect.Effect<TxPubSub<A>, never, Effect.Transaction> =>
+export const unbounded = <A = never>(): Effect.Effect<TxPubSub<A>> =>
   Effect.gen(function*() {
     const subscribersRef = yield* TxRef.make<Array<TxQueue.TxQueue<A>>>([])
     const shutdownRef = yield* TxRef.make(false)
     return makeTxPubSub(subscribersRef, shutdownRef, "unbounded", Number.POSITIVE_INFINITY)
-  })
+  }).pipe(Effect.tx)
 
 // =============================================================================
 // Getters
@@ -272,7 +272,7 @@ export const capacity = <A>(self: TxPubSub<A>): number => self.capacity
  * @since 4.0.0
  * @category getters
  */
-export const size = <A>(self: TxPubSub<A>): Effect.Effect<number, never, Effect.Transaction> =>
+export const size = <A>(self: TxPubSub<A>): Effect.Effect<number> =>
   Effect.gen(function*() {
     const subscribers = yield* TxRef.get(self.subscribersRef)
     let maxSize = 0
@@ -281,7 +281,7 @@ export const size = <A>(self: TxPubSub<A>): Effect.Effect<number, never, Effect.
       if (s > maxSize) maxSize = s
     }
     return maxSize
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Checks if the TxPubSub has no pending messages (all subscriber queues are empty).
@@ -300,8 +300,7 @@ export const size = <A>(self: TxPubSub<A>): Effect.Effect<number, never, Effect.
  * @since 4.0.0
  * @category getters
  */
-export const isEmpty = <A>(self: TxPubSub<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
-  Effect.map(size(self), (s) => s === 0)
+export const isEmpty = <A>(self: TxPubSub<A>): Effect.Effect<boolean> => Effect.map(size(self), (s) => s === 0)
 
 /**
  * Checks if any subscriber queue is at capacity.
@@ -320,7 +319,7 @@ export const isEmpty = <A>(self: TxPubSub<A>): Effect.Effect<boolean, never, Eff
  * @since 4.0.0
  * @category getters
  */
-export const isFull = <A>(self: TxPubSub<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
+export const isFull = <A>(self: TxPubSub<A>): Effect.Effect<boolean> =>
   Effect.gen(function*() {
     if (self.capacity === Number.POSITIVE_INFINITY) return false
     const subscribers = yield* TxRef.get(self.subscribersRef)
@@ -328,7 +327,7 @@ export const isFull = <A>(self: TxPubSub<A>): Effect.Effect<boolean, never, Effe
       if (yield* TxQueue.isFull(queue)) return true
     }
     return false
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Checks if the TxPubSub has been shut down.
@@ -348,8 +347,7 @@ export const isFull = <A>(self: TxPubSub<A>): Effect.Effect<boolean, never, Effe
  * @since 4.0.0
  * @category getters
  */
-export const isShutdown = <A>(self: TxPubSub<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
-  TxRef.get(self.shutdownRef)
+export const isShutdown = <A>(self: TxPubSub<A>): Effect.Effect<boolean> => TxRef.get(self.shutdownRef)
 
 // =============================================================================
 // Mutations
@@ -430,7 +428,7 @@ export const publish: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(value: A): (self: TxPubSub<A>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <A>(value: A): (self: TxPubSub<A>) => Effect.Effect<boolean>
   // =============================================================================
   // Mutations
   // =============================================================================
@@ -470,10 +468,10 @@ export const publish: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxPubSub<A>, value: A): Effect.Effect<boolean, never, Effect.Transaction>
+  <A>(self: TxPubSub<A>, value: A): Effect.Effect<boolean>
 } = dual(
   2,
-  <A>(self: TxPubSub<A>, value: A): Effect.Effect<boolean, never, Effect.Transaction> =>
+  <A>(self: TxPubSub<A>, value: A): Effect.Effect<boolean> =>
     Effect.gen(function*() {
       if (yield* TxRef.get(self.shutdownRef)) return false
 
@@ -486,7 +484,7 @@ export const publish: {
       }
 
       return allAccepted
-    })
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -546,7 +544,7 @@ export const publishAll: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(values: Iterable<A>): (self: TxPubSub<A>) => Effect.Effect<boolean, never, Effect.Transaction>
+  <A>(values: Iterable<A>): (self: TxPubSub<A>) => Effect.Effect<boolean>
   /**
    * Publishes all messages from an iterable to all current subscribers.
    *
@@ -575,10 +573,10 @@ export const publishAll: {
    * @since 4.0.0
    * @category mutations
    */
-  <A>(self: TxPubSub<A>, values: Iterable<A>): Effect.Effect<boolean, never, Effect.Transaction>
+  <A>(self: TxPubSub<A>, values: Iterable<A>): Effect.Effect<boolean>
 } = dual(
   2,
-  <A>(self: TxPubSub<A>, values: Iterable<A>): Effect.Effect<boolean, never, Effect.Transaction> =>
+  <A>(self: TxPubSub<A>, values: Iterable<A>): Effect.Effect<boolean> =>
     Effect.gen(function*() {
       if (yield* TxRef.get(self.shutdownRef)) return false
 
@@ -588,7 +586,7 @@ export const publishAll: {
         if (!accepted) allAccepted = false
       }
       return allAccepted
-    })
+    }).pipe(Effect.tx)
 )
 
 /**
@@ -623,8 +621,8 @@ export const publishAll: {
  */
 export const subscribe = <A>(self: TxPubSub<A>): Effect.Effect<TxQueue.TxQueue<A>, never, Scope.Scope> =>
   Effect.acquireRelease(
-    Effect.transaction(acquireSubscriber(self)),
-    (queue) => Effect.transaction(releaseSubscriber(self, queue))
+    Effect.tx(acquireSubscriber(self)),
+    (queue) => Effect.tx(releaseSubscriber(self, queue))
   )
 
 /**
@@ -691,7 +689,7 @@ export const releaseSubscriber: {
 const makeSubscriberQueue = <A>(
   strategy: "bounded" | "unbounded" | "dropping" | "sliding",
   cap: number
-): Effect.Effect<TxQueue.TxQueue<A>, never, Effect.Transaction> => {
+): Effect.Effect<TxQueue.TxQueue<A>> => {
   switch (strategy) {
     case "bounded":
       return TxQueue.bounded<A>(cap)
@@ -727,7 +725,7 @@ const makeSubscriberQueue = <A>(
  * @since 4.0.0
  * @category mutations
  */
-export const shutdown = <A>(self: TxPubSub<A>): Effect.Effect<void, never, Effect.Transaction> =>
+export const shutdown = <A>(self: TxPubSub<A>): Effect.Effect<void> =>
   Effect.gen(function*() {
     const alreadyShutdown = yield* TxRef.get(self.shutdownRef)
     if (alreadyShutdown) return
@@ -737,7 +735,7 @@ export const shutdown = <A>(self: TxPubSub<A>): Effect.Effect<void, never, Effec
     for (const queue of subscribers) {
       yield* TxQueue.shutdown(queue)
     }
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Waits for the TxPubSub to be shut down.
@@ -758,12 +756,12 @@ export const shutdown = <A>(self: TxPubSub<A>): Effect.Effect<void, never, Effec
  * @since 4.0.0
  * @category mutations
  */
-export const awaitShutdown = <A>(self: TxPubSub<A>): Effect.Effect<void, never, Effect.Transaction> =>
+export const awaitShutdown = <A>(self: TxPubSub<A>): Effect.Effect<void> =>
   Effect.gen(function*() {
     const shut = yield* TxRef.get(self.shutdownRef)
     if (shut) return
-    return yield* Effect.retryTransaction
-  })
+    return yield* Effect.txRetry
+  }).pipe(Effect.tx)
 
 // =============================================================================
 // Guards