ErrorHandling.cs

Go to the documentation of this file.

//Use project level define(s) when referencing with Paket.
//#define ERRH_INTERNAL //  Uncomment or define at build time to set accessibility to internal.
//#define ERRH_ENABLE_INLINE_METHODS // Uncomment or define at build time to enable method inlining when compiling for >= NET 4.5.
//#define ERRH_ADD_MAYBE_METHODS // Uncomment or define at build time to add methods that use Maybe type
 
using System;
using System.Collections.Generic;
using System.Linq;
#if ERRH_ADD_MAYBE_METHODS
using CSharpx;
#endif
 
namespace RailwaySharp.ErrorHandling
{
#if !ERRH_INTERNAL
    public
#endif
    internal enum ResultType
    {
        Ok,
        Bad,
    }
 
#if !ERRH_INTERNAL
    public
#endif
    internal abstract class Result<TSuccess, TMessage>
    {
        protected Result(ResultType tag)
        {
            Tag = tag;
        }
 
        public ResultType Tag { get; }
 
        public override string ToString()
        {
            switch (Tag)
            {
                default:
                    Ok<TSuccess, TMessage> ok = (Ok<TSuccess, TMessage>)this;
 
                    return string.Format("OK: {0} - {1}",
                                         ok.Success,
                                         string.Join(Environment.NewLine, ok.Messages.Select(v => v.ToString()))
                                        );
                case ResultType.Bad:
                    Bad<TSuccess, TMessage> bad = (Bad<TSuccess, TMessage>)this;
 
                    return string.Format("Error: {0}",
                                         string.Join(Environment.NewLine, bad.Messages.Select(v => v.ToString()))
                                        );
            }
        }
    }
 
#if !ERRH_INTERNAL
    public
#endif
    internal sealed class Ok<TSuccess, TMessage> : Result<TSuccess, TMessage>
    {
        private readonly Tuple<TSuccess, IEnumerable<TMessage>> _value;
 
        public Ok(TSuccess success, IEnumerable<TMessage> messages)
            : base(ResultType.Ok)
        {
            if (messages == null)
            {
                throw new ArgumentNullException(nameof(messages));
            }
 
            _value = Tuple.Create(success, messages);
        }
 
        public TSuccess Success => _value.Item1;
 
        public IEnumerable<TMessage> Messages => _value.Item2;
    }
 
#if !ERRH_INTERNAL
    public
#endif
    internal sealed class Bad<TSuccess, TMessage> : Result<TSuccess, TMessage>
    {
        public Bad(IEnumerable<TMessage> messages)
            : base(ResultType.Bad)
        {
            if (messages == null)
            {
                throw new ArgumentException(nameof(messages));
            }
 
            Messages = messages;
        }
 
        public IEnumerable<TMessage> Messages { get; }
    }
 
#if !ERRH_INTERNAL
    public
#endif
    internal static class Result
    {
        public static Result<TSuccess, TMessage> FailWith<TSuccess, TMessage>(IEnumerable<TMessage> messages)
        {
            if (messages == null)
            {
                throw new ArgumentException(nameof(messages));
            }
 
            return new Bad<TSuccess, TMessage>(messages);
        }
 
        public static Result<TSuccess, TMessage> FailWith<TSuccess, TMessage>(TMessage message)
        {
            if (message == null)
            {
                throw new ArgumentException(nameof(message));
            }
 
            return new Bad<TSuccess, TMessage>(new[] { message });
        }
 
        public static Result<TSuccess, TMessage> Succeed<TSuccess, TMessage>(TSuccess value)
        {
            return new Ok<TSuccess, TMessage>(value, Enumerable.Empty<TMessage>());
        }
 
        public static Result<TSuccess, TMessage> Succeed<TSuccess, TMessage>(TSuccess value, TMessage message)
        {
            if (message == null)
            {
                throw new ArgumentException(nameof(message));
            }
 
            return new Ok<TSuccess, TMessage>(value,
                                              new[] { message }
                                             );
        }
 
        public static Result<TSuccess, TMessage> Succeed<TSuccess, TMessage>(
            TSuccess value,
            IEnumerable<TMessage> messages)
        {
            if (messages == null)
            {
                throw new ArgumentException(nameof(messages));
            }
 
            return new Ok<TSuccess, TMessage>(value, messages);
        }
 
        public static Result<TSuccess, Exception> Try<TSuccess>(Func<TSuccess> func)
        {
            if (func == null)
            {
                throw new ArgumentException(nameof(func));
            }
 
            try
            {
                return new Ok<TSuccess, Exception>(func(),
                                                   Enumerable.Empty<Exception>()
                                                  );
            }
            catch (Exception ex)
            {
                return new Bad<TSuccess, Exception>(new[] { ex });
            }
        }
    }
 
#if !ERRH_INTERNAL
    public
#endif
    internal static class Trial
    {
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> Ok<TSuccess, TMessage>(TSuccess value)
        {
            return new Ok<TSuccess, TMessage>(value, Enumerable.Empty<TMessage>());
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> Pass<TSuccess, TMessage>(TSuccess value)
        {
            return new Ok<TSuccess, TMessage>(value, Enumerable.Empty<TMessage>());
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> Warn<TSuccess, TMessage>(TMessage message, TSuccess value)
        {
            if (message == null)
            {
                throw new ArgumentException(nameof(message));
            }
 
            return new Ok<TSuccess, TMessage>(value,
                                              new[] { message }
                                             );
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> Fail<TSuccess, TMessage>(TMessage message)
        {
            if (message == null)
            {
                throw new ArgumentException(nameof(message));
            }
 
            return new Bad<TSuccess, TMessage>(new[] { message });
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static bool Failed<TSuccess, TMessage>(Result<TSuccess, TMessage> result)
        {
            return result.Tag == ResultType.Bad;
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static TResult Either<TSuccess, TMessage, TResult>(
            Func<TSuccess, IEnumerable<TMessage>, TResult> successFunc,
            Func<IEnumerable<TMessage>, TResult> failureFunc,
            Result<TSuccess, TMessage> trialResult)
        {
            if (successFunc == null)
            {
                throw new ArgumentException(nameof(successFunc));
            }
 
            if (failureFunc == null)
            {
                throw new ArgumentException(nameof(failureFunc));
            }
 
            Ok<TSuccess, TMessage> ok = trialResult as Ok<TSuccess, TMessage>;
 
            if (ok != null)
            {
                return successFunc(ok.Success, ok.Messages);
            }
 
            Bad<TSuccess, TMessage> bad = (Bad<TSuccess, TMessage>)trialResult;
 
            return failureFunc(bad.Messages);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static TSuccess ReturnOrFail<TSuccess, TMessage>(Result<TSuccess, TMessage> result)
        {
            Func<IEnumerable<TMessage>, TSuccess> raiseExn = msgs =>
            {
                throw new Exception(string.Join(Environment.NewLine,
                                                msgs.Select(m => m.ToString())
                                               )
                                   );
            };
 
            return Either((succ, _) => succ, raiseExn, result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> MergeMessages<TSuccess, TMessage>(IEnumerable<TMessage> messages,
            Result<TSuccess, TMessage> result)
        {
            if (messages == null)
            {
                throw new ArgumentException(nameof(messages));
            }
 
            Func<TSuccess, IEnumerable<TMessage>, Result<TSuccess, TMessage>> successFunc =
                (succ, msgs) =>
                    new Ok<TSuccess, TMessage>(succ,
                                               messages.Concat(msgs)
                                              );
 
            Func<IEnumerable<TMessage>, Result<TSuccess, TMessage>> failureFunc =
                errors => new Bad<TSuccess, TMessage>(errors.Concat(messages));
 
            return Either(successFunc, failureFunc, result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> Bind<TValue, TSuccess, TMessage>(
            Func<TValue, Result<TSuccess, TMessage>> func,
            Result<TValue, TMessage> result)
        {
            if (func == null)
            {
                throw new ArgumentException(nameof(func));
            }
 
            Func<TValue, IEnumerable<TMessage>, Result<TSuccess, TMessage>> successFunc =
                (succ, msgs) => MergeMessages(msgs, func(succ));
 
            Func<IEnumerable<TMessage>, Result<TSuccess, TMessage>> failureFunc =
                messages => new Bad<TSuccess, TMessage>(messages);
 
            return Either(successFunc, failureFunc, result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> Flatten<TSuccess, TMessage>(
            Result<Result<TSuccess, TMessage>, TMessage> result)
        {
            return Bind(x => x, result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> Apply<TValue, TSuccess, TMessage>(
            Result<Func<TValue, TSuccess>, TMessage> wrappedFunction,
            Result<TValue, TMessage> result)
        {
            if (wrappedFunction == null)
            {
                throw new ArgumentException(nameof(wrappedFunction));
            }
 
            if (wrappedFunction.Tag == ResultType.Ok && result.Tag == ResultType.Ok)
            {
                Ok<Func<TValue, TSuccess>, TMessage> ok1 = (Ok<Func<TValue, TSuccess>, TMessage>)wrappedFunction;
                Ok<TValue, TMessage> ok2 = (Ok<TValue, TMessage>)result;
 
                return new Ok<TSuccess, TMessage>(ok1.Success(ok2.Success),
                                                  ok1.Messages.Concat(ok2.Messages)
                                                 );
            }
 
            if (wrappedFunction.Tag == ResultType.Bad && result.Tag == ResultType.Ok)
            {
                return new Bad<TSuccess, TMessage>(((Bad<TValue, TMessage>)result).Messages);
            }
 
            if (wrappedFunction.Tag == ResultType.Ok && result.Tag == ResultType.Bad)
            {
                return new Bad<TSuccess, TMessage>(((Bad<TValue, TMessage>)result).Messages);
            }
 
            Bad<Func<TValue, TSuccess>, TMessage> bad1 = (Bad<Func<TValue, TSuccess>, TMessage>)wrappedFunction;
            Bad<TValue, TMessage> bad2 = (Bad<TValue, TMessage>)result;
 
            return new Bad<TSuccess, TMessage>(bad1.Messages.Concat(bad2.Messages));
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess, TMessage> Lift<TValue, TSuccess, TMessage>(Func<TValue, TSuccess> func,
            Result<TValue, TMessage> result)
        {
            return Apply(Ok<Func<TValue, TSuccess>, TMessage>(func), result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TSuccess1, TMessage1> Lift2<TSuccess, TMessage, TSuccess1, TMessage1>(
            Func<TSuccess, Func<TMessage, TSuccess1>> func,
            Result<TSuccess, TMessage1> first,
            Result<TMessage, TMessage1> second)
        {
            return Apply(Lift(func, first), second);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<IEnumerable<TSuccess>, TMessage> Collect<TSuccess, TMessage>(
            IEnumerable<Result<TSuccess, TMessage>> xs)
        {
            return Lift(Enumerable.Reverse,
                        xs.Aggregate<Result<TSuccess, TMessage>, Result<IEnumerable<TSuccess>, TMessage>,
                            Result<IEnumerable<TSuccess>, TMessage>>(null,
                                                                     (result, next) =>
                                                                     {
                                                                         if (result.Tag == ResultType.Ok &&
                                                                             next.Tag == ResultType.Ok)
                                                                         {
                                                                             Ok<IEnumerable<TSuccess>, TMessage> ok1 =
                                                                                 (Ok<IEnumerable<TSuccess>, TMessage>)
                                                                                 result;
 
                                                                             Ok<TSuccess, TMessage> ok2 =
                                                                                 (Ok<TSuccess, TMessage>)next;
 
                                                                             return
                                                                                 new Ok<IEnumerable<TSuccess>,
                                                                                     TMessage>(Enumerable
                                                                                          .Empty<TSuccess>()
                                                                                          .Concat(new[] { ok2.Success }
                                                                                              )
                                                                                          .Concat(ok1.Success),
                                                                                      ok1.Messages.Concat(ok2.Messages)
                                                                                     );
                                                                         }
 
                                                                         if ((result.Tag == ResultType.Ok &&
                                                                              next.Tag == ResultType.Bad) ||
                                                                             (result.Tag == ResultType.Bad &&
                                                                              next.Tag == ResultType.Ok))
                                                                         {
                                                                             IEnumerable<TMessage> m1 =
                                                                                 result.Tag == ResultType.Ok
                                                                                     ? ((Ok<IEnumerable<TSuccess>,
                                                                                                 TMessage>)result)
                                                                                     .Messages
                                                                                     : ((Bad<TSuccess, TMessage>)next)
                                                                                     .Messages;
 
                                                                             IEnumerable<TMessage> m2 =
                                                                                 result.Tag == ResultType.Bad
                                                                                     ? ((Bad<IEnumerable<TSuccess>,
                                                                                                 TMessage>)result)
                                                                                     .Messages
                                                                                     : ((Ok<TSuccess, TMessage>)next)
                                                                                     .Messages;
 
                                                                             return new Bad<IEnumerable<TSuccess>,
                                                                                 TMessage>(m1.Concat(m2));
                                                                         }
 
                                                                         Bad<IEnumerable<TSuccess>, TMessage> bad1 =
                                                                             (Bad<IEnumerable<TSuccess>, TMessage>)
                                                                             result;
 
                                                                         Bad<TSuccess, TMessage> bad2 =
                                                                             (Bad<TSuccess, TMessage>)next;
 
                                                                         return new
                                                                             Bad<IEnumerable<TSuccess>, TMessage>(bad1
                                                                                     .Messages.Concat(bad2.Messages)
                                                                                 );
                                                                     },
                                                                     x => x
                                                                    )
                       );
        }
    }
 
#if !ERRH_INTERNAL
    public
#endif
    internal static class ResultExtensions
    {
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static void Match<TSuccess, TMessage>(this Result<TSuccess, TMessage> result,
                                                     Action<TSuccess, IEnumerable<TMessage>> ifSuccess,
                                                     Action<IEnumerable<TMessage>> ifFailure)
        {
            if (ifSuccess == null)
            {
                throw new ArgumentException(nameof(ifSuccess));
            }
 
            if (ifFailure == null)
            {
                throw new ArgumentException(nameof(ifFailure));
            }
 
            Ok<TSuccess, TMessage> ok = result as Ok<TSuccess, TMessage>;
 
            if (ok != null)
            {
                ifSuccess(ok.Success, ok.Messages);
 
                return;
            }
 
            Bad<TSuccess, TMessage> bad = (Bad<TSuccess, TMessage>)result;
            ifFailure(bad.Messages);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static TResult Either<TSuccess, TMessage, TResult>(this Result<TSuccess, TMessage> result,
                                                                  Func<TSuccess, IEnumerable<TMessage>, TResult>
                                                                      ifSuccess,
                                                                  Func<IEnumerable<TMessage>, TResult> ifFailure)
        {
            return Trial.Either(ifSuccess, ifFailure, result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TResult, TMessage> Map<TSuccess, TMessage, TResult>(this Result<TSuccess, TMessage> result,
            Func<TSuccess, TResult> func)
        {
            return Trial.Lift(func, result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<IEnumerable<TSuccess>, TMessage> Collect<TSuccess, TMessage>(
            this IEnumerable<Result<TSuccess, TMessage>> values)
        {
            return Trial.Collect(values);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<IEnumerable<TSuccess>, TMessage> Flatten<TSuccess, TMessage>(
            this Result<IEnumerable<Result<TSuccess, TMessage>>, TMessage> result)
        {
            if (result.Tag == ResultType.Ok)
            {
                Ok<IEnumerable<Result<TSuccess, TMessage>>, TMessage> ok =
                    (Ok<IEnumerable<Result<TSuccess, TMessage>>, TMessage>)result;
                IEnumerable<Result<TSuccess, TMessage>> values = ok.Success;
                Result<IEnumerable<TSuccess>, TMessage> result1 = Collect(values);
 
                if (result1.Tag == ResultType.Ok)
                {
                    Ok<IEnumerable<TSuccess>, TMessage> ok1 = (Ok<IEnumerable<TSuccess>, TMessage>)result1;
 
                    return new Ok<IEnumerable<TSuccess>, TMessage>(ok1.Success, ok1.Messages);
                }
 
                Bad<IEnumerable<TSuccess>, TMessage> bad1 = (Bad<IEnumerable<TSuccess>, TMessage>)result1;
 
                return new Bad<IEnumerable<TSuccess>, TMessage>(bad1.Messages);
            }
 
            Bad<IEnumerable<Result<TSuccess, TMessage>>, TMessage> bad =
                (Bad<IEnumerable<Result<TSuccess, TMessage>>, TMessage>)result;
 
            return new Bad<IEnumerable<TSuccess>, TMessage>(bad.Messages);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TResult, TMessage> SelectMany<TSuccess, TMessage, TResult>(
            this Result<TSuccess, TMessage> result,
            Func<TSuccess, Result<TResult, TMessage>> func)
        {
            return Trial.Bind(func, result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TResult, TMessage> SelectMany<TSuccess, TMessage, TValue, TResult>(
            this Result<TSuccess, TMessage> result,
            Func<TSuccess, Result<TValue, TMessage>> func,
            Func<TSuccess, TValue, TResult> mapperFunc)
        {
            if (func == null)
            {
                throw new ArgumentException(nameof(func));
            }
 
            if (mapperFunc == null)
            {
                throw new ArgumentException(nameof(mapperFunc));
            }
 
            Func<TSuccess, Func<TValue, TResult>> curriedMapper = suc => val => mapperFunc(suc, val);
 
            Func<
                Result<TSuccess, TMessage>,
                Result<TValue, TMessage>,
                Result<TResult, TMessage>
            > liftedMapper = (a, b) => Trial.Lift2(curriedMapper, a, b);
            Result<TValue, TMessage> v = Trial.Bind(func, result);
 
            return liftedMapper(result, v);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Result<TResult, TMessage> Select<TSuccess, TMessage, TResult>(
            this Result<TSuccess, TMessage> result,
            Func<TSuccess, TResult> func)
        {
            return Trial.Lift(func, result);
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static IEnumerable<TMessage> FailedWith<TSuccess, TMessage>(this Result<TSuccess, TMessage> result)
        {
            if (result.Tag == ResultType.Ok)
            {
                Ok<TSuccess, TMessage> ok = (Ok<TSuccess, TMessage>)result;
 
                throw new Exception(string.Format("Result was a success: {0} - {1}",
                                                  ok.Success,
                                                  string.Join(Environment.NewLine,
                                                              ok.Messages.Select(m => m.ToString())
                                                             )
                                                 )
                                   );
            }
 
            Bad<TSuccess, TMessage> bad = (Bad<TSuccess, TMessage>)result;
 
            return bad.Messages;
        }
 
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static TSuccess SucceededWith<TSuccess, TMessage>(this Result<TSuccess, TMessage> result)
        {
            if (result.Tag == ResultType.Ok)
            {
                Ok<TSuccess, TMessage> ok = (Ok<TSuccess, TMessage>)result;
 
                return ok.Success;
            }
 
            Bad<TSuccess, TMessage> bad = (Bad<TSuccess, TMessage>)result;
 
            throw new Exception(string.Format("Result was an error: {0}",
                                              string.Join(Environment.NewLine, bad.Messages.Select(m => m.ToString()))
                                             )
                               );
        }
 
        public static IEnumerable<TMessage> SuccessMessages<TSuccess, TMessage>(this Result<TSuccess, TMessage> result)
        {
            if (result.Tag == ResultType.Ok)
            {
                Ok<TSuccess, TMessage> ok = (Ok<TSuccess, TMessage>)result;
 
                return ok.Messages;
            }
 
            return Enumerable.Empty<TMessage>();
        }
 
#if ERRH_ADD_MAYBE_METHODS
#if ERRH_ENABLE_INLINE_METHODS
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
        public static Maybe<TSuccess> ToMaybe<TSuccess, TMessage>(this Result<TSuccess, TMessage> result)
        {
            if (result.Tag == ResultType.Ok)
            {
                Ok<TSuccess, TMessage> ok = (Ok<TSuccess, TMessage>)result;
 
                return Maybe.Just(ok.Success);
            }
 
            return Maybe.Nothing<TSuccess>();
        }
#endif
    }
}