F# Option type support for NFluent

FSharOptionCheckExtensions.cs

using Microsoft.FSharp.Core;
using NFluent;
using NFluent.Extensibility;

namespace UnitTests
{
    public static class FSharOptionCheckExtensions
    {  
        public static void IsNone<T>(this ICheck<FSharpOption<T>> check)
        {
            var checker = ExtensibilityHelper.ExtractChecker(check);
            var entity = string.Format("{0} option", typeof(T).Name);

            var notMessage = FluentMessage.BuildMessage("The {0} is None but should be Some.").For(entity);

            checker.ExecuteCheck(
                () =>
                {
                    if (!FSharpOption<T>.get_IsNone(checker.Value))
                    {
                        var message = FluentMessage.BuildMessage("The {0} is Some but should be None.")
                            .For(entity).On(checker.Value);
                        throw new FluentCheckException(message.ToString());
                    }
                },
                notMessage.ToString());
        }

        public static IFSharpOptionCheckLink<T> IsSome<T>(this ICheck<FSharpOption<T>> check)
        {
            var checker = ExtensibilityHelper.ExtractChecker(check);
            var entity = string.Format("{0} option", typeof(T).Name);

            var notMessage = FluentMessage.BuildMessage("The {0} is Some but should be None.")
                .For(entity).On(checker.Value);

            checker.ExecuteCheck(
                () =>
                {
                    if (!FSharpOption<T>.get_IsSome(checker.Value))
                    {
                        var message = FluentMessage.BuildMessage("The {0} is None but should be Some.")
                            .For(entity);
                        throw new FluentCheckException(message.ToString());
                    }
                },
                notMessage.ToString());
                
            return new FSharpOptionCheckLink<T>(check);
        }
    }
}

FSharpOptionCheckLink.cs

using System;
using JetBrains.Annotations;
using Microsoft.FSharp.Core;
using NFluent;
using NFluent.Extensibility;

namespace UnitTests
{
    internal class FSharpOptionCheckLink<TOptionValue> : IFSharpOptionCheckLink<TOptionValue>
    {
        private readonly ICheck<FSharpOption<TOptionValue>> previousCheck;

        public FSharpOptionCheckLink([NotNull] ICheck<FSharpOption<TOptionValue>> previousCheck)
        {
            if (previousCheck == null)
            {
                throw new ArgumentNullException("previousCheck");
            }
            this.previousCheck = previousCheck;
        }

        public ICheck<FSharpOption<TOptionValue>> And
        {
            get
            {
                var forkableCheck = (IForkableCheck)previousCheck;
                return forkableCheck.ForkInstance() as ICheck<FSharpOption<TOptionValue>>;
            }
        }

        public ICheck<TOptionValue> Which
        {
            get
            {
                var checkForExtensibility = ExtensibilityHelper.ExtractChecker(previousCheck);

                if (!FSharpOption<TOptionValue>.get_IsSome(checkForExtensibility.Value))
                {
                
                    throw new FluentCheckException(FluentMessage.BuildMessage("The checked option has no value to be checked.").ToString());
                }

                return Check.That(checkForExtensibility.Value.Value);            
            }
        }
    }
}

IFSharpOptionCheckLink.cs

using Microsoft.FSharp.Core;
using NFluent;

namespace UnitTests
{
    public interface IFSharpOptionCheckLink<TOptionValue>
    {
        ICheck<FSharpOption<TOptionValue>> And { get; }
        ICheck<TOptionValue> Which { get; }
    }
}