Çaylak soru için özür dilerim. Burada birkaç soru var farkındayımneve kısmen uygulanan tımar işlevleri vardır, ama farklı oldukları hakkında soruyorum. Basit bir örnek olarak, burada bile sayıları bulmak için körili bir fonksiyonudur:

def filter(xs: List[Int], p: Int => Boolean): List[Int] =
   if (xs.isEmpty) xs
   else if (p(xs.head)) xs.head :: filter(xs.tail, p)
   else filter(xs.tail, p)

def modN(n: Int)(x: Int) = ((x % n) == 0)

Aşağıda, bu kullanım için yazabilirsiniz:

val nums = List(1,2,3,4,5,6,7,8)
println(filter(nums, modN(2))

döner: List(2,4,6,8). Ama aynı şeyi bu şekilde yapabilirim bunu buldum:

def modN(n: Int, x: Int) = ((x % n) == 0)

val p = modN(2, _: Int)
println(filter(nums, p))

ayrıca verir: List(2,4,6,8).

Benim sorum, bu ikisi arasındaki temel fark nedir, ve ne zaman diğer üzerinde kullanmak istiyorsunuz? Bu bir diğer üzerinden kullanılan olabilir neden göstermek için bir örnek sadece çok basit. Yardımlarınız için çok fazla.

Anlamsal fark oldukça iyi the answer linked to by Plasty Grove açıklandı.

İşlevsellik açısından çok bir fark, ama yok. Hadi bazı örnekler doğrulamak için bak. İlk olarak, normal bir fonksiyonu

scala> def modN(n: Int, x: Int) = ((x % n) == 0)
scala> modN(5, _ : Int)
res0: Int => Boolean = <function1>

Zaten ilk tamsayı verdik Int, bir götüren kısmen uygulanan <function1> kurarız. Şimdiye kadar çok iyi. Şimdi tımar için:

scala> def modNCurried(n: Int)(x: Int) = ((x % n) == 0)

Bu gösterim ile, saf bir şekilde aşağıdaki iş için beklediğiniz:

scala> modNCurried(5)
<console>:9: error: missing arguments for method modN;
follow this method with `_' if you want to treat it as a partially applied function
          modNCurried(5)

Bu yüzdenbirden çok parametre listesigösterimde hiç oluşturmak için körili işlevi hemen (tahminimce önlemek için gereksiz ek yük) ama bekler, açıkça devlet istiyorsun körili (gösterimde olan bazı other advantages):

scala> modNCurried(5) _
res24: Int => Boolean = <function1>

Aynen daha önce de var aynı şey, hiçbir farkı burada, gösterim hariç. Başka bir örnek:

scala> modN _
res35: (Int, Int) => Boolean = <function2>

scala> modNCurried _
res36: Int => (Int => Boolean) = <function1>

Bu kısmen bir "" tüm parametreleri, kısmen birden çok parametre listeleri ile bir işlevi uygulama fonksiyonları bir zincir oluşturur ise, . alan bir fonksiyonun sonuçları normal uygulama gösterilmiştir ^strong>parametre listesi başına birolan, yeni bir işlev dönüş:

scala> def foo(a:Int, b:Int)(x:Int)(y:Int) = a * b   x - y
scala> foo _
res42: (Int, Int) => Int => (Int => Int) = <function2>

scala> res42(5)
<console>:10: error: not enough arguments for method apply: (v1: Int, v2: Int)Int => (Int => Int) in trait Function2.
Unspecified value parameter v2.

foo ilk parametre listesinde iki adet parametre vardır çünkü gördüğünüz gibi, körili zincirinin ilk fonksiyonu iki parametre vardır.

Özet olarak, kısmen fonksiyonları çok farklı değil uygulanan işlevsellik açısından körili fonksiyonları oluşturur. Bu kolay bir körili herhangi bir işlevi dönüştürebilirsiniz verilen doğrulandı

scala> (modN _).curried
res45: Int => (Int => Boolean) = <function1

scala> modNCurried _
res46: Int => (Int => Boolean) = <function1>

Post Post Scriptum:

Not:Senin örnek println(filter(nums, modN(2)) olmadan çalışır nedenle Scala derleyicisi sadece programcılar için bir kolaylık olarak alt çizgi varsayar modN(2) gibi görünüyor sonra alt çizgi.

Ayrıca:@Asflierl doğru olarak işaret ettiği gibi, Scala kısmen uygularken türünü anlaması mümkün görünmüyor "" fonksiyonlar . normal

scala> modN(5, _)
<console>:9: error: missing parameter type for expanded function ((x$1) => modN(5, x$1))

Bu bilgileri kullanarak birden çok parametre listesi gösterim yazılı: fonksiyonlar için kullanılabilir, ancak

scala> modNCurried(5) _
res3: Int => Boolean = <function1>

This answers Bu çok yararlı olabilir gösterir.