added main classes

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "dotnet.defaultSolution": "Just.Railway.sln"
+}

JustDotNet.Railway.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Railway", "Railway\Railway.csproj", "{23505B47-110B-4FB7-8615-741CC7F463D4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Raliway.Tests", "Raliway.Tests\Raliway.Tests.csproj", "{607F91E4-83A2-48C4-BAC2-2205BEE81D93}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{23505B47-110B-4FB7-8615-741CC7F463D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{23505B47-110B-4FB7-8615-741CC7F463D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{23505B47-110B-4FB7-8615-741CC7F463D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{23505B47-110B-4FB7-8615-741CC7F463D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{607F91E4-83A2-48C4-BAC2-2205BEE81D93}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{607F91E4-83A2-48C4-BAC2-2205BEE81D93}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{607F91E4-83A2-48C4-BAC2-2205BEE81D93}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{607F91E4-83A2-48C4-BAC2-2205BEE81D93}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

README.md

@@ -1,6 +1,7 @@
 # Base for Railway Programming in .NET
 
 This library uses features of C# to achieve railway-oriented programming.
+
 The desire is to make somewhat user-friendly experience while using result-object pattern.
 
 ## Contents

Railway/Ensure.cs

@@ -0,0 +1,323 @@
+namespace Just.Railway;
+
+public static class Ensure
+{
+    public delegate Error ErrorFactory(string valueExpression);
+
+    public const string DefaultErrorType = "EnsureFailed";
+
+    [Pure] public static Ensure<T> That<T>(T value, [CallerArgumentExpression(nameof(value))]string valueExpression = "") => new(value, valueExpression);
+    [Pure] public static async Task<Ensure<T>> That<T>(Task<T> value, [CallerArgumentExpression(nameof(value))]string valueExpression = "") => new(await value.ConfigureAwait(false), valueExpression);
+
+    [Pure] public static Result<T> Result<T>(this in Ensure<T> ensure) => ensure.State switch
+    {
+        ResultState.Success => new(ensure.Value),
+        ResultState.Error => new(ensure.Error!),
+        _ => throw new EnsureNotInitializedException(nameof(ensure))
+    };
+    [Pure]
+    public static async Task<Result<T>> Result<T>(this Task<Ensure<T>> ensureTask)
+    {
+        var ensure = await ensureTask.ConfigureAwait(false);
+        return ensure.State switch
+        {
+            ResultState.Success => new(ensure.Value),
+            ResultState.Error => new(ensure.Error!),
+            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+        };
+    }
+    [Pure]
+    public static Ensure<T> Satisfies<T>(this in Ensure<T> ensure, Func<T, bool> requirement, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => requirement(ensure.Value)
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} does not satisfy the requirement."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static Ensure<T> Satisfies<T>(this in Ensure<T> ensure, Func<T, bool> requirement, ErrorFactory errorFactory)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => requirement(ensure.Value)
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(errorFactory(ensure.ValueExpression), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static async Task<Ensure<T>> Satisfies<T>(this Task<Ensure<T>> ensureTask, Func<T, bool> requirement, Error error = default!)
+    {
+        var ensure = await ensureTask.ConfigureAwait(false);
+        return ensure.State switch
+        {
+            ResultState.Success => requirement(ensure.Value)
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} does not satisfy the requirement."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+        };
+    }
+    [Pure]
+    public static async Task<Ensure<T>> Satisfies<T>(this Task<Ensure<T>> ensureTask, Func<T, bool> requirement, ErrorFactory errorFactory)
+    {
+        var ensure = await ensureTask.ConfigureAwait(false);
+        return ensure.State switch
+        {
+            ResultState.Success => requirement(ensure.Value)
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(errorFactory(ensure.ValueExpression), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+        };
+    }
+    [Pure]
+    public static async Task<Ensure<T>> Satisfies<T>(this Ensure<T> ensure, Func<T, Task<bool>> requirement, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} does not satisfy the requirement."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static async Task<Ensure<T>> Satisfies<T>(this Ensure<T> ensure, Func<T, Task<bool>> requirement, ErrorFactory errorFactory)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(errorFactory(ensure.ValueExpression), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static async Task<Ensure<T>> Satisfies<T>(this Task<Ensure<T>> ensureTask, Func<T, Task<bool>> requirement, Error error = default!)
+    {
+        var ensure = await ensureTask.ConfigureAwait(false);
+        return ensure.State switch
+        {
+            ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} does not satisfy the requirement."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+        };
+    }
+    [Pure]
+    public static async Task<Ensure<T>> Satisfies<T>(this Task<Ensure<T>> ensureTask, Func<T, Task<bool>> requirement, ErrorFactory errorFactory)
+    {
+        var ensure = await ensureTask.ConfigureAwait(false);
+        return ensure.State switch
+        {
+            ResultState.Success => await requirement(ensure.Value).ConfigureAwait(false)
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(errorFactory(ensure.ValueExpression), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+        };
+    }
+
+    [Pure]
+    public static Ensure<T> NotNull<T>(this in Ensure<T?> ensure, Error error = default!)
+        where T : struct
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value.HasValue
+                ? new(ensure.Value.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is null."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static async Task<Ensure<T>> NotNull<T>(this Task<Ensure<T?>> ensureTask, Error error = default!)
+        where T : struct
+    {
+        var ensure = await ensureTask.ConfigureAwait(false);
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value.HasValue
+                ? new(ensure.Value.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is null."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+        };
+    }
+    [Pure]
+    public static Ensure<T> NotNull<T>(this in Ensure<T?> ensure, Error error = default!)
+        where T : notnull
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is null."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static async Task<Ensure<T>> NotNull<T>(this Task<Ensure<T?>> ensureTask, Error error = default!)
+        where T : notnull
+    {
+        var ensure = await ensureTask.ConfigureAwait(false);
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is null."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensureTask))
+        };
+    }
+
+    [Pure]
+    public static Ensure<T[]> NotEmpty<T>(this in Ensure<T[]> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null && ensure.Value.Length > 0
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static Ensure<List<T>> NotEmpty<T>(this in Ensure<List<T>> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static Ensure<IReadOnlyCollection<T>> NotEmpty<T>(this in Ensure<IReadOnlyCollection<T>> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static Ensure<ICollection<T>> NotEmpty<T>(this in Ensure<ICollection<T>> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static Ensure<IReadOnlyList<T>> NotEmpty<T>(this in Ensure<IReadOnlyList<T>> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static Ensure<IList<T>> NotEmpty<T>(this in Ensure<IList<T>> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null && ensure.Value.Count > 0
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static Ensure<IEnumerable<T>> NotEmpty<T>(this in Ensure<IEnumerable<T>> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => ensure.Value is not null && ensure.Value.Any()
+                ? new(ensure.Value, ensure.ValueExpression)
+                : new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+    [Pure]
+    public static Ensure<string> NotEmpty(this in Ensure<string> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => string.IsNullOrEmpty(ensure.Value)
+                ? new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty."), ensure.ValueExpression)
+                : new(ensure.Value, ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+
+    [Pure]
+    public static Ensure<string> NotWhitespace(this in Ensure<string> ensure, Error error = default!)
+    {
+        return ensure.State switch
+        {
+            ResultState.Success => string.IsNullOrWhiteSpace(ensure.Value)
+                ? new(error ?? Error.New(DefaultErrorType, $"Value {{{ensure.ValueExpression}}} is empty or consists exclusively of white-space characters."), ensure.ValueExpression)
+                : new(ensure.Value, ensure.ValueExpression),
+            ResultState.Error => new(ensure.Error!, ensure.ValueExpression),
+            _ => throw new EnsureNotInitializedException(nameof(ensure))
+        };
+    }
+}
+
+public readonly struct Ensure<T>
+{
+    internal readonly ResultState State;
+    internal readonly Error? Error;
+    internal readonly T Value;
+    internal readonly string ValueExpression;
+
+    internal Ensure(T value, string valueExpression)
+    {
+        Value = value;
+        ValueExpression = valueExpression;
+        State = ResultState.Success;
+    }
+
+    internal Ensure(Error error, string valueExpression)
+    {
+        Error = error;
+        ValueExpression = valueExpression;
+        Value = default!;
+        State = ResultState.Error;
+    }
+}
+
+[Serializable]
+public class EnsureNotInitializedException(string variableName = "this") : InvalidOperationException("Ensure was not properly initialized.")
+{
+    public string VariableName { get; } = variableName;
+}

Railway/Error.cs

@@ -0,0 +1,385 @@
+using System.Collections;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace Just.Railway;
+
+[JsonPolymorphic(TypeDiscriminatorPropertyName = "$$err")]
+[JsonDerivedType(typeof(ExpectedError), typeDiscriminator: 0)]
+[JsonDerivedType(typeof(ExceptionalError), typeDiscriminator: 1)]
+[JsonDerivedType(typeof(ManyErrors))]
+public abstract class Error : IEquatable<Error>, IComparable<Error>
+{
+    private IDictionary<string, object>? _extensionData;
+
+    protected internal Error(){}
+
+    /// <summary>
+    /// Create an <see cref="ExceptionalError"/>
+    /// </summary>
+    /// <param name="thisException">Exception</param>
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Error New(Exception thisException) => new ExceptionalError(thisException);
+    /// <summary>
+    /// Create a <see cref="ExceptionalError"/> with an overriden detail. This can be useful for sanitising the display message
+    /// when internally we're carrying the exception. 
+    /// </summary>
+    /// <param name="message">Error detail</param>
+    /// <param name="thisException">Exception</param>
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Error New(string message, Exception thisException) =>
+        new ExceptionalError(message, thisException);
+    /// <summary>
+    /// Create an <see cref="ExpectedError"/>
+    /// </summary>
+    /// <param name="message">Error detail</param>
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Error New(string message) =>
+        new ExpectedError("error", message);
+    /// <summary>
+    /// Create an <see cref="ExpectedError"/>
+    /// </summary>
+    /// <param name="type">Error code</param>
+    /// <param name="message">Error detail</param>
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Error New(string type, string message) =>
+        new ExpectedError(type, message);
+    /// <summary>
+    /// Create a <see cref="ManyErrors"/>
+    /// </summary>
+    /// <remarks>Collects many errors into a single <see cref="Error"/> type, called <see cref="ManyErrors"/></remarks>
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Error Many(Error error1, Error error2) => (error1, error2) switch
+    {
+        (null, null) => new ManyErrors(Enumerable.Empty<Error>()),
+        (Error err, null) => err,
+        (Error err, { IsEmpty: true }) => err,
+        (null, Error err) => err,
+        ({ IsEmpty: true }, Error err) => err,
+        (Error err1, Error err2) => new ManyErrors(err1, err2)
+    };
+    /// <summary>
+    /// Create a <see cref="ManyErrors"/>
+    /// </summary>
+    /// <remarks>Collects many errors into a single <see cref="Error"/> type, called <see cref="ManyErrors"/></remarks>
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Error Many(params Error[] errors) => errors.Length switch
+    {
+        1 => errors[0],
+        _ => new ManyErrors(errors)
+    };
+    /// <summary>
+    /// Create a <see cref="ManyErrors"/>
+    /// </summary>
+    /// <remarks>Collects many errors into a single <see cref="Error"/> type, called <see cref="ManyErrors"/></remarks>
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Error Many(IEnumerable<Error> errors) => new ManyErrors(errors);
+
+    [Pure] public abstract string Type { get; }
+    [Pure] public abstract string Message { get; }
+    [Pure, JsonExtensionData] public IDictionary<string, object> ExtensionData
+    {
+        get => _extensionData ??= new Dictionary<string, object>();
+        init => _extensionData = value ?? new Dictionary<string, object>();
+    }
+    [Pure] public object? this[string name]
+    {
+        get => _extensionData?.TryGetValue(name, out var val) == true ? val : null;
+
+        set
+        {
+            if (value is null)
+            {
+                _extensionData?.Remove(name);
+            }
+            else
+            {
+                _extensionData ??= new Dictionary<string, object>();
+                _extensionData[name] = value;
+            }
+        }
+    }
+
+    [Pure, JsonIgnore] public abstract int Count { get; }
+    [Pure, JsonIgnore] public abstract bool IsEmpty { get; }
+    [Pure, JsonIgnore] public abstract bool IsExpected { get; }
+    [Pure, JsonIgnore] public abstract bool IsExeptional { get; }
+
+    [Pure] public Error Append(Error? next)
+    {
+        if (next is null || next.IsEmpty)
+            return this;
+
+        if (this.IsEmpty)
+            return next;
+        
+        return new ManyErrors(this, next);
+    }
+    [Pure]
+    [return: NotNullIfNotNull(nameof(lhs))]
+    [return: NotNullIfNotNull(nameof(rhs))]
+    public static Error? operator +(Error? lhs, Error? rhs) => lhs is null ? rhs : lhs.Append(rhs);
+
+    [Pure] public abstract IEnumerable<Error> ToEnumerable();
+    
+    /// <summary>
+    /// Gets the <see cref="Exception"/>
+    /// </summary>
+    /// <returns>New <see cref="ErrorException"/> constructed from current error</returns>
+    [Pure] public virtual Exception ToException() => new ErrorException(Type, Message);
+
+    /// <summary>
+    /// Compares error types
+    /// </summary>
+    /// <returns><see cref="true"/> when other error has the same type</returns>
+    [Pure] public virtual bool IsSimilarTo([NotNullWhen(true)] Error? other) => Type == other?.Type;
+    [Pure] public virtual bool Equals([NotNullWhen(true)] Error? other) => IsSimilarTo(other) && Message == other.Message;
+    [Pure] public static bool operator ==(Error? lhs, Error? rhs) => lhs is null ? rhs is null : lhs.Equals(rhs);
+    [Pure] public static bool operator !=(Error? lhs, Error? rhs) => !(lhs == rhs);
+    [Pure] public sealed override bool Equals(object? obj) => Equals(obj as Error);
+    [Pure] public override int GetHashCode() => HashCode.Combine(Type, Message);
+
+    [Pure] public virtual int CompareTo(Error? other)
+    {
+        if (other is null)
+        {
+            return -1;
+        }
+        
+        var compareResult = string.Compare(Type, other.Type);
+        if (compareResult != 0)
+        {
+            return compareResult;
+        }
+
+        return string.Compare(Message, other.Message);
+    }
+
+    [Pure] public override string ToString() => Message;
+    [Pure] public void Deconstruct(out string type, out string message)
+    {
+        type = Type;
+        message = Message;
+    }
+}
+
+public sealed class ExpectedError : Error
+{
+    [JsonConstructor]
+    public ExpectedError(string type, string message)
+    {
+        Type = type;
+        Message = message;
+    }
+    public ExpectedError(string message)
+        : this("error", message)
+    {
+    }
+
+    [Pure] public override string Type { get; }
+    [Pure] public override string Message { get; }
+
+    [Pure, JsonIgnore] public override int Count => 1;
+    [Pure, JsonIgnore] public override bool IsEmpty => false;
+    [Pure, JsonIgnore] public override bool IsExpected => true;
+    [Pure, JsonIgnore] public override bool IsExeptional => false;
+
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override IEnumerable<Error> ToEnumerable()
+    {
+        yield return this;
+    }
+}
+
+public sealed class ExceptionalError : Error
+{
+    internal readonly Exception? Exception;
+
+    internal ExceptionalError(Exception exception)
+        : this(exception.GetType().Name, exception.Message)
+    {
+        Exception = exception;
+        FillExtensionData(exception);
+    }
+    internal ExceptionalError(string message, Exception exception)
+        : this(exception.GetType().Name, message)
+    {
+        Exception = exception;
+        FillExtensionData(exception);
+    }
+
+    [JsonConstructor]
+    public ExceptionalError(string type, string message)
+    {
+        Type = type;
+        Message = message;
+    }
+
+    [Pure] public override string Type { get; }
+    [Pure] public override string Message { get; }
+
+    [Pure, JsonIgnore] public override int Count => 1;
+    [Pure, JsonIgnore] public override bool IsEmpty => false;
+    [Pure, JsonIgnore] public override bool IsExpected => false;
+    [Pure, JsonIgnore] public override bool IsExeptional => true;
+
+    [Pure] public override Exception ToException() => Exception ?? base.ToException();
+
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override IEnumerable<Error> ToEnumerable()
+    {
+        yield return this;
+    }
+
+    private void FillExtensionData(Exception exception)
+    {
+        foreach (var key in exception.Data.Keys)
+        {
+            var value = exception.Data[key];
+            if (key is null || value is null)
+                continue;
+            this.ExtensionData[key.ToString() ?? string.Empty] = value;
+        }
+    }
+}
+
+[DataContract]
+public sealed class ManyErrors : Error, IEnumerable<Error>
+{
+    private readonly List<Error> _errors;
+    [Pure, DataMember] public IEnumerable<Error> Errors { get => _errors; }
+
+    internal ManyErrors(Error head, Error tail)
+    {
+        _errors = new List<Error>(head.Count + tail.Count);
+
+        if (head.Count == 1)
+            _errors.Add(head);
+        else if (head.Count > 1)
+            _errors.AddRange(head.ToEnumerable());
+
+        if (tail.Count == 1)
+            _errors.Add(tail);
+        else if (tail.Count > 1)
+            _errors.AddRange(tail.ToEnumerable());
+    }
+    public ManyErrors(IEnumerable<Error> errors)
+    {
+        _errors = errors.SelectMany(x => x.ToEnumerable())
+            .Where(x => !x.IsEmpty)
+            .ToList();
+    }
+
+    [Pure] public override string Type => "many_errors";
+    [Pure] public override string Message => ToFullArrayString();
+    [Pure] public override string ToString() => ToFullArrayString();
+
+    [Pure] private string ToFullArrayString()
+    {
+        var separator = Environment.NewLine;
+        var lastIndex = _errors.Count - 1;
+
+        var sb = new StringBuilder();
+        for (int i = 0; i < _errors.Count; i++)
+        {
+            sb.Append(_errors[i]);
+            if (i < lastIndex)
+                sb.Append(separator);
+        }
+
+        return sb.ToString();
+    }
+
+    [Pure] public override int Count => _errors.Count;
+    [Pure, JsonIgnore] public override bool IsEmpty => _errors.Count == 0;
+    [Pure, JsonIgnore] public override bool IsExpected => _errors.All(static x => x.IsExpected);
+    [Pure, JsonIgnore] public override bool IsExeptional => _errors.Any(static x => x.IsExeptional);
+
+    [Pure] public override Exception ToException() => new AggregateException(_errors.Select(static x => x.ToException()));
+    [Pure] public override IEnumerable<Error> ToEnumerable() => _errors;
+
+    [Pure] public override int CompareTo(Error? other)
+    {
+        if (other is null)
+            return -1;
+        if (other.Count != _errors.Count)
+            return _errors.Count.CompareTo(other.Count);
+        
+        var compareResult = 0;
+        int i = 0;
+        foreach (var otherErr in other.ToEnumerable())
+        {
+            var thisErr = _errors[i++];
+            compareResult = thisErr.CompareTo(otherErr);
+            if (compareResult != 0)
+            {
+                return compareResult;
+            }
+        }
+
+        return compareResult;
+    }
+    [Pure] public override bool IsSimilarTo([NotNullWhen(true)] Error? other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+        if (_errors.Count != other.Count)
+        {
+            return false;
+        }
+        int i = 0;
+        foreach (var otherErr in other.ToEnumerable())
+        {
+            var thisErr = _errors[i++];
+            if (!thisErr.IsSimilarTo(otherErr))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    [Pure] public override bool Equals([NotNullWhen(true)] Error? other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+        if (_errors.Count != other.Count)
+        {
+            return false;
+        }
+        int i = 0;
+        foreach (var otherErr in other.ToEnumerable())
+        {
+            var thisErr = _errors[i++];
+            if (!thisErr.Equals(otherErr))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    [Pure] public override int GetHashCode()
+    {
+        if (_errors.Count == 0)
+            return 0;
+        
+        var hash = new HashCode();
+        foreach (var err in _errors)
+        {
+            hash.Add(err);
+        }
+        return hash.ToHashCode();
+    }
+
+    [Pure] public IEnumerator<Error> GetEnumerator() => _errors.GetEnumerator();
+    [Pure] IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}
+
+[Serializable]
+public sealed class ErrorException(string type, string message) : Exception(message)
+{
+    public string Type { get; } = type ?? nameof(ErrorException);
+}

Railway/Railway.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <AssemblyName>Just.Railway</AssemblyName>
+    <RootNamespace>Just.Railway</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="$(AssemblyName).Tests" />
+  </ItemGroup>
+  
+</Project>

Railway/ReflectionHelper.cs

@@ -0,0 +1,67 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Just.Railway;
+
+internal static class ReflectionHelper
+{
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool IsEqual<T>(T? left, T? right) => TypeReflectionCache<T>.IsEqualFunc(left, right);
+
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int Compare<T>(T? left, T? right) => TypeReflectionCache<T>.CompareFunc(left, right);
+}
+
+file static class TypeReflectionCache<T>
+{
+    public static readonly Func<T?, T?, bool> IsEqualFunc;
+    public static readonly Func<T?, T?, int> CompareFunc;
+
+    static TypeReflectionCache()
+    {
+        var type = typeof(T);
+        var isNullableStruct = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
+        var underlyingType = isNullableStruct ? type.GenericTypeArguments.First() : type;
+        var thisType = typeof(TypeReflectionCache<T>);
+
+        var equatableType = typeof(IEquatable<>).MakeGenericType(underlyingType);
+        if (equatableType.IsAssignableFrom(underlyingType))
+        {
+            var isEqualFunc = thisType.GetMethod(isNullableStruct ? nameof(IsEqualNullable) : nameof(IsEqual), BindingFlags.Static | BindingFlags.Public)
+                !.MakeGenericMethod(underlyingType);
+
+            IsEqualFunc = (Func<T?, T?, bool>)Delegate.CreateDelegate(typeof(Func<T?, T?, bool>), isEqualFunc);
+        }
+        else
+        {
+            IsEqualFunc = static (left, right) => left is null ? right is null : left.Equals(right);
+        }
+
+        var comparableType = typeof(IComparable<>).MakeGenericType(underlyingType);
+        if (comparableType.IsAssignableFrom(underlyingType))
+        {
+            var compareFunc = thisType.GetMethod(isNullableStruct ? nameof(CompareNullable) : nameof(Compare), BindingFlags.Static | BindingFlags.Public)
+                !.MakeGenericMethod(underlyingType);
+
+            CompareFunc = (Func<T?, T?, int>)Delegate.CreateDelegate(typeof(Func<T?, T?, int>), compareFunc);
+        }
+        else
+        {
+            CompareFunc = static (left, right) => left is null
+                ? right is null ? 0 : -1
+                : right is null ? 1 : left.GetHashCode().CompareTo(right.GetHashCode());
+        }
+    }
+
+#pragma warning disable CS8604 // Possible null reference argument.
+    [Pure] public static bool IsEqual<R>(R? left, R? right) where R : notnull, IEquatable<R>, T => left is null ? right is null : left.Equals(right);
+    [Pure] public static bool IsEqualNullable<R>(R? left, R? right) where R : struct, IEquatable<R> => left is null ? right is null : right is not null && left.Value.Equals(right.Value);
+
+    [Pure] public static int Compare<R>(R? left, R? right) where R : notnull, IComparable<R>, T => left is null
+        ? right is null ? 0 : -1
+        : right is null ? 1 : left.CompareTo(right);
+    [Pure] public static int CompareNullable<R>(R? left, R? right) where R : struct, IComparable<R> => left is null
+        ? right is null ? 0 : -1
+        : right is null ? 1 : left.Value.CompareTo(right.Value);
+#pragma warning restore CS8604 // Possible null reference argument.
+}

Railway/Usings.cs

@@ -0,0 +1,5 @@
+global using System.Diagnostics.CodeAnalysis;
+global using System.Diagnostics.Contracts;
+global using System.Runtime.CompilerServices;
+global using System.Text.Json;
+global using System.Text.Json.Serialization;

Raliway.Tests/EnsureExtensions/Satisfy.cs

@@ -0,0 +1,55 @@
+namespace Raliway.Tests.EnsureExtensions;
+
+public class Satisfy
+{
+    [Fact]
+    public void WhenRequirementWasSatisfied_ShouldBeSuccessful()
+    {
+        var result = Ensure.That(69)
+            .Satisfies(i => i < 100)
+            .Result();
+        
+        Assert.True(result.IsSuccess);
+        Assert.Equal(69, result.Value);
+    }
+    [Fact]
+    public void WhenRequirementWasNotSatisfied_ShouldBeFailureWithDefaultError()
+    {
+        var error = Error.New(Ensure.DefaultErrorType, "Value {69} does not satisfy the requirement.");
+        var result = Ensure.That(69)
+            .Satisfies(i => i > 100)
+            .Result();
+        
+        Assert.True(result.IsFailure);
+        Assert.Equal(error, result.Error);
+    }
+
+    [Fact]
+    public void WhenAllRequirementsWasSatisfied_ShouldBeSuccessful()
+    {
+        var result = Ensure.That<string?>("69")
+            .NotNull()
+            .NotEmpty()
+            .NotWhitespace()
+            .Satisfies(s => s == "69")
+            .Result();
+        
+        Assert.True(result.IsSuccess);
+        Assert.Equal("69", result.Value);
+    }
+
+    [Fact]
+    public void WhenAnyRequirementWasNotSatisfied_ShouldBeFailureWithFirstError()
+    {
+        var error = Error.New(Ensure.DefaultErrorType, "Value {(string?)\"   \"} is empty or consists exclusively of white-space characters.");
+        var result = Ensure.That((string?)"   ")
+            .NotNull()
+            .NotEmpty()
+            .NotWhitespace()
+            .Satisfies(s => s == "69")
+            .Result();
+        
+        Assert.True(result.IsFailure);
+        Assert.Equal(error, result.Error);
+    }
+}

Raliway.Tests/Errors/Serialization.cs

@@ -0,0 +1,45 @@
+namespace Railway.Tests.Errors;
+
+public class Serialization
+{
+    [Fact]
+    public void WhenSerializingManyErrors()
+    {
+        // Given
+        Error many_errors = new ManyErrors(new Error[]{
+            new ExpectedError("err1", "msg1"){
+                ExtensionData = {
+                    ["ext"] = "ext_value"
+                }
+            },
+            new ExceptionalError(new Exception("msg2")),
+        });
+        // When
+        var result = JsonSerializer.Serialize(many_errors);
+        // Then
+        Assert.Equal(
+            expected: "[{\"$$err\":0,\"Type\":\"err1\",\"Message\":\"msg1\",\"ext\":\"ext_value\"},{\"$$err\":1,\"Type\":\"Exception\",\"Message\":\"msg2\"}]",
+            result);
+    }
+
+    [Fact]
+    public void WhenDeserializingManyErrors()
+    {
+        // Given
+        var json = "[{\"$$err\":0,\"Type\":\"err1\",\"Message\":\"msg1\",\"ext\":\"ext_value\"},{\"$$err\":1,\"Type\":\"Exception\",\"Message\":\"msg2\"}]";
+        // When
+        var result = JsonSerializer.Deserialize<Error[]>(json);
+        // Then
+        Assert.True(result?.Length == 2);
+        Assert.Equal(
+            expected: new ManyErrors(new Error[]{
+                new ExpectedError("err1", "msg1"),
+                new ExceptionalError(new Exception("msg2")),
+            }),
+            result
+        );
+        Assert.Equal(
+            expected: "ext_value",
+            result[0].ExtensionData["ext"].ToString());
+    }
+}

Raliway.Tests/Raliway.Tests.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <AssemblyName>Just.Railway.Tests</AssemblyName>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="xunit" Version="2.6.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Railway\Railway.csproj" />
+  </ItemGroup>
+
+</Project>

Raliway.Tests/Results/GeneralUsage.cs

@@ -0,0 +1,142 @@
+namespace Raliway.Tests.Results;
+
+public class GeneralUsage
+{
+    [Fact]
+    public void TwoResultCombination_WhenThereIsAnError()
+    {
+        // Given
+        var result1 = Result.Success(1);
+        var result2 = Result.Failure(Error.New("some error"));
+        // When
+        var result = Result.Combine(result1, result2);
+        // Then
+        Assert.True(result.IsFailure);
+        Assert.Equal(result2.Error, result.Error);
+    }
+    [Fact]
+    public void TwoResultCombination_WhenThereAreTwoErrors()
+    {
+        // Given
+        var result1 = Result.Failure<byte>(Error.New("1"));
+        var result2 = Result.Failure(Error.New("2"));
+        // When
+        var result = Result.Combine(result1, result2);
+        // Then
+        Assert.True(result.IsFailure);
+        Assert.Equal(result1.Error + result2.Error, result.Error);
+    }
+    [Fact]
+    public void TwoResultCombination_WhenThereIsNoError()
+    {
+        // Given
+        var result1 = Result.Success(1);
+        var result2 = Result.Success(3.14);
+        // When
+        var result = Result.Combine(result1, result2);
+        // Then
+        Assert.True(result.IsSuccess);
+    }
+    [Fact]
+    public void ThreeResultCombination_WhenThereIsAnError()
+    {
+        // Given
+        var result1 = Result.Success(1);
+        var result2 = Result.Success(3.14);
+        var result3 = Result.Failure(Error.New("some error"));
+        // When
+        Result<(int, double)> result = Result.Combine(result1, result2, result3);
+        // Then
+        Assert.True(result.IsFailure);
+        Assert.Equal(result3.Error, result.Error);
+    }
+    [Fact]
+    public void ThreeResultCombination_WhenThereAreTwoErrors()
+    {
+        // Given
+        var result1 = Result.Failure<int?>(Error.New("1"));
+        var result2 = Result.Success(3.14);
+        var result3 = Result.Failure(Error.New("3"));
+        // When
+        Result<(int?, double)> result = Result.Combine(result1, result2, result3);
+        // Then
+        Assert.True(result.IsFailure);
+        Assert.Equal(result1.Error + result3.Error, result.Error);
+    }
+    [Fact]
+    public void ThreeResultCombination_WhenThereIsNoError()
+    {
+        // Given
+        var result1 = Result.Success(1);
+        var result2 = Result.Success(3.14);
+        var result3 = Result.Success();
+        // When
+        var result = Result.Combine(result1, result2, result3);
+        // Then
+        Assert.True(result.IsSuccess);
+    }
+
+    [Fact]
+    public void ChainedResultExtensions_WhenThereIsNoError()
+    {
+        // Given
+
+        // When
+        var result = Result.Success()
+            .Append(() => Result.Success(1))
+            .Append("test")
+            .Map((i, s) => $"{s}_{i}")
+            .Append("some")
+            .Bind((s1, s2) => Result.Success(string.Join(';', s1, s2)))
+            .Match(
+                onSuccess: s => s.ToUpper(),
+                onFailure: _ =>
+                {
+                    Assert.Fail();
+                    return "";
+                }
+            );
+        
+        Assert.Equal("TEST_1;SOME", result);
+    }
+
+    [Fact]
+    public void ChainedResultExtensions_WhenThereIsAnError()
+    {
+        // Given
+        
+        // When
+        var error = Error.New("test");
+
+
+        var result = Result.Success()
+            .Append(() => Result.Failure<int>(error))
+            .Append("test")
+            .Map((i, s) =>
+            {
+                Assert.Fail();
+                return Result.Success("");
+            })
+            .Append("some")
+            .Bind((s1, s2) => 
+            {
+                Assert.Fail();
+                return Result.Success("");
+            })
+            .Match(
+                onSuccess: _ => 
+                {
+                    Assert.Fail();
+                    return "";
+                },
+                onFailure: err =>
+                {
+                    Assert.Equal(error, err);
+                    return "satisfied";
+                }
+            );
+        
+        // Then
+        Assert.Equal("satisfied", result);
+    }
+}

Raliway.Tests/Usings.cs

@@ -0,0 +1,3 @@
+global using System.Text.Json;
+global using Xunit;
+global using Just.Railway;