您如何用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中，但是在其他语言中，本机支持代数数据类型，这将是相似的。

事实证明，有一个明显的面向对象样式子类型的映射：数据类型成为抽象基类，每个数据构造函数都成为具体的子类。这是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＃中尝试使用代数数据类型时发现了两个绊脚石：

• 我不知道在C＃中到底该调用什么类型（即我不知道要放入什么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

您可以通过使用visitor模式来实现，该模式将补充模式匹配。例如

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全班实现的。它的每个方法都声明如何解构一个子类。您可以添加更多的子类，但是它必须实现accept并通过调用visit...方法之一来实现，因此它的行为必须类似于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”情况采用另一个函数。

每个回调函数都接受构造函数接受的值作为参数。因此，“空列表”情况不带任何参数，而“ cons cell”情况则带两个参数：列表的开头和结尾。

我们可以使用Tuple类或使用currying 对这些“多个参数”进行编码。在此示例中，我选择使用一个简单的Pair类。

该接口为每个构造函数实现一次。首先，我们有“空列表”的实现。该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。