Replacing Exceptions with // Maybe / Option

I don't have a compiler, but you can check my ext project language . It is a functional base class library for C #.

For your needs, it has:

• Seq<A>
  
  which is a downside, like a lazy enum that will only evaluate once
• Try<A>
  
  which is a delegate-based monad that allows you to catch exceptions from third-party code.
• Other common monads error handling: Option<A>
  
  , Either<L, R>
  
  etc.
• Bonus versions of these monads: OptionAsync<A>
  
  , TryOption<A>
  
  , TryAsync<A>
  
  ,TryOptionAsync<A>
  
  
• The ability to easily convert between these types: ToOption()
  
  , ToEither()
  
  etc.

To apply a function (LINQ select, map ...) in the lazy list argument of the method and will take each element of the list (lazily) and perform computations that may fail (throwing an exception or returning an Error / Lither), a List that will only be consumed " inside the "third party function, I don't want to iterate over each element more than once."

It's a little unclear what the purpose is. In ext-language, you can do this:

using LanguageExt;
using static LanguageExt.Prelude;

// Dummy lazy enumerable
IEnumerable<int> Values()
{
    for(int i = 0; i < 100; i++)
    {
        yield return UnreliableExternalFunc(i);
    }
}

// Convert to a lazy sequence
Seq<int> seq = Seq(Values());

// Invoke external function that takes an IEnumerable
ExternalFunction(seq);

// Calling it again won't evaluate it twice
ExternalFunction(seq);

      

        
        
        
      

    

But if the function Values()

threw an exception, then it would stop assigning it and return. So you should ideally do this:

// Dummy lazy enumerable
IEnumerable<Try<int>> Values()
{
    for(int i = 0; i < 100; i++)
    {
        yield return Try(() => UnreliableExternalFunc(i));
    }
}

      

        
        
        
      

    

Try

is a constructor function for a monad Try

. So your result will be a sequence of Try

thunks. If you don't care about the exception, you can convert it toOption

// Dummy lazy enumerable
IEnumerable<Option<int>> Values()
{
    for(int i = 0; i < 100; i++)
    {
        yield return Try(() => UnreliableExternalFunc(i)).ToOption();
    }
}

      

        
        
        
      

    

You can access all successes through:

var validValues = Values().Somes();

      

        
        
        
      

    

Or you can use instead Either

:

// Dummy lazy enumerable
IEnumerable<Either<Exception, A>> Values()
{
    for(int i = 0; i < 100; i++)
    {
        yield return Try(() => UnreliableExternalFunc(i)).ToEither();
    }
}

      

        
        
        
      

    

Then you can get reliable results:

var seq = Seq(Values());

var validValues = seq.Rights();

      

        
        
        
      

    

And errors:

var errors = seq.Lefts();

      

        
        
        
      

    

I converted it to Seq

so it doesn't evaluate twice.

Either way, if you want to catch an exception that occurs during lazy evaluation of an enum, then you will need to wrap each value. If an exception might be thrown from using a lazy value, but inside a function, then your only hope is to surround it Try

:

// Convert to a lazy sequence
Seq<int> seq = Seq(Values());  // Values is back to returning IEnumerable<int>

// Invoke external function that takes an IEnumerable
var res = Try(() => ExternalFunction(seq)).IfFail(Seq<int>.Empty);

// Calling it again won't evaluate it twice
ExternalFunction(seq);

      

        
        
        
      

    

Intuitively I tried to convert a list from the Eithers list to any of the list, but this can only be done by using a list with functions. For example, aggregate or decrease (does the Haskell sequence function act the same?).

You can do it in ext language like so:

IEnumerable<Either<L, R>> listOfEithers = ...;

Either<L, IEnumerable<R>> eitherList = listOfEithers.Sequence();

      

        
        
        
      

    

Traverse

also supported:

Either<L, IEnumerable<R>> eitherList = listOfEithers.Traverse(x => map(x));

      

        
        
        
      

    

All combinations of monads support Sequence()

and Traverse

; so you can do it with Seq<Either<L, R>>

to get Either<L, Seq<R>>

, which would ensure that the lazy sequence is not called multiple times. Either a Seq<Try<A>>

to get Try<Seq<A>>

, or any of the asynchronization options for parallel sequencing and traversal.

I'm not sure if this covers something you are asking about, the question is a bit broad. A more specific example would be helpful.