Что хороший правоассоциативные методы в Scala?

Короткий ответ заключается в том, что правоассоциативность может улучшить читаемость, сделав тип программиста совместимым с тем, что программа фактически делает.
Итак, если вы наберете ' 1 :: 2 :: 3 ', вы получите обратно список (1, 2, 3) вместо того, чтобы возвращать список в совершенно другом порядке.
Это потому, что « 1 :: 2 :: 3 :: Nil » на самом деле

List[Int].3.prepend(2).prepend(1)

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

, что одновременно:

• более читабельно
• более эффективно (O (1) для prepend , vs. O (n) для гипотетического метода добавления )

(Напоминание, выдержка из книги Программирование на Scala )
Если метод используется в обозначении оператора, например a * b , метод вызывается для левого операнда, как в a. * (B) - если имя метода не заканчивается в двоеточие.
Если имя метода заканчивается двоеточием, метод вызывается для правого операнда.
Следовательно, в 1 :: twoThree метод :: вызывается для twoThree , передавая 1, например: twoThree .: :( 1) .

Для List он играет роль операции добавления (кажется, что список добавляется после «1», образуя « 1 2 3 », где на самом деле это равно 1, который добавлен к списку ).
Список классов не предлагает настоящую операцию добавления, потому что время, необходимое для добавления в список, растет линейно с размером списка, тогда как добавление с :: требует постоянного времени .
myList :: 1 попытается добавить все содержимое myList к '1', что будет длиннее, чем добавление 1 к myList (как в ' 1 :: myList ')

Примечание: неважно какую ассоциативность имеет оператор, однако его операнды всегда оценивается слева направо.
Итак, если b - это выражение, которое не является простой ссылкой на неизменяемое значение, тогда a ::: b более точно рассматривается как следующий блок:

{ val x = a; b.:::(x) }

В этом блоке a по-прежнему оценивается до b, а затем результат этой оценки передается как операнд методу b :::.

зачем вообще различать левоассоциативные и правоассоциативные методы?

Это позволяет сохранить вид обычной левоассоциативной операции (' 1 :: myList '), фактически применяя операцию к правильному выражению, потому что;

• это более эффективно.
• , но он более читабелен с обратным ассоциативным порядком (' 1 :: myList ' vs. ' myList.prepend (1) ')

Итак, как вы говорите , "синтаксический сахар", насколько мне известно.
Обратите внимание, что в случае foldLeft , например, они могли зайти слишком далеко (с эквивалентом правоассоциативного оператора « /: »)

Чтобы включить некоторые из ваших комментариев, слегка перефразируя:

если вы рассматриваете левоассоциативную функцию 'append', то вы должны написать ' oneTwo append 3 append 4 append 5 '.
Однако, если бы к oneTwo добавить 3, 4 и 5 (что можно было бы предположить по тому, как это написано), получилось бы O (N).
То же самое с '::', если это было для "добавления". Но это не так. На самом деле это для "prepend"

. Это означает, что ' a :: b :: Nil ' для ' List []. B.prepend (a) '

Если бы "::" добавлялось в начало и все же оставалось левоассоциативным, то результирующий список был бы в неправильном порядке.
Можно было бы ожидать, что он вернет List (1, 2, 3, 4, 5), но в итоге он вернет List (5, 4, 3, 1, 2), что может быть неожиданным для программиста.
Это потому, что то, что вы сделали, было бы в левоассоциативном порядке:

(1,2).prepend(3).prepend(4).prepend(5) : (5,4,3,1,2)

Итак, правоассоциативность заставляет код совпадать с фактическим порядком возвращаемого значения.