Awesome

SharpX

SharpX is derived from CSharpx 2.8.0-rc.2 (which was practically a stable) and RailwaySharp 1.2.2. While both projects were meant mainly for source inclusion, SharpX is designed to be pulled from NuGet.

The library contains functional types and other utilities, including test oriented tools. It follows the don't reinvent the wheel philosophy. This project was originally inspired by Real-World Functional Programming and includes code from MoreLINQ.

Target

• .NET Standard 2.0

Install via NuGet

You can install it via NuGet:

$ dotnet add package SharpX --version 6.4.6
  Determining projects to restore...
  ...

Overview

All types are available in the root namespace. Extension methods (except the very specific ones) are in SharpX.Extensions. SharpX.FsCheck contains FsCheck generators for property-based testing.

Maybe

• Encapsulates an optional value that can contain a value or being empty.
• Similar to F# 'T option / Haskell data Maybe a = Just a | Nothing type.

var greet = true;
var value = greet ? "world".ToMaybe() : Maybe.Nothing<string>();
value.Match(
    who => Console.WriteLine($"hello {who}!"),
    () => Environment.Exit(1));

• Supports LINQ syntax:

var result1 = (30).ToJust();
var result2 = (10).ToJust();
var result3 = (2).ToJust();

var sum = from r1 in result1
          from r2 in result2
          where r1 > 0
          select r1 - r2 into temp
          from r3 in result3
          select temp * r3;

var value = sum.FromJust(); // outcome: 40

• Features sequence extensions:

var maybeFirst = new int[] {0, 1, 2}.FirstOrNothing(x => x == 1)
// outcome: Just(1)

Either

• Represents a value that can contain either a value or an error.
• Similar to Haskell data Either a b = Left a | Right b type.
• Similar also to F# Choice<'T, 'U>.
• Like in Haskell the convention is to let Right case hold the value and Left keep track of error or similar data.
• If you want a more complete implementation of this kind of types, consider using Result.

Result

This type was originally present in RailwaySharp. Check the test project to see a more complete usage example.

public static Result<Request, string> ValidateInput(Request input)
{
    if (input.Name == string.Empty) {
        return Result<Request, string>.FailWith("Name must not be blank");
    }
    if (input.EMail == string.Empty) {
        return Result<Request, string>.FailWith("Email must not be blank");
    }
    return Result<Request, string>.Succeed(input);
}

var request = new Request { Name = "Giacomo", EMail = "gsscoder@gmail.com" };
var result = Validation.ValidateInput(request);
result.Match(
    (x, msgs) => { Logic.SendMail(x.EMail); },
    msgs => { Logic.HandleFailure(msgs) });

Outcome

• Represents a value that can be a success or a failure in form of a type that can contains a custom error message and optionally an exception.

Outcome ValidateArtifact(Artifact artifact)
{
    try {
        artifact = ArtifactManager.Load(artifact.Path);
    }
    catch (IOException e) {
        return Result.Failure($"Unable to load artifcat {path}:\n{e.Message}", exception: e);
    }
    return artifact.CheckIntegrity() switch {
        Integrity.Healthy => Outcome.Success(),
        _                 => Outcome.Failure("Artifact integrity is compromised")
    };
}

if (ValidateArtifact(artifact).MatchFailure(out Error error)) {
    //Error::ToString creates a string with message and exception details
    _logger.LogError(error.Exception.FromJust(), error.ToString());
    Environment.Exit(1);
}
// do something useful with artifact

Unit

• Unit is similar to void but, since it's a real type. void is not, in fact you can't declare a variable of that type. Unit allows the use functions without a result in a computation (functional style). It's essentially F# unit and Haskell Unit.

// prints each word and returns 0 to the shell
static int Main(string[] args)
{
    var sentence = "this is a sentence";
    return (from _ in
            from word in sentence.Split()
            select Unit.Do(() => Console.WriteLine(word))
            select 0).Distinct().Single();
}

FSharpResultExtensions

• Convenient extension methods to consume FSharpResult<T, TError> in simple and functional for other .NET languages.

// pattern match like
var result = Query.GetStockQuote("ORCL");
result.Match(
    quote => Console.WriteLine($"Price: {quote.Price}"),
    error => Console.WriteLine($"Trouble: {error}"));
// mapping
var result = Query.GetIndex(".DJI");
result.Map(
    quote => CurrencyConverter.Change(quote.Price, "$", "€"));

• Blog post about it.

StringExtensions

• General purpose and randomness string manipulation extensions. Few more methods and non-extension version can be found in Strings class.

Console.WriteLine(
    "\t[hello\world@\t".Sanitize(normalizeWhiteSpace: true));
// outcome: ' hello world '

Console.WriteLine(
    "I want to change a word".ApplyAt(4, word => word.Mangle()));
// outcome like: 'I want to change &a word'

EnumerableExtensions

• Most useful extension methods from MoreLINQ.
• Some of these reimplemnted (e.g. Choose using Maybe):

var numbers = new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
var evens = numbers.Choose(x => x % 2 == 0
                                ? x.ToJust()
                                : Maybe.Nothing<int>());
// outcome: {0, 2, 4, 6, 8}

• With other useful methods too:

var sequence = new int[] {0, 1, 2, 3, 4}.Intersperse(5);
// outcome: {0, 5, 1, 5, 2, 5, 3, 5, 4}
var element = sequence.Choice();
// will choose a random element
var sequence = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }.ChunkBySize(3);
// outcome: { [0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10] }

Icon

Tool icon designed by Cattaleeya Thongsriphong from The Noun Project