Pourquoi ne puis-je pas enchaîner plusieurs appels de méthode Scala Infix

Question

Je travaille sur un DSL et j'ai rencontré un problème avec l'utilisation de méthodes comme opérateurs d'infixes dans une chaîne. Je vais juste essayer de l'expliquer avec du code. J'ai un trait Term et des classes de cas Literal et Variable l'étendre. Je souhaite construire une liste des instances de terme à l'aide de certains opérateurs.

case class Expr(val terms: List[Term]) {
 def +(v: String) = Expr(Literal(v) :: terms)
 def -->(func: List[String] => List[String]) = terms match {
  case Literal(v) :: ts => Expr(Variable(v, func) :: ts)
  case _ => throw new Exception("Can only apply function on literal")
 }
}

object foo {
 def bar(name: String) = Expr(Literal(name) :: Nil)
}

// some functions
val one = ... 
val all = ...

// works
foo bar "x"        
// res1: Expr = Expr(List(Literal(x)))

// works not
foo bar "x" --> all
// error: value --> is not a member of java.lang.String

// works
(foo bar "x") --> all 
// res1: Expr = Expr(List(Variable(x,<function1>)))

Je m'attendrais à ce que cela soit équivalent à foo.bar("x").-->(all) Mais l'interprète semble le voir comme foo.bar("x".-->(all)).

Answer 1

Tu peux trouver avantage de l'opérateur ici:

Précédence de l'opérateur dans Scala

Selon la première réponse - a une priorité plus élevée par rapport aux lettres. Donc, le compilateur regroupe l'expression comme ceci:

foo bar ("x" --> all)

Si vous remplacez --> Avec quelque chose de priorité inférieure (par exemple, les lettres), elle devrait se compiler. Par exemple:

foo bar "x" to all

Vous pouvez également choisir un opérateur de priorité plus élevé au lieu de bar. Quelque chose comme ~~> le fera, car ~ est un caractère spécial et il a la plus haute priorité:

foo ~~> "x" --> all