2015-06-19 12 views
5

Sto disegnando uno spazio vuoto su come realizzare quanto segue senza barare e usando asInstanceOf.Tipi dipendenti dalla corrispondenza del modello - come evitare asInstanceOf?

Supponiamo di disporre di alcuni tipi di oggetti sigillati, ognuno con i propri membri del tipo.

sealed trait Part { type A } 
    case object P1 extends Part { override type A = String } 
    case object P2 extends Part { override type A = Int } 

Ora dicono che ingloba un P e un valore P.A insieme ...

trait PartAndA { 
    val p: Part 
    val a: p.A 
    } 

    object PartAndA { 
    type Aux[P <: Part] = PartAndA {val p: P} 

    def apply(_p: Part)(_a: _p.A): Aux[_p.type] = 
     new PartAndA { 
     override val p: _p.type = _p 
     override val a   = _a 
     } 
    } 

Come posso tranquillamente realizzare i seguenti per la stanchezza controllo e senza calchi manuali?

def fold[A](pa: PartAndA)(p1: PartAndA.Aux[P1.type] => A, 
          p2: PartAndA.Aux[P2.type] => A): A = 
    pa.p match { 
     case P1 => p1(pa.asInstanceOf[PartAndA.Aux[P1.type]]) 
     case P2 => p2(pa.asInstanceOf[PartAndA.Aux[P2.type]]) 
    } 

risposta

1

Penso che il problema sia collegato a jvm type erasure. Senza di esso il problema potrebbe essere semplificata per:

sealed trait Part { type A } 
case class P1() extends Part { override type A = String } 
case class P2() extends Part { override type A = Int } 

trait PartAndA[P <: Part] { 
    val p: P 
    val a: p.A 
} 

object PartAndA { 
    type Aux[P <: Part] = PartAndA[P] 

    def apply(_p: Part)(_a: _p.A): PartAndA[_p.type] = 
    new PartAndA[_p.type] { 
     override val p: _p.type = _p 
     override val a   = _a 
    } 
} 

def fold[A, T: ClassTag](pa: PartAndA[T])(p1: PartAndA[P1] => A, 
          p2: PartAndA[P2] => A): A = 
    pa match { 
    case s: PartAndA[P1] => p1(pa) // here P1 is lost, err 
    case i: PartAndA[P2] => p2(pa) // here P2 is lost, err 
    } 

Secondo la mia conoscenza non c'è più breve (che il vostro o con typeTags/classTags) soluzione di tipo jvm cancellazione.

+0

Ah sì, sarebbe il caso se fossi in corrispondenza di 'pa', ma' pa.p' è concreto e possiamo abbinarlo senza problemi di cancellazione. Non so come costruire una dimostrazione che dice se conosco il tipo 'pa.p', quindi conosco il tipo' PartAndA.Aux'. – Golly

Problemi correlati