 	///   - body: The closure to invoke for any proposed value to `self`.
 	public convenience init<M: ComposableMutablePropertyProtocol>(
 		_ inner: M,
-		_ body: @escaping (M.Value, M.Value) -> Result<M.Value, TransactionError>
+		_ body: @escaping (M.Value) -> Result<M.Value, TransactionError>
 	) where M.Value == Value {
 		self.init(inner, transform: { $0 }, body)
 	}
 
 	/// Create an `TransactionalProperty` that presents `inner` as an
 	/// `TransactionalProperty` of `U` values and the same error type, and invoke
-	/// `body` with the current value of `inner` and the proposed value whenever
-	/// the setter is invoked.
+	/// `body` with the proposed value whenever the setter is invoked.
 	///
 	/// If `success` is returned by `body`, the associated value would be
 	/// persisted to `inner`. Otherwise, the failure would be emitted by the

extension TransactionalProperty {
	// Shared implementation of `validate(with:)`.
	fileprivate static func validate<Other: PropertyProtocol, Error>(
		_ initializer: (@escaping (Value, Value) -> Result<Value, Error>) -> TransactionalProperty<Value, Error>,
		with other: Other,
		_ predicate: @escaping (Value, Other.Value) -> Result<(), Error>
		) -> TransactionalProperty<Value, Error> {
		let other = Property(other)
		let proposed = Atomic<Value?>(nil)

		let property = initializer { _, proposedInput -> Result<Value, Error> in
			switch predicate(proposedInput, other.value) {
			case .success:
				proposed.value = nil

		forward: @escaping (Value) -> U,
		backward: @escaping (U) -> Value
	) -> TransactionalProperty<U, NoError> {
		return TransactionalProperty<U, NoError>(self, transform: forward) { proposedInput in
			return .success(backward(proposedInput))
		}
	}
