[SCALA] 스칼라의 목록에 여러 매개 변수 목록과 여러 매개 변수의 차이점은 무엇입니까?

스칼라의 목록에 여러 매개 변수 목록과 여러 매개 변수의 차이점은 무엇입니까?

스칼라에서 하나 (이 카레?) 쓸 수있는이 같은 기능을

def curriedFunc(arg1: Int) (arg2: String) = { ... }

하나의 파라미터리스트의 여러 파라미터를 가지는 두개의 파라미터리스트 및 상기 기능 curriedFunc 함수 정의의 차이는 무엇인가

def curriedFunc(arg1: Int, arg2: String) = { ... }

도면의 수학적 관점에서 이것은 (curriedFunc (X)) (Y)와 curriedFunc (x, y)는하지만, (= X + Y와 동일한 것이다 DEF SUM2을 (X) (Y)를 합산 DEF (X)를 작성할 수있다 Y) = X + Y

나는 단지 하나 개의 차이를 알고 -이 부분적으로 기능을 적용됩니다. 그러나 두 가지 방법이 나를 위해 동일합니다.

다른 어떤 차이가 있습니까?

해결법

1. ==============================

   1.틀림없이이 함수처럼 보이지만 엄밀히 말하면,이, 커리 기능을하지만, 여러 인자 목록과 방법이 아닙니다.

   틀림없이이 함수처럼 보이지만 엄밀히 말하면,이, 커리 기능을하지만, 여러 인자 목록과 방법이 아닙니다.

   당신이 말한 것처럼, 여러 인수 목록은 방법은 부분적으로 적용 함수의 장소에서 사용할 수 있습니다. (내가 사용하는 일반적 바보 예제 죄송합니다)

   object NonCurr {
     def tabulate[A](n: Int, fun: Int => A) = IndexedSeq.tabulate(n)(fun)
   }
   
   NonCurr.tabulate[Double](10, _)            // not possible
   val x = IndexedSeq.tabulate[Double](10) _  // possible. x is Function1 now
   x(math.exp(_))                             // complete the application
   

   또 다른 이점은 대신 두 번째 인수 목록은 하나의 함수 또는 썽크 구성되어 있다면 착해 보이는 괄호의 중괄호를 사용할 수 있다는 것입니다. 예를 들면

   NonCurr.tabulate(10, { i => val j = util.Random.nextInt(i + 1); i - i % 2 })
   

   대

   IndexedSeq.tabulate(10) { i =>
     val j = util.Random.nextInt(i + 1)
     i - i % 2
   }
   

   또는 썽크에 대한 :

   IndexedSeq.fill(10) {
     println("debug: operating the random number generator")
     util.Random.nextInt(99)
   }
   

   또 다른 장점은 당신이 또한 당신이 하나의 목록에서 그렇게 할 수없는 단점 말할 수 있지만 (기본 인자 값을 정의하기위한 이전의 인수 목록의 인수를 참조 할 수있다 :

   // again I'm not very creative with the example, so forgive me
   def doSomething(f: java.io.File)(modDate: Long = f.lastModified) = ???
   

   마지막으로, 왜 스칼라는 여러 매개 변수 목록과 여러 매개 변수 목록 당을 모두 제공 않습니다 관련 게시물에 대한 답변에서 세 가지 다른 응용 프로그램이 있습니까? . 난 그냥 여기에 복사하지만, 신용 크 누트 아르네 Vedaa, 케빈 라이트, 그리고 즉석로 이동합니다.

   첫째, 여러 var에 인수를 가질 수 있습니다 :

   def foo(as: Int*)(bs: Int*)(cs: Int*) = as.sum * bs.sum * cs.sum
   

   ... 하나의 인수 목록에서 가능하지 않을 것이다.

   둘째, 형식 유추는 에이즈 :

   def foo[T](a: T, b: T)(op: (T,T) => T) = op(a, b)
   foo(1, 2){_ + _}   // compiler can infer the type of the op function
   
   def foo2[T](a: T, b: T, op: (T,T) => T) = op(a, b)
   foo2(1, 2, _ + _)  // compiler too stupid, unfortunately
   

   전체 인수 목록의 수정이 암시 적으로 그리고, 이것은 당신이 암시 적 및 비 암시 인수를 가질 수있는 유일한 방법은, 마지막 :

   def gaga [A](x: A)(implicit mf: Manifest[A]) = ???   // ok
   def gaga2[A](x: A, implicit mf: Manifest[A]) = ???   // not possible
   

2. ==============================

   2.기본 매개 변수 : 0 __의 훌륭한 대답이 적용되지 않은 또 다른 차이가있다. 다른 매개 변수 목록에서 기본을 계산할 때 하나의 매개 변수 목록에서 매개 변수는 있지만 동일 하나, 사용할 수 있습니다.

   기본 매개 변수 : 0 __의 훌륭한 대답이 적용되지 않은 또 다른 차이가있다. 다른 매개 변수 목록에서 기본을 계산할 때 하나의 매개 변수 목록에서 매개 변수는 있지만 동일 하나, 사용할 수 있습니다.

   예를 들면 :

   def f(x: Int, y: Int = x * 2) = x + y // not valid
   def g(x: Int)(y: Int = x * 2) = x + y // valid
   

3. ==============================

   3.즉, 요점 년대 카레와 uncurried 형태가 동일이다! 다른 사람들이 지적했듯이, 하나 개 또는 다른 형태는 상황에 따라 작업 할 구문 더 편리 할 수 ​​있습니다, 그것은 다른 이상을 선호하는 유일한 이유입니다.

   즉, 요점 년대 카레와 uncurried 형태가 동일이다! 다른 사람들이 지적했듯이, 하나 개 또는 다른 형태는 상황에 따라 작업 할 구문 더 편리 할 수 ​​있습니다, 그것은 다른 이상을 선호하는 유일한 이유입니다.

   그것은 스칼라 카레 기능을 선언하는 특수 구문을 가지고 있지 않은 경우에도 당신은 여전히 ​​그들을 만들 수 있다는 것을 이해하는 것이 중요합니다; 이 기능을 반환하는 함수를 만들 수있는 능력을 가지고 일단 이것은 단지 수학적 필연성이다.

   이를 설명하기 위해 데프 foo는이 (가) (나) (다) = {...} 구문이 존재하지 않았다는 것을 상상한다. 그럼 당신은 여전히 ​​같은 똑같은 일을 달성 할 수 : 데프 foo는 (A) = (B) => (C) => {...}.

   스칼라의 많은 기능처럼,이 있지만, 조금 더 상세으로, 단지 어쨌든 가능할 것이다 무언가를위한 구문 편리합니다.

4. ==============================

   4.두 가지 형태의 동형이다. 주된 차이는 카레 함수가 아닌 함수 카레 약간 더 좋은 구문있는 동안 적어도 스칼라, 부분적으로 적용하기 용이하다는 것이다.

   두 가지 형태의 동형이다. 주된 차이는 카레 함수가 아닌 함수 카레 약간 더 좋은 구문있는 동안 적어도 스칼라, 부분적으로 적용하기 용이하다는 것이다.

from https://stackoverflow.com/questions/6803211/whats-the-difference-between-multiple-parameters-lists-and-multiple-parameters by cc-by-sa and MIT license