ക്ലോഷർ (കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗ്)

**ക്ലോഷർ** (**ലെക്സിക്കൽ ക്ലോഷർ** അല്ലെങ്കിൽ **ഫംഗ്ഷൻ ക്ലോഷർ**) എന്നത് ഒരു പ്രോഗ്രാമിംഗ് ടെക്നിക്കാണ്, അത് ഒരു ഫംഗ്ഷനെ അതിന്റെ ലെക്സിക്കൽ സ്കോപ്പ് (lexical scope) ഉപയോഗിച്ച് ബന്ധിപ്പിക്കുന്നു.(ലെക്സിക്കൽ സ്കോപ്പ് എന്നത്, ഒരു ഫംഗ്ഷന് അത് സൃഷ്ടിക്കുന്ന സ്ഥലത്ത് തന്നെ ലഭ്യമായ വേരിയബിളുകളെ മാത്രമേ കാണാനും ഉപയോഗിക്കാനുമുള്ള കഴിവ് ഉണ്ടാകുകയുള്ളു എന്ന് അർഥമാക്കുന്നു. അതായത്, ഒരു വേരിയബിൾ ഫംഗ്ഷന്റെ പുറത്ത് നിർവചിച്ചാൽ ആ ഫംഗ്ഷൻ അത് ഉപയോഗിക്കാമെങ്കിലും, ഫംഗ്ഷന്റെ ഉള്ളിൽ ആയിരിക്കും മറ്റൊരു വേരിയബിൾ ഉപയോഗിക്കപ്പെടുന്നത്) ഇത് ഒരു ഫംഗ്ഷനും അതിന്റെ എൻവയൺമെന്റ് (environment) ഒരുമിച്ച് സംഭരിക്കുന്ന ഒരു റെക്കോർഡ് പോലെയാണ് പ്രവർത്തിക്കുന്നത്. ക്ലോഷറുകൾ ഫസ്റ്റ്-ക്ലാസ് ഫംഗ്ഷനുകൾ  ഉള്ള ഭാഷകളിൽ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ സംരക്ഷിക്കാനും ഫംഗ്ഷനുകൾക്ക് അവയെ ആക്സസ് ചെയ്യാനും സഹായിക്കുന്നു. (ഫസ്റ്റ്-ക്ലാസ് ഫംഗ്ഷനുകൾ (First-class functions) എന്നാൽ, ഫംഗ്ഷനുകൾ പ്രോഗ്രാമിന്റെ സാധാരണ ഡാറ്റാ ഐറ്റംസ് പോലെ നമുക്ക് കൈകാര്യം ചെയ്യാവുന്നവയാകുന്നതാണ്. അതായത്, ഫംഗ്ഷനുകൾ ഒരു വേരിയബിൾ ആയി സൂക്ഷിക്കാനും മറ്റൊരു ഫംഗ്ഷനിൽ പരാമർശിക്കാനും, പിന്നെ മറ്റൊരു ഫംഗ്ഷൻ ആയി കൈമാറാനും, ഫംഗ്ഷൻ എക്‌സിക്യൂട്ട് ചെയ്യാനുമുള്ള സൗകര്യം സൃഷ്ടിക്കുന്നതാണ്). 
ജാവാസ്ക്രിപ്റ്റിൽ ക്ലോസർ (Closure) എങ്ങനെ പ്രവർത്തിക്കുന്നെന്ന് നോക്കാം:

```javascript
function outerFunction(x) {
    return function innerFunction(y) {
        return x + y;
    };
}

const add5 = outerFunction(5);
console.log(add5(10));  // Output: 15
```

ഇപ്പോൾ, `outerFunction` `innerFunction` നെ തിരികെ നൽകുന്നു. `innerFunction` പ്രക്രിയ ചെയ്യുന്ന സമയത്ത്, അത് `outerFunction` ന്റെ ആന്തരിക വേരിയബിൾ `x` (ഇപ്പോൾ 5) ഉപയോഗിക്കുന്നു. 

ഇതു കൊണ്ട്, `add5`  എന്ന ഫംഗ്ഷൻ 5 + 10 = 15 എന്ന ഫലം പ്രദാനം ചെയ്യുന്നു. ഈ ക്രമത്തിൽ, `innerFunction`  അവിടെ പ്രവർത്തിക്കുന്ന സാഹചര്യത്തിൽ `outerFunction` ന്റെ വ്യത്യസ്ത വേരിയബിളുകൾക്ക് ആക്സസ് നൽകുന്നു, ഈ പ്രക്രിയയെയാണ് ക്ലോസർ എന്ന് വിളിക്കുന്നത്.

എൻവയൺമെന്റ് എന്നത് ഒരു ഫംഗ്ഷനിൽ ഉപയോഗിക്കുന്ന, പക്ഷേ ഫംഗ്ഷന്റെ പുറത്ത് നിർവചിച്ചിരിക്കുന്ന വേരിയബിളുകളെ അവയുടെ മൂല്യങ്ങളുമായി ബന്ധിപ്പിക്കുന്ന ഒരു പട്ടികയാണ്. ഈ വേരിയബിളുകൾ ഫംഗ്ഷൻ എങ്ങനെ പ്രവർത്തിക്കും എന്ന് മനസ്സിലാക്കാൻ സഹായിക്കുന്നു. ക്ലോഷർ എന്നത് ഈ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ കണക്കിലെടുത്ത് പ്രവർത്തിക്കുന്ന ഒരു ഫംഗ്ഷനാണ്. ഒരു സാധാരണ ഫംഗ്ഷൻ കാണുമ്പോൾ, അത് പ്രവർത്തിക്കാൻ വേണ്ടിയുള്ള മൂല്യങ്ങൾ എവിടെ നിർവചിച്ചിരിക്കുന്നു എന്നതിന്റെ അടിസ്ഥാനത്തിലാണ് പ്രവർത്തിക്കുന്നത്. പക്ഷേ, ക്ലോഷർ എന്നത്, ഫംഗ്ഷൻ ആ സ്വഭാവമുള്ള മൂല്യങ്ങൾ മുഴുവാനായോ അല്ലെങ്കിൽ അവയുടെ കോപ്പികൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാനും അനുവദിക്കുന്നു. അപ്പോൾ ആ ഫംഗ്ഷൻ എവിടെ പ്രവർത്തിച്ചാലും, അതിന്റെ എക്സ്റ്റേർണൽ മൂല്യങ്ങൾ അങ്ങനെ പ്രവർത്തിക്കും.
## ചരിത്രവും പദോൽപ്പത്തിയും
ക്ലോഷർ 1960 കളിൽ λ-കാൽക്കുലസിൽ എക്സ്പ്രഷനുകൾ എങ്ങനെ വിലയിരുത്താമെന്ന് വിശകലനം ചെയ്യുന്നതിന് വികസിപ്പിച്ച ഒരു ആശയമാണ്. 1970-ൽ, പാൽ(PAL) എന്ന പ്രോഗ്രാമിംഗ് ഭാഷയിൽ ഇത് ഒരു പ്രത്യേക ഫീച്ചർ ആയി പരിചയപ്പെടുത്തി. ഇതിന്റെ സഹായത്തോടെ, ഫംഗ്ഷനുകൾക്ക് അവരുടെ ലെക്സിക്കൽ സ്‌കോപ്പിൽ ഉള്ള മൂല്യങ്ങൾ ഉപയോഗിക്കാൻ സാധിക്കും.

പീറ്റർ ലാൻഡിൻ 1964-ൽ ക്ലോഷർ എന്ന പദം ആദ്യമായി പരിചയപ്പെടുത്തിയത്, ഇതിൽ രണ്ട് ഭാഗങ്ങളുണ്ടായിരിക്കും. ഒന്ന് എഞ്ചിൻ, അതായത് ക്ലോഷർ എങ്ങനെ പ്രവർത്തിക്കാനാണ് ആകും എന്ന് പറയുന്ന ഭാഗം, രണ്ടാമത്തെത് അതിന്റെ നിയന്ത്രണം, അതായത് എങ്ങനെ ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഫലങ്ങൾ ലഭിക്കണമെന്നത്. ഈ ആശയം എസ്സിഡി(SECD) എന്ന മെഷീനിൽ എക്സ്പ്രഷനുകൾ പ്രവർത്തിപ്പിക്കാൻ ഉപയോഗിച്ചിരുന്നു. ക്ലോഷർ (Closure) എന്ന പദം ലാൻഡിൻ (Landin) ആണ് പ്രചാരത്തിൽ കൊണ്ടുവന്നത്, അത് ലാംഡാ എക്സ്പ്രഷനുകൾ (lambda expressions) ഉപയോഗിച്ച് വിശദീകരിക്കുന്നു.(ലാംഡാ എക്സ്പ്രഷനുകൾ ചുരുങ്ങിയ കോഡ് എഴുതുക വഴി ചെറിയ പ്രവർത്തനങ്ങൾ എളുപ്പത്തിൽ നിർവഹിക്കാൻ സഹായിക്കുന്നു. ഒരു പ്രത്യേക ഗണിത പ്രവർത്തനം ചെയ്യണമെങ്കിൽ, അത് ലാംഡാ എക്സ്പ്രഷനിലൂടെ കോഡ് എഴുതാം, പിന്നെ ഉപയോഗിക്കാം) ഇത് ഓപ്പൺ ബൈൻഡിംഗുകൾ (open bindings) അല്ലെങ്കിൽ ഫ്രീ വേരിയബിളുകൾ (free variables) ഉള്ള ഒരു എക്സ്പ്രഷനെ സൂചിപ്പിക്കുന്നു,(ഓപ്പൺ ബൈൻഡിംഗുകൾ എന്ന് പറഞ്ഞാൽ, ഒരു വേരിയബിളിന്റെ മൂല്യം എവിടെ വേണമെങ്കിലും വ്യക്തമാക്കാൻ ശേഷിയുള്ള അവസ്ഥയാണ്. ഇത് അതിന്റെ മൂല്യം എവിടെ നിന്നാണ് ലഭ്യമാകുന്നത് എന്ന് വ്യക്തമല്ലാത്ത ഒരു "വേറിട്ട സ്ഥലത്ത്" വെച്ചിരിക്കുന്നു) അവ ലെക്സിക്കൽ എൻവയൺമെന്റിൽ (lexical environment) ബന്ധിപ്പിക്കപ്പെടുന്നു.(ലെക്സിക്കൽ എൻവയൺമെന്റ്  എന്നത്, ഒരു പ്രോഗ്രാമിൽ കോഡ് എങ്ങനെയാണ് റൺ ചെയ്യുന്നത്, അതിന്റെ ചുറ്റുപാടുകളെ സൂചിപ്പിക്കുന്ന ഒരു സ്ഥിതി ആണ്. അതായത്, കോഡിന്റെ പ്രവർത്തനസമയം ഉപയോഗിക്കുന്ന വേരിയബിളുകൾ എവിടെ ആണെന്നും, ആ വേരിയബിളുകൾ എങ്ങനെ ബൈന്റ് ചെയ്യപ്പെടുന്നുവെന്നും നിർണ്ണയിക്കുന്നു) ഈ പ്രക്രിയയിൽ, ഓപ്പൺ ബൈൻഡിംഗുകൾ ക്ലോസ് ചെയ്യപ്പെടുന്നു, അത് ഒരു ക്ലോസ്ഡ് എക്സ്പ്രഷൻ (closed expression) അല്ലെങ്കിൽ ക്ലോഷർ ആക്കി മാറ്റുന്നു.(ക്ലോസ്ഡ് എക്സ്പ്രഷൻ എന്ന് പറയുന്നത്, അതിനുള്ളിൽ എല്ലാത്തരം വിവരങ്ങളും (മൂല്യങ്ങളും) ചേർത്ത് കൊടുത്തിരിക്കുന്ന ഒരു കോഡ് ആകുന്നു. അതിനാൽ, അത് മറ്റൊന്നിനെയും ആശ്രയിക്കുന്നില്ല) "ക്ലോസർ" എന്ന ആശയം 1975-ൽ സുസ്മാനും സ്റ്റീലും നിർവ്വചിച്ച സ്കീം പ്രോഗ്രാമിംഗ് ഭാഷയിൽ ഉൾക്കൊള്ളിച്ചു. സ്കീം, ലിസ്പിന്റെ ഒരു വേരിയേഷൻ ആയിട്ടാണ് പരിചയപ്പെടുത്തിയത്, ഇത് ലെക്സിക്കൽ സ്കോപ്പിംഗുള്ള ഒരു ഭാഷയാണ്, അതായത് ഒരു ഫംഗ്ഷൻ നിർവ്വചനത്തിന് വേണ്ടി ആ പരിസരത്തിലുള്ള വേരിയബിളുകളിൽ പ്രവേശിക്കാൻ കഴിയുന്നു. ഈ ആശയം സ്കീമിന്റെ പരിചയപ്പെടുത്തലിന് ശേഷം പ്രോഗ്രാമിംഗ് ലോകത്ത് വ്യാപകമായി ഉപയോഗിക്കപ്പെട്ടു.

## അവലംബം