with-transaction full-body retry vs with-retry commit-only retry for duplicate writes

Answer

With with-retry the body is executed exactly once; on a conflict only the commit phase is retried via transaction-commit. Therefore non‑idempotent I/O placed before the commit point is not re‑executed, assuming the body does not perform side effects after the commit attempt.

With with-transaction the entire body is retried from the start on any conflict, so any I/O inside the body will be repeated.

Confirmed facts (Racket 8.9+)

• The documentation states that with-retry splits the transaction into a body phase and a commit phase; retries affect only the commit phase.
• transaction-commit attempts to commit the current transaction state; it does not act as a guard that rolls back prior writes on retry.
• Side effects that occur before the explicit transaction-commit are not re‑executed when a conflict triggers a retry under with-retry because the body is not retried.

Likely explanation

The retry mechanism re‑enters the transaction at the point where the commit phase begins. If the body has already finished, its effects are retained in the transaction log and are not repeated; only the attempt to validate and write the transaction log is repeated.

Steps to verify safety for your case

1. Wrap the non‑idempotent operation (e.g., writing to a file) inside a with-retry block, placing it before a call to transaction-commit.
2. Inject a conflict (for example, by having another thread write to the same transaction‑protected location) to force a retry.
3. Check whether the operation’s output appears only once. If it appears multiple times, the operation is placed after the commit point or the version does not support the phase split.

Missing diagnostic detail

If you have side effects that must occur after the commit attempt (e.g., logging the commit outcome), please confirm whether those effects can be made idempotent or moved before the commit; otherwise the recommendation to use with-retry may need adjustment.

#lang racket
(require racket/transaction)
(with-retry
  (begin
    (display-to-file "log.txt" "side-effect\n") ; non-idempotent I/O
    (transaction-commit))) ; commit attempt

Run the snippet under a controlled conflict and examine log.txt for duplicate lines.