Documentation for zip and valdation

Author: Jimmy Byrd

gitbook/validation/ce.md

@@ -0,0 +1,29 @@
+## Validation Computation Expression
+
+Namespace: `FsToolkit.ErrorHandling`
+
+The `Validation` type is defined as:
+
+```fsharp
+type Validation<'a,'err> = Result<'a, 'err list>
+
+
+This CE can take advantage of the [and! operator](https://github.com/fsharp/fslang-suggestions/issues/579) to join multiple error results into a list.
+
+
+## Examples:
+
+### Example 1
+
+The example from [Validation.map3](../validation/map3.md#example-1) can be solved using the `validation` computation expression as below:
+
+```fsharp
+// Validation<int, string>
+let addResult = validation {
+  let! x = tryParseInt "35"
+  and! y = tryParseInt "5"
+  and! z = tryParseInt "2"
+  return add x y z
+}
+```
+

src/FsToolkit.ErrorHandling.JobResult/JobResult.fs

@@ -139,6 +139,7 @@ module JobResult =
   let teeErrorIf predicate f jobResult =
     jobResult |> Job.map (Result.teeErrorIf predicate f)
 
+  /// Takes two results and returns a tuple of the pair
   let zip j1 j2 =
     Job.zip j1 j2
     |> Job.map(fun (r1, r2) -> Result.zip r1 r2)

src/FsToolkit.ErrorHandling.TaskResult/Task.fs

@@ -25,6 +25,8 @@ module Task =
   let map3 f x y z =
     apply (map2 f x y) z
 
+  
+  /// Takes two tasks and returns a tuple of the pair
   let zip (a1 : Task<_>) (a2 : Task<_>) = task {
     let! r1 = a1
     let! r2 = a2

src/FsToolkit.ErrorHandling.TaskResult/TaskResult.fs

@@ -133,6 +133,7 @@ module TaskResult =
   let teeErrorIf predicate f taskResult =
     taskResult |> Task.map (Result.teeErrorIf predicate f)
 
+  /// Takes two results and returns a tuple of the pair
   let zip x1 x2 = 
     Task.zip x1 x2
     |> Task.map(fun (r1, r2) -> Result.zip r1 r2)

src/FsToolkit.ErrorHandling/Async.fs

@@ -19,6 +19,8 @@ module Async =
   let map3 f x y z =
     apply (map2 f x y) z
 
+
+  /// Takes two asyncs and returns a tuple of the pair
   let zip a1 a2 = async {
     let! r1 = a1
     let! r2 = a2

src/FsToolkit.ErrorHandling/AsyncResult.fs

@@ -138,6 +138,8 @@ module AsyncResult =
   let teeErrorIf predicate f asyncResult =
     asyncResult |> Async.map (Result.teeErrorIf predicate f)
 
+
+  /// Takes two results and returns a tuple of the pair
   let zip x1 x2 = 
     Async.zip x1 x2
     |> Async.map(fun (r1, r2) -> Result.zip r1 r2)

src/FsToolkit.ErrorHandling/Result.fs

@@ -157,6 +157,7 @@ module Result =
   let teeError f result =
     teeErrorIf (fun _ -> true) f result
 
+  /// Converts a Result<Async<_>,_> to an Async<Result<_,_>>
   let sequenceAsync (resAsync: Result<Async<'a>, 'b>) : Async<Result<'a, 'b>> =
     async {
       match resAsync with
@@ -172,6 +173,7 @@ module Result =
     | Ok x -> x
     | Error x -> f x
 
+  /// Takes two results and returns a tuple of the pair
   let zip x1 x2 = 
     match x1,x2 with
     | Ok x1res, Ok x2res -> Ok (x1res, x2res)