Est-il possible d'accepter un extracteur arbitraire comme argument de méthode?

Question

Je souhaite réutiliser des extracteurs existants et les composer. A => Option[B] correspond parfaitement à B => Option[C].

Mais je suis confus, comment pourrais-je exprimer une telle relation dans le code.

La manière évidente n'est pas disponible pour une bonne raison:

type Extractor[F,T] = { 
    def unapply(from : F) : Option[T] 
} 

def bind[A,B,C](l : Extractor[A,B], r : Extractor[B,C]) = new { 
    def unapply(from : A) : Option[C] = l.unapply(from).flatMap(r.unapply _) 
} 

scalac réponse:

Extractors.scala:7: error: Parameter type in structural refinement may not refer to an abstract type defined outside that refinement 
    def unapply(from : A) : Option[C] = l.unapply(from).flatMap(r.unapply _) 
       ^
Extractors.scala:3: error: Parameter type in structural refinement may not refer to an abstract type defined outside that refinement 
    def unapply(from : F) : Option[T] 
       ^
two errors found 

Internet indique qu'il est le comportement attendu en raison de l'effacement de type.

Est-il possible de reformuler le code pour qu'il fonctionne correctement?

Answer 1

type de paramètre dans le raffinement structurel ne peut pas faire référence à un type abstrait défini en dehors de cette refinement`

Comme l'erreur à appeler, pour structure type ne peut pas renvoyer l'generic type que défini à l'extérieur.

Pour votre exemple, vous pouvez utiliser trait pour faire la même chose, comme:

trait Extractor[F, T] { 
    def unapply(from: F): Option[T] 
} 

def bind[A, B, C](l: Extractor[A, B], r: Extractor[B, C]) = new Extractor[A, C] { 
    override def unapply(from: A): Option[C] = l.unapply(from).flatMap(r.unapply) 
}