Etrafında bir tartışma yaşıyorumMultiple Parameter ListsScala Stil kılavuzunda korumak. currying iki yolları olduğunu fark ettim ve kullanım durumları nedir merak ediyorum:

def add(a:Int)(b:Int) = {a   b}
// Works
add(5)(6)
// Doesn't compile
val f = add(5)
// Works
val f = add(5)_
f(10) // yields 15

def add2(a:Int) = { b:Int => a   b }
// Works
add2(5)(6)
// Also works
val f = add2(5)
f(10) // Yields 15
// Doesn't compile
val f = add2(5)_

Stil rehberi yanlış bu aynı, onlar açıkça değil ima eder. Kılavuzdur yapmaya çalışan bir noktası hakkında oluşturulan körili fonksiyonları, ve, ikincisi ise form değildir "kitabına göre" tımar, hala çok benzer ilk form (ama muhtemelen daha kolay kullanmak için ihtiyacın yok _)

Bu formları kullanmak, diğer üzerinden bir form kullanmak için görüşü nedir?

Birden Çok Parametre Listesi Yöntemleri

Tür Kesmesi İçin

Birden çok parametre bölümleri ile yöntemleri yerel tür kesmesi, ilk bölümünde parametreleri sonraki bölümünde bir değişken için beklenen bir tür sağlayacak bir tür bağımsız değişkenleri çıkarmayı kullanarak yardımcı olmak için kullanılabilir. Standart kütüphanede foldLeft Bu kurallı bir örnektir.

def foldLeft[B](z: B)(op: (B, A) => B): B

List("").foldLeft(0)(_   _.length)

Bu gibi yazılmış bu:

def foldLeft[B](z: B, op: (B, A) => B): B

Daha açık bir tür sağlamak için var:

List("").foldLeft(0, (b: Int, a: String) => a   b.length)
List("").foldLeft[Int](0, _   _.length)

Akıcı API için

Birden çok parametre bölümüne yöntemleri için başka bir kullanım bir dil yapısı gibi görünen bir API oluşturmak için. Arayan parantez yerine parantez kullanabilirsiniz.

def loop[A](n: Int)(body: => A): Unit = (0 until n) foreach (n => body)

loop(2) {
   println("hello!")
}

Uygulama N bağımsız değişken listesi için yöntem ile M parametresi bölümleri, nerede N < M, dönüştürülebilir bir işlevi açıkça bir _ veya dolaylı olarak, bir beklenen tip FunctionN[..]. Bu güvenlik özelliği, değişim Scala için notlara bakın Scala Başvurular 2.0,, bir arka plan için.

Körili Fonksiyonları

Körili fonksiyonları (veya kısaca, bu fonksiyonlar geri dönüş fonksiyonları) daha kolay N bağımsız değişken listesi için uygulanır.

val f: (a: Int) => (b: Int) => (c: Int) = a   b   c
val g = f(1)(2)

Bu küçük kolaylık bazen faydalıdır. Fonksiyonları tip parametrik olmaz ama, bazı durumlarda bir yöntem gerekli olduğunu unutmayın.

Bir melez ikinci örnek: bir işlev bir parametre bölümüne yöntemi.

Sahne Hesaplama Çok

Başka nerede körili işlevleri yararlıdır? İşte her zaman karşılaştığımız bir durum:

def v(t: Double, k: Double): Double = {
   // expensive computation based only on t
   val ft = f(t)

   g(ft, k)
}

v(1, 1); v(1, 2);

Nasıl 22 ** sonucu paylaşabilir miyiz? Ortak bir çözüm v vectorized bir sürümünü sağlar

def v(t: Double, ks: Seq[Double]: Seq[Double] = {
   val ft = f(t)
   ks map {k => g(ft, k)}
}

Çirkin! İlgisiz kaygıları -- g(f(t), k) hesaplama ks bir dizi eşleme üzerinde dolaşmış olduk.

val v = { (t: Double) =>
   val ft = f(t)
   (k: Double) => g(ft, k)       
}
val t = 1
val ks = Seq(1, 2)
val vs = ks map (v(t))

Ayrıca bir işlevi döndüren bir yöntem kullanabiliriz. Bu durumda onun biraz daha fazla okunabilir:

def v(t:Double): Double => Double = {
   val ft = f(t)
   (k: Double) => g(ft, k)       
}

Ama eğer birden fazla parametre bölümlü bir yöntem ile aynı çalışırsanız, sıkışıp:

def v(t: Double)(k: Double): Double = {
                ^
                `-- Can't insert computation here!
}