Scala: risultato inverso durante l'escape del carattere di sottolineatura con :::

Question

Quando si prova a rispondere a questa domanda: Leave off underscore in function literal Ho provato a codificare un esempio e ho affrontato uno strano comportamento.

scala> val myList = 1::2::Nil 
myList: List[Int] = List(1, 2) 

scala> def concat:(List[Int]=> List[Int]) = myList::: 
concat: (List[Int]) => List[Int] 

scala> concat(3::Nil) 
res1: List[Int] = List(3, 1, 2) 

mentre io ho la buona risposta quando uso _ o x=> f(x) sintassi.

scala> def concat0:(List[Int]=> List[Int]) = x=> myList:::x 
concat0: (List[Int]) => List[Int] 

scala> def concat1:(List[Int]=> List[Int]) = myList::: _ 
concat1: (List[Int]) => List[Int] 

scala> concat0(3::Nil) 
res2: List[Int] = List(1, 2, 3) 

scala> concat1(3::Nil) 
res3: List[Int] = List(1, 2, 3) 

C'è una spiegazione razionale per questo myList viene dopo 3::Nil nella funzione concat?

Answer 1

myList ::: _ corrisponde a _.:::(myList), mentre myList ::: corrisponde a myList.:::(_).

tl; dr

This post va in ulteriori dettagli sui metodi associativi giusti. Quello che sta succedendo qui è:

• def concat0:(List[Int]=> List[Int]) = x=> myList:::x
  • Scala compilatore può dedurre che x, se di tipo List[Int]
  • List ha un metodo :::
  • A causa delle regole di associatività a destra, questo si trasforma in x.:::(myList) , che antepone myList a x.
• def concat: (Lista [Int] => elenco [Int]) = myList :::
  • myList se di tipo List[Int]
  • Non v'è alcun lato destro della :::, quindi non c'è no associatività destra
  • Invece, il compilatore deduce a. tra myList e :::
  • myList.::: è la stessa x => myList.:::(x), che antepone x a myList.