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

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

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

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

некоторые вещи имейте в виду:

• чаще всего A operator+equal B сочетание переводится как A = A operator B, как в ||= или ++= примеры.

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

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

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

_._ содержит период. Точка в Scala всегда указывает на вызов метода. Таким образом, слева от периода у вас есть получатель, а справа от него сообщение (имя метода). Теперь _ это специальный символ в Scala. Об этом есть несколько сообщений, например эта запись в блоге все использовать случаи. Вот это анонимная функция short cut, что это ярлык для функции, которая принимает один аргумент и вызывает метод _ на нем. Теперь _ не является допустимым методом, поэтому, безусловно, вы видели _._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")

вуп, уже есть еще один случай странной пунктуации. Дефис и больше-чем символы, которые напоминают a стрелка вправо, является оператором, который производит Tuple2. Таким образом, нет никакой разницы в результате написания либо (1, "Eins") или 1 -> "Eins", только то, что последнее легче читать, особенно в списке кортежей, таких как карта образец. The -> нет магии, это, как и несколько других операторов, доступно, потому что у вас есть все подразумевается преобразования в объекте 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 метод на кортеж.

в дополнение к блестящим ответам Даниила и 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)из тела, выполненного при совпадении. Вы можете увидеть пример этого в моих предыдущих двух ответах. Во-первых, функция use:

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"
}

о :: есть еще Stackoverflow запись, которая охватывает :: случае. Короче говоря, он используется для построения Lists by'consing' головной элемент и хвостовой список. Это и класс который представляет собой список минусов и который может быть использован в качестве экстрактора, но чаще всего это метод on список. Как указывает Пабло Фернандес, поскольку он заканчивается двоеточием, это право ассоциативный, что означает, что получатель вызова метода находится справа, а аргумент-слева от оператора. Таким образом, вы можете элегантно выразить 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 idea I просто control-click или control-b В определения.

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

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

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`

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

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)

просто добавляя к другим отличным ответам. Scala предлагает два часто критикуемых символьных оператора,/: (foldLeft) и :\ (foldRight) операторы, первый из которых является правоассоциативным. Таким образом, следующие три утверждения эквивалентны:

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

как и эти трое:

( 1 to 100 ).foldRight( 0, _+_ )
( 1 to 100 ).:\( 0 )( _+_ )
( ( 1 to 100 ) :\ 0 )( _+_ )