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 스타일 하위 유형에 대한 명확한 매핑이 있음이 밝혀졌습니다. 데이터 유형은 추상 기본 클래스가되고 모든 데이터 생성자는 구체적인 하위 클래스가됩니다. 스칼라의 예는 다음과 같습니다.

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

방문자 패턴 을 사용하면 패턴 일치를 보완 할 수 있습니다 . 예를 들어

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...하므로 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이라고 생각할 수 있습니다 . 따라서 파생 항목을 지정하지 않으려면 "빈"으로 만 사용하면 됩니다.null

순진한 서브 클래 싱 외에 필요한 것은 클래스를 봉인하는 방법, 즉 서브 클래스를 계층 구조에 추가하는 것을 불가능하게하는 방법입니다.

자바에서는 할 수 없습니다. 그러나 기본 클래스를 개인 패키지로 선언 할 수 있습니다. 즉, 모든 직접 서브 클래스는 기본 클래스와 동일한 패키지에 속해야합니다. 그런 다음 서브 클래스를 final로 선언하면 더 이상 서브 클래 싱 할 수 없습니다.

그래도 이것이 실제 문제를 해결할 수 있을지 모르겠습니다 ...

데이터 유형 ConsList<A>은 인터페이스로 표시 될 수 있습니다. 인터페이스는 단일 유형을 노출시켜 deconstruct해당 유형의 값을 "해체"할 수 있습니다. 즉, 가능한 각 생성자를 처리합니다. deconstruct메소드 호출 case of은 Haskell 또는 ML 의 양식 과 유사합니다 .

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

이 deconstruct메소드는 ADT의 각 생성자에 대해 "콜백"함수를 사용합니다. 우리의 경우, 빈리스트 케이스를위한 함수와 "cons cell"케이스를위한 다른 함수를 취합니다.

각 콜백 함수는 생성자가 허용하는 값을 인수로 허용합니다. 따라서 "빈 목록"사례에는 인수가 없지만 "cons 셀"사례에는 목록의 머리와 꼬리라는 두 가지 인수가 있습니다.

Tuple클래스 또는 카레를 사용하여 이러한 "다중 인수"를 인코딩 할 수 있습니다 . 이 예제에서는 간단한 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. 일반적인 fold over 목록 인 함수를 작성할 수 있습니다 .

<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.