diff --git a/src/CommandLine/CommandLine.csproj b/src/CommandLine/CommandLine.csproj
index b05cbb04..22c4ef51 100644
--- a/src/CommandLine/CommandLine.csproj
+++ b/src/CommandLine/CommandLine.csproj
@@ -4,7 +4,7 @@
 		<AssemblyName>CommandLine</AssemblyName>
 		<OutputType>Library</OutputType>
 		<TargetFrameworks>netstandard2.0;net40;net45;net461</TargetFrameworks>
-		<DefineConstants>$(DefineConstants);CSX_EITHER_INTERNAL;CSX_REM_EITHER_BEYOND_2;CSX_ENUM_INTERNAL;ERRH_INTERNAL;ERRH_DISABLE_INLINE_METHODS;CSX_MAYBE_INTERNAL;CSX_REM_EITHER_FUNC;CSX_REM_CRYPTORAND</DefineConstants>
+		<DefineConstants>$(DefineConstants);CSX_EITHER_INTERNAL;CSX_REM_EITHER_BEYOND_2;CSX_ENUM_INTERNAL;ERRH_INTERNAL;CSX_MAYBE_INTERNAL;CSX_REM_EITHER_FUNC;CSX_REM_CRYPTORAND;ERRH_ADD_MAYBE_METHODS</DefineConstants>
 		<DefineConstants Condition="'$(BuildTarget)' != 'fsharp'">$(DefineConstants);SKIP_FSHARP</DefineConstants>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 		<AssemblyOriginatorKeyFile>..\..\CommandLine.snk</AssemblyOriginatorKeyFile>
diff --git a/src/CommandLine/Core/InstanceBuilder.cs b/src/CommandLine/Core/InstanceBuilder.cs
index 4aff4080..0ae564b5 100644
--- a/src/CommandLine/Core/InstanceBuilder.cs
+++ b/src/CommandLine/Core/InstanceBuilder.cs
@@ -98,10 +98,10 @@ public static ParserResult<T> Build<T>(
                 var validationErrors = specPropsWithValue.Validate(SpecificationPropertyRules.Lookup(tokens));
 
                 var allErrors =
-                    tokenizerResult.SuccessfulMessages()
+                    tokenizerResult.SuccessMessages()
                         .Concat(missingValueErrors)
-                        .Concat(optionSpecPropsResult.SuccessfulMessages())
-                        .Concat(valueSpecPropsResult.SuccessfulMessages())
+                        .Concat(optionSpecPropsResult.SuccessMessages())
+                        .Concat(valueSpecPropsResult.SuccessMessages())
                         .Concat(validationErrors)
                         .Concat(setPropertyErrors)
                         .Memoize();
diff --git a/src/CommandLine/Core/Tokenizer.cs b/src/CommandLine/Core/Tokenizer.cs
index 9fd8863c..ba6f1ef5 100644
--- a/src/CommandLine/Core/Tokenizer.cs
+++ b/src/CommandLine/Core/Tokenizer.cs
@@ -74,7 +74,7 @@ public static Result<IEnumerable<Token>, Error> ExplodeOptionList(
 
             var flattened = exploded.SelectMany(x => x);
 
-            return Result.Succeed(flattened, tokenizerResult.SuccessfulMessages());
+            return Result.Succeed(flattened, tokenizerResult.SuccessMessages());
         }
 
         public static IEnumerable<Token> Normalize(
diff --git a/src/CommandLine/Infrastructure/ErrorHandling.cs b/src/CommandLine/Infrastructure/ErrorHandling.cs
index 142e1461..8aee4bac 100644
--- a/src/CommandLine/Infrastructure/ErrorHandling.cs
+++ b/src/CommandLine/Infrastructure/ErrorHandling.cs
@@ -1,62 +1,17 @@
 //Use project level define(s) when referencing with Paket.
-//#define ERRH_INTERNAL // Uncomment this to set visibility to internal.
-//#define ERRH_DISABLE_INLINE_METHODS // Uncomment this to enable method inlining when compiling for >= NET 4.5.
-//#define ERRH_BUILTIN_TYPES // Uncomment this to use built-in Unit type, instead of extenral identical CSharpx.Unit.
+//#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;
-using System.Runtime.CompilerServices;
-#if !ERRH_BUILTIN_TYPES
+#if ERRH_ADD_MAYBE_METHODS
 using CSharpx;
 #endif
 
 namespace RailwaySharp.ErrorHandling
 {
-    #region Unit Type
-#if ERRH_BUILTIN_TYPES
-#if !ERRH_INTERNAL
-    public
-#endif
-    struct Unit : IEquatable<Unit>
-    {
-        private static readonly Unit @default = new Unit();
-
-        public bool Equals(Unit other)
-        {
-            return true;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return obj is Unit;
-        }
-
-        public override int GetHashCode()
-        {
-            return 0;
-        }
-
-        public override string ToString()
-        {
-            return "()";
-        }
-
-        public static bool operator ==(Unit first, Unit second)
-        {
-            return true;
-        }
-
-        public static bool operator !=(Unit first, Unit second)
-        {
-            return false;
-        }
-
-        public static Unit Default { get { return @default; } }
-    }
-#endif
-    #endregion
-
 #if !ERRH_INTERNAL
     public
 #endif
@@ -76,29 +31,28 @@ enum ResultType
 #endif 
     abstract class Result<TSuccess, TMessage>
     {
-        private readonly ResultType tag;
+        private readonly ResultType _tag;
 
         protected Result(ResultType tag)
         {
-            this.tag = tag;
+            _tag = tag;
         }
 
         public ResultType Tag
         {
-            get { return tag; }
+            get { return _tag; }
         }
 
         public override string ToString()
         {
-            switch (Tag)
-            {
-                case ResultType.Ok:
+            switch (Tag) {
+                default:
                     var ok = (Ok<TSuccess, TMessage>)this;
                     return string.Format(
                         "OK: {0} - {1}",
                         ok.Success,
                         string.Join(Environment.NewLine, ok.Messages.Select(v => v.ToString())));
-                default:
+                case ResultType.Bad:
                     var bad = (Bad<TSuccess, TMessage>)this;
                     return string.Format(
                         "Error: {0}",
@@ -117,22 +71,24 @@ public override string ToString()
 #endif 
     sealed class Ok<TSuccess, TMessage> : Result<TSuccess, TMessage>
     {
-        private readonly Tuple<TSuccess, IEnumerable<TMessage>> value;
+        private readonly Tuple<TSuccess, IEnumerable<TMessage>> _value;
 
         public Ok(TSuccess success, IEnumerable<TMessage> messages)
             : base(ResultType.Ok)
         {
-            this.value = Tuple.Create(success, messages);
+            if (messages == null) throw new ArgumentNullException(nameof(messages));
+
+            _value = Tuple.Create(success, messages);
         }
 
         public TSuccess Success
         {
-            get { return value.Item1; }
+            get { return _value.Item1; }
         }
 
         public IEnumerable<TMessage> Messages
         {
-            get { return value.Item2; }
+            get { return _value.Item2; }
         }
     }
 
@@ -146,17 +102,19 @@ public IEnumerable<TMessage> Messages
 #endif
     sealed class Bad<TSuccess, TMessage> : Result<TSuccess, TMessage>
     {
-        private readonly IEnumerable<TMessage> messages;
+        private readonly IEnumerable<TMessage> _messages;
 
         public Bad(IEnumerable<TMessage> messages)
             : base(ResultType.Bad)
         {
-            this.messages = messages;
+            if (messages == null) throw new ArgumentException(nameof(messages));
+
+            _messages = messages;
         }
 
         public IEnumerable<TMessage> Messages
         {
-            get { return messages; }
+            get { return _messages; }
         }
     }
 
@@ -170,6 +128,8 @@ static class Result
         /// </summary>
         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);
         }
 
@@ -178,6 +138,8 @@ public static Result<TSuccess, TMessage> FailWith<TSuccess, TMessage>(IEnumerabl
         /// </summary>
         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 });
         }
 
@@ -194,6 +156,8 @@ public static Result<TSuccess, TMessage> Succeed<TSuccess, TMessage>(TSuccess va
         /// </summary>
         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 });
         }
 
@@ -202,6 +166,8 @@ public static Result<TSuccess, TMessage> Succeed<TSuccess, TMessage>(TSuccess va
         /// </summary>
         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);
         }
 
@@ -210,13 +176,13 @@ public static Result<TSuccess, TMessage> Succeed<TSuccess, TMessage>(TSuccess va
         /// </summary>
         public static Result<TSuccess, Exception> Try<TSuccess>(Func<TSuccess> func)
         {
-            try
-            {
+            if (func == null) throw new ArgumentException(nameof(func));
+
+            try {
                 return new Ok<TSuccess, Exception>(
                         func(), Enumerable.Empty<Exception>());
             }
-            catch (Exception ex)
-            {
+            catch (Exception ex) {
                 return new Bad<TSuccess, Exception>(
                     new[] { ex });
             }
@@ -231,7 +197,7 @@ static class Trial
         /// <summary>
         /// Wraps a value in a Success.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<TSuccess, TMessage> Ok<TSuccess, TMessage>(TSuccess value)
@@ -242,7 +208,7 @@ public static Result<TSuccess, TMessage> Ok<TSuccess, TMessage>(TSuccess value)
         /// <summary>
         /// Wraps a value in a Success.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<TSuccess, TMessage> Pass<TSuccess, TMessage>(TSuccess value)
@@ -253,29 +219,33 @@ public static Result<TSuccess, TMessage> Pass<TSuccess, TMessage>(TSuccess value
         /// <summary>
         /// Wraps a value in a Success and adds a message.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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 });
         }
 
         /// <summary>
         /// Wraps a message in a Failure.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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 });
         }
 
         /// <summary>
         /// Returns true if the result was not successful.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static bool Failed<TSuccess, TMessage>(Result<TSuccess, TMessage> result)
@@ -286,7 +256,7 @@ public static bool Failed<TSuccess, TMessage>(Result<TSuccess, TMessage> result)
         /// <summary>
         /// Takes a Result and maps it with successFunc if it is a Success otherwise it maps it with failureFunc.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static TResult Either<TSuccess, TMessage, TResult>(
@@ -294,9 +264,11 @@ public static TResult Either<TSuccess, TMessage, TResult>(
             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));
+
             var ok = trialResult as Ok<TSuccess, TMessage>;
-            if (ok != null)
-            {
+            if (ok != null) {
                 return successFunc(ok.Success, ok.Messages);
             }
             var bad = (Bad<TSuccess, TMessage>)trialResult;
@@ -307,7 +279,7 @@ public static TResult Either<TSuccess, TMessage, TResult>(
         /// If the given result is a Success the wrapped value will be returned. 
         /// Otherwise the function throws an exception with Failure message of the result.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static TSuccess ReturnOrFail<TSuccess, TMessage>(Result<TSuccess, TMessage> result)
@@ -325,13 +297,15 @@ public static TSuccess ReturnOrFail<TSuccess, TMessage>(Result<TSuccess, TMessag
         /// <summary>
         /// Appends the given messages with the messages in the given result.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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>(
@@ -347,13 +321,15 @@ public static Result<TSuccess, TMessage> MergeMessages<TSuccess, TMessage>(
         /// If the result is a Success it executes the given function on the value.
         /// Otherwise the exisiting failure is propagated.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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));
 
@@ -366,7 +342,7 @@ public static Result<TSuccess, TMessage> Bind<TValue, TSuccess, TMessage>(
         /// <summary>
         /// Flattens a nested result given the Failure types are equal.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<TSuccess, TMessage> Flatten<TSuccess, TMessage>(
@@ -374,46 +350,44 @@ public static Result<TSuccess, TMessage> Flatten<TSuccess, TMessage>(
         {
             return Bind(x => x, result);
         }
-
+        
         /// <summary>
         /// If the wrapped function is a success and the given result is a success the function is applied on the value. 
         /// Otherwise the exisiting error messages are propagated.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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.Tag == ResultType.Ok && result.Tag == ResultType.Ok)
-            {
+            if (wrappedFunction == null) throw new ArgumentException(nameof(wrappedFunction));
+
+            if (wrappedFunction.Tag == ResultType.Ok && result.Tag == ResultType.Ok) {
                 var ok1 = (Ok<Func<TValue, TSuccess>, TMessage>)wrappedFunction;
                 var 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)
-            {
+            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)
-            {
+            if (wrappedFunction.Tag == ResultType.Ok && result.Tag == ResultType.Bad) {
                 return new Bad<TSuccess, TMessage>(
                     ((Bad<TValue, TMessage>)result).Messages);
             }
 
             var bad1 = (Bad<Func<TValue, TSuccess>, TMessage>)wrappedFunction;
             var bad2 = (Bad<TValue, TMessage>)result;
-
             return new Bad<TSuccess, TMessage>(bad1.Messages.Concat(bad2.Messages));
         }
 
         /// <summary>
         /// Lifts a function into a Result container and applies it on the given result.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<TSuccess, TMessage> Lift<TValue, TSuccess, TMessage>(
@@ -426,22 +400,22 @@ public static Result<TSuccess, TMessage> Lift<TValue, TSuccess, TMessage>(
         /// <summary>
         /// Promote a function to a monad/applicative, scanning the monadic/applicative arguments from left to right.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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> a,
-            Result<TMessage, TMessage1> b)
+            Result<TSuccess, TMessage1> first,
+            Result<TMessage, TMessage1> second)
         {
-            return Apply(Lift(func, a), b);
+            return Apply(Lift(func, first), second);
         }
 
         /// <summary>
         /// Collects a sequence of Results and accumulates their values.
         /// If the sequence contains an error the error will be propagated.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<IEnumerable<TSuccess>, TMessage> Collect<TSuccess, TMessage>(
@@ -449,21 +423,18 @@ public static Result<IEnumerable<TSuccess>, TMessage> Collect<TSuccess, TMessage
         {
             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)
-                    {
+                null, 
+                (result, next) => {
+                    if (result.Tag == ResultType.Ok && next.Tag == ResultType.Ok) {
                         var ok1 = (Ok<IEnumerable<TSuccess>, TMessage>)result;
                         var ok2 = (Ok<TSuccess, TMessage>)next;
                         return
                             new Ok<IEnumerable<TSuccess>, TMessage>(
-                                    Enumerable.Empty<TSuccess>().Concat(new[] { ok2.Success }).Concat(ok1.Success),
+                                    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))
-                    {
+                        || (result.Tag == ResultType.Bad && next.Tag == ResultType.Ok)) {
                         var m1 = result.Tag == ResultType.Ok
                             ? ((Ok<IEnumerable<TSuccess>, TMessage>)result).Messages
                             : ((Bad<TSuccess, TMessage>)next).Messages;
@@ -472,8 +443,9 @@ public static Result<IEnumerable<TSuccess>, TMessage> Collect<TSuccess, TMessage
                             : ((Ok<TSuccess, TMessage>)next).Messages;
                         return new Bad<IEnumerable<TSuccess>, TMessage>(m1.Concat(m2));
                     }
+
                     var bad1 = (Bad<IEnumerable<TSuccess>, TMessage>)result;
-                    var bad2 = (Bad<TSuccess, TMessage>)next;
+                    var bad2 = (Bad<TSuccess, TMessage>)next;            
                     return new Bad<IEnumerable<TSuccess>, TMessage>(bad1.Messages.Concat(bad2.Messages));
                 }, x => x));
         }
@@ -490,19 +462,22 @@ static class ResultExtensions
         /// <summary>
         /// Allows pattern matching on Results.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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));
+
             var ok = result as Ok<TSuccess, TMessage>;
-            if (ok != null)
-            {
+            if (ok != null) {
                 ifSuccess(ok.Success, ok.Messages);
                 return;
             }
+
             var bad = (Bad<TSuccess, TMessage>)result;
             ifFailure(bad.Messages);
         }
@@ -510,26 +485,20 @@ public static void Match<TSuccess, TMessage>(this Result<TSuccess, TMessage> res
         /// <summary>
         /// Allows pattern matching on Results.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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)
         {
-            var ok = result as Ok<TSuccess, TMessage>;
-            if (ok != null)
-            {
-                return ifSuccess(ok.Success, ok.Messages);
-            }
-            var bad = (Bad<TSuccess, TMessage>)result;
-            return ifFailure(bad.Messages);
+            return Trial.Either(ifSuccess, ifFailure, result);
         }
 
         /// <summary>
         /// Lifts a Func into a Result and applies it on the given result.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<TResult, TMessage> Map<TSuccess, TMessage, TResult>(this Result<TSuccess, TMessage> result,
@@ -542,7 +511,7 @@ public static Result<TResult, TMessage> Map<TSuccess, TMessage, TResult>(this Re
         /// Collects a sequence of Results and accumulates their values.
         /// If the sequence contains an error the error will be propagated.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<IEnumerable<TSuccess>, TMessage> Collect<TSuccess, TMessage>(
@@ -555,18 +524,16 @@ public static Result<IEnumerable<TSuccess>, TMessage> Collect<TSuccess, TMessage
         /// Collects a sequence of Results and accumulates their values.
         /// If the sequence contains an error the error will be propagated.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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)
-            {
+            if (result.Tag == ResultType.Ok) {
                 var ok = (Ok<IEnumerable<Result<TSuccess, TMessage>>, TMessage>)result;
                 var values = ok.Success;
                 var result1 = Collect(values);
-                if (result1.Tag == ResultType.Ok)
-                {
+                if (result1.Tag == ResultType.Ok) {
                     var ok1 = (Ok<IEnumerable<TSuccess>, TMessage>)result1;
                     return new Ok<IEnumerable<TSuccess>, TMessage>(ok1.Success, ok1.Messages);
                 }
@@ -581,7 +548,7 @@ public static Result<IEnumerable<TSuccess>, TMessage> Flatten<TSuccess, TMessage
         /// If the result is a Success it executes the given Func on the value.
         /// Otherwise the exisiting failure is propagated.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<TResult, TMessage> SelectMany<TSuccess, TMessage, TResult>(this Result<TSuccess, TMessage> result,
@@ -595,7 +562,7 @@ public static Result<TResult, TMessage> SelectMany<TSuccess, TMessage, TResult>(
         /// If the result of the Func is a Success it maps it using the given Func.
         /// Otherwise the exisiting failure is propagated.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<TResult, TMessage> SelectMany<TSuccess, TMessage, TValue, TResult>(
@@ -603,6 +570,9 @@ public static Result<TResult, TMessage> SelectMany<TSuccess, TMessage, TValue, T
             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>,
@@ -616,7 +586,7 @@ public static Result<TResult, TMessage> SelectMany<TSuccess, TMessage, TValue, T
         /// <summary>
         /// Lifts a Func into a Result and applies it on the given result.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#if ERRH_ENABLE_INLINE_METHODS
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public static Result<TResult, TMessage> Select<TSuccess, TMessage, TResult>(this Result<TSuccess, TMessage> result,
@@ -628,13 +598,12 @@ public static Result<TResult, TMessage> Select<TSuccess, TMessage, TResult>(this
         /// <summary>
         /// Returns the error messages or fails if the result was a success.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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)
-            {
+            if (result.Tag == ResultType.Ok) {
                 var ok = (Ok<TSuccess, TMessage>)result;
                 throw new Exception(
                     string.Format("Result was a success: {0} - {1}",
@@ -648,13 +617,12 @@ public static IEnumerable<TMessage> FailedWith<TSuccess, TMessage>(this Result<T
         /// <summary>
         /// Returns the result or fails if the result was an error.
         /// </summary>
-#if !ERRH_DISABLE_INLINE_METHODS
+#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)
-            {
+            if (result.Tag == ResultType.Ok) {
                 var ok = (Ok<TSuccess, TMessage>)result;
                 return ok.Success;
             }
@@ -663,5 +631,34 @@ public static TSuccess SucceededWith<TSuccess, TMessage>(this Result<TSuccess, T
                 string.Format("Result was an error: {0}",
                 string.Join(Environment.NewLine, bad.Messages.Select(m => m.ToString()))));
         }
+
+        /// <summary>
+        /// Returns messages in case of success, otherwise an empty sequence. 
+        /// </summary>
+        public static IEnumerable<TMessage> SuccessMessages<TSuccess, TMessage>(this Result<TSuccess, TMessage> result)
+        {
+            if (result.Tag == ResultType.Ok) {
+                var 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
+        /// <summary>
+        /// Builds a Maybe type instance from a Result one.
+        /// </summary>
+        public static Maybe<TSuccess> ToMaybe<TSuccess, TMessage>(this Result<TSuccess, TMessage> result)
+        {
+            if (result.Tag == ResultType.Ok) {
+                var ok = (Ok<TSuccess, TMessage>)result;
+                return Maybe.Just(ok.Success);
+            }
+            return Maybe.Nothing<TSuccess>();
+        }
+#endif
     }
 }
\ No newline at end of file
diff --git a/src/CommandLine/Infrastructure/ResultExtensions.cs b/src/CommandLine/Infrastructure/ResultExtensions.cs
deleted file mode 100644
index bdc2a480..00000000
--- a/src/CommandLine/Infrastructure/ResultExtensions.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
-
-using System.Collections.Generic;
-using System.Linq;
-
-using CSharpx;
-using RailwaySharp.ErrorHandling;
-
-namespace CommandLine.Infrastructure
-{
-    static class ResultExtensions
-    {
-        public static IEnumerable<TMessage> SuccessfulMessages<TSuccess, TMessage>(this Result<TSuccess, TMessage> result)
-        {
-            if (result.Tag == ResultType.Ok)
-            {
-                var ok = (Ok<TSuccess, TMessage>)result;
-                return ok.Messages;
-            }
-            return Enumerable.Empty<TMessage>();
-        }
-
-        public static Maybe<TSuccess> ToMaybe<TSuccess, TMessage>(this Result<TSuccess, TMessage> result)
-        {
-            if (result.Tag == ResultType.Ok)
-            {
-                var ok = (Ok<TSuccess, TMessage>)result;
-                return Maybe.Just(ok.Success);
-            }
-            return Maybe.Nothing<TSuccess>();
-        }
-    }
-}
\ No newline at end of file
diff --git a/tests/CommandLine.Tests/Unit/Core/TokenizerTests.cs b/tests/CommandLine.Tests/Unit/Core/TokenizerTests.cs
index 3bd95891..e2803a8f 100644
--- a/tests/CommandLine.Tests/Unit/Core/TokenizerTests.cs
+++ b/tests/CommandLine.Tests/Unit/Core/TokenizerTests.cs
@@ -121,7 +121,7 @@ public void Should_return_error_if_option_format_with_equals_is_not_correct()
 
             var result = Tokenizer.Tokenize(args, name => NameLookupResult.OtherOptionFound, token => token);
 
-            var tokens = result.SuccessfulMessages();
+            var tokens = result.SuccessMessages();
 
             Assert.NotNull(tokens);
             Assert.Equal(2, tokens.Count());