We're planting a tree for every job application! Click here to learn more

Error-Free C# Part I: The Maybe Monad

Eleanor Holley

27 Jan 2021

•

4 min read

Error-Free C# Part I: The Maybe Monad
  • Monads

Most people would probably be surprised to find that I consider myself both a professional C# developer and a professional functional programmer. C# is mainly an object-oriented language. The syntax isn't optimized for functional programming. This is entirely true, but just because Microsoft is behind the curve in supporting the new best practices in programming doesn't mean I have to be. This series will walk through how to build and use C# code that is guaranteed to run without any runtime errors.

The first class of errors to eliminate is the NullReferenceException. I want to emphasize: just because you use a mainly object-oriented language doesn't mean you have to live with tedious, manual null checking and occasional NullReferenceExceptions. You don't have to, especially if your language supports anonymous functions, and indeed C# does. We can eliminate the possibility of NullReferenceException by wrapping nullable values in a maybe monad.

In functional languages, a "maybe" is an interface over two possibilities: a"some" which has a value and a "none" which does not. Let's start there.

Maybe.cs

public interface IMaybe<T>{}

Now we need to decide how to control the construction of Some. Often, C# encourages throwing a NullArgumentException. However, this isn't a good practice as long as we have any other options, and we do. We are going to use the internal keyword here, thus following both the object-oriented best-practice of hiding implementations and the functional best-practice of making invalid states unrepresentable.

Some.cs

public class Some<T> : IMaybe<T>
{ 
    private T member; 
    internal Some(T member) { this.member = member; }
}

None.cs

public class None<T> : IMaybe<T>
{
}

Now we can add the following static class to our Maybe.cs. You can think oft his as the DRY principle of null checks. We will do this once here and never repeat our null check anyplace else in our code.

Maybe.cs

public interface IMaybe<T>
{
}

public static class Maybe
{
    public IMaybe<T> Factory(T member) 
      => member == null ? new None<T>() ? new Some<T>(member);
}

Congratulations, we've just written the last-ever null check.

Our "maybe" interface can prevent us from trying to interact with an object that isn't there. Let's add a method to allow for this interaction.

Maybe.cs

public interface IMaybe<T>
{ 
    /// <summary> 
    /// applies `func` if and only if object exists 
    /// </summary> 
    /// <returns>a new Some of the result, or None if this is None</returns> 
    IMaybe<TNext> Map<TNext>(Func<T, TNext> func);
}

public static class Maybe
{ 
    public IMaybe<T> Factory(T member) 
      => member == null ? new None<T>() ? new Some<T>(member);
}

Some.cs

public class Some<T> : IMaybe<T>
{ 
    private T member; 
    internal Some(T member) 
    { 
        this.member = member; 
    } 

    public IMaybe<TNext> Map<TNext>(Func<T, TNext> func) 
      => Maybe.Factory(func(member));
}

None.cs

public class None<T> : IMaybe<T>
{ 
    IMaybe<TNext> Map<TNext>(Func<T, TNext> func) 
      => new None<TNext>();
}

Now we can see how monads protect us. Every time we have an IMaybe, we can interact with it by calling .Map(), and if it turns out to be a None, it fails silently.

But what if we need to unwrap the value? We can do this safely by providing a fallback function. Let's implement a new method called Match (because it functions like a pattern match in functional programming).

Maybe.cs

public interface IMaybe<T>
{ 
    /// <summary> 
    /// applies `func` if and only if object exists 
    /// </summary> 
    /// <returns>a new Some of the result, or None if this is None</returns> 
    IMaybe<TNext> Map<TNext>(Func<T, TNext> func); 
    /// <summary> 
    /// applies `some` if value is present or `none` if no value.
    /// </summary> 
    /// <returns> an unwrapped value.</returns>
    TNext Match<TNext>(Func<T, TNext> some, Func<TNext> none);
}

public static class Maybe
{ 
    public IMaybe<T> Factory(T member) 
      => member == null ? new None<T>() ? new Some<T>(member);
}

Some.cs

public class Some<T> : IMaybe<T>
{ 
    private T member; 
    internal Some(T member) 
    { 
        this.member = member; 
    } 
    
    public IMaybe<TNext> Map<TNext>(Func<T, TNext> func) 
      => Maybe.Factory(func(member)); 
    
    public TNext Match<TNext>(Func<T, TNext> some, Func<TNext> none) 
      => some(member);
}

None.cs

public class None<T> : IMaybe<T>
{ 
    public IMaybe<TNext> Map<TNext>(Func<T, TNext> func) 
        => new None<TNext>(); 
    public TNext Match<TNext>(Func<T, TNext> some, Func<TNext> none) 
        => none();
}

Now, because we started with an IMaybe, we don't need to worry about whether or not we remembered to include a default value every time we unwrapped our unsafe value--the C# compiler will simply not allow us to write this kind of bug anymore.

This code can be a little clunky to work with, however, if we're safely wrapping every nullable value. We would end up with nested IMaybe monads that quickly become difficult to read and understand. We can greatly simplif your code if we include an option to FlatMap our IMaybes together, like so:

Maybe.cs

public interface IMaybe<T>
{ 
    /// <summary> 
    /// applies `func` and then flattens the result if the value
    /// exists. 
    /// </summary> 
    IMaybe<TNext> FlatMap<TNext>(Func<T, IMaybe<TNext>> func); 

    /// <summary> 
    /// applies `func` if and only if object exists 
    /// </summary> 
    /// <returns>a new Some of the result, or None if this is None</returns> 
    IMaybe<TNext> Map<TNext>(Func<T, TNext> func); 

    /// <summary> 
    /// applies `some` if value is present or `none` if no value.
    /// </summary> 
    /// <returns> an unwrapped value. 
    TNext Match<TNext>(Func<T, TNext> some, Func<TNext> none);
}

public static class Maybe
{ 
    public IMaybe<T> Factory(T member) 
        => member == null ? new None<T>() ? new Some<T>(member);
}

Some.cs

public class Some<T> : IMaybe<T>
{ 
    private T member; 
    internal Some(T member) 
    { 
        this.member = member; 
    } 
    
    public IMaybe<TNext> FlatMap<TNext>(Func<T, IMaybe<TNext>> func) 
        => func(member); 

    public IMaybe<TNext> Map<TNext>(Func<T, TNext> func) 
        => Maybe.Factory(func(member)); 
    
    public TNext Match<TNext>(Func<T, TNext> some, Func<TNext> none) 
        => some(member);
}

None.cs

public class None<T> : IMaybe<T>
{ 
    public IMaybe<TNext> FlatMap<TNext>(Func<T, IMaybe<TNext>> func) 
        => new None<TNext>(); 

    public IMaybe<TNext> Map<TNext>(Func<T, TNext> func) 
        => new None<TNext>(); 

    public TNext Match<TNext>(Func<T, TNext> some, Func<TNext> none) 
        => none();
}

Now we can easily handle multiple uncertain operations in a row. Now, as long as you make a habit of wrapping these values in the IMaybe monad, you will be certain to avoid NullReferenceException. In my next post, I will use C# extension methods to show how to use monads in list processing.

Did you like this article?

Eleanor Holley

an enthusiastic functional programmer.

See other articles by Eleanor

Related jobs

See all

Title

The company

  • Remote

Title

The company

  • Remote

Title

The company

  • Remote

Title

The company

  • Remote

Related articles

JavaScript Functional Style Made Simple

JavaScript Functional Style Made Simple

Daniel Boros

•

12 Sep 2021

JavaScript Functional Style Made Simple

JavaScript Functional Style Made Simple

Daniel Boros

•

12 Sep 2021

WorksHub

CareersCompaniesSitemapFunctional WorksBlockchain WorksJavaScript WorksAI WorksGolang WorksJava WorksPython WorksRemote Works
hello@works-hub.com

Ground Floor, Verse Building, 18 Brunswick Place, London, N1 6DZ

108 E 16th Street, New York, NY 10003

Subscribe to our newsletter

Join over 111,000 others and get access to exclusive content, job opportunities and more!

© 2024 WorksHub

Privacy PolicyDeveloped by WorksHub