[scala] 스칼라의 케이스 객체와 열거

업데이트 : 아래에 설명 된 솔루션보다 훨씬 우수한
새로운 매크로 기반 솔루션 이 만들어졌습니다. 이 새로운 매크로 기반 솔루션을 사용하는 것이 좋습니다 . 그리고 Dotty에 대한 계획은 이러한 스타일의 열거 형 솔루션을 언어의 일부로 만들 것입니다. 우와 후!

요약 : Scala 프로젝트 내
에서 Java를 재생산하기위한 세 가지 기본 패턴이 있습니다 Enum. 세 가지 패턴 중 두 가지; 직접 자바를 사용 Enum하고 scala.Enumeration, 스칼라의 철저한 패턴 매칭을 가능하게 할 수 없습니다. 그리고 세번째; “밀봉 된 특성 + 케이스 오브젝트”는 수행하지만 JVM 클래스 / 개체 초기화 복잡성이있어 순서가 일치하지 않는 서수 인덱스 생성이 발생합니다.

두 가지 클래스로 솔루션을 만들었습니다. 이 요지 에있는 Enumeration 및 EnumerationDecorated 입니다. 열거 형 파일이 상당히 커서 (이 라인에 400 줄-구현 컨텍스트를 설명하는 많은 주석이 들어 있으므로)이 스레드에 코드를 게시하지 않았습니다.
세부 사항 :
당신이 묻는 질문은 꽤 일반적입니다. “… 클래스 를 사용하고 확장하는 경우 ” 그리고 당신이 가지고있는 특정 프로젝트 요구 사항의 미묘함에 따라 각 대답이 가능한 많은 답변이 있음이 밝혀졌습니다. 답은 세 가지 기본 패턴으로 줄일 수 있습니다.

caseobjects[scala.]Enumeration

시작하려면 열거가 무엇인지에 대한 동일한 기본 아이디어로 작업하고 있는지 확인하십시오. EnumJava 5 (1.5) 현재 제공되는 관점에서 열거를 정의합시다 .

1. 자연스럽게 정렬 된 이름 지정된 멤버 세트를 포함합니다.
   1. 정해진 수의 회원이 있습니다
   2. 회원은 자연스럽게 주문되고 명시 적으로 색인됩니다
      • 일부 무식한 회원 쿼리 가능 기준에 따라 정렬되는 것과 대조적으로
   3. 각 멤버는 모든 멤버의 전체 세트 내에서 고유 한 이름을 갖습니다.
2. 인덱스를 기반으로 모든 멤버를 쉽게 반복 할 수 있습니다.
3. 대소 문자를 구분하는 이름으로 멤버를 검색 할 수 있습니다.
   1. 대소 문자를 구분하지 않는 이름으로 멤버를 검색 할 수 있다면 아주 좋을 것입니다.
4. 인덱스를 사용하여 멤버를 검색 할 수 있습니다
5. 멤버는 쉽고 투명하고 효율적으로 직렬화를 사용할 수 있습니다
6. 추가 관련 단일 데이터를 보유하도록 멤버를 쉽게 확장 할 수 있음
7. Java를 넘어 서면 Enum열거에 대해 Scala의 패턴 일치 철저 검사를 명시 적으로 활용할 수 있다면 좋을 것입니다.

: 다음은 게시 된 가장 일반적인 세 가지 솔루션 패턴의 버전 아래 삶은에서의 모습을 보자

A)를 실제로 직접 사용하여 자바Enum ) 혼합 스칼라 / 자바 프로젝트에서 패턴 (:

public enum ChessPiece {
    KING('K', 0)
  , QUEEN('Q', 9)
  , BISHOP('B', 3)
  , KNIGHT('N', 3)
  , ROOK('R', 5)
  , PAWN('P', 1)
  ;

  private char character;
  private int pointValue;

  private ChessPiece(char character, int pointValue) {
    this.character = character;
    this.pointValue = pointValue;
  }

  public int getCharacter() {
    return character;
  }

  public int getPointValue() {
    return pointValue;
  }
}

열거 정의에서 다음 항목을 사용할 수 없습니다.

1. 3.1-대소 문자를 구분하지 않는 이름으로 멤버를 검색 할 수 있다면 좋을 것입니다
2. 7-Java의 Enum을 넘어 서면 열거에 대해 Scala의 패턴 일치 철저 검사를 명시 적으로 활용할 수 있다면 좋을 것입니다

현재 프로젝트의 경우 Scala / Java 혼합 프로젝트 경로에서 위험을 감수 할 이점이 없습니다. 그리고 혼합 프로젝트를 수행 할 수 있다고해도 항목 7은 열거 형 멤버를 추가 / 제거하거나 기존 열거 형 멤버를 처리하기 위해 새로운 코드를 작성하는 경우 컴파일 시간 문제를 포착하는 데 중요합니다.

B) ” sealed trait+case objects “패턴 사용 :

sealed trait ChessPiece {def character: Char; def pointValue: Int}
object ChessPiece {
  case object KING extends ChessPiece {val character = 'K'; val pointValue = 0}
  case object QUEEN extends ChessPiece {val character = 'Q'; val pointValue = 9}
  case object BISHOP extends ChessPiece {val character = 'B'; val pointValue = 3}
  case object KNIGHT extends ChessPiece {val character = 'N'; val pointValue = 3}
  case object ROOK extends ChessPiece {val character = 'R'; val pointValue = 5}
  case object PAWN extends ChessPiece {val character = 'P'; val pointValue = 1}
}

열거 정의에서 다음 항목을 사용할 수 없습니다.

1. 1.2-회원은 자연스럽게 주문되고 명시 적으로 색인됩니다
2. 2-모든 멤버는 인덱스를 기반으로 쉽게 반복 할 수 있습니다.
3. 3-(대소 문자 구분) 이름으로 멤버를 검색 할 수 있습니다
4. 3.1-대소 문자를 구분하지 않는 이름으로 멤버를 검색 할 수 있다면 좋을 것입니다
5. 4-인덱스를 사용하여 멤버를 검색 할 수 있습니다

열거 정의 항목 5와 6을 실제로 충족한다고 주장 할 수 있습니다 .5의 경우 효율적이라고 주장하기가 어렵습니다. 6의 경우, 추가로 연관된 단일 톤 데이터를 보유하도록 확장하기가 쉽지 않습니다.

C)scala.Enumeration 패턴 사용 ( 이 StackOverflow 답변에서 영감을 얻음 ) :

object ChessPiece extends Enumeration {
  val KING = ChessPieceVal('K', 0)
  val QUEEN = ChessPieceVal('Q', 9)
  val BISHOP = ChessPieceVal('B', 3)
  val KNIGHT = ChessPieceVal('N', 3)
  val ROOK = ChessPieceVal('R', 5)
  val PAWN = ChessPieceVal('P', 1)
  protected case class ChessPieceVal(character: Char, pointValue: Int) extends super.Val()
  implicit def convert(value: Value) = value.asInstanceOf[ChessPieceVal]
}

열거 정의에서 다음 항목을 사용할 수 없습니다 (Java Enum을 직접 사용하기위한 목록과 동일해야 함).

1. 3.1-대소 문자를 구분하지 않는 이름으로 멤버를 검색 할 수 있다면 좋을 것입니다
2. 7-Java의 Enum을 넘어 서면 열거에 대해 Scala의 패턴 일치 철저 검사를 명시 적으로 활용할 수 있다면 좋을 것입니다

현재 프로젝트에서 항목 7은 열거 형 멤버를 추가 / 제거하거나 기존 열거 형 멤버를 처리하기 위해 새로운 코드를 작성하는 경우 컴파일 시간 문제를 포착하는 데 중요합니다.

따라서 열거에 대한 위의 정의가 주어지면 위의 세 가지 솔루션 중 어느 것도 위의 열거 정의에 요약 된 모든 것을 제공하지 않으므로 작동하지 않습니다.

1. 혼합 스칼라 / 자바 프로젝트에서 직접 Java Enum
2. “밀봉 된 특성 + 사례 개체”
3. 스칼라. 열거

이러한 각 솔루션은 결국 재 작업 / 확장 / 리팩터링되어 누락 된 요구 사항 중 일부를 처리 할 수 ​​있습니다. 그러나 Java Enum또는 scala.Enumeration솔루션을 충분히 확장하여 항목 7을 제공 할 수는 없습니다. 또한 내 프로젝트의 경우 Scala에서 닫힌 유형을 사용하는 데있어 가장 강력한 가치 중 하나입니다. 컴파일 타임 경고 / 오류를 선호하여 프로덕션 런타임 예외 / 실패에서 코드를 수집하지 않고 코드에 간격 / 문제가 있음을 나타냅니다.

이와 관련하여 case object위의 열거 정의를 모두 포함하는 솔루션을 생성 할 수 있는지 확인하기 위해 경로를 사용하여 작업을 시작했습니다 . 첫 번째 과제는 JVM 클래스 / 객체 초기화 문제의 핵심 ( 이 StackOverflow post 에서 자세히 다룰 것)을 추진하는 것이 었 습니다 . 그리고 마침내 해결책을 찾을 수있었습니다.

내 솔루션은 두 가지 특성입니다. Enumeration 및 EnumerationDecorated 이며 Enumeration특성이 + 400 줄 이상 (컨텍스트를 설명하는 많은 주석)이 넘기 때문에이 스레드에 붙여 넣기를 잊어 버렸습니다 (페이지를 상당히 축소시킵니다). 자세한 내용은 요점으로 바로 이동하십시오 .

위와 동일한 데이터 아이디어를 사용하여 솔루션을 완성한 것처럼 보이는 부분은 다음과 같습니다 (여기에서 사용할 수있는 주석이 달린 버전 ) EnumerationDecorated.

import scala.reflect.runtime.universe.{TypeTag,typeTag}
import org.public_domain.scala.utils.EnumerationDecorated

object ChessPiecesEnhancedDecorated extends EnumerationDecorated {
  case object KING extends Member
  case object QUEEN extends Member
  case object BISHOP extends Member
  case object KNIGHT extends Member
  case object ROOK extends Member
  case object PAWN extends Member

  val decorationOrderedSet: List[Decoration] =
    List(
        Decoration(KING,   'K', 0)
      , Decoration(QUEEN,  'Q', 9)
      , Decoration(BISHOP, 'B', 3)
      , Decoration(KNIGHT, 'N', 3)
      , Decoration(ROOK,   'R', 5)
      , Decoration(PAWN,   'P', 1)
    )

  final case class Decoration private[ChessPiecesEnhancedDecorated] (member: Member, char: Char, pointValue: Int) extends DecorationBase {
    val description: String = member.name.toLowerCase.capitalize
  }
  override def typeTagMember: TypeTag[_] = typeTag[Member]
  sealed trait Member extends MemberDecorated
}

이것은 열거 정의에 필요하고 요약 된 모든 기능을 구현하기 위해 내가 만든 ( 이 Gist에있는 ) 새로운 열거 특성 쌍의 사용 예 입니다.

표현 된 한 가지 우려는 열거 멤버 이름을 반복해야한다는 것입니다 ( decorationOrderedSet위 예에서). 한 번의 반복으로 최소화했지만 두 가지 문제로 인해 더 적게 만드는 방법을 알 수 없었습니다.

1. 이 특정 객체 / 케이스 객체 모델에 대한 JVM 객체 / 클래스 초기화가 정의되어 있지 않습니다 ( 이 Stackoverflow 스레드 참조 ).
2. 메소드에서 리턴 된 컨텐츠 getClass.getDeclaredClasses는 정의되지 않은 순서를 갖습니다 (그리고 case object소스 코드 의 선언 과 같은 순서는 아닐 것입니다 )

이 두 가지 문제를 감안할 때, 나는 암묵적 순서를 생성하려고 포기하고 클라이언트가 명시 적으로 일종의 순서 집합 개념으로 그것을 정의하고 선언해야했습니다. 스칼라 컬렉션에는 삽입 순서 집합 구현이 없으므로 내가 할 수있는 최선의 방법은 List런타임 집합이 실제로 집합인지 확인하는 것입니다. 내가 이것을 달성하는 것을 선호했던 방법이 아닙니다.

그리고 디자인에이 두 번째 목록 / 세트 순서가 필요하면 위 val의 ChessPiecesEnhancedDecorated예에서 추가 case object PAWN2 extends Member하고 추가하는 Decoration(PAWN2,'P2', 2)것을 잊을 수 decorationOrderedSet있었습니다. 따라서 목록이 세트 일뿐만 아니라을 확장하는 모든 케이스 오브젝트를 포함하는지 확인하기위한 런타임 검사가 있습니다 sealed trait Member. 그것은 특별한 형태의 반사 / 매크로 지옥이었습니다. 요점

에 대한 의견이나 피드백을 남겨주십시오 .

답변

trait Enum[A] {
  trait Value { self: A => }
  val values: List[A]
}

sealed trait Currency extends Currency.Value
object Currency extends Enum[Currency] {
  case object EUR extends Currency
  case object GBP extends Currency
  val values = List(EUR, GBP)
}

trait Enum[A <: {def name: String}] {
  trait Value { self: A =>
    _values :+= this
  }
  private var _values = List.empty[A]
  def values = _values
}

sealed abstract class Currency(val name: String) extends Currency.Value
object Currency extends Enum[Currency] {
  val EUR = new Currency("EUR") {}
  val GBP = new Currency("GBP") {}
}

trait Enum[A] {
  trait Value { self: A =>
    _values :+= this
  }
  private var _values = List.empty[A]
  def values = _values
}

sealed trait Currency extends Currency.Value
object Currency extends Enum[Currency] {
  case object EUR extends Currency
  case object GBP extends Currency
}

object Currency extends Enum[Currency]
sealed trait Currency extends Currency.Value
case object EUR extends Currency
case object GBP extends Currency

object DayOfWeek extends Enum {
  sealed abstract class Val extends EnumVal
  case object Mon extends Val; Mon()
  case object Tue extends Val; Tue()
  case object Wed extends Val; Wed()
  case object Thu extends Val; Thu()
  case object Fri extends Val; Fri()
  case object Sat extends Val; Sat()
  case object Sun extends Val; Sun()
}

object DayOfWeekTest extends App {

  // To get a map from Int id to enum:
  println( DayOfWeek.valuesById )

  // To get a map from String name to enum:
  println( DayOfWeek.valuesByName )

  // To iterate through a list of the enum values in definition order,
  // which can be made different from ID order, and get their IDs and names:
  DayOfWeek.values foreach { v => println( v.id + " = " + v ) }

  // To sort by ID or name:
  println( DayOfWeek.values.sorted mkString ", " )
  println( DayOfWeek.values.sortBy(_.toString) mkString ", " )

  // To look up enum values by name:
  println( DayOfWeek("Tue") ) // Some[DayOfWeek.Val]
  println( DayOfWeek("Xyz") ) // None

  // To look up enum values by id:
  println( DayOfWeek(3) )         // Some[DayOfWeek.Val]
  println( DayOfWeek(9) )         // None

  import DayOfWeek._

  // To compare enums as ordinals:
  println( Tue < Fri )

  // Warnings about non-exhaustive pattern matches:
  def aufDeutsch( day: DayOfWeek.Val ) = day match {
    case Mon => "Montag"
    case Tue => "Dienstag"
    case Wed => "Mittwoch"
    case Thu => "Donnerstag"
    case Fri => "Freitag"
 // Commenting these out causes compiler warning: "match is not exhaustive!"
 // case Sat => "Samstag"
 // case Sun => "Sonntag"
  }

}

DayOfWeekTest.scala:31: warning: match is not exhaustive!
missing combination            Sat
missing combination            Sun

  def aufDeutsch( day: DayOfWeek.Val ) = day match {
                                         ^
one warning found

Map(0 -> Mon, 5 -> Sat, 1 -> Tue, 6 -> Sun, 2 -> Wed, 3 -> Thu, 4 -> Fri)
Map(Thu -> Thu, Sat -> Sat, Tue -> Tue, Sun -> Sun, Mon -> Mon, Wed -> Wed, Fri -> Fri)
0 = Mon
1 = Tue
2 = Wed
3 = Thu
4 = Fri
5 = Sat
6 = Sun
Mon, Tue, Wed, Thu, Fri, Sat, Sun
Fri, Mon, Sat, Sun, Thu, Tue, Wed
Some(Tue)
None
Some(Thu)
None
true

abstract class Enum {

  type Val <: EnumVal

  protected var nextId: Int = 0

  private var values_       =       List[Val]()
  private var valuesById_   = Map[Int   ,Val]()
  private var valuesByName_ = Map[String,Val]()

  def values       = values_
  def valuesById   = valuesById_
  def valuesByName = valuesByName_

  def apply( id  : Int    ) = valuesById  .get(id  )  // Some|None
  def apply( name: String ) = valuesByName.get(name)  // Some|None

  // Base class for enum values; it registers the value with the Enum.
  protected abstract class EnumVal extends Ordered[Val] {
    val theVal = this.asInstanceOf[Val]  // only extend EnumVal to Val
    val id = nextId
    def bumpId { nextId += 1 }
    def compare( that:Val ) = this.id - that.id
    def apply() {
      if ( valuesById_.get(id) != None )
        throw new Exception( "cannot init " + this + " enum value twice" )
      bumpId
      values_ ++= List(theVal)
      valuesById_   += ( id       -> theVal )
      valuesByName_ += ( toString -> theVal )
    }
  }

}

object DayOfWeek extends Enum {

  sealed abstract class Val( val isWeekday:Boolean = true ) extends EnumVal {
    def isWeekend = !isWeekday
    val abbrev = toString take 3
  }
  case object    Monday extends Val;    Monday()
  case object   Tuesday extends Val;   Tuesday()
  case object Wednesday extends Val; Wednesday()
  case object  Thursday extends Val;  Thursday()
  case object    Friday extends Val;    Friday()
  nextId = -2
  case object  Saturday extends Val(false); Saturday()
  case object    Sunday extends Val(false);   Sunday()

  val (weekDays,weekendDays) = values partition (_.isWeekday)
}

@enum
 class Toggle {
  ON
  OFF
 }

@enum
sealed trait Toggle
case object ON  extends Toggle
case object OFF extends Toggle