Complete Traverse performance optimisations

src/FsToolkit.ErrorHandling/List.fs

@@ -5,30 +5,31 @@ module List =
 
   let rec private traverseResultM' (state : Result<_,_>) (f : _ -> Result<_,_>) xs =
     match xs with
-    | [] -> state
+    | [] ->
+      state |> Result.map List.rev
     | x :: xs ->
       let r = result {
         let! y = f x
         let! ys = state
-        return ys @ [y]
+        return y :: ys
       }
       match r with
       | Ok _ -> traverseResultM' r f xs
       | Error _ -> r
 
   let rec private traverseAsyncResultM' (state : Async<Result<_,_>>) (f : _ -> Async<Result<_,_>>) xs =
     match xs with
-    | [] -> state
+    | [] ->
+      state |> AsyncResult.map List.rev
     | x :: xs ->
       async {
         let! r = asyncResult {
           let! ys = state
           let! y = f x
-          return ys @ [y]
+          return y :: ys
         }
         match r with
-        | Ok _ ->
-          return! traverseAsyncResultM' (Async.singleton r) f xs
+        | Ok _ -> return! traverseAsyncResultM' (Async.singleton r) f xs
         | Error _ -> return r
       }
 
@@ -47,28 +48,30 @@ module List =
 
   let rec private traverseResultA' state f xs =
     match xs with
-    | [] -> state
+    | [] ->
+      state |> Result.map List.rev
     | x :: xs ->
       let fR =
         f x |> Result.mapError List.singleton
       match state, fR with
       | Ok ys, Ok y ->
-        traverseResultA' (Ok (ys @ [y])) f xs
+        traverseResultA' (Ok (y :: ys)) f xs
       | Error errs, Error e ->
         traverseResultA' (Error (errs @ e)) f xs
       | Ok _, Error e | Error e , Ok _  ->
         traverseResultA' (Error e) f xs
 
   let rec private traverseAsyncResultA' state f xs =
     match xs with
-    | [] -> state
+    | [] ->
+      state |> AsyncResult.map List.rev
     | x :: xs ->
       async {
         let! s = state
         let! fR = f x |> AsyncResult.mapError List.singleton
         match s, fR with
         | Ok ys, Ok y ->
-          return! traverseAsyncResultA' (AsyncResult.retn (ys @ [y])) f xs
+          return! traverseAsyncResultA' (AsyncResult.retn (y :: ys)) f xs
         | Error errs, Error e ->
           return! traverseAsyncResultA' (AsyncResult.returnError (errs @ e)) f xs
         | Ok _, Error e | Error e , Ok _  ->
@@ -82,12 +85,10 @@ module List =
     traverseResultA id xs
 
   let rec traverseValidationA' state f xs =
-    match state, xs with
-    | Ok items, [] ->
-      Ok (List.rev items)
-    | errors, [] ->
-      errors
-    | _, x :: xs ->
+    match xs with
+    | [] ->
+      state |> Result.map List.rev
+    | x :: xs ->
       let fR = f x
       match state, fR with
       | Ok ys, Ok y ->