Finish adding documentation for modules thru Task

Author: tw0po1nt

gitbook/SUMMARY.md

@@ -73,7 +73,7 @@
     * [map](resultOption/map.md)
     * [map2](resultOption/map2.md)
     * [map3](resultOption/map3.md)
-    * [mapError](pr.md)
+    * [mapError](resultOption/mapError.md)
     * [Operators](resultOption/operators.md)
     * [zip](resultOption/zip.md)
     * [zipError](resultOption/zipError.md)
@@ -96,8 +96,8 @@
     * [mapError](asyncResult/mapError.md)
     * [Operators](asyncResult/operators.md)
     * [Other Functions](asyncResult/others.md)
-    * [zip](pr.md)
-    * [zipError](pr.md)
+    * [zip](asyncResult/zip.md)
+    * [zipError](asyncResult/zipError.md)
     * List
       * [traverseAsyncResultM](list/traverseAsyncResultM.md)
       * [sequenceAsyncResultM](list/sequenceAsyncResultM.md)
@@ -139,18 +139,17 @@
       * [ofResult](asyncResultOption/ofResult.md)
 
   * Task
-    * [apply](pr.md)
-    * [bind](pr.md)
-    * [bindV](pr.md)
-    * [catch](pr.md)
-    * [Computation Expression](pr.md)
-    * [ignore](pr.md)
-    * [map](pr.md)
-    * [mapV](pr.md)
-    * [map2](pr.md)
-    * [map3](pr.md)
-    * [ofUnit](pr.md)
-    * [zip](pr.md)
+    * [apply](task/apply.md)
+    * [bind](task/bind.md)
+    * [bindV](task/bindV.md)
+    * [catch](task/catch.md)
+    * [Computation Expression](task/ce.md)
+    * [ignore](task/ignore.md)
+    * [map](task/map.md)
+    * [mapV](task/mapV.md)
+    * [map2](task/map2.md)
+    * [map3](task/map3.md)
+    * [zip](task/zip.md)
     * Transforms
       * [ofUnit](task/ofUnit.md)
 

gitbook/asyncResult/zip.md

@@ -0,0 +1,32 @@
+# AsyncResult.zip
+
+Namespace: `FsToolkit.ErrorHandling`
+
+## Function Signature
+
+```fsharp
+Async<Result<'leftOk, 'error>> -> Async<Result<'rightOk, 'error>> -> Async<Result<'leftOk * 'rightOk, 'error>>
+```
+
+## Examples
+
+### Example 1
+
+```fsharp
+let result = AsyncResult.zip (AsyncResult.ok 1) (AsyncResult.ok 2)
+// async { Ok (1, 2) }
+```
+
+### Example 2
+
+```fsharp
+let result = AsyncResult.zip (AsyncResult.ok 1) (AsyncResult.error "Bad")
+// async { Error "Bad" }
+```
+
+### Example 3
+
+```fsharp
+let result = AsyncResult.zip (AsyncResult.error "Bad1") (AsyncResult.error "Bad2")
+// async { Error "Bad1" }
+```

gitbook/asyncResult/zipError.md

@@ -0,0 +1,32 @@
+# AsyncResult.zipError
+
+Namespace: `FsToolkit.ErrorHandling`
+
+## Function Signature
+
+```fsharp
+Async<Result<'ok, 'leftError>> -> Async<Result<'ok, 'rightError>> -> Async<Result<'ok, 'leftError * 'rightError>>
+```
+
+## Examples
+
+### Example 1
+
+```fsharp
+let result = AsyncResult.zipError (AsyncResult.ok 1) (AsyncResult.ok 2)
+// async { Ok 1 }
+```
+
+### Example 2
+
+```fsharp
+let result = AsyncResult.zipError (AsyncResult.ok 1) (AsyncResult.error "Bad")
+// async { Ok 1 }
+```
+
+### Example 3
+
+```fsharp
+let result = AsyncResult.zipError (AsyncResult.error "Bad1") (AsyncResult.error "Bad2")
+// async { Error("Bad1", "Bad2") }
+```

gitbook/result/zipError.md

@@ -13,20 +13,20 @@ Result<'ok, 'leftError> -> Result<'ok, 'rightError> -> Result<'ok, 'leftError *
 ### Example 1
 
 ```fsharp
-let result = Result.zip (Ok 1) (Ok 2)
+let result = Result.zipError (Ok 1) (Ok 2)
 // Ok  1
 ```
 
 ### Example 2
 
 ```fsharp
-let result = Result.zip (Ok 1) (Error "Bad")
+let result = Result.zipError (Ok 1) (Error "Bad")
 // Ok  1
 ```
 
 ### Example 3
 
 ```fsharp
-let result = Result.zip (Error "Bad1") (Error "Bad2")
+let result = Result.zipError (Error "Bad1") (Error "Bad2")
 // Error("Bad1", "Bad2")
 ```

gitbook/resultOption/mapError.md

@@ -0,0 +1,30 @@
+## ResultOption.mapError
+
+Namespace: `FsToolkit.ErrorHandling`
+
+Function Signature:
+
+```fsharp
+('errorInput -> 'errorOutput) -> Result<'ok option, 'errorInput> -> Result<'ok option, 'errorOutput>
+```
+
+## Examples
+
+### Example 1
+
+From the [ResultOption.map](../resultOption/map.md#example-3) example, if we want to map the error part alone, we can do it as below:
+
+```fsharp
+// string -> int
+let getErrorCode (message: string) =
+    match message with
+    | "bad things happened" -> 1
+    | _ -> 0
+
+let result : Result<string option, int> =
+  Error "bad things happened" // Result<string option, string>
+  |> ResultOption.mapError getErrorCode // Result<string option, int>
+
+// Error 1
+```
+

gitbook/task/apply.md

@@ -0,0 +1,28 @@
+# Task.apply
+
+Namespace: `FsToolkit.ErrorHandling`
+
+Function Signature:
+
+```fsharp
+Task<('a -> 'b)> -> Task<'a> -> Task<'b>
+```
+
+## Examples
+
+Take the following function for example
+
+```fsharp
+// string -> int
+let characterCount (s: string) = s.Length
+```
+
+### Example 1
+
+```fsharp
+let result =
+    Task.singleton "foo" // Task<string>
+    |> Task.apply (Task.singleton characterCount) // Task<int>
+
+// task { 3 }
+```

gitbook/task/bind.md

@@ -0,0 +1,28 @@
+## Task.bind
+
+Namespace: `FsToolkit.ErrorHandling`
+
+Function Signature:
+
+```fsharp
+('a -> Task<'b>>) -> Task<'a> -> Task<'b>
+```
+
+## Examples
+
+Note: Many use-cases requiring `bind` operations can also be solved using [the `task` computation expression](../task/ce.md).
+
+### Example 1
+
+Continuing from the [Task.map2 example](../task/map2.md#example-1) and given the function
+
+```fsharp
+let notifyFollowers : NotifyNewPostRequest -> Task<unit>
+```
+
+we can notify all followers using `Task.bind` as below:
+
+```fsharp
+newPostRequestResult |> Task.bind notifyFollowers
+```
+

gitbook/task/bindV.md

@@ -0,0 +1,32 @@
+## Task.bindV
+
+Namespace: `FsToolkit.ErrorHandling`
+
+Like [Task.bind](../task/bind.md), but taking a `ValueTask<'a>` as input
+
+Function Signature:
+
+```fsharp
+('a -> Task<'b>>) -> ValueTask<'a> -> Task<'b>
+```
+
+## Examples
+
+Note: Many use-cases requiring `bind` operations can also be solved using [the `task` computation expression](../task/ce.md).
+
+### Example 1
+
+Continuing from the [Task.map2 example](../task/map2.md#example-1 and given the function
+
+```fsharp
+let notifyFollowers : NotifyNewPostRequest -> Task<unit>
+```
+
+and assuming `newPostRequestResult` has type `ValueTask<NotifyNewPostRequest>`
+
+we can notify all followers using `Task.bindV` as below:
+
+```fsharp
+newPostRequestResult |> Task.bindV notifyFollowers
+```
+

gitbook/task/catch.md

@@ -0,0 +1,40 @@
+## Task.catch
+
+Namespace: `FsToolkit.ErrorHandling`
+
+Creates a `Task` that attempts to execute the provided task, returning `Choice1Of2` with the result if the task completes without exceptions, or `Choice2Of2` with the exception if an exception is thrown.
+
+Function Signature:
+
+```fsharp
+Task<'a> -> Task<Choice<'a, exn>>
+```
+
+## Examples
+
+Given the function:
+
+```fsharp
+let taskThrow () =
+  task {
+    failwith "something bad happened"
+    return Error ""
+  }
+```
+
+### Example 1
+
+```fsharp
+let result = Task.catch (Task.singleton 42)
+// task { Choice1Of2(42) }
+```
+
+### Example 2
+
+Given the function
+
+```fsharp
+let result = Task.catch (taskThrow ())
+// task { Choice2Of2(exn("something bad happened")) }
+```
+

gitbook/task/ce.md

@@ -0,0 +1,26 @@
+## Task Computation Expression
+
+Namespace: `FsToolkit.ErrorHandling`
+
+## Examples:
+
+### Example 1
+
+Given a personId and an age, find a person and update their age.
+
+```fsharp
+parseInt : string -> int
+findPersonById : int -> Task<Person>
+updatePerson : Person -> Task<unit>
+```
+
+```fsharp
+// Task<unit>
+let addResult = task {
+  let personId = parseInt "3001"
+  let age = parseInt "35"
+  let! person = findPersonById personId
+  let person = { person with Age = age }
+  do! updatePerson person
+}
+```