update docs

Author: meech-ward

README.md

@@ -64,34 +64,11 @@ if let error {
 }
 ```
 
-### Basic Synchronous Usage
-
-```swift
-// Returns (error, result, success)
-let (error, result, success) = mightFail {
-    return "Success"
-}
-
-// Check success
-if success {
-    print(result) // "Success"
-}
-```
-
-### Simplified Return Type
-
-```swift
-// Returns just (error, result)
-let (error, result) = mightFail {
-    return 42
-}
-
-print(result) // 42
-print(error) // nil
-```
 
 ### Handling Errors
 
+Like I said, always guard. So the success case is at the bottom of the function.
+
 #### Traditional Error Handling:
 
 ```swift
@@ -135,6 +112,40 @@ guard success else {
 print("Success! Yum.")
 ```
 
+### Basic Synchronous Usage
+
+```swift
+// Returns (error, result, success)
+let (error, result, success) = mightFail {
+    return "Success"
+}
+
+// Check success
+guard success else {
+    print(error)
+    return
+}
+
+print(result) // "Success"
+```
+
+### Simplified Return Type
+
+```swift
+// Returns just (error, result)
+let (error, result) = mightFail {
+    return 42
+}
+
+guard let result else {
+    print(error) 
+    return
+}
+
+print(result) // 42
+```
+
+
 ### Async Support
 
 ```swift
@@ -195,22 +206,35 @@ for deleteResult in deleteResults.filter({ $0.success == true }) {
 
 ### Optional Values
 
-MightFail handles optional values gracefully:
+If you pass an optional value to mightFail, the first guard is for the error check, you'll need a second guard to see if you have a value.
 
 ```swift
 func returnOptional() throws -> String? {
     return nil
 }
 
-let (error, result, success) = mightFail {
+let (error, result) = mightFail {
     try returnOptional()
 }
 
-// success will be true
-// result will be nil
-// error will be nil
+// result is String??
+guard let result else {
+    // there was an error, handle it 
+    print(error)
+    return
+}
+
+guard let result else {
+   // no error, but result is nil, handle it 
+   print("No result")
+   return
+}
+
+print(result) // "Success"
 ```
 
+---
+
 # do, try, catch is bad
 
 I think throwing exceptions is nice, I like that an exception breaks control flow and I like exception propogation. The only thing I don't like catching exceptions.

Sources/MightFail/MightFail.docc/GettingStarted.md

@@ -10,7 +10,7 @@ Add MightFail as a dependency to your `Package.swift`:
 
 ```swift
 dependencies: [
-    .package(url: "https://github.com/might-fail/swift.git", from: "0.1.0")
+    .package(url: "https://github.com/might-fail/swift.git", from: "0.2.1")
 ]
 ```
 
@@ -65,9 +65,12 @@ let (error, result, success) = mightFail {
 }
 
 // Check success
-if success {
-    print(result) // "Success"
+guard success else {
+    print(error)
+    return
 }
+
+print(result) // "Success"
 ```
 
 ### Simplified Return Type
@@ -78,8 +81,12 @@ let (error, result) = mightFail {
     return 42
 }
 
+guard let result else {
+    print(error)
+    return
+}
+
 print(result) // 42
-print(error) // nil
 ```
 
 ### Handling Errors
@@ -153,12 +160,13 @@ let results = mightFail([
 ])
 
 // Check results
-results.forEach { (error, result) in
-    guard let result else {
-        print("Error: \(error)")
-        return
+for (index, (error, result, success)) in results.enumerated() {
+    guard success else {
+        print("Operation \(index + 1) failed with error: \(error)")
+        continue
     }
-    print("Result: \(result)")
+    
+    print("Operation \(index + 1) succeeded with result: \(result!)")
 }
 ```
 
@@ -185,18 +193,29 @@ for deleteResult in deleteResults.filter({ $0.success == true }) {
 
 ### Optional Values
 
-MightFail handles optional values gracefully:
+If you pass an optional value to mightFail, the first guard is for the error check, you'll need a second guard to see if you have a value.
 
 ```swift
 func returnOptional() throws -> String? {
     return nil
 }
 
-let (error, result, success) = mightFail {
+let (error, result) = mightFail {
     try returnOptional()
 }
 
-// success will be true
-// result will be nil
-// error will be nil
+// result is String??
+guard let result else {
+    // there was an error, handle it 
+    print(error)
+    return
+}
+
+guard let result else {
+   // no error, but result is nil, handle it 
+   print("No result")
+   return
+}
+
+print(result) // "Success"
 ```

Sources/MightFail/MightFail.docc/MightFail.md

@@ -4,19 +4,23 @@ A Swift package for handling potentially failing operations with ease.
 
 ## Overview
 
-MightFail provides a set of functions to handle operations that might throw errors, allowing you to handle success and failure cases without using do-catch blocks.
+MightFail provides a set of functions to handle operations that might throw errors, allowing you to handle success and failure cases without using do-catch blocks. It works with both synchronous and asynchronous code.
+
+Visit the [GitHub repository](https://github.com/might-fail/swift.git) for more information, issues, and contributions.
 
 ## Topics
 
 ### Essentials
 
 - <doc:GettingStarted>
+- <doc:DoTryCatchIsBad>
+- <doc:OtherLanguages>
 
 ### Functions
 
-<!-- - `mightFail(_:)-5owtv`
-- `mightFail(_:)-1gr5o`
-- `mightFail(_:)-7bt4a`
-- `mightFail(_:)-1m6lj`
-- `mightFail(_:)-2s1e4`
-- `mightFail(_:)-8avrp` -->
+- ``mightFail(_:)-90d29`` - Sync with success
+- ``mightFail(_:)-cq0w`` - Async with success
+- ``mightFail(_:)-51klq`` - Sync without success
+- ``mightFail(_:)-2mkjp`` - Async without success
+- ``mightFail(_:)-1rji`` - Multiple sync operations
+- ``mightFail(_:)-4qoxi`` - Multiple async operations

Tests/MightFailTests/MightFailTests.swift

@@ -219,9 +219,21 @@ enum TestError: Error, Equatable {
       try returnStringOptional()
     }
 
-    #expect(success)
-    #expect(result == nil)
-    #expect(error == nil)
+    guard let result else {
+      print("failed and there is an error")
+      throw TestError.withMessage("Failed operation")
+    }
+
+    guard let result else {
+      // this is just checking if there's a value
+      // should have no value in this case
+      #expect(success)
+      #expect(result == nil)
+      #expect(error != nil)
+      return
+    }
+
+    throw TestError.withMessage("Failed operation \(result)")
   }
 
   @Test("Handling optional values")
@@ -233,9 +245,18 @@ enum TestError: Error, Equatable {
       try returnStringOptional()
     }
 
+    guard let result else {
+      print("failed and there is an error \(error)")
+      throw TestError.withMessage("Failed operation")
+    }
+    guard let result else {
+      // just checking if there's a value
+      throw TestError.withMessage("Failed operation")
+    }
+
     #expect(success)
     #expect(result == "Hello")
-    #expect(error == nil)
+    #expect(error != nil)
   }
 
   // Add these tests in the "Asynchronous Tests" section
@@ -247,10 +268,21 @@ enum TestError: Error, Equatable {
     let (error, result, success) = await mightFail {
       try await returnStringOptional()
     }
+    guard let result else {
+      print("failed and there is an error")
+      throw TestError.withMessage("Failed operation")
+    }
+    guard let result else {
+      // this is just checking if there's a value
+      // should have no value in this case
+      #expect(success)
+      #expect(result == nil)
+      #expect(error != nil)
+      return
+    }
+
+    throw TestError.withMessage("Failed operation \(result)")
 
-    #expect(success)
-    #expect(result == nil)
-    #expect(error == nil)
   }
 
   @Test("Handling async optional values")
@@ -262,9 +294,18 @@ enum TestError: Error, Equatable {
       try await returnStringOptional()
     }
 
+    guard let result else {
+      print("failed and there is an error \(error)")
+      throw TestError.withMessage("Failed operation")
+    }
+    guard let result else {
+      // just checking if there's a value
+      throw TestError.withMessage("Failed operation")
+    }
+
     #expect(success)
     #expect(result == "Hello")
-    #expect(error == nil)
+    #expect(error != nil)
   }
 
 }