Что означают все символические операторы Scala?

Одно (хорошее, IMO) различие между Scala и другими языками состоит в том, что он позволяет вам называть ваши методы практически любым символом.

То, что вы перечисляете, это не "пунктуация", а простые и простые методы, и поэтому их поведение варьируется от одного объекта к другому (хотя существуют некоторые соглашения).

Например, проверьте документацию Scaladoc для списка, и вы увидите некоторые из описанных здесь методов.

Некоторые вещи, которые нужно иметь в виду:

• В большинстве случаев комбинация A operator+equal B преобразуется в A = A operator B, как в примерах ||= или ++=.

• Методы, заканчивающиеся на :, являются правильными ассоциативными, это означает, что A :: B на самом деле B.::(A).

Вы найдете большинство ответов, просмотрев документацию Scala. Сохранение ссылки здесь удвоило бы усилия, и оно быстро отстало:)

Вы можете сгруппировать их по определенным критериям. В этом посте я просто объясню символ подчеркивания и стрелку вправо.

_._ содержит период. Период в Scala всегда указывает вызов метода. Итак, слева от периода у вас есть получатель, а справа от него - сообщение (имя метода). Теперь _ является специальным символом в Scala. Есть несколько сообщений об этом, например в этой записи в блоге все варианты использования. Здесь это короткая вырезка анонимной функции, то есть это ярлык для функции, которая принимает один аргумент и вызывает метод _ на нем. Теперь _ не является допустимым методом, поэтому, наверняка, вы видели _._1 или что-то подобное, то есть вызывать метод _._1 в аргументе функции. _1 to _22 - это методы кортежей, которые извлекают конкретный элемент кортежа. Пример:

val tup = ("Hallo", 33)
tup._1 // extracts "Hallo"
tup._2 // extracts 33

Теперь давайте предположим пример использования ярлыка приложения приложения. Для карты, которая отображает целые числа в строки:

val coll = Map(1 -> "Eins", 2 -> "Zwei", 3 -> "Drei")

Wooop, есть еще одно появление странной пунктуации. Дефис и символы большего размера, которые напоминают правую стрелку, представляют собой оператор, который создает Tuple2. Таким образом, нет никакой разницы в результатах написания (1, "Eins") или 1 -> "Eins", только то, что последнее легче читать, особенно в списке кортежей, подобных примеру карты. -> не является магии, он, как и несколько других операторов, доступен, потому что у вас есть все неявные преобразования в объекте scala.Predef в области, Преобразование, которое происходит здесь,

implicit def any2ArrowAssoc [A] (x: A): ArrowAssoc[A] 

Где ArrowAssoc имеет метод ->, который создает Tuple2. Таким образом, 1 -> "Eins" является фактическим вызовом Predef.any2ArrowAssoc(1).->("Eins"). ОК. Вернемся к исходному вопросу с символом подчеркивания:

// lets create a sequence from the map by returning the
// values in reverse.
coll.map(_._2.reverse) // yields List(sniE, iewZ, ierD)

Подчеркнутый символ сокращает следующий эквивалентный код:

coll.map(tup => tup._2.reverse)

Обратите внимание, что метод map карты передает в кортеж ключа и значение аргумент функции. Поскольку нас интересуют только значения (строки), мы извлекаем их с помощью метода _2 на кортеже.

В дополнение к блестящим ответам Daniel и 0__, я должен сказать, что Scala понимает Unicode аналоги для некоторых из символов, поэтому вместо

for (n <- 1 to 10) n % 2 match {
  case 0 => println("even")
  case 1 => println("odd")
}

можно написать

for (n ← 1 to 10) n % 2 match {
  case 0 ⇒ println("even")
  case 1 ⇒ println("odd")
}

<= аналогичен тому, как вы "читали" его: "меньше или равно". Итак, это математический оператор в списке < (меньше?), > (больше?), == (равно?), != (не равно?), <= (меньше или равно?) и >= (больше или равно?).

Это не следует путать с =>, который является видом двойной правой стрелки, используемой для разделения списка аргументов из тела функции и разделения условия тестирования в шаблоне (a case block) из тела, выполняемого при совпадении. Вы можете увидеть пример этого в моих предыдущих двух ответах. Во-первых, функция использует:

coll.map(tup => tup._2.reverse)

который уже сокращен, поскольку типы опущены. Следующей функцией будет

// function arguments         function body
(tup: Tuple2[Int, String]) => tup._2.reverse

и использование шаблона:

def extract2(l: List[Int]) = l match {
   // if l matches Nil    return "empty"
   case Nil            => "empty"
   // etc.
   case ::(head, Nil)  => "exactly one element (" + head + ")"
   // etc.
   case ::(head, tail) => "more than one element"
}

Относительно :: есть еще одна запись https://stackoverflow.com/questions/5311653/scala-and-the-object, которая охватывает случай ::. Короче говоря, он используется для построения Lists с помощью consing "элемента head и хвостового списка. Это как класс, который представляет собой список cons'ed и который может использоваться как экстрактор, но чаще всего это метод на список. Как указывает Пабло Фернандес, поскольку он заканчивается в двоеточии, это правильный ассоциативный, то есть получатель вызова метода находится справа, а аргумент слева от оператора. Таким образом, вы можете элегантно выражать consing как добавление нового элемента head в существующий список:

val x = 2 :: 3 :: Nil  // same result as List(2, 3)
val y = 1 :: x         // yields List(1, 2, 3)

Это эквивалентно

val x = Nil.::(3).::(2) // successively prepend 3 and 2 to an empty list
val y = x.::(1)         // then prepend 1

Использование в качестве объекта-экстрактора выглядит следующим образом:

def extract(l: List[Int]) = l match {
   case Nil          => "empty"
   case head :: Nil  => "exactly one element (" + head + ")"
   case head :: tail => "more than one element"
}

extract(Nil)          // yields "empty"
extract(List(1))      // yields "exactly one element (33)"
extract(List(2, 3))   // yields "more than one element"

Это выглядит как оператор здесь, но это действительно просто другой (более читаемый) способ записи

def extract2(l: List[Int]) = l match {
   case Nil            => "empty"
   case ::(head, Nil)  => "exactly one element (" + head + ")"
   case ::(head, tail) => "more than one element"
}

Подробнее об экстракторах читайте в этот пост.

Я считаю, что современная среда IDE имеет решающее значение для понимания больших проектов scala. Поскольку эти операторы также являются методами, в идее intellij я просто управляю щелчком или control-b в определениях.

Вы можете щелкнуть правой кнопкой мыши в оператор cons (::) и в конце в scala javadoc say "Добавляет элемент в начале этого списка". В пользовательских операторах это становится еще более критичным, поскольку они могут быть определены в труднодоступных имплицитах... ваша IDE знает, где неявный был определен.

Просто добавление к другим отличным ответам. Scala также имеет операторы /: (foldLeft) и :\ (foldRight), которые являются право-ассоциативными инфиксными операторами. Итак, следующие три утверждения одинаковы:

( 1 to 100 ).foldLeft( 0, _+_ )
( 1 to 100 )./:( 0 )( _+_ )
( 0 /: ( 1 to 100 ) )( _+_ )

То же самое относится к foldRight и :\.

Scala наследует большинство Java-арифметических операторов. Это включает в себя побитовое или | (однотрубный символ), побитовое и &, бит-исключение или ^, а также логические (логические) или || (двухтрубные символы) и логические и &&. Интересно, что вы можете использовать одиночные символьные операторы на boolean, поэтому логические операторы java'ish полностью избыточны:

true && true   // valid
true & true    // valid as well

3 & 4          // bitwise-and (011 & 100 yields 000)
3 && 4         // not valid

Как указано в другом сообщении, вызовы, заканчивающиеся на знак равенства =, разрешаются (если метод с этим именем не существует!) путем переназначения:

var x = 3
x += 1         // `+=` is not a method in `int`, Scala makes it `x = x + 1`

Эта "двойная проверка" позволяет легко обменивать mutable для неизменяемой коллекции:

val m = collection.mutable.Set("Hallo")   // `m` a val, but holds mutable coll
var i = collection.immutable.Set("Hallo") // `i` is a var, but holds immutable coll

m += "Welt" // destructive call m.+=("Welt")
i += "Welt" // re-assignment i = i + "Welt" (creates a new immutable Set)