Implements while loops in simple way

Author: TheAngryByrd

src/FsToolkit.ErrorHandling/OptionCE.fs

@@ -74,13 +74,15 @@ module OptionCE =
                 [<InlineIfLambda>] generator: unit -> unit option
             ) : unit option =
 
-            let rec whileBuilder () =
-                if guard () then
-                    this.Bind(this.Run(fun () -> generator ()), (fun () -> this.Run(fun () -> whileBuilder ())))
-                else
-                    this.Zero()
-
-            this.Run(fun () -> whileBuilder ())
+            let mutable doContinue = true
+            let mutable result = Some ()
+            while doContinue && guard () do
+                match generator () with
+                | Some () -> ()
+                | None ->
+                    doContinue <- false
+                    result <- None
+            result
 
         member inline this.For
             (

src/FsToolkit.ErrorHandling/ResultCE.fs

@@ -75,13 +75,36 @@ module ResultCE =
                 [<InlineIfLambda>] generator: unit -> Result<unit, 'error>
             ) : Result<unit, 'error> =
 
-            let rec whileBuilder () =
-                if guard () then
-                    this.Bind(this.Run(fun () -> generator ()), (fun () -> this.Run(fun () -> whileBuilder ())))
-                else
-                    this.Zero()
-
-            this.Run(fun () -> whileBuilder ())
+            let mutable doContinue = true
+            let mutable result = Ok ()
+            while doContinue && guard () do
+                match generator () with
+                | Ok () -> ()
+                | Error e ->
+                    doContinue <- false
+                    result <- Error e
+            result
+            // let rec whileBuilder () =
+            //     if guard () then
+            //         this.Bind(this.Run(fun () -> generator ()), (fun () -> this.Run(fun () -> whileBuilder ())))
+            //     else
+            //         this.Zero()
+
+            // this.Run(fun () -> whileBuilder ())
+
+            // if guard () then
+            //     let mutable whileBuilder = Unchecked.defaultof<_>
+
+            //     whileBuilder <-
+            //         fun () ->
+            //             this.Bind(
+            //                 this.Run generator,
+            //                 (fun () -> if guard () then this.Run whileBuilder else this.Zero())
+            //             )
+
+            //     this.Run whileBuilder
+            // else
+            //     this.Zero()
 
 
         member inline this.For

src/FsToolkit.ErrorHandling/ValidationCE.fs

@@ -74,13 +74,15 @@ module ValidationCE =
                 [<InlineIfLambda>] guard: unit -> bool,
                 [<InlineIfLambda>] generator: unit -> Validation<unit, 'error>
             ) : Validation<unit, 'error> =
-            let rec whileBuilder () =
-                if guard () then
-                    this.Bind(this.Run(fun () -> generator ()), (fun () -> this.Run(fun () -> whileBuilder ())))
-                else
-                    this.Zero()
-
-            this.Run(fun () -> whileBuilder ())
+            let mutable doContinue = true
+            let mutable result = Ok ()
+            while doContinue && guard () do
+                match generator () with
+                | Ok () -> ()
+                | Error e ->
+                    doContinue <- false
+                    result <- Error e
+            result
 
         member inline this.For
             (

src/FsToolkit.ErrorHandling/ValueOptionCE.fs

@@ -73,13 +73,15 @@ module ValueOptionCE =
                 [<InlineIfLambda>] generator: unit -> _ voption
             ) : _ voption =
 
-            let rec whileBuilder () =
-                if guard () then
-                    this.Bind(this.Run(fun () -> generator ()), (fun () -> this.Run(fun () -> whileBuilder ())))
-                else
-                    this.Zero()
-
-            this.Run(fun () -> whileBuilder ())
+            let mutable doContinue = true
+            let mutable result = ValueSome ()
+            while doContinue && guard () do
+                match generator () with
+                | ValueSome () -> ()
+                | ValueNone ->
+                    doContinue <- false
+                    result <- ValueNone
+            result
 
         member inline this.For
             (

tests/FsToolkit.ErrorHandling.Tests/OptionCE.fs

@@ -144,8 +144,23 @@ let ceTests =
                     Expect.equal index maxIndex "Index should reach maxIndex"
                     Expect.equal actual (Some data) "Should be ok"
         ]
-        
-            
+
+        testCase "while bind error" <| fun () ->
+            let items = [Some 3; Some 4; None]
+
+            let mutable index = 0
+
+            let actual = option {
+                while index < items.Length do
+                    let! _ = items[index]
+                    index <- index + 1
+
+                return index
+            }
+            Expect.equal index (items.Length - 1) "Index should reach maxIndex"
+            Expect.equal actual (None) "Should be NOPE"
+
+
         testCase "For in"
         <| fun () ->
             let data = 42

tests/FsToolkit.ErrorHandling.Tests/ResultCE.fs

@@ -250,6 +250,21 @@ let ``ResultCE loop Tests`` =
                     Expect.equal index (maxIndex) "Index should reach maxIndex"
                     Expect.equal actual (Ok data) "Should be ok"
         ]
+        testCase "while bind error" <| fun () ->
+            let items = [Ok 3; Ok 4; Error "NOPE"]
+
+            let mutable index = 0
+
+            let actual = result {
+                while index < items.Length do
+                    let! _ = items[index]
+                    index <- index + 1
+
+                return index
+            }
+            Expect.equal index (items.Length - 1) "Index should reach maxIndex"
+            Expect.equal actual (Error "NOPE") "Should be NOPE"
+
         testCase "for in"
         <| fun () ->
             let data = 42

tests/FsToolkit.ErrorHandling.Tests/ValidationCE.fs

@@ -295,6 +295,20 @@ let ``ValidationCE loop Tests`` =
                     Expect.equal index maxIndex "Index should reach maxIndex"
                     Expect.equal actual (Ok data) "Should be ok"
         ]
+        testCase "while bind error" <| fun () ->
+            let items = [Ok 3; Ok 4; Error "NOPE"]
+
+            let mutable index = 0
+
+            let actual = validation {
+                while index < items.Length do
+                    let! _ = items[index]
+                    index <- index + 1
+
+                return index
+            }
+            Expect.equal index (items.Length - 1) "Index should reach maxIndex"
+            Expect.equal actual (Error ["NOPE"]) "Should be NOPE"
         testCase "for in"
         <| fun () ->
             let data = 42

tests/FsToolkit.ErrorHandling.Tests/ValueOptionCE.fs

@@ -147,6 +147,22 @@ let ceTests =
                     Expect.equal index maxIndex "Index should reach maxIndex"
                     Expect.equal actual (ValueSome data) "Should be ok"
         ]
+
+        testCase "while bind error" <| fun () ->
+            let items = [ValueSome 3; ValueSome 4; ValueNone]
+
+            let mutable index = 0
+
+            let actual = voption {
+                while index < items.Length do
+                    let! _ = items[index]
+                    index <- index + 1
+
+                return index
+            }
+            Expect.equal index (items.Length - 1) "Index should reach maxIndex"
+            Expect.equal actual (ValueNone) "Should be NOPE"
+
         testCase "For in"
         <| fun () ->
             let data = 42