Saya cukup sering melihat di Internet berbagai keluhan bahwa contoh kari orang lain tidak kari, tetapi sebenarnya hanya sebagian aplikasi.

Saya belum menemukan penjelasan yang layak tentang apa aplikasi parsial itu, atau bagaimana itu berbeda dari currying. Tampaknya ada kebingungan umum, dengan contoh-contoh yang setara digambarkan sebagai kari di beberapa tempat, dan aplikasi parsial di tempat lain.

Bisakah seseorang memberi saya definisi dari kedua istilah, dan detail tentang bagaimana mereka berbeda?

Currying mengkonversi fungsi tunggal n argumen ke n fungsi dengan satu argumen masing-masing. Diberikan fungsi berikut:

function f(x,y,z) { z(x(y));}

Saat kari, menjadi:

function f(x) { lambda(y) { lambda(z) { z(x(y)); } } }

Untuk mendapatkan aplikasi lengkap dari f (x, y, z), Anda perlu melakukan ini:

f(x)(y)(z);

Banyak bahasa fungsional memungkinkan Anda menulis f x y z. Jika Anda hanya memanggil f x yatau f (x) (y) maka Anda mendapatkan fungsi yang diterapkan sebagian — nilai kembali adalah penutupan lambda(z){z(x(y))}dengan nilai x dan y yang diteruskan f(x,y).

Salah satu cara untuk menggunakan aplikasi parsial adalah dengan mendefinisikan fungsi sebagai aplikasi parsial dari fungsi umum, seperti lipatan :

function fold(combineFunction, accumulator, list) {/* ... */}
function sum     = curry(fold)(lambda(accum,e){e+accum}))(0);
function length  = curry(fold)(lambda(accum,_){1+accum})(empty-list);
function reverse = curry(fold)(lambda(accum,e){concat(e,accum)})(empty-list);

/* ... */
@list = [1, 2, 3, 4]
sum(list) //returns 10
@f = fold(lambda(accum,e){e+accum}) //f = lambda(accumulator,list) {/*...*/}
f(0,list) //returns 10
@g = f(0) //same as sum
g(list)  //returns 10

Cara termudah untuk melihat perbedaannya adalah dengan mempertimbangkan contoh nyata . Mari kita asumsikan bahwa kita memiliki fungsi Addyang mengambil 2 angka sebagai input dan mengembalikan angka sebagai output, misalnya Add(7, 5)mengembalikan 12. Pada kasus ini:

• Menerapkan sebagian fungsi Adddengan suatu nilai 7akan memberi kita fungsi baru sebagai output. Fungsi itu sendiri membutuhkan 1 angka sebagai input dan menghasilkan angka. Dengan demikian:

  Partial(Add, 7); // returns a function f2 as output
  
                   // f2 takes 1 number as input and returns a number as output
  

  Jadi kita bisa melakukan ini:

  f2 = Partial(Add, 7);
  f2(5); // returns 12;
         // f2(7)(5) is just a syntactic shortcut
  

• Currying fungsi Addakan memberi kita fungsi baru sebagai output. Fungsi itu sendiri memakan waktu 1 angka sebagai input dan output belum fungsi baru yang lain. Fungsi ketiga itu kemudian mengambil 1 angka sebagai input dan mengembalikan angka sebagai output. Dengan demikian:

  Curry(Add); // returns a function f2 as output
  
              // f2 takes 1 number as input and returns a function f3 as output
              // i.e. f2(number) = f3
  
              // f3 takes 1 number as input and returns a number as output
              // i.e. f3(number) = number
  

  Jadi kita bisa melakukan ini:

  f2 = Curry(Add);
  f3 = f2(7);
  f3(5); // returns 12
  

Dengan kata lain, "currying" dan "aplikasi parsial" adalah dua fungsi yang sama sekali berbeda. Currying mengambil tepat 1 input, sedangkan aplikasi parsial membutuhkan 2 (atau lebih) input.

Meskipun keduanya mengembalikan fungsi sebagai output, fungsi yang dikembalikan adalah bentuk yang sama sekali berbeda seperti yang ditunjukkan di atas.

Catatan: ini diambil dari F # Basics , artikel pengantar yang sangat baik untuk pengembang .NET masuk ke pemrograman fungsional.

Currying berarti memecah suatu fungsi dengan banyak argumen menjadi serangkaian fungsi yang masing-masing mengambil satu argumen dan pada akhirnya menghasilkan hasil yang sama dengan fungsi aslinya. Currying mungkin adalah topik yang paling menantang bagi pengembang yang baru mengenal pemrograman fungsional, terutama karena sering bingung dengan aplikasi parsial. Anda dapat melihat keduanya bekerja dalam contoh ini:

let multiply x y = x * y    
let double = multiply 2
let ten = double 5

Segera, Anda akan melihat perilaku yang berbeda dari bahasa yang paling penting. Pernyataan kedua menciptakan fungsi baru yang disebut ganda dengan meneruskan satu argumen ke fungsi yang membutuhkan dua. Hasilnya adalah fungsi yang menerima satu argumen int dan menghasilkan output yang sama seolah-olah Anda telah memanggil multiply dengan x sama dengan 2 dan y sama dengan argumen itu. Dalam hal perilaku, sama dengan kode ini:

let double2 z = multiply 2 z

Seringkali, orang keliru mengatakan bahwa multiply adalah kari untuk membentuk dobel. Tetapi ini hanya benar. Fungsi multiply dikeringkan, tetapi itu terjadi ketika itu didefinisikan karena fungsi dalam F # dikeringkan secara default. Ketika fungsi ganda dibuat, itu lebih akurat untuk mengatakan bahwa fungsi multiply diterapkan sebagian.

Fungsi multiply sebenarnya adalah serangkaian dari dua fungsi. Fungsi pertama mengambil satu argumen int dan mengembalikan fungsi lainnya, secara efektif mengikat x ke nilai tertentu. Fungsi ini juga menerima argumen int yang dapat Anda anggap sebagai nilai untuk diikat ke y. Setelah memanggil fungsi kedua ini, x dan y keduanya terikat, sehingga hasilnya adalah produk dari x dan y sebagaimana didefinisikan dalam tubuh ganda.

Untuk membuat dobel, fungsi pertama dalam rantai fungsi gandakan dievaluasi untuk menerapkan sebagian gandakan. Fungsi yang dihasilkan diberi nama ganda. Ketika dobel dievaluasi, ia menggunakan argumennya bersama dengan nilai yang diterapkan sebagian untuk menciptakan hasilnya.

Pertanyaan menarik. Setelah sedikit mencari, "Aplikasi Fungsi Sebagian tidak kari" memberikan penjelasan terbaik yang saya temukan. Saya tidak bisa mengatakan bahwa perbedaan praktisnya sangat jelas bagi saya, tetapi kemudian saya bukan ahli FP ...

Halaman lain yang tampak bermanfaat (yang saya akui belum sepenuhnya saya baca) adalah "Currying and Partial Application with Java Closures" .

Memang terlihat seperti ini adalah pasangan istilah yang membingungkan, ingatlah.

Saya telah menjawab ini di utas lain https://stackoverflow.com/a/12846865/1685865 . Singkatnya, aplikasi fungsi parsial adalah tentang memperbaiki beberapa argumen dari fungsi multivariabel yang diberikan untuk menghasilkan fungsi lain dengan argumen yang lebih sedikit, sementara Currying adalah tentang mengubah fungsi argumen N menjadi fungsi unary yang mengembalikan fungsi unary ... [Contoh dari Kari ditampilkan di akhir posting ini.]

Currying sebagian besar adalah kepentingan teoretis: seseorang dapat mengekspresikan komputasi hanya menggunakan fungsi unary (yaitu setiap fungsi unary). Dalam praktik dan sebagai produk sampingan, ini adalah teknik yang dapat membuat banyak aplikasi fungsional yang berguna (tetapi tidak semua) sepele, jika bahasa tersebut memiliki fungsi yang digulung. Sekali lagi, ini bukan satu-satunya cara untuk mengimplementasikan aplikasi parsial. Jadi Anda bisa menemukan skenario di mana aplikasi sebagian dilakukan dengan cara lain, tetapi orang-orang salah mengartikannya sebagai Currying.

(Contoh Kari)

Dalam praktiknya orang tidak akan hanya menulis

lambda x: lambda y: lambda z: x + y + z

atau javascript yang setara

function (x) { return function (y){ return function (z){ return x + y + z }}}

dari pada

lambda x, y, z: x + y + z

demi Currying.

Currying adalah fungsi dari satu argumen yang mengambil fungsi fdan mengembalikan fungsi baru h. Catatan yang hmengambil argumen dari Xdan mengembalikan fungsi yang memetakan Yke Z:

curry(f) = h 
f: (X x Y) -> Z 
h: X -> (Y -> Z)

Aplikasi parsial adalah fungsi dari dua (atau lebih) argumen yang mengambil fungsi fdan satu atau lebih argumen tambahan ke fdan mengembalikan fungsi baru g:

part(f, 2) = g
f: (X x Y) -> Z 
g: Y -> Z

Kebingungan muncul karena dengan fungsi dua argumen kesetaraan berikut berlaku:

partial(f, a) = curry(f)(a)

Kedua belah pihak akan menghasilkan fungsi satu argumen yang sama.

Kesetaraan tidak benar untuk fungsi arity yang lebih tinggi karena dalam hal ini currying akan mengembalikan fungsi satu argumen, sedangkan aplikasi parsial akan mengembalikan fungsi multi-argumen.

Perbedaannya juga dalam perilaku, sedangkan kari mengubah seluruh fungsi asli secara rekursif (satu kali untuk setiap argumen), aplikasi parsial hanyalah penggantian satu langkah.

Sumber: Currying Wikipedia .

Perbedaan antara aplikasi kari dan sebagian dapat digambarkan dengan baik melalui contoh JavaScript berikut ini:

function f(x, y, z) {
    return x + y + z;
}

var partial = f.bind(null, 1);

6 === partial(2, 3);

Aplikasi parsial menghasilkan fungsi arity yang lebih kecil; dalam contoh di atas, fmemiliki arity 3 sementara partialhanya arity 2. Lebih penting lagi, fungsi yang diterapkan sebagian akan mengembalikan hasilnya segera setelah dipanggil , bukan fungsi lain di rantai currying. Jadi jika Anda melihat sesuatu seperti partial(2)(3), itu bukan aplikasi parsial dalam kenyataannya.

Bacaan lebih lanjut:

• Pemrograman Fungsional dalam 5 menit
• Currying: Kontras dengan Aplikasi Fungsi Parsial

Jawaban sederhana

Curry: memungkinkan Anda memanggil suatu fungsi, membaginya dalam beberapa panggilan, memberikan satu argumen per-panggilan.

Partial: memungkinkan Anda memanggil suatu fungsi, membaginya dalam beberapa panggilan, memberikan beberapa argumen per-panggilan.

Petunjuk sederhana

Keduanya memungkinkan Anda untuk memanggil fungsi yang menyediakan lebih sedikit argumen (atau, lebih baik, menyediakannya secara kumulatif). Sebenarnya keduanya mengikat (pada setiap panggilan) nilai tertentu untuk argumen fungsi tertentu.

Perbedaan nyata dapat dilihat ketika fungsi memiliki lebih dari 2 argumen.

Sederhana e (c) (sampel)

(dalam Javascript)

function process(context, success_callback, error_callback, subject) {...}

mengapa selalu melewati argumen, seperti konteks dan panggilan balik, jika mereka akan selalu sama? Ikat saja beberapa nilai untuk fungsi tersebut

processSubject = _.partial(process, my_context, my_success, my_error)

dan menyebutnya di subject1 dan foobar dengan

processSubject('subject1');
processSubject('foobar');

Nyaman bukan? 😉

Dengan kari Anda harus melewati satu argumen per waktu

curriedProcess = _.curry(process);
processWithBoundedContext = curriedProcess(my_context);
processWithCallbacks = processWithBoundedContext(my_success)(my_error); // note: these are two sequential calls

result1 = processWithCallbacks('subject1');
// same as: process(my_context, my_success, my_error, 'subject1');
result2 = processWithCallbacks('foobar'); 
// same as: process(my_context, my_success, my_error, 'foobar');

Penolakan

Saya melewatkan semua penjelasan akademik / matematika. Karena aku tidak tahu itu. Mungkin itu membantu 🙃

Saya punya banyak pertanyaan saat belajar dan sejak itu telah ditanyakan berkali-kali. Cara paling sederhana yang bisa saya jelaskan perbedaannya adalah bahwa keduanya sama-sama :) Mari saya jelaskan ... jelas ada perbedaan.

Baik aplikasi parsial maupun currying melibatkan penyediaan argumen ke suatu fungsi, mungkin tidak sekaligus. Contoh yang cukup kanonik adalah menambahkan dua angka. Dalam pseudocode (sebenarnya JS tanpa kata kunci), fungsi dasar mungkin sebagai berikut:

add = (x, y) => x + y

Jika saya ingin fungsi "addOne", saya bisa menerapkannya sebagian atau menjilatnya:

addOneC = curry(add, 1)
addOneP = partial(add, 1)

Sekarang menggunakannya jelas:

addOneC(2) #=> 3
addOneP(2) #=> 3

Jadi apa bedanya? Yah, itu halus, tetapi aplikasi parsial melibatkan penyediaan beberapa argumen dan fungsi yang dikembalikan kemudian akan menjalankan fungsi utama pada doa berikutnya sedangkan currying akan terus menunggu sampai memiliki semua argumen yang diperlukan:

curriedAdd = curry(add) # notice, no args are provided
addOne = curriedAdd(1) # returns a function that can be used to provide the last argument
addOne(2) #=> returns 3, as we want

partialAdd = partial(add) # no args provided, but this still returns a function
addOne = partialAdd(1) # oops! can only use a partially applied function once, so now we're trying to add one to an undefined value (no second argument), and we get an error

Singkatnya, gunakan aplikasi parsial untuk mengambil beberapa nilai, mengetahui bahwa saat Anda memanggil metode berikutnya, itu akan mengeksekusi, meninggalkan semua argumen yang tidak ditentukan tidak ditentukan; gunakan currying ketika Anda ingin terus mengembalikan fungsi yang diterapkan sebagian sebanyak yang diperlukan untuk memenuhi tanda tangan fungsi. Satu contoh akhir yang dibuat:

curriedAdd = curry(add)
curriedAdd()()()()()(1)(2) # ugly and dumb, but it works

partialAdd = partial(add)
partialAdd()()()()()(1)(2) # second invocation of those 7 calls fires it off with undefined parameters

Semoga ini membantu!

UPDATE: Beberapa bahasa atau implementasi lib akan memungkinkan Anda untuk lulus arity (jumlah total argumen dalam evaluasi akhir) ke implementasi aplikasi parsial yang dapat mengubah dua deskripsi saya menjadi kekacauan yang membingungkan ... tetapi pada saat itu, kedua teknik tersebut sebagian besar dipertukarkan.

Bagi saya sebagian aplikasi harus membuat fungsi baru di mana argumen yang digunakan sepenuhnya terintegrasi ke dalam fungsi yang dihasilkan.

Sebagian besar bahasa fungsional menerapkan currying dengan mengembalikan penutupan: jangan mengevaluasi di bawah lambda ketika diterapkan sebagian. Jadi, untuk aplikasi parsial menjadi menarik, kita perlu membuat perbedaan antara currying dan aplikasi parsial dan menganggap aplikasi parsial sebagai currying plus evaluasi di bawah lambda.

Saya bisa saja sangat salah di sini, karena saya tidak memiliki latar belakang yang kuat dalam matematika teoretis atau pemrograman fungsional, tetapi dari perampokan singkat saya ke FP, tampaknya kari cenderung mengubah fungsi argumen N menjadi fungsi N dari satu argumen, sedangkan aplikasi parsial [dalam praktek] bekerja lebih baik dengan fungsi variad dengan jumlah argumen yang tidak ditentukan. Saya tahu beberapa contoh dalam jawaban sebelumnya menentang penjelasan ini, tetapi itu telah membantu saya untuk paling memisahkan konsep. Pertimbangkan contoh ini (ditulis dalam CoffeeScript untuk ringkasnya, permintaan maaf saya jika membingungkan lebih lanjut, tapi tolong minta klarifikasi, jika perlu):

# partial application
partial_apply = (func) ->
  args = [].slice.call arguments, 1
  -> func.apply null, args.concat [].slice.call arguments

sum_variadic = -> [].reduce.call arguments, (acc, num) -> acc + num

add_to_7_and_5 = partial_apply sum_variadic, 7, 5

add_to_7_and_5 10 # returns 22
add_to_7_and_5 10, 11, 12 # returns 45

# currying
curry = (func) ->
  num_args = func.length
  helper = (prev) ->
    ->
      args = prev.concat [].slice.call arguments
      return if args.length < num_args then helper args else func.apply null, args
  helper []

sum_of_three = (x, y, z) -> x + y + z
curried_sum_of_three = curry sum_of_three
curried_sum_of_three 4 # returns a function expecting more arguments
curried_sum_of_three(4)(5) # still returns a function expecting more arguments
curried_sum_of_three(4)(5)(6) # returns 15
curried_sum_of_three 4, 5, 6 # returns 15

Ini jelas merupakan contoh yang dibuat-buat, tetapi perhatikan bahwa sebagian menerapkan fungsi yang menerima sejumlah argumen memungkinkan kita untuk mengeksekusi fungsi tetapi dengan beberapa data awal. Currying suatu fungsi serupa tetapi memungkinkan kita untuk mengeksekusi fungsi N-parameter dalam potongan sampai, tetapi hanya sampai, semua parameter N diperhitungkan.

Sekali lagi, ini adalah pendapat saya dari hal-hal yang saya baca. Jika ada yang tidak setuju, saya akan sangat menghargai komentar mengapa daripada langsung downvote. Juga, jika CoffeeScript sulit dibaca, silakan kunjungi coffeescript.org, klik "coba coffeescript" dan tempelkan kode saya untuk melihat versi yang dikompilasi, yang (semoga) lebih masuk akal. Terima kasih!

Saya akan menganggap kebanyakan orang yang mengajukan pertanyaan ini sudah akrab dengan konsep dasar sehingga mereka tidak perlu membicarakan hal itu. Tumpang tindihlah yang merupakan bagian yang membingungkan.

Anda mungkin dapat sepenuhnya menggunakan konsep-konsep ini, tetapi Anda memahaminya bersama-sama sebagai pengaburan konseptual amorf pseudo-atomik ini. Yang hilang adalah mengetahui di mana batas di antara mereka.

Daripada mendefinisikan apa masing-masing, lebih mudah untuk menyoroti perbedaan mereka saja — batasnya.

Currying adalah saat Anda mendefinisikan fungsi.

Aplikasi Parsial adalah ketika Anda memanggil fungsi.

Aplikasi adalah matematika-berbicara untuk memanggil suatu fungsi.

Aplikasi parsial membutuhkan memanggil fungsi curried dan mendapatkan fungsi sebagai tipe kembali.

Ada jawaban bagus lainnya di sini tapi saya percaya contoh ini (sesuai pemahaman saya) di Jawa mungkin bermanfaat bagi sebagian orang:

public static <A,B,X> Function< B, X > partiallyApply( BiFunction< A, B, X > aBiFunction, A aValue ){
    return b -> aBiFunction.apply( aValue, b );
}

public static <A,X> Supplier< X > partiallyApply( Function< A, X > aFunction, A aValue ){
    return () -> aFunction.apply( aValue );
}

public static <A,B,X> Function<  A, Function< B, X >  > curry( BiFunction< A, B, X > bif ){
    return a -> partiallyApply( bif, a );
}

Jadi currying memberi Anda fungsi satu argumen untuk membuat fungsi, di mana sebagian aplikasi membuat fungsi wrapper yang mengkode satu atau lebih argumen.

Jika Anda ingin menyalin & menempel, yang berikut ini lebih ribut tetapi lebih ramah untuk digunakan karena jenisnya lebih lunak:

public static <A,B,X> Function< ? super B, ? extends X > partiallyApply( final BiFunction< ? super A, ? super B, X > aBiFunction, final A aValue ){
    return b -> aBiFunction.apply( aValue, b );
}

public static <A,X> Supplier< ? extends X > partiallyApply( final Function< ? super A, X > aFunction, final A aValue ){
    return () -> aFunction.apply( aValue );
}

public static <A,B,X> Function<  ? super A,  Function< ? super B, ? extends X >  > curry( final BiFunction< ? super A, ? super B, ? extends X > bif ){
    return a -> partiallyApply( bif, a );
}

Dalam menulis ini, saya bingung kari dan tidak. Mereka adalah transformasi terbalik pada fungsi. Tidak masalah apa yang Anda panggil, selama Anda mendapatkan apa yang diwakili oleh transformasi dan kebalikannya.

Ketidaksesuaian tidak didefinisikan dengan sangat jelas (atau lebih tepatnya, ada definisi "bertentangan" yang semuanya menangkap semangat gagasan). Pada dasarnya, ini berarti mengubah fungsi yang mengambil banyak argumen menjadi fungsi yang membutuhkan satu argumen. Sebagai contoh,

(+) :: Int -> Int -> Int

Sekarang, bagaimana Anda mengubahnya menjadi fungsi yang membutuhkan satu argumen? Kamu curang, tentu saja!

plus :: (Int, Int) -> Int

Perhatikan bahwa plus sekarang mengambil argumen tunggal (yang terdiri dari dua hal). Super!

Apa gunanya ini? Nah, jika Anda memiliki fungsi yang membutuhkan dua argumen, dan Anda memiliki sepasang argumen, senang mengetahui bahwa Anda dapat menerapkan fungsi ke argumen, dan masih mendapatkan apa yang Anda harapkan. Dan, sebenarnya, pipa ledeng untuk melakukannya sudah ada, sehingga Anda tidak perlu melakukan hal-hal seperti pencocokan pola eksplisit. Yang harus Anda lakukan adalah:

(uncurry (+)) (1,2)

Jadi apa aplikasi fungsi parsial? Ini adalah cara yang berbeda untuk mengubah fungsi dalam dua argumen menjadi fungsi dengan satu argumen. Ini bekerja secara berbeda. Sekali lagi, mari kita ambil (+) sebagai contoh. Bagaimana kita mengubahnya menjadi fungsi yang menggunakan Int tunggal sebagai argumen? Kami curang!

((+) 0) :: Int -> Int

Itulah fungsi yang menambahkan nol ke Int.

((+) 1) :: Int -> Int

menambahkan 1 ke Int. Dll. Dalam setiap kasus ini, (+) "diterapkan sebagian".