Какая формальная разница в Scala между фигурными скобками и скобками, и когда они должны использоваться?
В чем формальная разница между передачей аргументов функциям в скобках () и в фигурных скобках {}?
Чувство, которое я получил от книги " Программирование в Scala", заключается в том, что Scala довольно гибкая, и я должен использовать ту, которая мне нравится больше всего, но я считаю, что некоторые случаи компилируются, а другие нет.
Например (только в качестве примера; я был бы признателен за любой ответ, который обсуждает общий случай, а не только этот конкретный пример):
val tupleList = List[(String, String)]()
val filtered = tupleList.takeWhile( case (s1, s2) => s1 == s2 )
=> ошибка: неверное начало простого выражения
val filtered = tupleList.takeWhile{ case (s1, s2) => s1 == s2 }
=> хорошо.
8 ответов
Я однажды пытался написать об этом, но в конце концов сдался, так как правила несколько размыты. По сути, вам придется освоить его.
Возможно, лучше сконцентрироваться на том, где фигурные скобки и скобки можно использовать взаимозаменяемо: при передаче параметров в вызовы методов. Вы можете заменить скобки фигурными скобками, если и только если метод ожидает один параметр. Например:
List(1, 2, 3).reduceLeft{_ + _} // valid, single Function2[Int,Int] parameter
List{1, 2, 3}.reduceLeft(_ + _) // invalid, A* vararg parameter
Однако вам нужно знать больше, чтобы лучше понять эти правила.
Увеличена проверка компиляции с помощью паренов
Авторы Spray рекомендуют использовать круглые скобки, потому что они повышают проверку компиляции. Это особенно важно для DSL, таких как Spray. Используя parens, вы говорите компилятору, что он должен содержать только одну строку; поэтому, если вы случайно дадите ему два или более, он будет жаловаться. Теперь это не относится к фигурным скобкам - если, например, вы где-то забудете оператор, ваш код скомпилируется, и вы получите неожиданные результаты и потенциально очень трудную ошибку, которую можно найти. Ниже придумано (так как выражения чистые и, по крайней мере, выдаст предупреждение), но важно:
method {
1 +
2
3
}
method(
1 +
2
3
)
Первый компилирует, второй дает error: ')' expected but integer literal found, Автор хотел написать 1 + 2 + 3,
Можно утверждать, что это похоже на многопараметрические методы с аргументами по умолчанию; Нельзя случайно забыть запятую для разделения параметров при использовании паренов.
многословие
Важное часто пропускаемое примечание о многословии. Использование фигурных скобок неизбежно приводит к многословному коду, поскольку в руководстве по стилю Scala четко указано, что закрывающие фигурные скобки должны находиться на отдельной строке:
… Закрывающая фигурная скобка находится на отдельной строке сразу после последней строки функции.
Многие автоформаты, как в IntelliJ, автоматически выполнят это переформатирование для вас. Поэтому старайтесь использовать круглые скобки, когда можете.
Инфиксная нотация
При использовании инфиксной записи, например, List(1,2,3) indexOf (2) Вы можете опустить круглые скобки, если есть только один параметр, и записать его как List(1, 2, 3) indexOf 2, Это не случай точечной нотации.
Также обратите внимание, что когда у вас есть один параметр, который является выражением с несколькими токенами, например x + 2 или же a => a % 2 == 0 Вы должны использовать круглые скобки, чтобы указать границы выражения.
Кортеж
Поскольку иногда вы можете опустить круглые скобки, иногда кортежу нужны дополнительные круглые скобки, как в ((1, 2)) и иногда внешняя скобка может быть опущена, как в (1, 2), Это может вызвать путаницу.
Литералы функций / частичных функций с case
Scala имеет синтаксис для литералов функций и частичных функций. Это выглядит так:
{
case pattern if guard => statements
case pattern => statements
}
Единственные другие места, где вы можете использовать case заявления с match а также catch ключевые слова:
object match {
case pattern if guard => statements
case pattern => statements
}
try {
block
} catch {
case pattern if guard => statements
case pattern => statements
} finally {
block
}
Вы не можете использовать case заявления в любом другом контексте. Итак, если вы хотите использовать case Вам нужны фигурные скобки. Если вам интересно, что делает различие между функцией и частичной функцией буквальным, ответ: контекст. Если Scala ожидает функцию, функция, которую вы получите. Если он ожидает частичную функцию, вы получите частичную функцию. Если оба ожидаются, это дает ошибку о неоднозначности.
Выражения и блоки
Скобки могут быть использованы для создания подвыражений. Фигурные скобки могут использоваться для создания блоков кода (это не буквальная функция, поэтому остерегайтесь использовать ее как единое целое). Блок кода состоит из нескольких операторов, каждый из которых может быть оператором импорта, объявлением или выражением. Это выглядит так:
{
import stuff._
statement ; // ; optional at the end of the line
statement ; statement // not optional here
var x = 0 // declaration
while (x < 10) { x += 1 } // stuff
(x % 5) + 1 // expression
}
( expression )
Итак, если вам нужны объявления, несколько операторов, import или что-то в этом роде, вам нужны фигурные скобки. А поскольку выражение является утверждением, скобки могут появляться внутри фигурных скобок. Но интересно то, что блоки кода также являются выражениями, поэтому вы можете использовать их в любом месте выражения:
( { var x = 0; while (x < 10) { x += 1}; x } % 5) + 1
Таким образом, поскольку выражения являются операторами, а блоки кодов являются выражениями, все приведенное ниже является действительным:
1 // literal
(1) // expression
{1} // block of code
({1}) // expression with a block of code
{(1)} // block of code with an expression
({(1)}) // you get the drift...
Где они не взаимозаменяемы
В принципе, вы не можете заменить {} с () или наоборот где-нибудь еще. Например:
while (x < 10) { x += 1 }
Это не вызов метода, поэтому вы не можете написать его другим способом. Ну, вы можете поставить фигурные скобки в скобках для condition, а также использовать скобки внутри фигурных скобок для блока кода:
while ({x < 10}) { (x += 1) }
Надеюсь, это поможет.
Здесь происходит несколько различных правил и выводов: во-первых, Scala выводит фигурные скобки, когда параметр является функцией, например, в list.map(_ * 2) брекеты выведены, это просто более короткая форма list.map({_ * 2}), Во-вторых, Scala позволяет пропустить скобки в последнем списке параметров, если этот список параметров имеет один параметр и является функцией, поэтому list.foldLeft(0)(_ + _) можно записать как list.foldLeft(0) { _ + _ } (или же list.foldLeft(0)({_ + _}) если вы хотите быть более явным).
Однако, если вы добавите case вы получаете, как уже упоминалось, частичную функцию вместо функции, и Scala не будет выводить скобки для частичных функций, поэтому list.map(case x => x * 2) не сработает, но оба list.map({case x => 2 * 2}) а также list.map { case x => x * 2 } будут.
Сообщество пытается стандартизировать использование скобок и скобок, см. Руководство по стилю Scala (стр. 21): http://www.codecommit.com/scala-style-guide.pdf
Рекомендуемый синтаксис для вызовов методов более высокого порядка - всегда использовать фигурные скобки и пропускать точку:
val filtered = tupleList takeWhile { case (s1, s2) => s1 == s2 }
Для "обычных" вызовов методов вы должны использовать точку и скобки.
val result = myInstance.foo(5, "Hello")
Я не думаю, что в Scala есть что-то особенное или сложное в фигурных скобках. Чтобы освоить кажущееся сложным использование их в Scala, просто помните пару простых вещей:
- фигурные скобки образуют блок кода, который вычисляется до последней строки кода (это делают почти все языки)
- функция при желании может быть сгенерирована с помощью блока кода (следует правилу 1)
- фигурные скобки могут быть опущены для однострочного кода, за исключением предложения case (выбор Scala)
- круглые скобки могут быть опущены при вызове функции с блоком кода в качестве параметра (выбор Scala)
Давайте объясним пару примеров согласно вышеупомянутым трем правилам:
val tupleList = List[(String, String)]()
// doesn't compile, violates case clause requirement
val filtered = tupleList.takeWhile( case (s1, s2) => s1 == s2 )
// block of code as a partial function and parentheses omission,
// i.e. tupleList.takeWhile({ case (s1, s2) => s1 == s2 })
val filtered = tupleList.takeWhile{ case (s1, s2) => s1 == s2 }
// curly braces omission, i.e. List(1, 2, 3).reduceLeft({_+_})
List(1, 2, 3).reduceLeft(_+_)
// parentheses omission, i.e. List(1, 2, 3).reduceLeft({_+_})
List(1, 2, 3).reduceLeft{_+_}
// not both though it compiles, because meaning totally changes due to precedence
List(1, 2, 3).reduceLeft _+_ // res1: String => String = <function1>
// curly braces omission, i.e. List(1, 2, 3).foldLeft(0)({_ + _})
List(1, 2, 3).foldLeft(0)(_ + _)
// parentheses omission, i.e. List(1, 2, 3).foldLeft(0)({_ + _})
List(1, 2, 3).foldLeft(0){_ + _}
// block of code and parentheses omission
List(1, 2, 3).foldLeft {0} {_ + _}
// not both though it compiles, because meaning totally changes due to precedence
List(1, 2, 3).foldLeft(0) _ + _
// error: ';' expected but integer literal found.
List(1, 2, 3).foldLeft 0 (_ + _)
def foo(f: Int => Unit) = { println("Entering foo"); f(4) }
// block of code that just evaluates to a value of a function, and parentheses omission
// i.e. foo({ println("Hey"); x => println(x) })
foo { println("Hey"); x => println(x) }
// parentheses omission, i.e. f({x})
def f(x: Int): Int = f {x}
// error: missing arguments for method f
def f(x: Int): Int = f x
Я думаю, что стоит объяснить их использование в вызовах функций и почему происходят разные вещи. Как уже говорилось, фигурные скобки определяют блок кода, который также является выражением, поэтому его можно поместить туда, где ожидается выражение, и оно будет оценено. При оценке выполняются его операторы, а значение последнего оператора является результатом оценки всего блока (как в Ruby).
Имея это, мы можем сделать такие вещи, как:
2 + { 3 } // res: Int = 5
val x = { 4 } // res: x: Int = 4
List({1},{2},{3}) // res: List[Int] = List(1,2,3)
Последний пример - это просто вызов функции с тремя параметрами, каждый из которых оценивается первым.
Теперь, чтобы увидеть, как это работает с вызовами функций, давайте определим простую функцию, которая принимает другую функцию в качестве параметра.
def foo(f: Int => Unit) = { println("Entering foo"); f(4) }
Чтобы вызвать его, нам нужно передать функцию, которая принимает один параметр типа Int, поэтому мы можем использовать литерал функции и передать ее в foo:
foo( x => println(x) )
Теперь, как было сказано ранее, мы можем использовать блок кода вместо выражения, поэтому давайте использовать его
foo({ x => println(x) })
Здесь происходит то, что код внутри {} вычисляется, и значение функции возвращается как значение оценки блока, затем это значение передается в foo. Семантически это то же самое, что и предыдущий вызов.
Но мы можем добавить что-то еще:
foo({ println("Hey"); x => println(x) })
Теперь наш блок кода содержит два оператора, и поскольку он вычисляется перед выполнением foo, происходит то, что сначала печатается "Hey", затем наша функция передается в foo, печатается "Entering foo" и, наконец, "4",
Это выглядит немного уродливо, и Scala позволяет нам пропустить скобки в этом случае, поэтому мы можем написать:
foo { println("Hey"); x => println(x) }
или же
foo { x => println(x) }
Это выглядит намного лучше и эквивалентно первым. Здесь все еще блок кода оценивается первым, а результат оценки (то есть x => println(x)) передается в качестве аргумента в foo.
Потому что вы используете caseВы определяете частичную функцию, а частичные функции требуют фигурных скобок.
Увеличена проверка компиляции с помощью паренов
Авторы Spray рекомендуют, чтобы круглые скобки увеличивали проверку компиляции. Это особенно важно для DSL, таких как Spray. Используя паренсы, вы говорите компилятору, что ему нужно дать только одну строку, поэтому, если вы случайно дали ему две или более, он будет жаловаться. Теперь это не относится к фигурным скобкам, если, например, вы забудете оператор где-то, где ваш код скомпилируется, вы получите неожиданные результаты и потенциально очень трудную ошибку, которую можно найти. Ниже выдумано (так как выражения чистые и, по крайней мере, даст предупреждение), но подчеркивает
method {
1 +
2
3
}
method(
1 +
2
3
)
Первый компилирует, второй дает error: ')' expected but integer literal found. автор хотел написать 1 + 2 + 3,
Можно утверждать, что это похоже на многопараметрические методы с аргументами по умолчанию; Нельзя случайно забыть запятую для разделения параметров при использовании паренов.
многословие
Важное часто пропускаемое примечание о многословии. Использование фигурных скобок неизбежно приводит к подробному коду, поскольку в руководстве по стилю scala четко указано, что закрывающие фигурные скобки должны быть на своей строке: http://docs.scala-lang.org/style/declarations.html "... закрывающая фигурная скобка находится на отдельной строке сразу после последней строки функции." Многие автоформаты, как в Intellij, автоматически выполнят это переформатирование для вас. Поэтому старайтесь использовать круглые скобки, когда можете. Например List(1, 2, 3).reduceLeft{_ + _} будет выглядеть так:
List(1, 2, 3).reduceLeft {
_ + _
}
Круглые скобки в идеальном стиле кодирования в основном используются для однострочного кода. Но если конкретный фрагмент кода является многострочным, то лучше использовать фигурные скобки.
С фигурными скобками у вас есть точка с запятой для вас, а скобки нет. Рассматривать takeWhile функция, так как она ожидает частичную функцию, только {case xxx => ??? } допустимое определение вместо скобок вокруг выражения case.