Add Maybe back. (#72)

Author: xavierjohn

Examples/Xunit/MaybeExamples.cs

@@ -0,0 +1,147 @@
+namespace Example.Tests;
+using Xunit;
+public class MaybeExamples
+{
+    [Fact]
+    public void Explicit_construction()
+    {
+        // Arrange
+        Maybe<string> apple1 = Maybe.From("apple");
+        var apple2 = Maybe.From("apple");
+
+        // Assert
+        apple1.Should().BeOfType<Maybe<string>>();
+        apple2.Should().BeOfType<Maybe<string>>();
+        apple1.Value.Should().Be("apple");
+        apple2.Value.Should().Be("apple");
+    }
+
+    [Fact]
+    public void Construction_None_X2F_No_Value()
+    {
+        // Arrange
+        Maybe<string> fruit1 = Maybe.None<string>();
+        Maybe<string> fruit2 = null; // reference type
+        Maybe<int> fruit3 = default; // value type
+
+        // Assert
+        fruit1.Should().BeOfType<Maybe<string>>();
+        fruit1.HasNoValue.Should().BeTrue();
+
+
+        fruit2.Should().BeOfType<Maybe<string>>();
+        fruit2.HasNoValue.Should().BeTrue();
+
+        fruit3.Should().BeOfType<Maybe<int>>();
+        fruit3.HasNoValue.Should().BeTrue();
+    }
+
+    [Fact]
+    public void Implicit_Conversion()
+    {
+        // Arrange
+        Maybe<string> apple = "apple"; // implicit conversion
+
+        // Or as a method return value
+        static Maybe<string> GetFruit(string fruit)
+        {
+            if (string.IsNullOrWhiteSpace(fruit))
+                return Maybe.None<string>();
+
+            return fruit; // implicit conversion
+        }
+
+        // Act
+        var fruit = GetFruit("apple");
+
+        // Assert
+        apple.Should().BeOfType<Maybe<string>>();
+        apple.Value.Should().Be("apple");
+
+        fruit.Should().BeOfType<Maybe<string>>();
+        fruit.Value.Should().Be("apple");
+
+    }
+
+    [Fact]
+    public void Equality()
+    {
+        // Arrange
+        Maybe<string> apple = "apple";
+        Maybe<string> orange = "orange";
+        string alsoOrange = "orange";
+        Maybe<string> noFruit = Maybe.None<string>();
+
+        // Act
+
+
+        // Assert
+        apple.Should().NotBe(orange);
+        orange.Should().Be(alsoOrange);
+        noFruit.Should().NotBe(orange);
+    }
+
+
+    [Fact]
+    public void Convert_to_string()
+    {
+        // Arrange
+        Maybe<string> apple = "apple";
+        Maybe<string> noFruit = Maybe.None<string>();
+
+        // Act
+
+
+        // Assert
+        apple.ToString().Should().Be("apple");
+        noFruit.ToString().Should().Be("Maybe has no value.");
+    }
+
+    [Fact]
+    public void GetValueOrThrow()
+    {
+        // Arrange
+        Maybe<string> apple = "apple";
+        Maybe<string> noFruit = Maybe.None<string>();
+
+        // Act
+        var action1 = () => apple.GetValueOrThrow();
+        var action2 = () => noFruit.GetValueOrThrow();
+
+        // Assert
+        action1.Should().NotThrow<InvalidOperationException>();
+        action2.Should().Throw<InvalidOperationException>();
+    }
+
+    [Fact]
+    public void HasValue_and_HasNoValue()
+    {
+        // Arrange
+        Maybe<string> apple = "apple";
+        Maybe<string> noFruit = Maybe.None<string>();
+
+        // Act
+
+
+        // Assert
+        apple.HasValue.Should().BeTrue();
+        noFruit.HasNoValue.Should().BeTrue();
+    }
+
+    [Fact]
+    public void GetValueOrDefault()
+    {
+        // Arrange
+        Maybe<string> apple = "apple";
+        Maybe<string> unknownFruit = Maybe.None<string>();
+
+        // Act
+        string appleValue = apple.GetValueOrDefault("banana");
+        string unknownFruitValue = unknownFruit.GetValueOrDefault("banana");
+
+        // Assert
+        apple.Should().Be("apple");
+        unknownFruitValue.Should().Be("banana");
+    }
+}
+

RailwayOrientedProgramming/README.md

@@ -21,6 +21,22 @@ public readonly struct Result<TValue>
     public static implicit operator Result<TValue>(Error error) => Result.Failure<TValue>(error);
  }
  ```
+ 
+ ### [Maybe](RailwayOrientedProgramming\src\Maybe\Maybe{T}.cs)
+
+Maybe object holds a value or nothing. It is defined as
+
+```csharp
+ public readonly struct Maybe<T> :
+    IEquatable<T>,
+    IEquatable<Maybe<T>>
+    where T : notnull
+{
+   public T Value;
+   public bool HasValue;
+   public bool HasNoValue;
+}
+```
 
 ### Functions
 
@@ -59,3 +75,12 @@ Tee calls the given function if the result is in success state and returns the s
 ### Finally
 
  Finally unwraps the `Result` and returns the success value or the error.
+
+ ### Maybe
+
+ Maybe states if it contains a value or not.
+ It has the following methods:
+
+- HasValue - returns true if it has a value.
+- HasNoValue - returns true if it does not have a value.
+- Value - returns the value if it has a value. Otherwise `InvalidOperationException`

RailwayOrientedProgramming/src/Maybe/Extensions/AsMaybe.cs

@@ -0,0 +1,20 @@
+namespace FunctionalDDD;
+
+using System.Diagnostics.CodeAnalysis;
+
+public static partial class MaybeExtensions
+{
+    /// <summary>
+    /// Converts the <see cref="Nullable"/> struct to a <see cref="Maybe{T}"/>.
+    /// </summary>
+    /// <returns>Returns the <see cref="Maybe{T}"/> equivalent to the <see cref="Nullable{T}"/>.</returns>
+    public static Maybe<T> AsMaybe<T>(in this T? value) where T : struct =>
+        value is null ? default : new(value.Value);
+
+    /// <summary>
+    /// Wraps the class instance in a <see cref="Maybe{T}"/>.
+    /// </summary>
+    /// <returns>Returns <see cref="Maybe.None"/> if the class instance is null, otherwise returns <see cref="Maybe.From{T}(T)"/>.</returns>
+    public static Maybe<T> AsMaybe<T>([MaybeNull] this T value) where T : class =>
+            value is null ? default : new(value);
+}

RailwayOrientedProgramming/src/Maybe/Extensions/AsNullable.cs

@@ -0,0 +1,19 @@
+
+namespace FunctionalDDD;
+
+public static partial class MaybeExtensions
+{
+    /// <summary>
+    /// Converts the <see cref="Maybe{T}"/> to a <see cref="Nullable"/> struct.
+    /// </summary>
+    /// <returns>Returns the <see cref="Nullable{T}"/> equivalent to the <see cref="Maybe{T}"/>.</returns>
+    public static T? AsNullable<T>(in this Maybe<T> value)
+        where T : struct
+    {
+        if (value.TryGetValue(out var result))
+        {
+            return result;
+        }
+        return default;
+    }
+}

RailwayOrientedProgramming/src/Maybe/Extensions/ToResult.cs

@@ -0,0 +1,27 @@
+namespace FunctionalDDD;
+
+public static partial class MaybeExtensions
+{
+    public static Result<TOk> ToResult<TOk>(in this Maybe<TOk> maybe, Error error)
+        where TOk : notnull
+    {
+        if (maybe.HasNoValue)
+            return Result.Failure<TOk>(error);
+
+        return Result.Success<TOk>(maybe.GetValueOrThrow());
+    }
+
+    public static async Task<Result<TOk>> ToResultAsync<TOk>(this Task<Maybe<TOk>> maybeTask, Error errors)
+        where TOk : notnull
+    {
+        var maybe = await maybeTask.ConfigureAwait(false);
+        return maybe.ToResult(errors);
+    }
+
+    public static async ValueTask<Result<TOk>> ToResultAsync<TOk>(this ValueTask<Maybe<TOk>> maybeTask, Error errors)
+        where TOk : notnull
+    {
+        Maybe<TOk> maybe = await maybeTask;
+        return maybe.ToResult(errors);
+    }
+}

RailwayOrientedProgramming/src/Maybe/Maybe.cs

@@ -0,0 +1,12 @@
+namespace FunctionalDDD;
+
+public sealed class Maybe
+{
+    private Maybe()
+    {
+    }
+
+    public static Maybe<T> None<T>() where T : notnull => new();
+
+    public static Maybe<T> From<T>(T? value) where T : notnull => new(value);
+}

RailwayOrientedProgramming/src/Maybe/Maybe{T}.cs

@@ -0,0 +1,85 @@
+namespace FunctionalDDD;
+
+using System.Diagnostics.CodeAnalysis;
+
+public readonly struct Maybe<T> :
+    IEquatable<T>,
+    IEquatable<Maybe<T>>
+    where T : notnull
+{
+    private readonly bool _isValueSet;
+    private readonly T? _value;
+
+    private const string NoValue = "Maybe has no value.";
+
+    public T GetValueOrThrow(string? errorMessage = null)
+    {
+        if (_isValueSet)
+            return _value!;
+
+        throw new InvalidOperationException(errorMessage ?? NoValue);
+    }
+
+    public T GetValueOrDefault(T defaultValue)
+    {
+        if (_isValueSet)
+            return _value!;
+
+        return defaultValue;
+    }
+
+    public bool TryGetValue([MaybeNullWhen(false)] out T value)
+    {
+        value = _value;
+        return _isValueSet;
+    }
+
+    public T Value => GetValueOrThrow();
+
+    public bool HasValue => _isValueSet;
+
+    public bool HasNoValue => !_isValueSet;
+
+    internal Maybe(T? value)
+    {
+        _isValueSet = value is not null;
+        _value = value!;
+    }
+
+    public static implicit operator Maybe<T>(T? value) =>
+        value is Maybe<T> maybe ? maybe : new(value);
+
+    public static bool operator ==(Maybe<T> maybe, T value) => maybe.Equals(value);
+
+    public static bool operator !=(Maybe<T> maybe, T value) => !maybe.Equals(value);
+
+    public static bool operator ==(Maybe<T> maybe, object other) => maybe.Equals(other);
+
+    public static bool operator !=(Maybe<T> maybe, object other) => !maybe.Equals(other);
+
+    public static bool operator ==(Maybe<T> first, Maybe<T> second) => first.Equals(second);
+
+    public static bool operator !=(Maybe<T> first, Maybe<T> second) => !first.Equals(second);
+
+    public override bool Equals(object? obj) =>
+        obj switch
+        {
+            Maybe<T> other => Equals(other),
+            T other => Equals(other),
+            _ => false,
+        };
+
+    public bool Equals(Maybe<T> other) =>
+        _isValueSet && other._isValueSet
+        ? EqualityComparer<T>.Default.Equals(_value, other._value)
+        : !_isValueSet && !other._isValueSet;
+
+    public bool Equals(T? other) =>
+        _isValueSet
+        ? EqualityComparer<T>.Default.Equals(_value, other)
+        : !_isValueSet;
+
+    public override int GetHashCode() => _value?.GetHashCode() ?? 0;
+
+    public override string ToString() => _value?.ToString() ?? NoValue;
+}