변경 불가능한 클래스의 다형성 업데이트

Question

나는이 문제를 해결하기 위해 노력했지만이 문제에 대한 해결책을 찾을 수없는 것 같습니다. 스칼라에서 제대로 모델링 할 수없는 것 같습니다.

내가 구현하는 불변 클래스가있는 MyTrait이라는 특성이 있다고 가정 해 보겠습니다.

그리고 다음과 같은 :

• 을 슈퍼 특성의 방법을 통해 불변 클래스 업데이트 : 나는 다음과 같이 그들은 것 내 문제를 요약한다면

  trait MyTrait { 
      type Repr <: MyTrait 
  
      def substitute(original: Item, replacement: Item) : Repr 
  
      def substituteAll(
      originals: List[Item], 
      replacement: Item 
  ) : Repr = { 
      originals match { 
       case head :: tail => substitute(head).substituteAll(tail, replacement) 
       case Nil => this //this complains that this is not of type Repr 
      }  
      } 
  } 
  
  trait MyTrait2 { ... } 
  
  case class MyClassA(originals: List[Item]) 
  extends MyTrait with MyTrait2 { 
      type Repr = MyClassA 
  
      def substitute(original: Item, replacement: Item) : MyClassA = { 
      //whatever code that updates the list etc. 
  
      MyClassA(newOriginals) 
      }  
  } 
  
  case class MyClassB(originals: List[Item]) 
  extends MyTrait with MyTrait2 { 
      type Repr = MyClassB 
  
      def substitute(original: Item, replacement: Item) : MyClassB = { 
      //whatever code that updates the list etc. 
  
      MyClassB(newOriginals) 
      }  
  } 
  
  case class CompoundClass(list : List[MyTrait with MyTrait2]) 
  extends MyTrait { 
      type Repr = CompoundClass 
  
      def substitute(
      original: Item, 
      replacement: Item 
  ) : CompoundClass = 
      CompoundClass(list.map(
       myClass => myClass.substitute(original, replacement) 
      )) 
  ) 
      //the above complains that it is expecting 
      // List[MyTrait with MyTrait2] 
      //while in fact it is getting MyTrait2#Repr 
  } 
  

  같은 종류의 구현 클래스를 반환해야합니다.

• 수퍼 형질은 다른 객체를 반환하기보다는 this을 반환 할 수 있어야합니다. 나는 이것에 문제가있는 것 같다.

• 실제 유형을 모른 채 슈퍼 - 특성을 기능에 전달할 수 있어야합니다. 표준 다형성. 따라서 함수는 실제 구체적인 유형을 아는 것없이 특성의 메소드를 호출 할 수 있습니다.

• 수업을 결합하여 다른 수업에 조합 할 수 있어야합니다. (하위 표현식으로 구성된 표현식을 상상해보십시오). 그것은 표준 구성처럼 보이지만, 위와 나는 원래 MyTrait[T]에서 제네릭 형식을 사용하여 시도했다 #Repr

으로 이러한 오류를 얻고있다 그러나 이것은 불가능 내가 원하는 구체적인 클래스를 통과 할 수 있습니다. 나는 추상적 인 타입을 사용하려고 노력하고 있는데, 나는 컴파일 타임에 같은 문제에 직면 해있는 것처럼 보인다. 근본적으로 나는 지금 정말로 차이가 없다고 생각한다. 나는 다시 같은 함정에 빠지게된다.

내가 뭘 잘못하고 있니? 나는 이것을 잘못된 방향으로보고 있는가?

Answer 1

여기에 몇 가지 문제가 있습니다. 그 중 일부는 다형성과 완전히 관련이 없습니다.

trait MyTrait { 
    type Repr <: MyTrait 

    def substitute(original: Item, replacement: Item) : Repr 

    def substituteAll(
    originals: List[Item], 
    replacements: List[Item] 
) : Repr = { 
    originals match { 
     case head :: tail => substitute(head).substituteAll(tail) 
     case Nil => this 
    }  
    } 
} 

substitute 및 substituteAll 모두 두 개의 인수를, 아직 한 그들을 호출을 시도하고 있습니다 :

substituteAll 방법으로 시작. 이것은 결코 작동 할 수 없다!

또한 컴파일러에 this이 Repr이라는 증거가 없다는 문제가 있습니다.

trait MyTrait { 
    type Repr <: MyTrait 

    def substitute(original: Item, replacement: Item) : Repr 

    def substituteAll(
    originals: List[Item], 
    replacements: List[Item] 
)(implicit typed: this.type => Repr) : Repr = { 
    def loop(pairs: List[(Item, Item)]): Repr = pairs match { 
     case (orig, rep) :: tail => 
     substitute(orig, rep) 
     loop(tail) 
     case Nil => typed(this) //this complains that this is not of type Repr 
    } 
    loop(originals zip replacements) 
    } 
} 

내 다음 문제는 Repr이다 : 첫 번째 문제는 다음 내부 기능을 사용 튜플 하나의리스트로 두 개의 입력을 압축하는 쉽게 충분히 고정 될 수 있고, 두 번째는 수동 증거를 제공함으로써 해결 될 수있다 type param은 복합 유형 MyTrait with MyTrait2에 대해 보유하려는 유형을 보유하지 않습니다.

Repr 매개 변수는 여전히 추상이므로 완전한 유형은 아닙니다.당신이 원하는 정말것은이 다소 복잡 감안할 때 완전 지정된 유형 MyTrait with MyTrait2 { type Repr = MyTrait with MyTrait2 }

입니다, 그것을 표현하기 위해 다른 특성을 소개하는 것이 더 쉽습니다 :

이

trait CompoundElem extends MyTrait with MyTrait2 { 
    type Repr <: CompoundElem 
} 

당신은 다음의 나머지 부분이 사용할 수 있습니다 코드 : 당신이 조금 더의 둘레에 매달려 요소 유형을 유지하려면

case class MyClassA(originals: List[Item]) extends CompoundElem { 
    type Repr = MyClassA 

    def substitute(original: Item, replacement: Item) : MyClassA = { 
    val newOriginals = originals 
    MyClassA(newOriginals) 
    } 
} 

case class MyClassB(originals: List[Item]) extends CompoundElem { 
    type Repr = MyClassB 

    def substitute(original: Item, replacement: Item) : MyClassB = { 
    val newOriginals = originals 
    MyClassB(newOriginals) 
    } 
} 

case class CompoundClass(list : List[CompoundElem]) extends MyTrait { 
    type Repr = CompoundClass 

    def substitute(
    original: Item, 
    replacement: Item 
) = CompoundClass(
    list.map(_.substitute(original, replacement)) 
) 
} 

,이 마지막 클래스도 작성할 수 있습니다 :

object MyTrait { 
    //type alias helper to view the type member as though it were a param 
    //A neat trick, shamelessly borrowed from the shapeless library 
    type Aux[R] = MyTrait { type Repr = R } 
} 

case class CompoundClass[E <: MyTrait.Aux[E]](list : List[E]) extends MyTrait { 
    type Repr = CompoundClass[E] 

    def substitute(
    original: Item, 
    replacement: Item 
) = CompoundClass(
    list.map(_.substitute(original, replacement)) 
) 
} 

이렇게 작성하면 대부분의 시나리오에서 중간 특성이 필요하지 않습니다. 예를 들어, ClassA의 List를 포함하는 CompoundClass은 정상적으로 작동합니다. 당신이 다음 분류 된 ClassA의 List 's 및 ClassB의를 원하는 경우에

는 여전히 컴파일러 Repr이해야 정확히 수습하기 위해 중간체가 필요합니다, 그것은 계산할 수 아니다이해야 또한 ClassA with ClassB의 ReprClassA with ClassB이됩니다.

당신이 완전히 요소의 유형을 삭제 괜찮다면, 당신은이 작업을 수행 할 수 있습니다

case class CompoundClass(list : List[MyTrait]) extends MyTrait { 
    type Repr = CompoundClass  
    def substitute(
    original: Item, 
    replacement: Item 
) = CompoundClass(
    list.map(_.substitute(original, replacement)) 
) 
} 

그것은 단지 CompoundClassMyTraits의있을 거 야, 당신은 패턴 매칭 할 때를 사용해야합니다 요소를 끌어 당겨 ClassA 또는 ClassB 또는 MyTrait2으로 처리하지만 중급 형식은 일 필요가 없습니다.

---

마지막으로 참조 용으로 F-Bounds를 사용하여 다시 구현 된 아이디어가 있습니다. 유형 매개 변수가 self type 수 있도록하는 방법을 참고, 그래서 당신은 명시 적으로 모든 서브 클래스에서 Repr을 정의 할 필요가 없습니다 : 눈에서

trait Item {} 

trait MyTrait { 
    type Repr <: MyTrait 

    def substitute(original: Item, replacement: Item) : Repr 
    def substituteAll(originals: List[Item], replacements: List[Item]) : Repr 
} 

object MyTrait { 
    trait Aux[T <: MyTrait.Aux[T]] extends MyTrait { self: T => 
    type Repr = T 

    def substituteAll(originals: List[Item], replacements: List[Item]) : T = { 
     def loop(pairs: List[(Item, Item)]): Repr = pairs match { 
     case (orig, rep) :: tail => 
      substitute(orig, rep) 
      loop(tail) 
     case Nil => this 
     } 
     loop(originals zip replacements) 
    } 
    } 
} 

trait MyTrait2 { } 

case class MyClassA(originals: List[Item]) extends MyTrait.Aux[MyClassA] with MyTrait2 { 
    def substitute(original: Item, replacement: Item) = MyClassA(originals) 
} 

case class MyClassB(originals: List[Item]) extends MyTrait.Aux[MyClassB] with MyTrait2 { 
    def substitute(original: Item, replacement: Item) = MyClassB(originals) 
} 

case class CompoundClass(list : List[MyTrait]) extends MyTrait.Aux[CompoundClass] { 
    def substitute(
    original: Item, 
    replacement: Item 
) = CompoundClass(
    list.map(_.substitute(original, replacement)) 
) 
}