Maybe monad

using System;
using NUnit.Framework;
using Shouldly;

namespace IoC.Site.Tests.ParallelTests
{
    //Maybe monad
    public sealed class Maybe<T> where T : class
    {
        private readonly T _value;

        public Maybe(T value)
        {
            _value = value;
        }

        public bool IsNothing
        {
            get { return _value == null; }
        }

        public Maybe<TT> Bind<TT>(Func<T, TT> func) where TT : class
        {
            return new Maybe<TT>(IsNothing ? null : func(_value));
        }

        public TT Return<TT>(TT defaultValue, Func<T, TT> func) where TT : class
        {
            return IsNothing ? defaultValue : func(_value);
        }
    }

    public class MaybeTests
    {
        class MyClass
        {
            public MyClass(string name)
            {
                Name = name;
            }

            public string Name { get; private set; }
            public MyClass Item { get; set; }
        }

        [Test]
        public void TestNullPropagation()
        {
            var myClass = new MyClass("test");
            var maybeMyClass = new Maybe<MyClass>(myClass);

            maybeMyClass
                .Bind(x => x.Item)
                .Bind(x => x.Item)
                .Bind(x => x.Item)
                .Bind(x => x.Name)
                .Return("default", x => x).ShouldBe("default");
        }

        [Test]
        public void AccessingPropertyWithoutNullChecks()
        {
            var myClass = new MyClass("test") { Item = new MyClass("test2") };
            var maybeMyClass = new Maybe<MyClass>(myClass);

            maybeMyClass
                .Bind(x => x.Item)
                .Bind(x => x.Name)
                .Return("default", x => x).ShouldBe("test2");
        }
    }
}