 		_ predicate: @escaping (Value, P.Value) -> Result<(), TransactionError>
 	) -> TransactionalProperty<Value, TransactionError> {
 		return TransactionalProperty<Value, TransactionError>
-			.validate({ TransactionalProperty(self, $0) }, with: other, predicate)
-	}
-}
+			.validate({ TransactionalProperty(self, transform: { $0 }, errorTransform: { $0 }, $0) },
+			          with: other,
+			          predicate)
+	}
+}
+
+extension _TransactionalPropertyProtocol where TransactionError == NoError {
+	// - The overriding failable `map` that invokes the `TransactionalProperty`
+	//   specialization of `TransactionalProperty.init`.
+	/// Create a mutable mapped view to `self` with a failable setter.
+	///
+	/// - parameters:
+	///   - forward: The value transform to convert `Self.Value` to `U`.
+	///   - attemptBackward: The failable value transform to convert `U` to
+	///                      `Self.Value`.
+	///
+	/// - returns: A mapping `TransactionalProperty`.
+	public func map<U, NewError: Swift.Error>(
+		forward: @escaping (Value) -> U,
+		attemptBackward: @escaping (U) -> Result<Value, NewError>
+	) -> TransactionalProperty<U, NewError> {
+		return TransactionalProperty(self, transform: forward) { proposedInput in
+			return attemptBackward(proposedInput)
+		}
+	}
+
+	// - The overriding `validate` that invokes the `TransactionalProperty`
+	//   specialization of `TransactionalProperty.init`.
+
+	/// Create a mutable view to `self` that validates any proposed value.
+	///
+	/// - parameters:
+	///   - predicate: The closure that validates any proposed value to the
+	///                property.
+	///
+	/// - returns: A validating `TransactionalProperty`.
+	public func validate<NewError: Swift.Error>(
+		_ predicate: @escaping (Value) -> Result<(), NewError>
+	) -> TransactionalProperty<Value, NewError> {
+		return TransactionalProperty(self, transform: { $0 }) { proposedInput in
+			switch predicate(proposedInput) {
+			case .success:
+				return .success(proposedInput)
+
+			case let .failure(error):
+				return .failure(error)
+			}
+		}
+	}
+
+	// - The overriding `validate(with:)` that invokes the `TransactionalProperty`
+	//   specialization of `TransactionalProperty.init`.
+
+	/// Create a mutable view to `self` that validates any proposed value in
+	/// consideration of `other`.
+	///
+	/// If `self` has failed the predicate and `other` changes subsequently, the
+	/// predicate would be reevaluated automatically.
+	///
+	/// - parameters:
+	///   - predicate: The closure that validates any proposed value to the
+	///                property.
+	///
+	/// - returns: A validating `TransactionalProperty`.
+	public func validate<P: PropertyProtocol, NewError: Swift.Error>(
+		with other: P,
+		_ predicate: @escaping (Value, P.Value) -> Result<(), NewError>
+	) -> TransactionalProperty<Value, NewError> {
+		return TransactionalProperty<Value, NewError>
+			.validate({ TransactionalProperty(self, transform: { $0 }, $0) },
+			          with: other,
+			          predicate)
+	}
+}

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

			if let value = proposed.swap(nil) {
				property?.value = value
			} else {
				property?.property.revalidate()
			}
		}

