![](https://i.imgur.com/RApuF8I.jpg) Apart from the Identity monad, the Maybe monad is probably the easiest to understand so I will start there. In C# think Nullable but able to wrap reference types as well as reference types. I will also forgo the standard monad return/bind semantics in favor of full LINQ integration. If you missed it you can find the Introduction [Here](https://steemit.com/programming/@woz.software/lets-build-a-monad-library-for-c-introduction). This means the following. * ToMaybe() and ToSome() in place of return, construction semantics. * SelectMany() in place of bind/flatmap/fmap, it is the same signature. * Select() to complete LINQ integration, this is Map. We start with an interface: ``` using System; namespace Woz.Monads { public interface IMaybe { bool HasValue { get; } T Value { get; } IMaybe Select( Func selector); IMaybe SelectMany( Func> selector); IMaybe SelectMany( Func> selector, Func projection); IMaybe Where(Func predicate); TResult Match( Func someSelector, Func noneSelector); IMaybe Recover(T defaultValue); IMaybe Recover(Func defaultFactory); void Do(Action action); } } ``` There is a lot going on here so I will detail each part. * HasValue - true/false to indicate if the monad has a value. true = Some(value), false = None * Value - Returns the wrapped value or throws an exception when no value in place. * Select - This is map. Operates the same as IEnumerable.Select() but only runs when there is a value. * SelectMany - This is bind. Operates the same as IEnumerable.SelectMany() but only runs when there is a value. * Where - This operates like an if statement. If the predicate is true maintains the monad state otherwise returns a None. * Match - A way to trigger an operation against the Some(value) or None and return a value. * Recover - A way to get back to a Some(value) when the monad is None. * Do - Triggers the action if the monad is Some(value). So lets look at the Some class so you can see what is going on here. Most of this should make sense. We already know we have a value so we can just operate on it with the semantics of the interface. ``` using System; namespace Woz.Monads { internal class Some : IMaybe { internal Some(T value) { Value = value; } public bool HasValue => true; public T Value { get; } public IMaybe Select( Func selector) => selector(Value).ToMaybe(); public IMaybe SelectMany( Func> selector) => selector(Value); public IMaybe SelectMany( Func> selector, Func projection) => selector(Value).SelectMany(value => projection(Value, value).ToMaybe()); public IMaybe Where(Func predicate) => predicate(Value) ? this : None.Default; public TResult Match( Func someSelector, Func noneSelector) => someSelector(Value); public IMaybe Recover(T defaultValue) => this; public IMaybe Recover(Func defaultFactory) => this; public void Do(Action action) => action(Value); } } ``` Next we explore None. This is the implementation of when we have no value, in all cases it propagates no value reshaping as required. ``` using System; namespace Woz.Monads { internal class None : IMaybe { internal static readonly IMaybe Default = new None(); private None() {} public T Value { get { throw new InvalidOperationException("No value"); } } public bool HasValue => false; public IMaybe Select( Func selector) => None.Default; public IMaybe SelectMany( Func> selector) => None.Default; public IMaybe SelectMany( Func> selector, Func projection) => None.Default; public IMaybe Where(Func predicate) => this; public TResult Match(Func someSelector, Func noneSelector) => noneSelector(); public IMaybe Recover(T defaultValue) => defaultValue.ToMaybe(); public IMaybe Recover(Func defaultFactory) => defaultFactory().ToMaybe(); public void Do(Action action) {} } } ``` The final pieces of the puzzle are some statics to construction. This is split into a generic and non generic class this is because I prefer the non-generic class semantics for the construction but the generic class is required to support the None property. ``` namespace Woz.Monads { public static class Maybe { public static IMaybe ToSome(this T value) => new Some(value); public static IMaybe ToMaybe(this T value) => value == null ? Maybe.None : new Some(value); } public static class Maybe { public static IMaybe None => None.Default; } } ``` I will show some usage in the next article and also push this to a git repo when I get a chance. I have written this on my Surface which only has VS2015. I will port this to .NET Core in VS2017 on my main dev box when I get a chance. For now, here is a quick example of usage. ``` // Wrap some values var someA = 5.ToSome(); var someB = "Hello".ToSome(); var none = Maybe.None; // someValue is the string "5 Hello" var someResult = from intValue in someA from strValue in someB select $"{intValue} {strValue}"; // noneValue is None because one of the monads is a None var noneValue = from intNone in none from strValue in someB select $"{intNone} {strValue}"; ``` As you can see, no null/none checks that is all abstracted away via LINQ. Feel free to ask any questions Happy coding Woz