 	private let cache: Property<Value>
 
 	/// Create an `TransactionalProperty` that presents `inner` as a property of
-	/// `Value`, and invoke `body` with the current value of `inner` and the
-	/// proposed value whenever the setter is invoked.
+	/// `Value`, and invoke `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

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

		_ inner: TransactionalProperty<U, E>,
		transform: @escaping (U) -> Value,
		errorTransform: @escaping (E) -> TransactionError,
		_ body: @escaping (Value) -> Result<U, TransactionError>
	) {
		let current = inner.value
		let initialValidation = body(transform(current)).map { _ in }
		let _validations = MutableProperty<Result<(), TransactionError>>(initialValidation)

		self.lifetime = inner.lifetime
