FunctionalExtensions.Nuget 0.0.25

FunctionalExtensions

This library extends C# to provide a set of functional programming features.

Unlike other libraries attempting the same, here the idea is to build a simple, light-weight set of helpers and types to make functional programming easier and more idiomatic, but without twisting too much the language and accepting the imperative nature of C#, as well as it's inherent limitations.

Therefore, between a clear, intuitive C# syntax and a perfect functional implementation, the choice will always fall on the first one.

If what you see reminds you Scala it's not a coincidence. Scala is what I'm using as reference for it's hybrid nature that makes it a good example of what C# could aim to be.

• Option
• Try and Functional Try
• Functional If

Option

Scala Reference

Represent an optional value. Instances of Option<T> are either an instance of Some<T> or None<T>.

The most idiomatic way to use an Option<T> instance is to treat it as a collection with 0 or 1 elements and use Map, FlatMap, Filter and Foreach

Creating an Option

Explicit:

var option = Option.Some("value"); // Throw exception if null
var option = Option.None<string>();

From value:

var option = Option.From("value"); // Option is Some("value")
var option = Option.From((string)null); // Option is None

Implicit conversion:

Option<string> option = "value"; // Option is Some("value")
Option<string> option = (string)null; // Option is None

Pattern Matching and Deconstruction

var result = myOption switch
{
    Some<string>(var value) => value,
    _ => "default"
};

Option Members

Try and Functional Try

Scala Reference

The Try type represents a computation that may either result in an exception, or return a successfully computed value. It's similar to, but semantically different from the Either type.

Instances of Try<T>, are either an instance of Success<T> or Failure<T>.

For example, Try can be used to evaluate non-pure functions, without the need to do explicit exception-handling in all of the places that an exception might occur.

Creating a Try

Functional Try:

var tryObj = Try.Eval(() => "value".ToUpper()); // Try is Success("VALUE")
var tryObj = Try.Eval(() => ((string)null).ToUpper()); // Try is Failure(error)

Explicit:

var tryObj = Try.Success("value"); // Try is Success("value")
var tryObj = Try.Failure<string>(new Exception());  // Try is Failure(error)

From value:

var tryObj = Try.From("value"); // Try is Success("value")
var tryObj = Try.From<string>(new Exception());  // Try is Failure(error)

Implicit conversion:

Try<string> tryObj = "value"; // Try is Success("value")
Try<string> tryObj = new Exception();  // Try is Failure(error)

Pattern Matching and Deconstruction

var result = tryObj switch
{
    Success<string>(var value) => value,
    Failure<string>(var error) => error.Message
};

Try Members

Functional If

Usage

Exhaustive matching:

var result = If
    .Eval(
        () => value == 1,
        () => "value1")
    .ElseIf(
        () => value == 2,
        () => "value2")
    .ElseIf(
        () => value == 3,
        () => "value3")
    .Else(
        () => "default");

Partial matching:

Return Some(value) if a predicate was satisfied, None otherwise

var option = If
    .Eval(
        () => value == 1,
        () => "value1")
    .ElseIf(
        () => value == 2,
        () => "value2")
    .ElseIf(
        () => value == 3,
        () => "value3")
    .ToOption();