모나드가 무엇인지 아직 모른다면 오늘 배우기에 좋은 날이 될 것입니다. 나는 여기에 OO 프로그래머를위한 부드러운 소개가있다 :

https://ericlippert.com/2013/02/21/monads-part-one/

귀하의 시나리오는 “아마도 모나드”에 대한 작은 확장 Nullable<T>이며 C # 및 Optional<T>기타 언어 로도 알려져 있습니다.

모나드를 나타내는 추상 유형이 있다고 가정 해 봅시다.

abstract class Measurement<T> { ... }

그리고 세 개의 서브 클래스 :

final class Unknown<T> : Measurement<T> { ... a singleton ...}
final class Empty<T> : Measurement<T> { ... a singleton ... }
final class Actual<T> : Measurement<T> { ... a wrapper around a T ...}

바인드 구현이 필요합니다.

abstract class Measurement<T>
{
    public Measurement<R> Bind(Func<T, Measurement<R>> f)
  {
    if (this is Unknown<T>) return Unknown<R>.Singleton;
    if (this is Empty<T>) return Empty<R>.Singleton;
    if (this is Actual<T>) return f(((Actual<T>)this).Value);
    throw ...
  }

이것으로부터이 간단한 바인드 버전을 작성할 수 있습니다 :

public Measurement<R> Bind(Func<A, R> f)
{
  return this.Bind(a => new Actual<R>(f(a));
}

이제 끝났습니다. 당신은 Measurement<int>손이 있습니다. 당신은 그것을 두 배로하고 싶습니다 :

Measurement<int> m = whatever;
Measurement<int> doubled = m.Bind(a => a * 2);
Measurement<string> asString = m.Bind(a => a.ToString());

그리고 논리를 따르십시오. 경우가 m있다 Empty<int>다음 asStringIS Empty<String>, 우수한.

마찬가지로, 우리가 가지고 있다면

Measurement<int> First()

과

Measurement<double> Second(int i);

그런 다음 두 가지 측정을 결합 할 수 있습니다.

Measurement<double> d = First().Bind(Second);

다시, 경우가 First()있다 Empty<int>다음 d이다 Empty<double>등등.

핵심 단계는 바인드 작업을 올바르게하는 것 입니다. 그것에 대해 열심히 생각하십시오.

답변

public class Measurement
{
    private int value;
    private bool isUnknown = false;
    private bool isMissing = false;

    private Measurement() { }
    public Measurement(int value) { this.value = value; }

    public int Value {
        get {
            if (!isUnknown && !isMissing)
            {
                return this.value;
            }
            throw new SomeException("...");
        }
    }

    public static readonly Measurement Unknown = new Measurement
    {
        isUnknown = true
    };

    public static readonly Measurement Missing = new Measurement
    {
        isMissing = true
    };
}

class Measurement {
    public bool IsEmpty;
    public bool IsKnown;
    public int Value {
        get {
            if(!IsEmpty && IsKnown) return _value;
            throw new Exception("NaN");
            }
        }
}

public static Measurement operator+ (Measurement a, Measurement b) {
    if(a.IsEmpty) { return b; }
    ...etc
}

var value = Measurement.of(2);
out.println(value.map(x -> x * 2));

var empty = Measurement.empty();
out.println(empty.map(x -> x * 2));

var unknown = Measurement.unknown();
out.println(unknown.map(x -> x * 2));

Value(4)
Empty()
Unknown()