스칼라가 연결된 (투영) 유형 멤버를 연결할 때 관련 유형의 트랙을 잃습니다

Question

저는 walking around a problem입니다. 유형 프로젝션과 추상 유형에 새로운 이상한 문제가 발견되었습니다. 트랜잭션을 생성하는 시스템이 있고 브리지 할 피어 시스템이 있다고 가정 해보십시오.

trait Txn[S <: Sys[S]] { 
    def peer: S#Peer#Tx 
    def newID(): S#ID 
    def newVar[A](id: S#ID, init: A): S#Var[A] 
} 
trait Sys[S <: Sys[S]] { 
    type Tx <: Txn[S] 
    type Peer <: Sys[Peer] // parallel system 
    type Var[A] 
    type ID 
} 

내가 직접 시스템을 사용할 수 있습니다 : 다음은 나에게 좋아 보인다

def indirectDoesnt[S <: Sys[S]](implicit tx: S#Tx): Unit = { 
    val p = tx.peer 
    val id = p.newID() 
    val v = p.newVar(id, 0) // what the **** - id is not compatible?? 
} 

error: type mismatch; 
found : id.type (with underlying type S#Peer#ID) 
required: _30129.Peer#ID where val _30129: S 
      val v = p.newVar(id, 0) 
          ^

:

def directWorks[S <: Sys[S]](implicit tx: S#Tx): Unit = { 
    val id = tx.newID() 
    val v = tx.newVar(id, 0) 
} 

하지만를 어떻게 든 거래의 peer 방법은 다음에서 볼 수 있듯이, 결함이

나는 영리 해지고 그걸 해결하려고했다.

def clever[S <: Sys[S]](implicit tx: S#Tx): Unit = { 
    def directWorks[S <: Sys[S]](implicit tx: S#Tx): Unit = { 
    val id = tx.newID() 
    val v = tx.newVar(id, 0) 
    } 
    directWorks(tx.peer) 
} 

...하지만 그 잘못에 대한 자세한 단서를주고, 너무, 실패

error: inferred type arguments [S#Peer] do not conform to method 
     directWorks's type parameter bounds [S <: Sys[S]] 
      directWorks(tx.peer) 
     ^

그것은 모두가 하나 def peer: S#Peer#Tx 문제를 소개하고, 또는 제안으로 사용하지 않을 때 type Peer <: Sys[Peer]이 문제입니다 (가능성을?) 매개 변수을 입력하고 구성원을 입력하십시오.

Answer 1

여기에 거의 수용 가능한 해결책이 있습니다. 표현 유형을 Sys에 "고정"하는 아이디어를 기반으로합니다. 구체적인 시스템 S에서는 항상 S#S#Tx == S#Tx 등이 있습니다.이 솔루션에 대한 나의 이해는 사용 책임 사이트에서 시스템 자체로 분산에 대한 책임을 이동한다는 것입니다.

일부 기념식이 포함되기 때문에이 기념식을 삭제하거나 축소하는 것과 관련된 추가 답변에 대해 계속 감사드립니다. 이 작동 이유에 대한 설명과 fix에 대한 호출을 생략 한 것에 대한 설명은 작동하지 않습니다.

trait VarLike[ -Tx, A ] { def update(value: A)(implicit tx: Tx) : Unit } 

trait Sys[ S <: Sys[ S ]] { 
    type Tx  <: Txn[ S ] 
    type Var[ A ] <: VarLike[ S#Tx, A ] 
    type ID 
    type Peer  <: Sys[ Peer ] 

    // 'pop' the representation type ?! 
    def fix[ A ](v: S#Peer#Var[ A ]) : Peer#Var[ A ] 
    def peer(tx: S#Tx) : Peer#Tx 
} 

trait Txn[ S <: Sys[ S ]] { 
    def newID() : S#ID 
    def newVar[ A ](id: S#ID, init: A) : S#Var[ A ] 
    def system: S 
} 

이제 두 가지 예제 시스템이 있습니다. 첫째 :

class InMemTx(val system: InMem) extends Txn[ InMem ] { 
    def newID() {} 
    def newVar[ A ](id: InMem#ID, init: A) : InMem#Var[ A ] = 
     new VarLike[ InMemTx, A ] { 
     def update(v: A)(implicit tx: InMemTx) {} 
     } 
} 
class InMem extends Sys[ InMem ] { 
    type Tx  = InMemTx 
    type Var[ A ] = VarLike[ Tx, A ] 
    type ID  = Unit 
    type Peer  = InMem // reflect back to ourself 

    def fix[ A ](v: Var[ A ]) : Var[ A ] = v 
    def peer(tx: Tx) : Tx = tx 
} 

둘째 :

class DurableTx(val system: Durable, val peer: InMem#Tx) extends Txn[ Durable ] { 
    def newID() = 33 
    def newVar[ A ](id: Durable#ID, init: A) : Durable#Var[ A ] = 
     new VarLike[ DurableTx, A ] { 
     def update(v: A)(implicit tx: DurableTx) {} 
     } 
} 
class Durable extends Sys[ Durable ] { 
    type Tx  = DurableTx 
    type Var[ A ] = VarLike[ Tx, A ] 
    type ID  = Int 
    type Peer  = InMem 

    def fix[ A ](v: InMem#Var[ A ]) : InMem#Var[ A ] = v 
    def peer(tx: Tx) : InMem#Tx = tx.peer 
} 

그리고에서 인증 할를 사용하는 사이트 :

// let's make sure we can use the system as intended 
trait TestTrait[ S <: Sys[ S ]] { 
    def v : S#Peer#Var[ Int ] 

    def test(implicit tx: S#Tx) { 
     val s   = tx.system 
     implicit val p = s.peer(tx) 
     val vf   = s.fix(v) // not cool... 
     vf()   = 1 
    } 
} 

// see if we can actually create variables 
class TestImpl[ S <: Sys[ S ]](implicit tx: S#Tx) extends TestTrait[ S ] { 
    val v = { 
     val s   = tx.system 
     implicit val p = s.peer(tx) 
     val id   = p.newID() 
     p.newVar(id, 0) 
    } 
}