effect 4.0.0-beta.17 → 4.0.0-beta.19

package/src/TxRef.ts

@@ -35,12 +35,12 @@ const TypeId = "~effect/transactions/TxRef"
  *   const ref: TxRef.TxRef<number> = yield* TxRef.make(0)
  *
  *   // Use within a transaction
- *   yield* Effect.atomic(Effect.gen(function*() {
+ *   yield* Effect.transaction(Effect.gen(function*() {
  *     const current = yield* TxRef.get(ref)
  *     yield* TxRef.set(ref, current + 1)
  *   }))
  *
- *   const final = yield* TxRef.get(ref)
+ *   const final = yield* Effect.transaction(TxRef.get(ref))
  *   console.log(final) // 1
  * })
  * ```
@@ -64,21 +64,28 @@ export interface TxRef<in out A> extends Pipeable {
  *
  * const program = Effect.gen(function*() {
  *   // Create a transactional reference with initial value
- *   const counter = yield* TxRef.make(0)
- *   const name = yield* TxRef.make("Alice")
+ *   const counter = yield* Effect.transaction(TxRef.make(0))
+ *   const name = yield* Effect.transaction(TxRef.make("Alice"))
  *
  *   // Use in transactions
- *   yield* Effect.atomic(Effect.gen(function*() {
+ *   yield* Effect.transaction(Effect.gen(function*() {
  *     yield* TxRef.set(counter, 42)
  *     yield* TxRef.set(name, "Bob")
  *   }))
  *
- *   console.log(yield* TxRef.get(counter)) // 42
- *   console.log(yield* TxRef.get(name)) // "Bob"
+ *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 42
+ *   console.log(yield* Effect.transaction(TxRef.get(name))) // "Bob"
  * })
  * ```
  */
-export const make = <A>(initial: A) => Effect.sync(() => makeUnsafe(initial))
+export const make = <A>(initial: A) =>
+  Effect.withTxState((state) =>
+    Effect.sync(() => {
+      const ref = makeUnsafe(initial)
+      state.journal.set(ref, { version: ref.version, value: ref.value })
+      return ref
+    })
+  )
 
 /**
  * Creates a new `TxRef` with the specified initial value.
@@ -121,12 +128,12 @@ export const makeUnsafe = <A>(initial: A): TxRef<A> => ({
  *   const counter = yield* TxRef.make(0)
  *
  *   // Modify and return both old and new value
- *   const result = yield* Effect.atomic(
+ *   const result = yield* Effect.transaction(
  *     TxRef.modify(counter, (current) => [current * 2, current + 1])
  *   )
  *
  *   console.log(result) // 0 (the return value: current * 2)
- *   console.log(yield* TxRef.get(counter)) // 1 (the new value: current + 1)
+ *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 1 (the new value: current + 1)
  * })
  * ```
  */
@@ -144,16 +151,16 @@ export const modify: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Modify and return both old and new value
-   *   const result = yield* Effect.atomic(
+   *   const result = yield* Effect.transaction(
    *     TxRef.modify(counter, (current) => [current * 2, current + 1])
    *   )
    *
    *   console.log(result) // 0 (the return value: current * 2)
-   *   console.log(yield* TxRef.get(counter)) // 1 (the new value: current + 1)
+   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 1 (the new value: current + 1)
    * })
    * ```
    */
-  <A, R>(f: (current: NoInfer<A>) => [returnValue: R, newValue: A]): (self: TxRef<A>) => Effect.Effect<R>
+  <A, R>(f: (current: NoInfer<A>) => [returnValue: R, newValue: A]): (self: TxRef<A>) => Effect.Effect<R, never, Effect.Transaction>
   /**
    * Modifies the value of the `TxRef` using the provided function.
    *
@@ -167,20 +174,23 @@ export const modify: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Modify and return both old and new value
-   *   const result = yield* Effect.atomic(
+   *   const result = yield* Effect.transaction(
    *     TxRef.modify(counter, (current) => [current * 2, current + 1])
    *   )
    *
    *   console.log(result) // 0 (the return value: current * 2)
-   *   console.log(yield* TxRef.get(counter)) // 1 (the new value: current + 1)
+   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 1 (the new value: current + 1)
    * })
    * ```
    */
-  <A, R>(self: TxRef<A>, f: (current: A) => [returnValue: R, newValue: A]): Effect.Effect<R>
+  <A, R>(self: TxRef<A>, f: (current: A) => [returnValue: R, newValue: A]): Effect.Effect<R, never, Effect.Transaction>
 } = dual(
   2,
-  <A, R>(self: TxRef<A>, f: (current: A) => [returnValue: R, newValue: A]): Effect.Effect<R> =>
-    Effect.atomicWith((state) =>
+  <A, R>(
+    self: TxRef<A>,
+    f: (current: A) => [returnValue: R, newValue: A]
+  ): Effect.Effect<R, never, Effect.Transaction> =>
+    Effect.withTxState((state) =>
       Effect.sync(() => {
         if (!state.journal.has(self)) {
           state.journal.set(self, { version: self.version, value: self.value })
@@ -206,11 +216,11 @@ export const modify: {
  *   const counter = yield* TxRef.make(10)
  *
  *   // Update the value using a function
- *   yield* Effect.atomic(
+ *   yield* Effect.transaction(
  *     TxRef.update(counter, (current) => current * 2)
  *   )
  *
- *   console.log(yield* TxRef.get(counter)) // 20
+ *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 20
  * })
  * ```
  */
@@ -228,15 +238,15 @@ export const update: {
    *   const counter = yield* TxRef.make(10)
    *
    *   // Update the value using a function
-   *   yield* Effect.atomic(
+   *   yield* Effect.transaction(
    *     TxRef.update(counter, (current) => current * 2)
    *   )
    *
-   *   console.log(yield* TxRef.get(counter)) // 20
+   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 20
    * })
    * ```
    */
-  <A>(f: (current: NoInfer<A>) => A): (self: TxRef<A>) => Effect.Effect<void>
+  <A>(f: (current: NoInfer<A>) => A): (self: TxRef<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Updates the value of the `TxRef` using the provided function.
    *
@@ -250,18 +260,19 @@ export const update: {
    *   const counter = yield* TxRef.make(10)
    *
    *   // Update the value using a function
-   *   yield* Effect.atomic(
+   *   yield* Effect.transaction(
    *     TxRef.update(counter, (current) => current * 2)
    *   )
    *
-   *   console.log(yield* TxRef.get(counter)) // 20
+   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 20
    * })
    * ```
    */
-  <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void>
+  <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void, never, Effect.Transaction>
 } = dual(
   2,
-  <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void> => modify(self, (current) => [void 0, f(current)])
+  <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void, never, Effect.Transaction> =>
+    modify(self, (current) => [void 0, f(current)])
 )
 
 /**
@@ -277,7 +288,7 @@ export const update: {
  *   const counter = yield* TxRef.make(42)
  *
  *   // Read the value within a transaction
- *   const value = yield* Effect.atomic(
+ *   const value = yield* Effect.transaction(
  *     TxRef.get(counter)
  *   )
  *
@@ -285,7 +296,8 @@ export const update: {
  * })
  * ```
  */
-export const get = <A>(self: TxRef<A>): Effect.Effect<A> => modify(self, (current) => [current, current])
+export const get = <A>(self: TxRef<A>): Effect.Effect<A, never, Effect.Transaction> =>
+  modify(self, (current) => [current, current])
 
 /**
  * Sets the value of the `TxRef`.
@@ -300,11 +312,11 @@ export const get = <A>(self: TxRef<A>): Effect.Effect<A> => modify(self, (curren
  *   const counter = yield* TxRef.make(0)
  *
  *   // Set a new value within a transaction
- *   yield* Effect.atomic(
+ *   yield* Effect.transaction(
  *     TxRef.set(counter, 100)
  *   )
  *
- *   console.log(yield* TxRef.get(counter)) // 100
+ *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 100
  * })
  * ```
  */
@@ -322,15 +334,15 @@ export const set: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Set a new value within a transaction
-   *   yield* Effect.atomic(
+   *   yield* Effect.transaction(
    *     TxRef.set(counter, 100)
    *   )
    *
-   *   console.log(yield* TxRef.get(counter)) // 100
+   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 100
    * })
    * ```
    */
-  <A>(value: A): (self: TxRef<A>) => Effect.Effect<void>
+  <A>(value: A): (self: TxRef<A>) => Effect.Effect<void, never, Effect.Transaction>
   /**
    * Sets the value of the `TxRef`.
    *
@@ -344,13 +356,13 @@ export const set: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Set a new value within a transaction
-   *   yield* Effect.atomic(
+   *   yield* Effect.transaction(
    *     TxRef.set(counter, 100)
    *   )
    *
-   *   console.log(yield* TxRef.get(counter)) // 100
+   *   console.log(yield* Effect.transaction(TxRef.get(counter))) // 100
    * })
    * ```
    */
-  <A>(self: TxRef<A>, value: A): Effect.Effect<void>
-} = dual(2, <A>(self: TxRef<A>, value: A): Effect.Effect<void> => update(self, () => value))
+  <A>(self: TxRef<A>, value: A): Effect.Effect<void, never, Effect.Transaction>
+} = dual(2, <A>(self: TxRef<A>, value: A): Effect.Effect<void, never, Effect.Transaction> => update(self, () => value))

package/src/TxSemaphore.ts

@@ -100,7 +100,7 @@ const makeTxSemaphore = (permitsRef: TxRef.TxRef<number>, capacity: number): TxS
  * @since 4.0.0
  * @category constructors
  */
-export const make = (permits: number): Effect.Effect<TxSemaphore> =>
+export const make = (permits: number): Effect.Effect<TxSemaphore, never, Effect.Transaction> =>
   Effect.gen(function*() {
     if (permits < 0) {
       return yield* Effect.die(new Error("Permits must be non-negative"))
@@ -140,7 +140,8 @@ export const make = (permits: number): Effect.Effect<TxSemaphore> =>
  * @since 4.0.0
  * @category combinators
  */
-export const available = (self: TxSemaphore): Effect.Effect<number> => TxRef.get(self.permitsRef)
+export const available = (self: TxSemaphore): Effect.Effect<number, never, Effect.Transaction> =>
+  TxRef.get(self.permitsRef)
 
 /**
  * Gets the maximum capacity (total permits) of the semaphore.
@@ -200,16 +201,14 @@ export const capacity = (self: TxSemaphore): Effect.Effect<number> => Effect.suc
  * @since 4.0.0
  * @category combinators
  */
-export const acquire = (self: TxSemaphore): Effect.Effect<void> =>
-  Effect.atomic(
-    Effect.gen(function*() {
-      const permits = yield* TxRef.get(self.permitsRef)
-      if (permits <= 0) {
-        return yield* Effect.retryTransaction
-      }
-      yield* TxRef.set(self.permitsRef, permits - 1)
-    })
-  )
+export const acquire = (self: TxSemaphore): Effect.Effect<void, never, Effect.Transaction> =>
+  Effect.gen(function*() {
+    const permits = yield* TxRef.get(self.permitsRef)
+    if (permits <= 0) {
+      return yield* Effect.retryTransaction
+    }
+    yield* TxRef.set(self.permitsRef, permits - 1)
+  })
 
 /**
  * Acquires the specified number of permits from the semaphore. If not enough
@@ -238,19 +237,17 @@ export const acquire = (self: TxSemaphore): Effect.Effect<void> =>
  * @since 4.0.0
  * @category combinators
  */
-export const acquireN = (self: TxSemaphore, n: number): Effect.Effect<void> => {
+export const acquireN = (self: TxSemaphore, n: number): Effect.Effect<void, never, Effect.Transaction> => {
   if (n <= 0) {
     return Effect.die(new Error("Number of permits must be positive"))
   }
-  return Effect.atomic(
-    Effect.gen(function*() {
-      const permits = yield* TxRef.get(self.permitsRef)
-      if (permits < n) {
-        return yield* Effect.retryTransaction
-      }
-      yield* TxRef.set(self.permitsRef, permits - n)
-    })
-  )
+  return Effect.gen(function*() {
+    const permits = yield* TxRef.get(self.permitsRef)
+    if (permits < n) {
+      return yield* Effect.retryTransaction
+    }
+    yield* TxRef.set(self.permitsRef, permits - n)
+  })
 }
 
 /**
@@ -280,7 +277,7 @@ export const acquireN = (self: TxSemaphore, n: number): Effect.Effect<void> => {
  * @since 4.0.0
  * @category combinators
  */
-export const tryAcquire = (self: TxSemaphore): Effect.Effect<boolean> =>
+export const tryAcquire = (self: TxSemaphore): Effect.Effect<boolean, never, Effect.Transaction> =>
   TxRef.modify(self.permitsRef, (permits: number) => {
     if (permits > 0) {
       return [true, permits - 1]
@@ -316,7 +313,7 @@ export const tryAcquire = (self: TxSemaphore): Effect.Effect<boolean> =>
  * @since 4.0.0
  * @category combinators
  */
-export const tryAcquireN = (self: TxSemaphore, n: number): Effect.Effect<boolean> => {
+export const tryAcquireN = (self: TxSemaphore, n: number): Effect.Effect<boolean, never, Effect.Transaction> => {
   if (n <= 0) {
     return Effect.die(new Error("Number of permits must be positive"))
   }
@@ -356,7 +353,7 @@ export const tryAcquireN = (self: TxSemaphore, n: number): Effect.Effect<boolean
  * @since 4.0.0
  * @category combinators
  */
-export const release = (self: TxSemaphore): Effect.Effect<void> =>
+export const release = (self: TxSemaphore): Effect.Effect<void, never, Effect.Transaction> =>
   TxRef.update(self.permitsRef, (permits: number) => permits >= self.capacity ? permits : permits + 1)
 
 /**
@@ -388,7 +385,7 @@ export const release = (self: TxSemaphore): Effect.Effect<void> =>
  * @since 4.0.0
  * @category combinators
  */
-export const releaseN = (self: TxSemaphore, n: number): Effect.Effect<void> => {
+export const releaseN = (self: TxSemaphore, n: number): Effect.Effect<void, never, Effect.Transaction> => {
   if (n <= 0) {
     return Effect.die(new Error("Number of permits must be positive"))
   }
@@ -441,9 +438,9 @@ export const withPermit = <A, E, R>(
   effect: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R> =>
   Effect.acquireUseRelease(
-    acquire(self),
+    Effect.transaction(acquire(self)),
     () => effect,
-    () => release(self)
+    () => Effect.transaction(release(self))
   )
 
 /**
@@ -491,9 +488,9 @@ export const withPermits = <A, E, R>(
   effect: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R> =>
   Effect.acquireUseRelease(
-    acquireN(self, n),
+    Effect.transaction(acquireN(self, n)),
     () => effect,
-    () => releaseN(self, n)
+    () => Effect.transaction(releaseN(self, n))
   )
 
 /**
@@ -537,8 +534,8 @@ export const withPermits = <A, E, R>(
  */
 export const withPermitScoped = (self: TxSemaphore): Effect.Effect<void, never, Scope.Scope> =>
   Effect.acquireRelease(
-    acquire(self),
-    () => release(self)
+    Effect.transaction(acquire(self)),
+    () => Effect.transaction(release(self))
   )
 
 /**