C＃またはJavaのような言語で代数データ型をどのようにエンコードしますか？

代数データ型で簡単に解決できる問題がいくつかあります。たとえば、リスト型は次のように簡潔に表現できます。

data ConsList a = Empty | ConsCell a (ConsList a)

consmap f Empty          = Empty
consmap f (ConsCell a b) = ConsCell (f a) (consmap f b)

l = ConsCell 1 (ConsCell 2 (ConsCell 3 Empty))
consmap (+1) l

この特定の例はHaskellにありますが、代数データ型をネイティブにサポートする他の言語でも同様です。

OOスタイルのサブタイプへの明らかなマッピングがあることがわかります。データ型は抽象基本クラスになり、すべてのデータコンストラクターは具体的なサブクラスになります。Scalaの例を次に示します。

sealed abstract class ConsList[+T] {
  def map[U](f: T => U): ConsList[U]
}

object Empty extends ConsList[Nothing] {
  override def map[U](f: Nothing => U) = this
}

final class ConsCell[T](first: T, rest: ConsList[T]) extends ConsList[T] {
  override def map[U](f: T => U) = new ConsCell(f(first), rest.map(f))
}

val l = (new ConsCell(1, new ConsCell(2, new ConsCell(3, Empty)))
l.map(1+)

単純なサブクラス化以外に必要なのは、クラスを封印する方法、つまり、サブクラスを階層に追加できないようにする方法です。

C＃やJavaなどの言語でこの問題にどのように対処しますか？C＃で代数データ型を使用しようとしたときに見つけた2つの障害は次のとおりです。

• C＃でbottom型が何と呼ばれているのかわかりませんでした（つまり、何を入れるのかわかりませんでしたclass Empty : ConsList< ??? >）
• サブクラスを階層に追加できないようにシール する方法がわかりませんでしたConsList

C＃やJavaで代数データ型を実装する最も慣用的な方法は何でしょうか？または、それが不可能な場合、慣用的な置き換えは何でしょうか？

Javaでクラスを封印する簡単でありながら定型的な方法があります。基本クラスにプライベートコンストラクターを配置し、そのサブクラスを内部クラスにします。

public abstract class List<A> {

   // private constructor is uncallable by any sublclasses except inner classes
   private List() {
   }

   public static final class Nil<A> extends List<A> {
   }

   public static final class Cons<A> extends List<A> {
      public final A head;
      public final List<A> tail;

      public Cons(A head, List<A> tail) {
         this.head = head;
         this.tail = tail;
      }
   }
}

ディスパッチのためのビジターパターンのタック。

私のプロジェクトjADT：Java Algebraic DataTypesがすべてのボイラープレートを生成しますhttps://github.com/JamesIry/jADT

これは、パターンマッチングを補完する訪問者パターンを使用して実現できます。例えば

data List a = Nil | Cons { value :: a, sublist :: List a }

Javaで次のように記述できます。

interface List<T> {
    public <R> R accept(Visitor<T,R> visitor);

    public static interface Visitor<T,R> {
        public R visitNil();
        public R visitCons(T value, List<T> sublist);
    }
}

final class Nil<T> implements List<T> {
    public Nil() { }

    public <R> R accept(Visitor<T,R> visitor) {
        return visitor.visitNil();
    }
}
final class Cons<T> implements List<T> {
    public final T value;
    public final List<T> sublist;

    public Cons(T value, List<T> sublist) {
        this.value = value;
        this.sublist = sublist;
    }

    public <R> R accept(Visitor<T,R> visitor) {
        return visitor.visitCons(value, sublist);
    }
}

密閉はVisitorクラスによって達成されます。各メソッドは、サブクラスの1つを分解する方法を宣言します。さらにサブクラスを追加できますがaccept、visit...メソッドの1つを呼び出して実装する必要があるため、like Consまたはlikeのいずれかを実行する必要がありNilます。

C＃名前付きパラメーター（C＃4.0で導入された）を乱用する場合、簡単に照合できる代数データ型を作成できます。

Either<string, string> e = MonthName(2);

// Match with no return value.
e.Match
(
    Left: err => { Console.WriteLine("Could not convert month: {0}", err); },
    Right: name => { Console.WriteLine("The month is {0}", name); }
);

// Match with a return value.
string monthName =
    e.Match
    (
        Left: err => null,
        Right: name => name
    );
Console.WriteLine("monthName: {0}", monthName);

Eitherクラスの実装は次のとおりです。

public abstract class Either<L, R>
{
    // Subclass implementation calls the appropriate continuation.
    public abstract T Match<T>(Func<L, T> Left, Func<R, T> Right);

    // Convenience wrapper for when the caller doesn't want to return a value
    // from the match expression.
    public void Match(Action<L> Left, Action<R> Right)
    {
        this.Match<int>(
            Left: x => { Left(x); return 0; },
            Right: x => { Right(x); return 0; }
        );
    }
}

public class Left<L, R> : Either<L, R>
{
    L Value {get; set;}

    public Left(L Value)
    {
        this.Value = Value;
    }

    public override T Match<T>(Func<L, T> Left, Func<R, T> Right)
    {
        return Left(Value);
    }
}

public class Right<L, R> : Either<L, R>
{
    R Value { get; set; }

    public Right(R Value)
    {
        this.Value = Value;
    }

    public override T Match<T>(Func<L, T> Left, Func<R, T> Right)
    {
        return Right(Value);
    }
}

C＃では、具体Empty化のために、ベースタイプはメンバータイプごとに異なるため、そのタイプを持つことはできません。あなただけを持つことができますEmpty<T>。それほど便利ではありません。

Javaでは、Empty : ConsList型消去が原因で発生する可能性がありますが、型チェッカーがどこかで悲鳴を上げないかどうかはわかりません。

ただし、両方の言語にがあるためnull、すべての参照タイプを「Whatever | Null」と考えることができます。そのnullため、「空」としてを使用するだけで、派生するものを指定する必要がなくなります。

単純なサブクラス化以外に必要なのは、クラスをシールする方法、つまり、サブクラスを階層に追加できないようにする方法だけです。

Javaではできません。ただし、基本クラスをパッケージプライベートとして宣言できます。つまり、すべての直接サブクラスは基本クラスと同じパッケージに属している必要があります。その後、サブクラスをfinalとして宣言すると、それ以上サブクラスを作成できなくなります。

これがあなたの本当の問題に対処するかどうかはわかりませんが...

データ型ConsList<A>はインターフェイスとして表すことができます。インターフェイスは、deconstructそのタイプの値を「分解」することを可能にする単一のメソッドを公開します。つまり、可能な各コンストラクターを処理します。deconstructメソッドの呼び出しは、case ofHaskellまたはMLのフォームに似ています。

interface ConsList<A> {
  <R> R deconstruct(
    Function<Unit, R> emptyCase,
    Function<Pair<A,ConsList<A>>, R> consCase
  );
}

このdeconstructメソッドは、ADTの各コンストラクターに対して「コールバック」関数を取ります。私たちの場合、空のリストの場合には関数を、「cons cell」の場合には別の関数を取ります。

各コールバック関数は、コンストラクターによって受け入れられる値を引数として受け入れます。したがって、「空のリスト」の場合は引数を取りませんが、「コンセル」の場合はリストの先頭と末尾の2つの引数を取ります。

Tupleクラスまたはカリー化を使用して、これらの「複数の引数」をエンコードできます。この例では、単純なPairクラスを使用することにしました。

インターフェイスは、コンストラクタごとに1回実装されます。まず、「空のリスト」の実装があります。deconstruct実装は、単純に呼び出すemptyCaseコールバック関数を。

class ConsListEmpty<A> implements ConsList<A> {
  public ConsListEmpty() {}

  public <R> R deconstruct(
    Function<Unit, R> emptyCase,
    Function<Pair<A,ConsList<A>>, R> consCase
  ) {
    return emptyCase.apply(new Unit());
  }
}

次に、「cons cell」ケースを同様に実装します。今回はクラスにプロパティがあります：空でないリストの先頭と末尾。ではdeconstruct実装、これらのプロパティはに渡されるconsCaseコールバック関数。

class ConsListConsCell<A> implements ConsList<A> {
  private A head;
  private ConsList<A> tail;

  public ConsListCons(A head, ConsList<A> tail) {
    this.head = head;
    this.tail = tail;
  }

  public <R> R deconstruct(
    Function<Unit, R> emptyCase,
    Function<Pair<A,ConsList<A>>, R> consCase
  ) {
    return consCase.apply(new Pair<A,ConsList<A>>(this.head, this.tail));
  }
}

ADTのこのエンコーディングの使用例を次にreduce示します。通常の折り返しリストである関数を作成できます。

<T> T reduce(Function<Pair<T,A>,T> reducer, T initial, ConsList<T> l) {
  return l.deconstruct(
    ((unit) -> initial),
    ((t) -> reduce(reducer, reducer.apply(initial, t.v1), t.v2))
  );
}

これは、Haskellでのこの実装に類似しています。

reduce reducer initial l = case l of
  Empty -> initial
  Cons t_v1 t_v2  -> reduce reducer (reducer initial t_v1) t_v2

単純なサブクラス化以外に必要なのは、クラスをシールする方法、つまり、サブクラスを階層に追加できないようにする方法だけです。

C＃やJavaなどの言語でこの問題にどのように対処しますか？

これを行う良い方法はありませんが、恐ろしいハックに耐える意思がある場合は、抽象基本クラスのコンストラクターに明示的な型チェックを追加できます。Javaでは、これは次のようになります

protected ConsList() {
    Class<?> clazz = getClass();
    if (clazz != Empty.class && clazz != ConsCell.class) throw new Exception();
}

C＃では、ジェネリックが具体化されているため、より複雑です。最も単純なアプローチは、型を文字列に変換してマングルすることです。

Javaでは、このメカニズムでさえ、シリアル化モデルまたはを介して本当にやりたい人が理論的にバイパスできることに注意してくださいsun.misc.Unsafe。