Pendahuluan

Pendahuluan mengenai Lambda Expression bisa dilihat di sini

Lalu ada lagi istilah Closure

Apa lagi ini ?


Closure di dalam lambda calculus


Tentu saja kita akan melihat asal muasal dari Closure ini.

Lagi-lagi dari konsep Lambda Calculus.

Lambda Calculus - λ , mengisyaratkan bahwa sebuah fungsi lambda terdiri dari :

  • variable
  • abstraksi lambda atau penulisan variable beserta isi body nya. Yaa maksudnya ini adalah penulisan fungsinya.
  • aplikasi lambda, atau pengisian nilai ke variable diatas dan dijalankan di bodynya tersebut, sehingga didapatkan hasilnya.

Contohnya :

Misalkan kita ingin membuat fungsi penambahan sebuah variable dengan nilai 1 :

fungsi(x) { return x + 1 };

Maka konstruksinya lambdanya :

x –> variable x
(λ.x) ( x + 1 ) –> abstraksi lambda atau penulisan fungsinya.
(λ.x) ( x + 1 ) (3) ==> 3 + 1 ==> 4 –> aplikasi lambda
(f x) (3) ==> 3 + 1 ==> 4 –> aplikasi lambda, kalau kita bungkus dalam bentuk fungsi

Kalau kita lihat di contoh diatas, maka ada satu variable x yang dari awal sudah di “ikat” di dalam fungsinya dan cocok dengan parameternya.

Ini kita sebut Bind Variable.

Tidak perlu lagi mencari dimana variable lainnya.


Akan tetapi bagaimana kalau kita mengubah fungsinya seperti ini ?

  • Fungsi yang di dalam codenya, membutuhkan variable yang terletak diluar dari fungsinya. Misalnya fungsi yang x+1 ingin kita ganti menjadi x+1+y dengan tujuan agar secara dinamik kita bisa mendapatkan hasil dari inputan runtime.

Contohnya :

fungsi(x) { return x + 1 + y };

Hmmm, bagaimana kita bisa menyelesaikan hasil kembalian dari fungsi ini ?

Tentunya tidak bisa.

Wong ada variable yang tidak di Bind di fungsinya.

Variable y ini kita sebut sebagai Free Variable, karena tidak ada parameter yang bisa menggantikannya di parameter fungsi.

Sehingga fungsi diatas disebut Open Lambda, atau Lambda yang masih terbuka dan belum sempurna pengisian nilai variablenya.

Kalau kita nanti bisa mendapatkan nilai y yang diatas, maka fungsi diatas berubah menjadi Close Lambda atau Closure.

Kalau kita lihat konstruksinya :

x –> variable x
(λ.x) ( x + 1 + y ) –> abstraksi lambda atau penulisan fungsinya.
(λ.x) ( x + 1 + y) (3) ==> 3 + 1 + y ==> 4 + y –> aplikasi lambda
(f x) (3) ==> 3 + y ==> 4 + y –> aplikasi lambda, kalau kita bungkus dalam bentuk fungsi

Lalu bagaimana caranya mendapatkan nilai y ?

Tentunya misalnya dengan :

  • setting nilai parameter y di luar fungsi sebagai nilai statik.
  • dengan inner function, yaitu membungkus fungsi diatas didalam fungsi yang lain yang menerima inputan y saat runtime.

misalkan :

function outerfunc() {
  const y = 12;

  function innerfunc(int x) { return x + 1 + y; };

  return innerfunc(3);
}

outerfunc()

atau

function outerfunc(int y) {

  function innerfunc(int x) { return x + 1 + y; };

  return innerfunc(3);
}

outerfunc(12);

Dengan kata lain, nilai dari variable y sebenarnya disupply dari nilai yang dipassing pada saat fungsi tersebut dijalankan.

Tetapi bukan merupakan parameter asli dari fungsinya tersebut.

Dengan men-supply nilai y tadi, yang merupakan Free Variable, maka kita mengubah Lambda yang sebelumnya adalah Open Lambda menjadi Close Lambda, atau disebut Closure.


Kenapa kita butuh Closure ?

Hmmm..

Ok..ok..

Terkadang kita membutuhkan fungsi yang bisa dipakai berulang-ulang, dengan data dari kondisi runtime saat itu.

misalnya memproses Callback, dimana kita membutuhkan fungsi yang bisa menganalisa kembalian dari sebuah proses asinkronous.

atau fungsi closure yang membutuhkan referensi object dari luar agar bisa diproses berbeda tergantung dari object luarnya tersebut.

atau

lebih tepatnya

Kita bisa memproses secara dinamik sebuah inputan untuk diproses oleh fungsi closure dengan cara yang elegan dan lebih abstrak.

Itu…