Bir de yazabilir Scala (körili?) bu gibi işlevleri

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

İki parametre listeleri ile curriedFunc fonksiyon yukarıdaki tanım ve tek bir parametre listesinde birden fazla parametreleri ile fonksiyonları arasındaki fark nedir

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

Görüş matematiksel açıdan, bu (curriedFunc(x))(y) curriedFunc(x,y) def sum(x) (y) = x y yazabiliyorum ve aynı def sum2(x, y) = x y olacak

Ben tek farkla bu kısmen uygulanan işlevleri. Ama iki şekilde de benim için eşdeğerdir.

Başka farklılıklar var mı?

Kuşkusuz bir fonksiyonu gibi görünüyor, ancak kesinlikle konuşma, bu körili bir işlev değil, ancak birden fazla bağımsız değişken ile bir yöntem listeler.

Dediğin gibi, birden çok bağımsız değişken listeleri yöntemi kısmen uygulanan bir işlevi yerine kullanılır. (Genellikle saçma örnekler için üzgünüm kullanıyorum)

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

Başka bir yararı ise ikinci bağımsız değişken listesi tek bir fonksiyon ya da thunk oluşuyorsa güzel görünüyor parantez yerine ayraç kullanabilirsiniz. E. g.

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

karşı

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

Ya thunk:

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

Diğer bir avantajı, tanımlama varsayılan bağımsız değişken değerleri için önceki bağımsız değişken bağımsız değişken listesi (de diyebilirsiniz, ancak tek bir listede bunu bir dezavantaj olarak:) başvurabilirsiniz

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

Son olarak, ilgili Mesaja cevap Why does Scala provide both multiple parameters lists and multiple parameters per list? diğer üç uygulama var . Onları buraya aktaracağım, ama kredi Arne Vedaa, Kevin Wright, ve otomatik Knut gider.

Birden fazla var besten var . Birincisi:

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

...tek bir bağımsız değişken listesinde mümkün olmaz.

İkinci olarak, bu tür kesmesi yardımcı olur:

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

Ve son olarak, bu implicit bütün argüman listesi için bir değiştirici olarak örtülü ve örtülü olmayan argümanlar var, tek yolu vardır:

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