RailwaySharp.ErrorHandling.Trial Class Reference

Static Public Member Functions
static Result< TSuccess, TMessage >	Ok< TSuccess, TMessage > (TSuccess value)
	Wraps a value in a Success.
static Result< TSuccess, TMessage >	Pass< TSuccess, TMessage > (TSuccess value)
	Wraps a value in a Success.
static Result< TSuccess, TMessage >	Warn< TSuccess, TMessage > (TMessage message, TSuccess value)
	Wraps a value in a Success and adds a message.
static Result< TSuccess, TMessage >	Fail< TSuccess, TMessage > (TMessage message)
	Wraps a message in a Failure.
static bool	Failed< TSuccess, TMessage > (Result< TSuccess, TMessage > result)
	Returns true if the result was not successful.
static TResult	Either< TSuccess, TMessage, TResult > (Func< TSuccess, IEnumerable< TMessage >, TResult > successFunc, Func< IEnumerable< TMessage >, TResult > failureFunc, Result< TSuccess, TMessage > trialResult)
	Takes a Result and maps it with successFunc if it is a Success otherwise it maps it with failureFunc.
static TSuccess	ReturnOrFail< TSuccess, TMessage > (Result< TSuccess, TMessage > result)
	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.
static Result< TSuccess, TMessage >	MergeMessages< TSuccess, TMessage > (IEnumerable< TMessage > messages, Result< TSuccess, TMessage > result)
	Appends the given messages with the messages in the given result.
static Result< TSuccess, TMessage >	Bind< TValue, TSuccess, TMessage > (Func< TValue, Result< TSuccess, TMessage > > func, Result< TValue, TMessage > result)
	If the result is a Success it executes the given function on the value. Otherwise the exisiting failure is propagated.
static Result< TSuccess, TMessage >	Flatten< TSuccess, TMessage > (Result< Result< TSuccess, TMessage >, TMessage > result)
	Flattens a nested result given the Failure types are equal.
static Result< TSuccess, TMessage >	Apply< TValue, TSuccess, TMessage > (Result< Func< TValue, TSuccess >, TMessage > wrappedFunction, Result< TValue, TMessage > result)
	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.
static Result< TSuccess, TMessage >	Lift< TValue, TSuccess, TMessage > (Func< TValue, TSuccess > func, Result< TValue, TMessage > result)
	Lifts a function into a Result container and applies it on the given result.
static Result< TSuccess1, TMessage1 >	Lift2< TSuccess, TMessage, TSuccess1, TMessage1 > (Func< TSuccess, Func< TMessage, TSuccess1 > > func, Result< TSuccess, TMessage1 > first, Result< TMessage, TMessage1 > second)
	Promote a function to a monad/applicative, scanning the monadic/applicative arguments from left to right.
static Result< IEnumerable< TSuccess >, TMessage >	Collect< TSuccess, TMessage > (IEnumerable< Result< TSuccess, TMessage > > xs)
	Collects a sequence of Results and accumulates their values. If the sequence contains an error the error will be propagated.

Detailed Description

Definition at line 209 of file ErrorHandling.cs.

Member Function Documentation

Apply< TValue, TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.Apply< TValue, TSuccess, TMessage > ( Result< Func< TValue, TSuccess >, TMessage >  wrappedFunction, Result< TValue, TMessage >  result  )

static

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.

Definition at line 401 of file ErrorHandling.cs.

        {
            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));
        }

Bind< TValue, TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.Bind< TValue, TSuccess, TMessage > ( Func< TValue, Result< TSuccess, TMessage > >  func, Result< TValue, TMessage >  result  )

static

If the result is a Success it executes the given function on the value. Otherwise the exisiting failure is propagated.

Definition at line 364 of file ErrorHandling.cs.

        {
            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);
        }

Collect< TSuccess, TMessage >()

static Result< IEnumerable< TSuccess >, TMessage > RailwaySharp.ErrorHandling.Trial.Collect< TSuccess, TMessage > ( IEnumerable< Result< TSuccess, TMessage > >  xs )

static

Collects a sequence of Results and accumulates their values. If the sequence contains an error the error will be propagated.

Definition at line 469 of file ErrorHandling.cs.

        {
            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
                                                                    )
                       );
        }

Either< TSuccess, TMessage, TResult >()

static TResult RailwaySharp.ErrorHandling.Trial.Either< TSuccess, TMessage, TResult > ( Func< TSuccess, IEnumerable< TMessage >, TResult >  successFunc, Func< IEnumerable< TMessage >, TResult >  failureFunc, Result< TSuccess, TMessage >  trialResult  )

static

Takes a Result and maps it with successFunc if it is a Success otherwise it maps it with failureFunc.

Definition at line 284 of file ErrorHandling.cs.

        {
            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);
        }

Fail< TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.Fail< TSuccess, TMessage > ( TMessage  message )

static

Wraps a message in a Failure.

Definition at line 257 of file ErrorHandling.cs.

        {
            if (message == null)
            {
                throw new ArgumentException(nameof(message));
            }
 
            return new Bad<TSuccess, TMessage>(new[] { message });
        }

Failed< TSuccess, TMessage >()

static bool RailwaySharp.ErrorHandling.Trial.Failed< TSuccess, TMessage > ( Result< TSuccess, TMessage >  result )

static

Returns true if the result was not successful.

Definition at line 273 of file ErrorHandling.cs.

        {
            return result.Tag == ResultType.Bad;
        }

Flatten< TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.Flatten< TSuccess, TMessage > ( Result< Result< TSuccess, TMessage >, TMessage >  result )

static

Flattens a nested result given the Failure types are equal.

Definition at line 388 of file ErrorHandling.cs.

        {
            return Bind(x => x, result);
        }

Lift2< TSuccess, TMessage, TSuccess1, TMessage1 >()

static Result< TSuccess1, TMessage1 > RailwaySharp.ErrorHandling.Trial.Lift2< TSuccess, TMessage, TSuccess1, TMessage1 > ( Func< TSuccess, Func< TMessage, TSuccess1 > >  func, Result< TSuccess, TMessage1 >  first, Result< TMessage, TMessage1 >  second  )

static

Promote a function to a monad/applicative, scanning the monadic/applicative arguments from left to right.

Definition at line 454 of file ErrorHandling.cs.

        {
            return Apply(Lift(func, first), second);
        }

Lift< TValue, TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.Lift< TValue, TSuccess, TMessage > ( Func< TValue, TSuccess >  func, Result< TValue, TMessage >  result  )

static

Lifts a function into a Result container and applies it on the given result.

Definition at line 442 of file ErrorHandling.cs.

        {
            return Apply(Ok<Func<TValue, TSuccess>, TMessage>(func), result);
        }

MergeMessages< TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.MergeMessages< TSuccess, TMessage > ( IEnumerable< TMessage >  messages, Result< TSuccess, TMessage >  result  )

static

Appends the given messages with the messages in the given result.

Definition at line 337 of file ErrorHandling.cs.

        {
            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);
        }

Ok< TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.Ok< TSuccess, TMessage > ( TSuccess  value )

static

Wraps a value in a Success.

Definition at line 217 of file ErrorHandling.cs.

        {
            return new Ok<TSuccess, TMessage>(value, Enumerable.Empty<TMessage>());
        }

Pass< TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.Pass< TSuccess, TMessage > ( TSuccess  value )

static

Wraps a value in a Success.

Definition at line 228 of file ErrorHandling.cs.

        {
            return new Ok<TSuccess, TMessage>(value, Enumerable.Empty<TMessage>());
        }

ReturnOrFail< TSuccess, TMessage >()

static TSuccess RailwaySharp.ErrorHandling.Trial.ReturnOrFail< TSuccess, TMessage > ( Result< TSuccess, TMessage >  result )

static

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.

Definition at line 318 of file ErrorHandling.cs.

        {
            Func<IEnumerable<TMessage>, TSuccess> raiseExn = msgs =>
            {
                throw new Exception(string.Join(Environment.NewLine,
                                                msgs.Select(m => m.ToString())
                                               )
                                   );
            };
 
            return Either((succ, _) => succ, raiseExn, result);
        }

Warn< TSuccess, TMessage >()

static Result< TSuccess, TMessage > RailwaySharp.ErrorHandling.Trial.Warn< TSuccess, TMessage > ( TMessage  message, TSuccess  value  )

static

Wraps a value in a Success and adds a message.

Definition at line 239 of file ErrorHandling.cs.

        {
            if (message == null)
            {
                throw new ArgumentException(nameof(message));
            }
 
            return new Ok<TSuccess, TMessage>(value,
                                              new[] { message }
                                             );
        }

---

The documentation for this class was generated from the following file:

• deps/commandlineparser/src/CommandLine/Infrastructure/ErrorHandling.cs