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

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

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

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

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

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

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

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

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

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

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

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

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

ВООП, есть уже другое появление странной пунктуации. Дефис и больше-чем символы, которые напоминают стрелка вправо, является оператором, который производит 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 метод на кортеже.

в дополнение к блестящим ответам Даниила и 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 функция и отделить условие испытаний в сопоставлении с образцом (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"
}

о :: есть еще Stackoverflow запись, которая охватывает :: случае. Короче говоря, он используется для построения Lists by'consing' головной элемент и хвостовой список. Это как класс который представляет собой список минусов и который может быть использован в качестве экстрактора, но чаще всего это метод on список. Как указывает Пабло Фернандес, поскольку он заканчивается двоеточием, это право ассоциативный, что означает, что получатель вызова метода находится справа, а аргумент-слева от оператора. Таким образом, вы можете элегантно выразить консинг как перед новый головной элемент в существующий список:

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 я просто control-click или control-b В определения.

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

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

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 )( _+_ )