Yet another Option type for C#

Having been bitten again recently by some code which could contain null as a meaningful value, I set down and put together my own variation on this theme. Unlike the first hit I got for "c# option type", which when faced with the question of whether you could have a Just null, went with "Yes." that on the basis of an example with meaningful nulls (getting the first element if any of a sequence that might contain nulls), I'm going to say that the whole motivation for such a type is to avoid the trap of meaningful nulls, and if you occasionally need a transient Maybe<Maybe<T>>, that should represent an edge case which you'd expect to need handle with care anyway.

The constraints of the C# language mean that there isn't a perfect representation -- we need a struct to avoid any null values of the null-eliminating type, but that means we can't inherit to distinguish cases with and without value, or initialize fields, which means we have to explicitly do at runtime what we would do by virtual method calls.

Inside the struct, I just build on the well known dodge of using null-object IEnumerable-as-Maybe idea; which also allows us to access the vast number of Enumerable extension methods to augment the type. So we start out with

	public struct Maybe<T> : IEquatable<Maybe<T>>
	{
	private static readonly ICollection<T> Nothing = new ReadOnlyCollection<T>(new List<T>());
	private ICollection<T> enumerable;
	public Maybe(T value)
	{
	this.enumerable = Nothing;
	if ((object)value != null)
	{
	this.enumerable = new ReadOnlyCollection<T>(new List<T> { value });
	}
	}
	public bool IsJust
	{
	get
	{
	return this.AsEnumerable.Any();
	}
	}
	public bool IsNothing
	{
	get
	{
	return !this.IsJust;
	}
	}
	public IEnumerable<T> AsEnumerable
	{
	get
	{
	if (this.enumerable == null)
	{
	this.enumerable = Nothing;
	}
	return this.enumerable;
	}
	}
	/*
	where the ReadOnlyCollection is for immutability when we expose this value.
	The run-time look-up hit is in the AsEnumerable, where we have to check and
	maybe lazy-initialize the Nothing case every time (rather than making a
	vtable branch). Now, having set up, we can extract
	*/
	private T Value
	{
	get
	{
	return this.AsEnumerable.Single();
	}
	}
	public bool TryGetValue(out T value)
	{
	if (this.IsJust)
	{
	value = this.Value;
	return true;
	}
	value = default(T);
	return false;
	}
	public T GetValueOrElse(T fallback)
	{
	if (this.IsJust)
	{
	return this.Value;
	}
	return fallback;
	}
	/*
	but having made the first functional steps, we might as well embrace
	the notion and move the control flow into a method
	*/
	public void ForEach(Action<T> action)
	{
	foreach (var value in this.AsEnumerable)
	{
	action(value);
	}
	}
	public void ForEachOrElse(Action<T> action, Action fallback)
	{
	if (this.IsJust)
	{
	this.ForEach(action);
	}
	else
	{
	fallback();
	}
	}
	public Maybe<T> Where(Func<T, bool> filter)
	{
	if (this.AsEnumerable.Any(filter))
	{
	return this;
	}
	return new Maybe<T>();
	}
	public Maybe<TOut> Select<TOut>(Func<T, TOut> map)
	{
	if (this.IsJust)
	{
	return new Maybe<TOut>(map(this.Value));
	}
	return new Maybe<TOut>();
	}
	public Maybe<TOut> SelectMany<TOut>(Func<T, Maybe<TOut>> map)
	{
	if (this.IsJust)
	{
	return map(this.Value);
	}
	return new Maybe<TOut>();
	}
	/*
	which latter makes this more explicitly monadic (and with the identity function,
	unwraps any Maybe<Maybe<T>> intermediates). Then we have some housekeeping to do
	*/
	public override bool Equals(object other)
	{
	if (other is Maybe<T>)
	{
	return this.TestEquals((Maybe<T>)other);
	}
	return false;
	}
	public bool Equals(Maybe<T> other)
	{
	return this.TestEquals(other);
	}
	public override int GetHashCode()
	{
	if (this.IsNothing)
	{
	return 0;
	}
	return this.Value.GetHashCode();
	}
	public override string ToString()
	{
	if (this.IsNothing)
	{
	return "Nothing";
	}
	return "Just " + this.Value.ToString();
	}
	private bool TestEquals(Maybe<T> other)
	{
	if (this.IsNothing != other.IsNothing)
	{
	return false;
	}
	if (this.IsNothing)
	{
	return true;
	}
	return this.Value.Equals(other.Value);
	}
	}
	// and add a class with some auxiliary helper methods
	public static class Maybe
	{
	public static Maybe<T> Nothing<T>()
	{
	return new Maybe<T>();
	}
	public static Maybe<T> Just<T>(T value)
	{
	return new Maybe<T>(value);
	}
	public static Maybe<T> ToMaybe<T>(this IEnumerable<T> source)
	{
	var value = source.Take(1).ToList();
	return value.Count == 0 ? new Maybe<T>() : new Maybe<T>(value[0]);
	}
	public static Maybe<T> ToMaybe<T>(this Nullable<T> source) where T : struct
	{
	return source.HasValue ? new Maybe<T>(source.Value) : new Maybe<T>();
	}
	public static Nullable<T> ToNullable<T>(this Maybe<T> source) where T : struct
	{
	return source.IsJust ? new Nullable<T>(source.GetValueOrElse(default(T))) : new Nullable<T>();
	}
	public static T AsReference<T>(this Maybe<T> source) where T : class
	{
	return source.GetValueOrElse(default(T));
	}
	}

view raw gistfile1.cs hosted with ❤ by GitHub

The first two serve to move the generic from the type to the function name; then we have a series of conversions that invert or augment ones that we already have. Analogues of any further Enumerable extension methods desired can now be written in the form AsEnumerable.EnumerableExtensionMethodReturningIEnumerable().ToMaybe() -- the one that I see as most likely to see heavy use being OfType<T>() to conditionally extract the value as a subtype.