0Pricing
Lua Academy · Pelajaran

Aplikasi Parsial

Isi sebagian argumen fungsi terlebih dahulu.

Aplikasi Parsial adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Lua Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Lua Academy mencakup 4 pelajaran total.

Apa Itu Penerapan Parsial?

Penerapan parsial berarti menetapkan sebagian argumen fungsi sekarang dan memberikan sisanya nanti. Anda mendapatkan fungsi baru yang memerlukan lebih sedikit argumen.

Dengan cara ini, Anda dapat mengubah fungsi umum menjadi fungsi khusus dengan mengunci nilai yang sudah Anda ketahui.

Contoh Manual

Misalkan Anda memiliki fungsi add. Anda dapat membuat addFive dengan menulis penutupan yang menangkap 5 dan menunggu angka kedua.

Nilai yang ditangkap tersimpan di dalam fungsi yang dikembalikan, sehingga setiap pemanggilan hanya memerlukan argumen yang tersisa.

local function add(a, b)
  return a + b
end

local function addFive(b)
  return add(5, b)
end

print(addFive(10))
print(addFive(2))

Mengikat Argumen Pertama

Kita dapat menggeneralisasi pola tersebut. Pembantu bind1 menerima sebuah fungsi dan argumen pertama yang tetap, lalu mengembalikan fungsi baru yang mengharapkan argumen kedua.

Penutupan tersebut menangkap f dan nilai yang dikunci, lalu meneruskan semuanya ketika dipanggil.

local function bind1(f, a)
  return function(b)
    return f(a, b)
  end
end

local function mul(x, y) return x * y end
local double = bind1(mul, 2)
print(double(7))
print(double(50))

Menggunakan Argumen Variadik

Untuk menetapkan sejumlah argumen awal, gunakan sintaks argumen variadik Lua, yaitu .... Anda menangkap argumen tetap tersebut, lalu menambahkan argumen berikutnya saat pemanggilan.

Fungsi table.pack dan table.unpack membantu menyimpan dan menyebarkan daftar argumen.

local function partial(f, ...)
  local fixed = table.pack(...)
  return function(...)
    local rest = table.pack(...)
    local args = {}
    for i = 1, fixed.n do args[i] = fixed[i] end
    for i = 1, rest.n do args[fixed.n + i] = rest[i] end
    return f(table.unpack(args, 1, fixed.n + rest.n))
  end
end

local function add3(a, b, c) return a + b + c end
local add10 = partial(add3, 10)
print(add10(2, 3))

Menetapkan Beberapa Argumen

Karena partial menerima sejumlah argumen variabel, Anda dapat menetapkan lebih dari satu argumen sekaligus. Fungsi yang dikembalikan kemudian hanya memerlukan argumen yang tersisa.

Di sini, dua dari tiga argumen telah diisi sebelumnya, sehingga tersisa fungsi dengan satu argumen.

local function partial(f, ...)
  local fixed = table.pack(...)
  return function(...)
    local rest = table.pack(...)
    local args = {}
    for i = 1, fixed.n do args[i] = fixed[i] end
    for i = 1, rest.n do args[fixed.n + i] = rest[i] end
    return f(table.unpack(args, 1, fixed.n + rest.n))
  end
end

local function label(prefix, sep, value) return prefix .. sep .. value end
local tag = partial(label, "id", ":")
print(tag(42))

Penggunaan Praktis

Aplikasi parsial sangat berguna untuk fungsi utilitas umum. Tetapkan konfigurasi sekali, lalu gunakan kembali fungsi khusus tersebut berkali-kali.

Di bawah ini, fungsi greet yang umum diubah menjadi fungsi penyapa dengan bahasa tetap yang hanya memerlukan nama.

local function greet(lang, name)
  if lang == "tr" then return "Merhaba, " .. name end
  return "Hello, " .. name
end

local function bind1(f, a) return function(b) return f(a, b) end end
local greetTr = bind1(greet, "tr")
print(greetTr("Ada"))
print(greetTr("Lin"))

Aplikasi Parsial vs Pengubahan Berantai

Pengubahan berantai mengubah fungsi dengan banyak argumen menjadi rangkaian fungsi satu argumen, yang masing-masing mengembalikan fungsi berikutnya. Aplikasi parsial hanya menetapkan beberapa argumen dan mempertahankan sisanya sebagai pemanggilan biasa.

Keduanya berkaitan, tetapi berbeda: pengubahan berantai dilakukan satu per satu, sedangkan aplikasi parsial menetapkan sebagian argumen saat itu juga.

local function curryAdd(a)
  return function(b)
    return function(c)
      return a + b + c
    end
  end
end

print(curryAdd(1)(2)(3))

Mengubah Fungsi Dua Argumen Secara Berantai

Pembantu kecil dapat mengubah fungsi dengan dua argumen menjadi bentuk berantai secara otomatis. Pembantu ini mengembalikan fungsi untuk argumen pertama, yang kemudian mengembalikan fungsi untuk argumen kedua.

Hasilnya adalah pembangun yang dapat digunakan kembali, masing-masing dengan satu argumen, dan mudah dibaca dalam alur data.

local function curry2(f)
  return function(a)
    return function(b)
      return f(a, b)
    end
  end
end

local function pow(base, exp) return base ^ exp end
local cpow = curry2(pow)
print(cpow(2)(10))

Penutupan Membuatnya Berfungsi

Setiap fungsi parsial dan fungsi yang diubah secara berantai bergantung pada penutupan. Argumen yang ditetapkan adalah variabel lokal yang ditangkap dan diingat oleh fungsi yang dikembalikan.

Karena setiap fungsi yang dikembalikan memiliki nilai tangkapannya sendiri, Anda dapat membuat banyak variasi khusus dengan aman.

local function bind1(f, a) return function(b) return f(a, b) end end
local function sub(x, y) return x - y end

local from100 = bind1(sub, 100)
local from10 = bind1(sub, 10)
print(from100(40))
print(from10(3))

Kapan Menggunakannya

Gunakan aplikasi parsial untuk mengurangi pengulangan saat Anda memanggil fungsi dengan argumen awal yang sama berulang kali.

Aplikasi ini juga membantu menyesuaikan fungsi dengan antarmuka yang mengharapkan lebih sedikit argumen, seperti panggilan balik yang hanya meneruskan satu nilai.

Panggilan Balik dengan Konfigurasi

Aplikasi parsial cocok digunakan bersama pemetaan dan penyaringan. Anda dapat mengisi argumen konfigurasi terlebih dahulu sehingga panggilan balik hanya menerima elemen daftar.

Dengan begitu, alur data tetap rapi dan Anda tetap dapat menyesuaikan perilakunya.

local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function bind1(f, a) return function(b) return f(a, b) end end
local function scale(factor, x) return factor * x end

local r = map({1,2,3,4}, bind1(scale, 10))
print(table.concat(r, ", "))

Pemeriksaan Singkat

Ingat kembali perbedaan antara dua gagasan yang berkaitan.

Ringkasan

Aplikasi parsial menetapkan beberapa argumen dan mengembalikan fungsi baru yang mengharapkan sisanya, dengan menggunakan penutupan yang menangkap nilai-nilai yang telah ditetapkan.

Pembantu partial berbasis argumen variabel menggeneralisasi cara ini, sedangkan pengubahan berantai membentuk rangkaian fungsi satu argumen. Keduanya mengurangi pengulangan dan menyesuaikan fungsi dengan panggilan balik.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Aplikasi Parsial” gratis?

Ya — teks lengkap “Aplikasi Parsial” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Lua Academy, upgrade ke CoddyKit PRO. Kursus Lua Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Aplikasi Parsial”?

Isi sebagian argumen fungsi terlebih dahulu. Kamu berlatih Lua Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Lua Academy?

Tidak diperlukan pengalaman sebelumnya. Lua Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Aplikasi Parsial” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Lua Academy ini?

Ya. Setiap pelajaran Lua Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Fungsi sebagai Nilai
  2. map, filter, reduce
  3. Aplikasi Parsial
  4. Menyusun Fungsi
← Kembali ke Lua Academy