Cycle around Either<> result (a SelfFoldWhile function?)

I have derived this very simple example of a problem that I’m facing:

public class CalculationTest
{
    private static Either<string, decimal> Evaluate(decimal x)
    {
        if (x < 0 || x > 1)
            return "value outside boundaries";
        return x / 2;
    }

    [Fact]
    public void Test()
    {
        decimal x = 0.8M;
        decimal epsilon = 0.00001M;

        while (x >= epsilon)
        {
            Either<string, decimal> v = Evaluate(x).Map(d => x = d);
            
            if (v.IsLeft)
                break;
        }

        Assert.True(x < epsilon);
    }
}

My real code is more complex, but we can recognize the idea: I have a function that can fail (so the return type is an Either<>, with a simple string as the error, in this example), and I need to call it repeatedly progressively approximating the result (that means reusing the returned value).
This is the best formulation that I could find, but I feel there should be a more elegant solution that I don’t see…
What could be a better approach? Thank you.

[louthy]

I assume x changes within the while loop?

There’s a couple of patterns that are relevant here:

• Recursive functions
• Folds

This is a recursive approach

    Recursive(decimal x) =>
        from v in Evaluate(x).Map(d => x = d)
        from r in v < epsilon
                ? Right<string, decimal>(r)
                : Recursive(x + 1)       // this is where the x changes per loop
        select r;

The next way is to turn the x value into a stream of xs and Fold or FoldWhile. You can create a stream of xs by having a for loop that yields an IEnumerable, or use Prelude.unfold:

[ABIOLI-COM]

Oh, I really read it very badly… 😦 Sorry, and thanks again for your patience! Now it’s all clear! Thank you again… AB