effect 4.0.0-beta.4 → 4.0.0-beta.40

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

@@ -7,6 +7,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import { NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import type * as Scope from "./Scope.ts"
 import * as TxRef from "./TxRef.ts"
 
@@ -100,7 +101,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 +141,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 +202,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 +238,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 +278,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 +314,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 +354,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 +386,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"))
   }
@@ -436,15 +434,102 @@ export const releaseN = (self: TxSemaphore, n: number): Effect.Effect<void> => {
  * @since 4.0.0
  * @category combinators
  */
-export const withPermit = <A, E, R>(
-  self: TxSemaphore,
-  effect: Effect.Effect<A, E, R>
-): Effect.Effect<A, E, R> =>
-  Effect.acquireUseRelease(
-    acquire(self),
+export const withPermit: {
+  /**
+   * Executes an effect with a single permit from the semaphore. The permit is
+   * automatically acquired before execution and released afterwards, even if the
+   * effect fails or is interrupted.
+   *
+   * **Note**: The permit acquisition and release operations use atomic semantics
+   * to ensure proper resource management with Effect's scoped operations.
+   *
+   * @example
+   * ```ts
+   * import { Console, Effect, TxSemaphore } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const semaphore = yield* TxSemaphore.make(2)
+   *
+   *   // Execute database operation with automatic permit management
+   *   const result = yield* TxSemaphore.withPermit(
+   *     semaphore,
+   *     Effect.gen(function*() {
+   *       yield* Console.log("Permit acquired, accessing database...")
+   *       yield* Effect.sleep("100 millis") // Simulate database work
+   *       yield* Console.log("Database operation complete")
+   *       return "query result"
+   *     })
+   *   )
+   *
+   *   yield* Console.log(`Result: ${result}`)
+   *   // Permit is automatically released here
+   * })
+   * ```
+   *
+   * @param self - The TxSemaphore to acquire a permit from
+   * @param effect - The effect to execute with the permit
+   * @returns Effect that succeeds with the result of the provided effect
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: TxSemaphore): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  /**
+   * Executes an effect with a single permit from the semaphore. The permit is
+   * automatically acquired before execution and released afterwards, even if the
+   * effect fails or is interrupted.
+   *
+   * **Note**: The permit acquisition and release operations use atomic semantics
+   * to ensure proper resource management with Effect's scoped operations.
+   *
+   * @example
+   * ```ts
+   * import { Console, Effect, TxSemaphore } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const semaphore = yield* TxSemaphore.make(2)
+   *
+   *   // Execute database operation with automatic permit management
+   *   const result = yield* TxSemaphore.withPermit(
+   *     semaphore,
+   *     Effect.gen(function*() {
+   *       yield* Console.log("Permit acquired, accessing database...")
+   *       yield* Effect.sleep("100 millis") // Simulate database work
+   *       yield* Console.log("Database operation complete")
+   *       return "query result"
+   *     })
+   *   )
+   *
+   *   yield* Console.log(`Result: ${result}`)
+   *   // Permit is automatically released here
+   * })
+   * ```
+   *
+   * @param self - The TxSemaphore to acquire a permit from
+   * @param effect - The effect to execute with the permit
+   * @returns Effect that succeeds with the result of the provided effect
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <A, E, R>(self: TxSemaphore, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+} = ((...args: Array<any>) => {
+  if (args.length === 1) {
+    const [self] = args
+    return (effect: Effect.Effect<any, any, any>) =>
+      Effect.acquireUseRelease(
+        Effect.transaction(acquire(self)),
+        () => effect,
+        () => Effect.transaction(release(self))
+      )
+  }
+  const [self, effect] = args
+  return Effect.acquireUseRelease(
+    Effect.transaction(acquire(self)),
     () => effect,
-    () => release(self)
+    () => Effect.transaction(release(self))
   )
+}) as any
 
 /**
  * Executes an effect with the specified number of permits from the semaphore.
@@ -485,16 +570,104 @@ export const withPermit = <A, E, R>(
  * @since 4.0.0
  * @category combinators
  */
-export const withPermits = <A, E, R>(
-  self: TxSemaphore,
-  n: number,
-  effect: Effect.Effect<A, E, R>
-): Effect.Effect<A, E, R> =>
-  Effect.acquireUseRelease(
-    acquireN(self, n),
+export const withPermits: {
+  /**
+   * Executes an effect with the specified number of permits from the semaphore.
+   * The permits are automatically acquired before execution and released afterwards,
+   * even if the effect fails or is interrupted.
+   *
+   * **Note**: The permit acquisition and release operations use atomic semantics
+   * to ensure proper resource management with Effect's scoped operations.
+   *
+   * @example
+   * ```ts
+   * import { Console, Effect, TxSemaphore } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const semaphore = yield* TxSemaphore.make(5)
+   *
+   *   // Execute batch operation with 3 permits
+   *   const results = yield* TxSemaphore.withPermits(
+   *     semaphore,
+   *     3,
+   *     Effect.gen(function*() {
+   *       yield* Console.log("3 permits acquired, processing batch...")
+   *       yield* Effect.sleep("200 millis") // Simulate batch processing
+   *       return ["result1", "result2", "result3"]
+   *     })
+   *   )
+   *
+   *   yield* Console.log(`Batch results: ${results.join(", ")}`)
+   *   // All 3 permits are automatically released here
+   * })
+   * ```
+   *
+   * @param self - The TxSemaphore to acquire permits from
+   * @param n - The number of permits to acquire (must be positive)
+   * @param effect - The effect to execute with the permits
+   * @returns Effect that succeeds with the result of the provided effect
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: TxSemaphore, n: number): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  /**
+   * Executes an effect with the specified number of permits from the semaphore.
+   * The permits are automatically acquired before execution and released afterwards,
+   * even if the effect fails or is interrupted.
+   *
+   * **Note**: The permit acquisition and release operations use atomic semantics
+   * to ensure proper resource management with Effect's scoped operations.
+   *
+   * @example
+   * ```ts
+   * import { Console, Effect, TxSemaphore } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   const semaphore = yield* TxSemaphore.make(5)
+   *
+   *   // Execute batch operation with 3 permits
+   *   const results = yield* TxSemaphore.withPermits(
+   *     semaphore,
+   *     3,
+   *     Effect.gen(function*() {
+   *       yield* Console.log("3 permits acquired, processing batch...")
+   *       yield* Effect.sleep("200 millis") // Simulate batch processing
+   *       return ["result1", "result2", "result3"]
+   *     })
+   *   )
+   *
+   *   yield* Console.log(`Batch results: ${results.join(", ")}`)
+   *   // All 3 permits are automatically released here
+   * })
+   * ```
+   *
+   * @param self - The TxSemaphore to acquire permits from
+   * @param n - The number of permits to acquire (must be positive)
+   * @param effect - The effect to execute with the permits
+   * @returns Effect that succeeds with the result of the provided effect
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  <A, E, R>(self: TxSemaphore, n: number, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+} = ((...args: Array<any>) => {
+  if (args.length === 2) {
+    const [self, n] = args
+    return (effect: Effect.Effect<any, any, any>) =>
+      Effect.acquireUseRelease(
+        Effect.transaction(acquireN(self, n)),
+        () => effect,
+        () => Effect.transaction(releaseN(self, n))
+      )
+  }
+  const [self, n, effect] = args
+  return Effect.acquireUseRelease(
+    Effect.transaction(acquireN(self, n)),
     () => effect,
-    () => releaseN(self, n)
+    () => Effect.transaction(releaseN(self, n))
   )
+}) as any
 
 /**
  * Acquires a single permit from the semaphore in a scoped manner. The permit
@@ -537,8 +710,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))
   )
 
 /**
@@ -566,4 +739,4 @@ export const withPermitScoped = (self: TxSemaphore): Effect.Effect<void, never,
  * @since 4.0.0
  * @category guards
  */
-export const isTxSemaphore = (u: unknown): u is TxSemaphore => typeof u === "object" && u !== null && TypeId in u
+export const isTxSemaphore = (u: unknown): u is TxSemaphore => hasProperty(u, TypeId)