Use throwing closures instead of Swift.Result

Author: griotspeak

Sources/DiscriminatedUnionMacros/DiscriminatedUnionMacro.swift

@@ -229,11 +229,11 @@ private struct TupleExtractionPropertyGenerator {
 
         return """
             
-            public static func tupleFrom\(raw: titleCasedName)(_ instance: Self) -> Swift.Result<\(raw: tupleType), PayloadExtractionError> {
+            public static func tupleFrom\(raw: titleCasedName)(_ instance: Self) throws(PayloadExtractionError) -> \(raw: tupleType) {
                 if case .\(raw: caseName)(\(raw: pBindings)) = instance {
-                    .success(\(raw: returnValue(parameterClause: parameterClause)))
+                    return \(raw: returnValue(parameterClause: parameterClause))
                 } else {
-                    .failure(.invalidExtraction(expected: .\(raw: caseName), actual: instance.discriminant))
+                    throw .invalidExtraction(expected: .\(raw: caseName), actual: instance.discriminant)
                 }
             }
             

Tests/DiscriminatedUnionTests/DiscriminatedUnionTests.swift

@@ -85,27 +85,27 @@ enum Pet {
         case invalidExtraction(expected: Discriminant, actual: Discriminant)
     }
 
-    public static func tupleFromCat(_ instance: Self) -> Swift.Result<Bool, PayloadExtractionError> {
+    public static func tupleFromCat(_ instance: Self) throws(PayloadExtractionError) -> Bool {
         if case .cat(let curious) = instance {
-            .success(curious)
+            return curious
         } else {
-            .failure(.invalidExtraction(expected: .cat, actual: instance.discriminant))
+            throw .invalidExtraction(expected: .cat, actual: instance.discriminant)
         }
     }
 
-    public static func tupleFromBird(_ instance: Self) -> Swift.Result<(name: String, Int), PayloadExtractionError> {
+    public static func tupleFromBird(_ instance: Self) throws(PayloadExtractionError) -> (name: String, Int) {
         if case .bird(let name, let index1) = instance {
-            .success((name, index1))
+            return (name, index1)
         } else {
-            .failure(.invalidExtraction(expected: .bird, actual: instance.discriminant))
+            throw .invalidExtraction(expected: .bird, actual: instance.discriminant)
         }
     }
 
-    public static func tupleFromHydra(_ instance: Self) -> Swift.Result<(() -> String, String), PayloadExtractionError> {
+    public static func tupleFromHydra(_ instance: Self) throws(PayloadExtractionError) -> (() -> String, String) {
         if case .hydra(let index0, let index1) = instance {
-            .success((index0, index1))
+            return (index0, index1)
         } else {
-            .failure(.invalidExtraction(expected: .hydra, actual: instance.discriminant))
+            throw .invalidExtraction(expected: .hydra, actual: instance.discriminant)
         }
     }
 }