Compute a compound result optimally

Author: dungntm58

Example/FormHookExample/ContentView.swift

@@ -153,7 +153,6 @@ struct ContentView: HookView {
                     picker
                     Text(error)
                         .font(.system(size: 10)).foregroundColor(.red)
-                        .font(.system(size: 10)).foregroundColor(.red)
                 }
             } else {
                 picker

Sources/FormHook/Form.swift

@@ -548,7 +548,7 @@ public struct ContextualForm<Content, FieldName>: View where Content: View, Fiel
                 shouldUnregister: Bool = true,
                 shouldFocusError: Bool = true,
                 delayErrorInNanoseconds: UInt64 = 0,
-                onFocusedField: @escaping (FieldName) -> Void,
+                @_implicitSelfCapture onFocusedField: @escaping (FieldName) -> Void,
                 @ViewBuilder content: @escaping (FormControl<FieldName>) -> Content
     ) {
         self.formOptions = .init(

Sources/FormHook/Hook/UseForm.swift

@@ -17,7 +17,7 @@ public func useForm<FieldName>(
     shouldUnregister: Bool = true,
     shouldFocusError: Bool,
     delayErrorInNanoseconds: UInt64 = 0,
-    onFocusedField: @escaping (FieldName) -> Void
+    @_implicitSelfCapture onFocusedField: @escaping (FieldName) -> Void
 ) -> FormControl<FieldName> where FieldName: Hashable {
     useForm(
         FormOption(

Sources/FormHook/Validation/CompoundValidator.swift

@@ -48,61 +48,79 @@ private struct CompoundValidator<Value>: Validator {
     }
 
     func validate(_ value: Value) async -> CompountValidationResult {
-        let pairs = await withTaskGroup(of: ValidatorResultPair.self) { group in
+        await withTaskGroup(of: ValidatorResultPair.self) { group in
             validators.forEach { validator in
                 group.addTask {
                     let result = await validator.validate(value)
                     return (validator, result)
                 }
             }
-            var results: [ValidatorResultPair] = []
             if shouldGetAllMessages {
-                for await resultPair in group {
-                    results.append(resultPair)
+                var isValid: Bool
+                var results: [ValidatorResultPair] = []
+                switch `operator` {
+                case .and:
+                    isValid = true
+                    for await resultPair in group {
+                        results.append(resultPair)
+                        if !resultPair.0.isValid(result: resultPair.1) {
+                            isValid = false
+                        }
+                    }
+                case .or:
+                    isValid = false
+                    for await resultPair in group {
+                        results.append(resultPair)
+                        if resultPair.0.isValid(result: resultPair.1) {
+                            isValid = true
+                        }
+                    }
                 }
-                return results
+                return CompountValidationResult(
+                    messages: results.flatMap { (validator, result) in validator.generateMessage(result: result) },
+                    boolValue: isValid
+                )
             }
+            var results: [ValidatorResultPair] = []
             switch `operator` {
             case .and:
                 for await resultPair in group {
                     results.append(resultPair)
                     guard resultPair.0.isValid(result: resultPair.1) else {
-                        return results
+                        return CompountValidationResult(
+                            messages: results.flatMap { (validator, result) in validator.generateMessage(result: result) },
+                            boolValue: false
+                        )
                     }
                 }
-                return results
+                return CompountValidationResult(
+                    messages: results.flatMap { (validator, result) in validator.generateMessage(result: result) },
+                    boolValue: true
+                )
             case .or:
                 for await resultPair in group {
                     results.append(resultPair)
                     if resultPair.0.isValid(result: resultPair.1) {
-                        return results
+                        return CompountValidationResult(
+                            messages: results.flatMap { (validator, result) in validator.generateMessage(result: result) },
+                            boolValue: true
+                        )
                     }
                 }
-                return results
+                return CompountValidationResult(
+                    messages: results.flatMap { (validator, result) in validator.generateMessage(result: result) },
+                    boolValue: false
+                )
             }
         }
-        return CompountValidationResult(pairs: pairs, operator: self.operator)
     }
 }
 
 private typealias ValidatorResultPair = (AnyValidator, Any)
 
 private struct CompountValidationResult: BoolConvertible, MessageGenerator {
-    let pairs: [ValidatorResultPair]
-    let `operator`: CompoundValidatorOperator
-
-    var boolValue: Bool {
-        switch `operator` {
-        case .and:
-            return !pairs.contains { validator, result in !validator.isValid(result: result) }
-        case .or:
-            return pairs.contains { validator, result in validator.isValid(result: result) }
-        }
-    }
-
-    var messages: [String] {
-        pairs.flatMap { validator, result in validator.generateMessage(result: result) }
-    }
+    let messages: [String]
+    let boolValue: Bool
 }
 
 private struct PreMapValidator<Value, Result, Output>: Validator {