effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/TxRef.ts

@@ -3,7 +3,7 @@
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and in order to
  * track changes, a transaction will retry whenever a conflict is detected or whenever the
- * transaction explicitely calls to `Effect.retryTransaction` and any of the accessed TxRef values
+ * transaction explicitely calls to `Effect.txRetry` and any of the accessed TxRef values
  * change.
  *
  * @since 4.0.0
@@ -21,7 +21,7 @@ const TypeId = "~effect/transactions/TxRef"
  *
  * Accessed values are tracked by the transaction in order to detect conflicts and in order to
  * track changes, a transaction will retry whenever a conflict is detected or whenever the
- * transaction explicitely calls to `Effect.retryTransaction` and any of the accessed TxRef values
+ * transaction explicitely calls to `Effect.txRetry` and any of the accessed TxRef values
  * change.
  *
  * @since 4.0.0
@@ -35,7 +35,7 @@ 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.tx(Effect.gen(function*() {
  *     const current = yield* TxRef.get(ref)
  *     yield* TxRef.set(ref, current + 1)
  *   }))
@@ -68,7 +68,7 @@ export interface TxRef<in out A> extends Pipeable {
  *   const name = yield* TxRef.make("Alice")
  *
  *   // Use in transactions
- *   yield* Effect.atomic(Effect.gen(function*() {
+ *   yield* Effect.tx(Effect.gen(function*() {
  *     yield* TxRef.set(counter, 42)
  *     yield* TxRef.set(name, "Bob")
  *   }))
@@ -121,9 +121,7 @@ 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(
- *     TxRef.modify(counter, (current) => [current * 2, current + 1])
- *   )
+ *   const result = yield* 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)
@@ -144,9 +142,7 @@ export const modify: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Modify and return both old and new value
-   *   const result = yield* Effect.atomic(
-   *     TxRef.modify(counter, (current) => [current * 2, current + 1])
-   *   )
+   *   const result = yield* 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)
@@ -167,9 +163,7 @@ export const modify: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Modify and return both old and new value
-   *   const result = yield* Effect.atomic(
-   *     TxRef.modify(counter, (current) => [current * 2, current + 1])
-   *   )
+   *   const result = yield* 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)
@@ -177,10 +171,12 @@ export const modify: {
    * ```
    */
   <A, R>(self: TxRef<A>, f: (current: A) => [returnValue: R, newValue: A]): Effect.Effect<R>
-} = dual(
-  2,
-  <A, R>(self: TxRef<A>, f: (current: A) => [returnValue: R, newValue: A]): Effect.Effect<R> =>
-    Effect.atomicWith((state) =>
+} = dual(2, <A, R>(
+  self: TxRef<A>,
+  f: (current: A) => [returnValue: R, newValue: A]
+): Effect.Effect<R> =>
+  Effect.Transaction.asEffect().pipe(
+    Effect.flatMap((state) =>
       Effect.sync(() => {
         if (!state.journal.has(self)) {
           state.journal.set(self, { version: self.version, value: self.value })
@@ -190,8 +186,9 @@ export const modify: {
         current.value = next
         return returnValue
       })
-    )
-)
+    ),
+    Effect.tx
+  ))
 
 /**
  * Updates the value of the `TxRef` using the provided function.
@@ -206,7 +203,7 @@ export const modify: {
  *   const counter = yield* TxRef.make(10)
  *
  *   // Update the value using a function
- *   yield* Effect.atomic(
+ *   yield* Effect.tx(
  *     TxRef.update(counter, (current) => current * 2)
  *   )
  *
@@ -228,7 +225,7 @@ export const update: {
    *   const counter = yield* TxRef.make(10)
    *
    *   // Update the value using a function
-   *   yield* Effect.atomic(
+   *   yield* Effect.tx(
    *     TxRef.update(counter, (current) => current * 2)
    *   )
    *
@@ -250,7 +247,7 @@ export const update: {
    *   const counter = yield* TxRef.make(10)
    *
    *   // Update the value using a function
-   *   yield* Effect.atomic(
+   *   yield* Effect.tx(
    *     TxRef.update(counter, (current) => current * 2)
    *   )
    *
@@ -259,10 +256,10 @@ export const update: {
    * ```
    */
   <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void>
-} = dual(
-  2,
-  <A>(self: TxRef<A>, f: (current: A) => A): Effect.Effect<void> => modify(self, (current) => [void 0, f(current)])
-)
+} = dual(2, <A>(
+  self: TxRef<A>,
+  f: (current: A) => A
+): Effect.Effect<void> => modify(self, (current) => [void 0, f(current)]))
 
 /**
  * Reads the current value of the `TxRef`.
@@ -277,7 +274,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.tx(
  *     TxRef.get(counter)
  *   )
  *
@@ -300,7 +297,7 @@ 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.tx(
  *     TxRef.set(counter, 100)
  *   )
  *
@@ -322,7 +319,7 @@ export const set: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Set a new value within a transaction
-   *   yield* Effect.atomic(
+   *   yield* Effect.tx(
    *     TxRef.set(counter, 100)
    *   )
    *
@@ -344,7 +341,7 @@ export const set: {
    *   const counter = yield* TxRef.make(0)
    *
    *   // Set a new value within a transaction
-   *   yield* Effect.atomic(
+   *   yield* Effect.tx(
    *     TxRef.set(counter, 100)
    *   )
    *
@@ -353,4 +350,7 @@ export const set: {
    * ```
    */
   <A>(self: TxRef<A>, value: A): Effect.Effect<void>
-} = dual(2, <A>(self: TxRef<A>, value: A): Effect.Effect<void> => update(self, () => value))
+} = dual(2, <A>(
+  self: TxRef<A>,
+  value: A
+): Effect.Effect<void> => 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"
 
@@ -108,7 +109,7 @@ export const make = (permits: number): Effect.Effect<TxSemaphore> =>
 
     const permitsRef = yield* TxRef.make(permits)
     return makeTxSemaphore(permitsRef, permits)
-  })
+  }).pipe(Effect.tx)
 
 /**
  * Gets the current number of available permits in the semaphore.
@@ -201,15 +202,13 @@ export const capacity = (self: TxSemaphore): Effect.Effect<number> => Effect.suc
  * @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)
-    })
-  )
+  Effect.gen(function*() {
+    const permits = yield* TxRef.get(self.permitsRef)
+    if (permits <= 0) {
+      return yield* Effect.txRetry
+    }
+    yield* TxRef.set(self.permitsRef, permits - 1)
+  }).pipe(Effect.tx)
 
 /**
  * Acquires the specified number of permits from the semaphore. If not enough
@@ -242,15 +241,13 @@ export const acquireN = (self: TxSemaphore, n: number): Effect.Effect<void> => {
   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.txRetry
+    }
+    yield* TxRef.set(self.permitsRef, permits - n)
+  }).pipe(Effect.tx)
 }
 
 /**
@@ -436,15 +433,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(
+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(
+        acquire(self),
+        () => effect,
+        () => release(self)
+      )
+  }
+  const [self, effect] = args
+  return Effect.acquireUseRelease(
     acquire(self),
     () => effect,
     () => release(self)
   )
+}) as any
 
 /**
  * Executes an effect with the specified number of permits from the semaphore.
@@ -485,16 +569,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(
+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(
+        acquireN(self, n),
+        () => effect,
+        () => releaseN(self, n)
+      )
+  }
+  const [self, n, effect] = args
+  return Effect.acquireUseRelease(
     acquireN(self, n),
     () => effect,
     () => releaseN(self, n)
   )
+}) as any
 
 /**
  * Acquires a single permit from the semaphore in a scoped manner. The permit
@@ -566,4 +738,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)