Add the missing Result type... branch may be wrong name

src/AStar.Dev.Functional.Extensions/AStar.Dev.Functional.Extensions.csproj

@@ -18,14 +18,14 @@
         <PackageLicenseFile>LICENSE</PackageLicenseFile>
         <PackageProjectUrl>https://github.com/astar-development/astar-dev-functional-extensions/</PackageProjectUrl>
         <PackageReadmeFile>Readme.md</PackageReadmeFile>
-        <PackageReleaseNotes>Update.</PackageReleaseNotes>
+        <PackageReleaseNotes>Add a basic implementation of Result.</PackageReleaseNotes>
         <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
         <RepositoryType>git</RepositoryType>
         <RepositoryUrl>https://github.com/astar-development/astar-dev-functional-extensions.git</RepositoryUrl>
         <SymbolPackageFormat>snupkg</SymbolPackageFormat>
         <TargetFramework>net9.0</TargetFramework>
         <Title>AStar.Dev.Functional.Extensions</Title>
-        <Version>0.1.0</Version>
+        <Version>0.2.0</Version>
     </PropertyGroup>
 
     <ItemGroup>

src/AStar.Dev.Functional.Extensions/Result.cs

@@ -0,0 +1,73 @@
+namespace AStar.Dev.Functional.Extensions;
+
+
+/// <summary>
+///
+/// </summary>
+/// <typeparam name="TError"></typeparam>
+/// <typeparam name="TSuccess"></typeparam>
+public readonly struct Result<TError, TSuccess>
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public readonly TSuccess? Value { get; }
+
+    /// <summary>
+    ///
+    /// </summary>
+    public readonly TError?   Error { get; }
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="successObject"></param>
+    /// <param name="errorObject"></param>
+    /// <param name="isSuccess"></param>
+    private Result(TSuccess? successObject, TError? errorObject, bool isSuccess)
+    {
+        Value          = successObject;
+        Error          = errorObject;
+        this.IsSuccess = isSuccess;
+    }
+
+    /// <summary>
+    ///
+    /// </summary>
+    public bool IsSuccess { get; }
+
+    /// <summary>
+    ///
+    /// </summary>
+    public bool IsFailure => !IsSuccess;
+
+#pragma warning disable CA1000
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    public static Result<TError, TSuccess> Success(TSuccess value) => new(value, default, true);
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="error"></param>
+    /// <returns></returns>
+    public static Result<TError, TSuccess?> Failure(TError error) => new(default, error, false);
+#pragma warning restore CA1000
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="success"></param>
+    /// <returns></returns>
+    public static implicit operator Result<TError, TSuccess>(TSuccess success) => new(success, default, true);
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="error"></param>
+    /// <returns></returns>
+    public static implicit operator Result<TError, TSuccess>(TError error) => new(default, error, false);
+}

test/AStar.Dev.Functional.Extensions.Tests.Unit/ResultShould.cs

@@ -0,0 +1,75 @@
+using JetBrains.Annotations;
+
+namespace AStar.Dev.Functional.Extensions;
+
+[TestSubject(typeof(Result<,>))]
+public class ResultShould
+{
+    [Fact]
+    public void BeOfTypeStruct() => typeof(Result<,>).IsValueType.ShouldBeTrue();
+
+    [Fact]
+    public void BeImmutable() => typeof(Result<,>)?.DeclaringType?.Name.ShouldBe("sdsds");
+
+    [Fact]
+    public void ContainTwoGenericClassParameters()
+    {
+        var result = typeof(Result<,>).GetGenericArguments();
+
+        result.Length.ShouldBe(2);
+    }
+
+    [Fact]
+    public void ContainTheIsSuccessFlagSetToFalseByDefault()
+        => new Result<string, string>().IsSuccess.ShouldBeFalse();
+
+    [Fact]
+    public void ContainTheIsFailureFlagSetToTrueByDefault()
+        => new Result<string, string>().IsFailure.ShouldBeTrue();
+
+    [Fact]
+    public void CreateSuccessResult()
+    {
+        var result = Result<string, string>.Success("Some value here");
+
+        result.IsSuccess.ShouldBeTrue();
+        result.Value.ShouldBe("Some value here");
+    }
+
+    [Fact]
+    public void CreateFailureResult()
+    {
+        var result = Result<string, string>.Failure("Some value here");
+
+        result.IsSuccess.ShouldBeFalse();
+        result.Value.ShouldBeNull();
+    }
+
+    [Fact]
+    public void CreateImplicitSuccessResult()
+    {
+        var result = ImplicitResult(false);
+
+        result.IsSuccess.ShouldBeTrue();
+        result.Value.ShouldBe("Some value here");
+    }
+
+    [Fact]
+    public void CreateImplicitFailureResult()
+    {
+        var result = ImplicitResult(true);
+
+        result.IsSuccess.ShouldBeFalse();
+        result.Value.ShouldBeNull();
+    }
+
+    private static Result<int, string> ImplicitResult(bool fail)
+    {
+        if (!fail)
+        {
+            return "Some value here";
+        }
+
+        return -1;
+    }
+}