Language-ext: Chaining methods - Breaking out when first method provides a Some(x)

[TonyHernandezAtMS]

First, I love this library. I'm learning so much about FP and this library has helped me a ton!

Question: How do I take the imperative logic below and make it FP using the library?

Problem - Get the first Some value from a chain of delegates that call external sources or provide a default value

I was reading your wiki page on Function Signatures. You stated it is best to stay in context and use Match as a last resort when you need to get to the bound values. I'm trying to figure out the best way to build a pipeline and stay in context _(I assume this means that evaluation stays lazy and at the end of the pipeline, I end up with something monadic over T)_.

Requirements

• Chain of external sources will return an Option<string>.
• All external calls should catch exceptions, write them to our telemetry client through an Action<Exception> delegate. and return an Option<string>.None.
• At the end of the chain of external calls, if the current result is still None then return a default value provided by a Func<string> getDefaultValue = () => {...} delegate.
• Keep everything lazy. No delegates should be called unless they are needed.
  
  
  
  • Even better if we could memoize some calls but not others.
    
    

    Example - Imperative

  
  

static readonly Action<Exception> WriteExceptionsToTelemetryClient = (Exception ex) => {...};
static Option<string> HandleDelegatesToExternalSources(Func<string> GetStringFromExternalSource)
{
    Option<string> result;
    try
    {
        result = GetStringFromExternalSource();
    }
    catch (Exception ex)
    {
        WriteExceptionsToTelemetryClient(ex);
        result = Option<string>.None;
    }
    return result;
}

static readonly Func<string> GetStringFromFirstExternalSource = () =>  throw new Exception();
static readonly Func<string> GetStringFromSecondExternalSource = () => null;
static readonly Func<Some<string>> GetStringFromSourceThatDoesntThrowExceptions = () => LanguageExt.Some.Create<string>("foo");

// Function signature indicates that caller gets an Option in Some state. Returning None is not an option.
static Some<string> GetString()
{
    Option<string> result;

    // First external source
    result = HandleDelegatesToExternalSources(GetStringFromFirstExternalSource);
    if (result.IsSome) return new Some<string>(result);

    // Second external source
    result = HandleDelegatesToExternalSources(GetStringFromSecondExternalSource);
    if (result.IsSome) return new Some<string>(result);

    // Default value
    return GetStringFromSourceThatDoesntThrowExceptions();
}

The result of calling GetString() is Some<string>("foo"). Also the Telemetry Client wrote an exception.

[louthy]

I'd do something like this:

```c#
using LanguageExt;
using static LanguageExt.Prelude;
using System;

namespace ConsoleApp11
{
public static class Telemetry
{
public static readonly Action Client = (Exception ex) =>
{
Console.WriteLine(ex.Message);
};
}

public static class TryExtensions
{
    public static Try<A> LogFailures<A>(this Try<A> ma) =>
        ma.Match(
            Succ: x => Try(x),
            Fail: ex =>
            {
                Telemetry.Client(ex);
                return Try<A>(ex);
            });
}

class Program
{
    static readonly Func<string> GetStringFromFirstExternalSource = () => throw new Exception();
    static readonly Func<string> GetStringFromSecondExternalSource = () => null;
    static readonly Func<string> GetStringFromSourceThatDoesntThrowExceptions = () => LanguageExt.Some.Create<string>("foo");

    static string GetStringOrDefault() =>
       GetString().IfNone(GetStringFromSourceThatDoesntThrowExceptions());

    static Option<string> GetString() =>
        Get(Seq(GetStringFromFirstExternalSource, GetStringFromSecondExternalSource));

    static Option<A> Get<A>(Seq<Func<A>> delegates) =>
        delegates.FoldWhile(
            Option<A>.None,
            (state, fun) => Try(fun).LogFailures().ToOption(),
            (state) => state.IsNone);
}

}
```

Personally I wouldn't bother so much with the Some<A> type, mostly because now that I always use Option for optional values, when I see a reference type that isn't an Option then I know it should never be null. This does require a certain amount of team discipline obviously.

You'll notice I created an extension method for Try<A> for logging, this is only required if you don't use the built in error-logger in TryConfig, and instead you want to make a decision on a case-by-case basis whether you want to log or not.

I have split the GetString method up into a more general Get and then less general GetString, and GetStringOrDefault method. This makes each function much simpler and easier to reason about.

One thing I'd warn against is the path you appear to be going down of creating lots of 'global' fields. That's going to get you in to trouble quite quickly. Consider either passing external IO functions through to the functions, or trying to move IO to the edges, or build your own monadic types to capture IO operations.

Pure functions are your best friend, and that's where you'll get the most wins from taking a functional approach.

[TonyHernandezAtMS]

Thanks! Can you explain what you mean by "global" fields? I've been struggling with how to handle connections, clients, telemetry, etc.

[MrYossu]

@louthy Wow, another amazing reply! I wish you would turn these replies into articles, there is sooo much useful info in here, and it just gets lost when the issue is closed.

Anyway, I'm working my way through this, trying to understand it all, but am struggling to understand what the Reader monad is used for. You created a Div function that takes two strings, and attempts to divide their int values. Please can you explain a) how you would use such a function, as I can't see what you do with the Reader<World, int> that is returned, and b) what the Reader adds here that you didn't have with the code you showed earlier.

Thanks again for another great article

[MrYossu]

@louthy Paul, I know you just closed this, but is there any chance you could answer the two questions I asked on Feb 7?

Thanks