[scala] 중괄호와 괄호 사이의 스칼라의 공식적인 차이점은 무엇이며 언제 사용해야합니까?

나는 이것에 대해 한 번 쓰려고했지만 규칙이 다소 확산되어 결국 포기했습니다. 기본적으로, 당신은 그것을 끊어야합니다.

매개 변수를 메서드 호출에 전달할 때 중괄호와 괄호를 서로 바꿔 사용할 수있는 위치에 집중하는 것이 가장 좋습니다. 메소드에 단일 매개 변수가 필요한 경우에만 중괄호로 괄호를 대체 할 수 있습니다 . 예를 들면 다음과 같습니다.

List(1, 2, 3).reduceLeft{_ + _} // valid, single Function2[Int,Int] parameter

List{1, 2, 3}.reduceLeft(_ + _) // invalid, A* vararg parameter

그러나 이러한 규칙을 더 잘 이해하려면 알아야 할 것이 더 많습니다.

Parens를 통한 컴파일 검사 향상

Spray의 저자는 라운드 검사를 권장합니다. 컴파일 검사가 증가하기 때문입니다. 이것은 스프레이와 같은 DSL에 특히 중요합니다. parens를 사용하면 컴파일러에게 단 한 줄만 주어져야한다는 것을 알리는 것입니다. 따라서 실수로 둘 이상을 제공하면 불만이 표시됩니다. 이제 중괄호의 경우에는 해당되지 않습니다. 예를 들어 어딘가에서 연산자를 잊어 버린 경우 코드가 컴파일되고 예기치 않은 결과가 발생하고 찾기 어려운 버그가 발생할 수 있습니다. 아래는 (표현이 순수하고 적어도 경고를 줄 것이기 때문에) 고안되었지만, 요점을 지적합니다.

method {
  1 +
  2
  3
}

method(
  1 +
  2
  3
)

첫 번째 컴파일, 두 번째는 제공합니다 error: ')' expected but integer literal found. 저자는 글을 쓰고 싶었다 1 + 2 + 3.

기본 인수를 가진 다중 매개 변수 메소드와 유사하다고 주장 할 수 있습니다. Parens를 사용할 때 매개 변수를 구분하기 위해 실수로 쉼표를 잊어 버리는 것은 불가능합니다.

다변

자세한 정보에 대해 간과되는 중요한 메모입니다. 중괄호를 사용하면 필연적으로 자세한 코드가 생깁니다. 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

스칼라는 함수와 부분 함수 리터럴에 대한 구문을 가지고 있습니다. 다음과 같이 보입니다 :

{
    case pattern if guard => statements
    case pattern => statements
}

case명령문 을 사용할 수있는 유일한 다른 위치 는 matchand 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당신은 필요 중괄호. 함수와 부분 함수 리터럴을 구별하는 것이 궁금한 경우 대답은 다음과 같습니다. 문맥. 스칼라는 함수를 기대하면 얻을 수있는 함수입니다. 부분 함수가 필요한 경우 부분 함수를 얻습니다. 둘 다 예상되는 경우 모호성에 대한 오류가 발생합니다.

표현과 블록

괄호를 사용하여 하위 표현식을 만들 수 있습니다. 중괄호는 코드 블록을 만드는 데 사용할 수 있습니다 (이것은 함수 리터럴 이 아니므 로 코드 처럼 사용하도록주의하십시오). 코드 블록은 여러 명령문으로 구성되며 각 명령문은 가져 오기 명령문, 선언 또는 표현식 일 수 있습니다. 다음과 같이 진행됩니다.

{
    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) }

그래서 이것이 도움이되기를 바랍니다.

답변

val filtered = tupleList takeWhile { case (s1, s2) => s1 == s2 }

val result = myInstance.foo(5, "Hello")

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

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

foo( x => println(x) )

foo({ x => println(x) })

foo({ println("Hey"); x => println(x) })

foo { println("Hey"); x => println(x) }

foo { x => println(x) }

method {
  1 +
  2
  3
}

method(
  1 +
  2
  3
 )

List(1, 2, 3).reduceLeft {
  _ + _
}