അപ്പാച്ചെ ഗ്രൂവി

ജാവ പ്ലാറ്റ്ഫോമിനുള്ള ഒരു ജാവ വാക്യഘടനാ-അനുയോജ്യമായ ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് പ്രോഗ്രാമിങ് ഭാഷയാണ് **അപ്പാച്ചഗ്രൂവി**. പൈത്തൺ, റൂബി, പേൾ, സ്മാൾടാക് തുടങ്ങിയവയ്ക്ക് സമാനമായ സവിശേഷതകളുള്ള സ്റ്റാറ്റിക്, ഡൈനാമിക്ക് ഭാഷയാണ് ഇത്. ജാവ പ്ലാറ്റ്ഫോമിനായി ഇത് ഒരു പ്രോഗ്രാമിങ് ഭാഷയായും സ്ക്രിപ്റ്റിങ്ങ് ഭാഷയായും ആയി ഉപയോഗിക്കാവുന്നതാണ്, ജാവ വെർച്വൽ മെഷീൻ (ജെവിഎം) ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്തിട്ടുണ്ട്, കൂടാതെ മറ്റ് ജാവ കോഡുകളും ലൈബ്രറികളും തമ്മിൽ ആശയവിനിമയം നടത്തുന്നു. ജാവയെപോലെ ഒരു വളഞ്ഞ ബ്രാക്കറ്റ് വാക്യഘടന ഉപയോഗിക്കുന്നു. ഗ്രൂവീസ് ക്ലോസ്സേഴ്സ്, ഒന്നിലധികം സ്ട്രിംഗുകൾ, സ്ട്രിംഗുകളിൽ ഉൾച്ചേർത്ത എക്സ്പ്രഷനുകൾ എന്നിവയെ  പിന്തുണക്കുന്നു. ഗ്രൂവിയുടെ അധികശക്തി, എ.എസ്.ടി പരിവർത്തനങ്ങളിലും, വ്യാഖ്യാനങ്ങളിലൂടെ ട്രിഗർ ചെയ്തിട്ടുണ്ട്.

2007 ജനുവരി 2 നു് ഗ്രൂവർ 1.0 യും 2012 ജൂലൈയിൽ ഗ്രൂവി 2.0 യും പുറത്തിറങ്ങി. പതിപ്പ് 2 മുതൽ, ഗ്രൂവിയെ സ്ഥിരമായി സമാഹരിക്കുവാനും, ജാവയോട് കിടപിടിക്കുന്ന ടൈപ്പ് അനുമാനവും പ്രകടനവും ഇതിനുണ്ട്.പിവൊട്ടൽ സോഫ്റ്റ്‌വേർ സ്പോൺസർഷിപ്പിനു കീഴിലുള്ള അവസാനത്തെ പ്രധാന റിലീസ് ഗ്രൂവി 2.4, 2015 മാർച്ചിൽ അവസാനിപ്പിച്ചു.2.5.2 ഗ്രൂവിയുടെ ഏറ്റവും പുതിയ സ്ഥിര പതിപ്പാണ്. അപ്പാച്ചെ സോഫ്റ്റ്‌വേർ ഫൗണ്ടേഷനിൽ പ്രോജക്ട് മാനേജ്മെൻറ് കമ്മിറ്റി ഗ്രൂവിയെ ഗവേണൻസ് ഘടനയിലേക്ക്  മാറ്റി.
## ചരിത്രം
2003 ആഗസ്ത് മാസത്തിൽ അദ്ദേഹത്തിന്റെ ബ്ലോഗിൽ ജൊവാൻ സ്ട്രോച്ചൻ ആദ്യം ഗ്രൂവിയുടെ ഡെവലപ്പ്മെന്റിനെക്കുറിച്ച് സംസാരിച്ചു.2004 മാർച്ചിൽ ജി.എസ്.പിയുടെ ജി.എസ്.ആർ 241 എന്ന പേരിൽ ഗ്രൂവി സമർപ്പിക്കപ്പെടുകയും ബാലറ്റ് സ്വീകരിക്കുകയും ചെയ്തു. 2004 ലും 2006 ലും നിരവധി പതിപ്പുകൾ പുറത്തിറങ്ങി. ജാവ കമ്യൂണിറ്റി പ്രോസസ് (JCP) നിലവാരമുള്ള പ്രയത്നം ആരംഭിച്ചു, പതിപ്പ് നമ്പറിംഗ് മാറി, 2007 ജനുവരി 2 നാണ് "1.0" എന്ന പതിപ്പ് പുറത്തിറങ്ങിയത്. വിവിധ ബീറ്റാകൾക്കും റിലീസ് സ്ഥാനാർത്ഥികൾക്കും ശേഷം  2007 ഡിസംബർ 7 ന് ഗ്രൂവിയുടെ 1.1 ഫൈനൽ പുറത്തിറങ്ങി പിന്നീട് നിരവധി മാറ്റങ്ങൾ വരുത്താനായി ഗ്രൂവിയെ 1.5 ആയി പുനർനാമകരണം ചെയ്തു.

2007-ൽ, ജാക്സിൽ(JAX) വച്ച് 2007 ലെ  ഇന്നവേഷൻ അവാർഡ് വേദിയിൽ ഫസ്റ്റ് പ്രൈസ് ഗ്രൂവി സ്വന്തമാക്കി.2008-ൽ ഗ്രൈൽസ്, ഒരു ഗ്രൂവി വെബ് ചട്ടക്കൂട്, 2008 ൽ ജാക്സിൽ വച്ച് നടന്ന 2008 നവീകരണ പുരസ്കാര വേദിയിൽ വച്ച് രണ്ടാമത്തെ സമ്മാനം ലഭിച്ചു.

2008 നവംബറിൽ, ഗ്രൂവിയും ഗ്രേല്സ് കമ്പനിയും കൂടി സ്പ്രിങ്സോഴ്സ് (G2One) ഏറ്റെടുത്തു.2009 ഓഗസ്റ്റിൽ വിഎംവെയർ സ്പ്രിങ്സോഴ്സിനെ ഏറ്റെടുത്തു.എട്ടു വർഷത്തെ നിഷ്ക്രിയത്വത്തിനുശേഷം 2012 ൽ സ്പെക്ക് ലീഡ് ജെഎസ്ആർ 241 എന്ന നിലയിലേക്ക് മാറ്റി.

2007 ൽ ഗ്രോവി 1.0 റിലീസിന് മുമ്പായി സ്ട്രാച്ചൻ ഈ പദ്ധതി ഉപേക്ഷിച്ചു.2016 ഒക്റ്റോബറിൽ, സ്ട്രാച്ചൻ ഇങ്ങനെ പറഞ്ഞു: "ഞാനിപ്പോഴും ഗ്രൂവിയെ ഇഷ്ടപ്പെടുന്നു (ജെൻകിൻ പൈപ്പ് ലൈനുകൾ ഗ്രൂവിയാണ്), ജാവ, ഗോ, ടൈപ്പ്സ്ക്രിപ്റ്റ്, കോട്ലിൻ(kotlin)".

2012 ജൂലൈ 2 ന്, ഗ്രൂവി 2.0 പുറത്തിറങ്ങി, മറ്റ് പുതിയ സവിശേഷതകളായ സ്റ്റാറ്റിക് കംപൈൽ ചെയ്യലും സ്റ്റാറ്റിക് ടൈപ്പ് പരിശോധനയും ചേർത്തു. ഇഎംസി കോർപ്പറേഷൻ (EMC), വിഎംവെയർ തുടങ്ങിയ പിവൊട്ടൽ സോഫ്റ്റ്‌വേർ സംയുക്ത സംരംഭങ്ങൾ ഏപ്രിൽ 2013 ൽ പിളർന്നു. ഏപ്രിൽ  2015 മുതൽ ഗ്രൂവിക്ക്, ഗ്രയിലിന്റെ  സ്പോൺസറിംഗ് ഇല്ലാതായി. അപ്പാച്ചെ സോഫ്റ്റ്‌വേർ ഫൌണ്ടേഷനിൽ ഇൻകുബേറ്ററിലൂടെ പ്രൊജക്റ്റ് മാനേജ്മെന്റ് കമ്മിറ്റി (പിഎംസി)അതേ മാസം തന്നെ, ഗ്രൂവിയുടെ ഭരണനിർവ്വഹണ ഘടന കോഡ്ഹാസസ് റിപ്പോസിറ്ററിയിൽ നിന്ന് മാറ്റി. അപ്പാച്ചെയുടെ ഇൻകുബേറ്ററിൽ നിന്ന് ഗ്രൂവി ക്രമേണ മാറി, നവംബർ  2015-ൽ ഒരു ഉന്നതതല പ്രൊജക്ടായി മാറി.
## സവിശേഷതകൾ
ഏറ്റവും സാധുവായ ജാവാ ഫയലുകൾ പോലെതന്നെ സാധുവാണ് ഗ്രൂവി ഫയലുകളും. രണ്ട് ഭാഷകളും ഒരേപോലെയാണെങ്കിലും, ഗ്രൂവി കോഡ് കൂടുതൽ ഒതുക്കമുള്ളതാക്കാൻ കഴിയും, കാരണം ഇതിന് ജാവയുടെ എല്ലാ ഘടകങ്ങളും ആവശ്യമില്ല.കൂടുതൽ ഗ്രൂവി പ്രോഗ്രാമിങ് ഭാഷ ശൈലി ആർജ്ജിക്കുന്നതിനു മുമ്പ് ജാവാ പ്രോഗ്രാമർമാർക്ക് പരിചിതമായ ജാവ സിന്റാക്സിൽ ആരംഭിക്കുന്നതിലൂടെ ക്രമാനുഗതമായി ഗ്രൂവിയെ പഠിക്കുവാൻ സഹായിക്കുന്നു.

ജാവയിൽ ലഭ്യമല്ലാത്ത ഗ്രൂവിയുടെ പ്രത്യേകതകളായ സ്റ്റാറ്റിക്, ഡൈനാമിക് ടൈപ്പിംഗ് (`def`കീവേഡ് ഉപയോഗിച്ച്), ഓപ്പറേറ്റർ ഓവർലോഡിംഗ്, ലിസ്റ്റുകൾ, അസ്സോറ്റീവ് അറേകൾക്കായുള്ള നേറ്റീവ് വാക്യഘടനകൾ (മാപ്പുകൾ), റെഗുലർ എക്സ്പ്രഷനുകൾക്കുള്ള നേറ്റീവ് പിന്തുണ, പോളിമോർഫിക് ഇറ്ററേഷൻ, സ്ട്രിംഗ് ഇന്റർപോളേഷൻ, ഹെൽപ്പർ മെഥേഡുകൾ, സുരക്ഷിത നാവിഗേഷൻ ഓപ്പറേറ്റർ `.?` എന്നിവ കൂട്ടിച്ചേർത്തു, നൾ പോയിന്ററുകൾ സ്വയം പ്രേരിതമായി പരിശോധിക്കുന്നു (ഉദാഹരണത്തിന്, `variable?.method()`, or `variable?.field`).

പതിപ്പ് 2 ഗ്രൂവിക്ക് മൊഡ്യുലാരിറ്റിക്ക് പിന്തുണ നൽകുന്നതിനാൽ (പ്രോജക്റ്റ് ആവശ്യകതകൾക്ക് അനുസൃതമായി ആവശ്യമുള്ള ജാറുകൾ മാത്രം ഷിപ്പുചെയ്യാൻ കഴിയുന്നു, ഇങ്ങനെ ഗ്രൂവി ലൈബ്രറിയുടെ വലിപ്പം കുറയ്ക്കുന്നു), ടൈപ്പ് ചെക്കിങ്ങ്, സ്റ്റാറ്റിക് കംപൈൽ, പ്രോജക്റ്റ് കോയിൻ സിന്റക്സ് എൻഹാൻസ്മെൻറുകൾ,  ടൈപ്പ് ചെക്കിങ്ങ്, സ്റ്റാറ്റിക് കംപൈൽ, പ്രോജക്റ്റ് കോയിൻ സിന്റക്സ് എൻഹാൻസ്മെൻറുകൾ, ജാവ 7 ൽ അവതരിപ്പിച്ച `invokedynamic` നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് മൾട്ടിക്ചാറ്റ് ബ്ലോക്കുകളും നിലവിലെ പ്രകടനം മെച്ചപ്പെടുത്തി.

എക്സ്.എം.എൽ(XML), എച്ച്ടിഎംഎൽ(HTML), തുടങ്ങിയ വിവിധ മാർക്കപ്പ് ഭാഷകൾക്ക് കൂട്ടായ പിന്തുണ നൽകുന്നു,
ഇൻലൈൻ പ്രമാണം ഒബ്ജക്റ്റ് മോഡൽ (DOM) സിന്റാക്സ് ഉപയോഗിച്ച് പൂർത്തിയാക്കി. ഈ സവിശേഷത നിർവചനം, കൃത്രിമത്വം എന്നിവ പ്രാപ്തമാക്കുന്നു, നിരവധി തരത്തിലുള്ള വൈവിധ്യമാർന്ന ഡാറ്റ ആസ്തികൾ ഏകീകൃതവും സംക്ഷിപ്തവുമായ വാക്യഘടന, പ്രോഗ്രാമിങ് രീതി എന്നിവ അവലംബിക്കുന്നു.

ജാവയിൽ നിന്ന് വ്യത്യസ്തമായി, ഒരു ഗ്രൂവി സോഴ്സ് കോഡ് ഫയൽ ഒരു (അൺകംപൈൽഡ്) സ്ക്രിപ്റ്റിനായി എക്സിക്യൂട്ട് ചെയ്യാവുന്നതാണ്, ഏതെങ്കിലും രീതിയിലുള്ള ഒരു നിർവചനം പുറത്തുള്ള കോഡിൽ ഉണ്ടെങ്കിൽ, പ്രധാന മാർഗ്ഗം ഉള്ള ഒരു ക്ലാസ് ആണെങ്കിൽ അല്ലെങ്കിൽ അത് ഒരു റണ്ണബിൾ(Runnable) അല്ലെങ്കിൽ ഗ്രൂവിടെസ്റ്റ്കേസ്(GroovyTestCase) ആണെങ്കിലും എക്സിക്യൂട്ട് ചെയ്യാൻ സാധിക്കും. ഒരു ഗ്രൂവിക്ക് സ്ക്രിപ്റ്റ് പൂർണ്ണമായി പാഴ്സ് ചെയ്യുകയും, കംപൈൽ ചെയ്യുകയും, എക്സിക്യൂട്ട് ചെയ്യുന്നതിനു മുൻപായി (പേളിനും റൂബിക്കും സമാനമായി) സൃഷ്ടിക്കുകയും ചെയ്യുന്നു. ഇത് ഹുഡിന്റെ കീഴിൽ സംഭവിക്കുന്നു, ഒപ്പം കമ്പൈൽ ചെയ്ത പതിപ്പ് പ്രക്രിയയുടെ ഒരു ആർട്ടിഫാറ്റായി സംരക്ഷിക്കില്ല.
### ഗ്രൂവിബീൻസ്(GroovyBeans), പ്രോപ്പർട്ടികൾ
ജാവാബീൻസിന്റെ ഗ്രൂവി പതിപ്പാണ് ഗ്രൂവിബീൻസ്. ഗ്രൂവി വ്യന്ഗ്യമായി ഗെറ്ററുകളും സെറ്ററുകളും ജനറേറ്റുചെയ്യുന്നു. താഴെ പറയുന്ന കോഡിൽ `setColor (String color)` ഉം `getColor ()` ഉം വ്യന്ഗ്യമായി ജനറേറ്റുചെയ്തു. നേരിട്ട് നിറം ലഭിക്കാൻ സാധ്യതയുള്ള അവസാനത്തെ വരികൾ വ്യന്ഗ്യമായി പരിണമിച്ച മെത്തേഡുകൾ വിളിക്കുന്നു.

```groovy
class AGroovyBean {
  String color
}

def myGroovyBean = new AGroovyBean()

myGroovyBean.setColor('baby blue')
assert myGroovyBean.getColor() == 'baby blue'

myGroovyBean.color = 'pewter'
assert myGroovyBean.color == 'pewter'
```

ഗ്രൂവി ലളിതമാണ്, ലിസ്റ്റുകളും മാപ്പുകളും കൈകാര്യം ചെയ്യുന്നതിനുള്ള സ്ഥിരമായ വാക്യഘടന, ജാവയുടെ അരേ സിന്റാക്സിനെ അനുസ്മരിപ്പിക്കുന്നു.

```groovy
def movieList = ['Dersu Uzala', 'Ran', 'Seven Samurai']  // Looks like an array, but is a list
assert movieList[2] == 'Seven Samurai'
movieList[3] = 'Casablanca'  // Adds an element to the list
assert movieList.size() == 4

def monthMap = [ 'January' : 31, 'February' : 28, 'March' : 31 ]  // Declares a map
assert monthMap['March'] == 31  // Accesses an entry
monthMap['April'] = 30  // Adds an entry to the map
assert monthMap.size() == 4
```

### പ്രോട്ടോടൈപ്പ് എക്സ്റ്റൻഷൻ
`ExpandoMetaClass` വഴി പ്രോട്ടോടൈപ്പ് വിപുലീകരണത്തിനുള്ള പിന്തുണ, എക്സ്റ്റൻഷൻ മൊഡ്യൂളുകൾ (ഗ്രൂവി 2-ൽ മാത്രം), ഒബ്ജക്റ്റീവ്-സി-പോലുള്ള വിഭാഗങ്ങളും `DelegatingMetaClass`.
`ExpandoMetaClass`എളുപ്പത്തിൽ ക്ലാസിലെ മാറ്റങ്ങൾ പ്രകടിപ്പിക്കാൻ ഒരു ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ഭാഷ (DSL) നൽകുന്നു, റൂബിയുടെ തുറന്ന ക്ലാസ്സ് ആശയത്തിന് സമാനമാണ്:

```groovy
Number.metaClass {
  sqrt = { Math.sqrt(delegate) }
}

assert 9.sqrt() == 3
assert 4.sqrt() == 2
```

പ്രോട്ടോടൈപ്പിങിൽ ഗ്രൂവിയുടെ കോഡ് മാറ്റങ്ങൾ ജാവയിൽ ദൃശ്യമാകില്ല, കാരണം ഗ്രൂവിയുടെ ഓരോ ആട്രിബ്യൂട്ട് / രീതികൾ മെറ്റാക്ലസ് രജിസ്ട്രിയിലൂടെ കടന്നുപോകുന്നു. മെറ്റാക്ലാസ് രജിസ്ട്രിയിലേക്ക് പോകുന്നത് വഴി മാത്രമേ ജാവയിൽ നിന്ന് മാറ്റം വരുത്തിയ കോഡ് ആക്സസ് ചെയ്യാൻ കഴിയൂ. ഗ്രൂവി ഓവർറൈഡിംഗ് രീതിയും `getProperty ()`, `propertyMissing ()` എന്നിവയോടൊപ്പം അനുവദിക്കുന്നു, ലളിതമായ ഒരു വശത്തേക്കുള്ള വഴിയിൽ ഒബ്ജക്റ്റിലേക്ക് കോളുകൾ തടസ്സപ്പെടുത്താനും ഡവലപ്പർമാർക്ക് പ്രവർത്തനങ്ങൾ വ്യക്തമാക്കാനും സാധിക്കുന്നു. താഴെക്കൊടുത്തിരിക്കുന്ന കോഡ് ഹെക്സ് പ്രോപ്പർട്ടിയോട് പ്രതികരിക്കാൻ `class java.lang.String`സജ്ജമാക്കുന്നു:

```groovy
enum Color {
  BLACK('#000000'), WHITE('#FFFFFF'), RED('#FF0000'), BLUE('#0000FF')
  String hex
  Color(String hex) { 
    this.hex = hex 
  }
}

String.metaClass.getProperty = { String property ->
  def stringColor = delegate
  if (property == 'hex') {
    Color.values().find { it.name().equalsIgnoreCase stringColor }?.hex
  }
}

assert "WHITE".hex == "#FFFFFF"
assert "BLUE".hex == "#0000FF"
assert "BLACK".hex == "#000000"
assert "GREEN".hex == null
```

ഗോം(GORM) ഡൈനാമിക് ഫൈൻഡറുകൾ പ്രാപ്തമാക്കുന്നതിന് ഗ്രേൽസ്(Grails) ചട്ടക്കൂട് വിപുലമായി മെറ്റാപ്രോഗ്രാമിംഗ് ഉപയോഗിക്കുന്നു, `User.findByName ('ജോഷ്')` തുടങ്ങിയവയെപ്പോലെ.
### പൂർണ്ണവിരാമവും, ആവരണചിഹ്നവും(Dot and  parenthesis)
ചില സാഹചര്യങ്ങളിൽ, ആവരണചിഹ്നവും, പൂർണ്ണവിരാമവും ഒഴിവാക്കുന്നതിന് ഗ്രൂവിയുടെ വാക്യഘടന അനുവാദം നൽകുന്നു. ഇനിപ്പറയുന്ന ഗ്രൂവി കോഡ് ഇത് കാണിച്ചിരിക്കുന്നു

```groovy
take(coffee).with(sugar, milk).and(liquor)
```

താഴെ കാണും വിധം എഴുതാൻ കഴിയും

```groovy
take coffee with sugar, milk and liquor
```

ലളിതമായ ഇംഗ്ലീഷിൽ കാണപ്പെടുന്ന ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ഭാഷകളുടെ (DSL- കൾ) വികസനം പ്രാപ്തമാക്കുന്നു.
### പ്രവർത്തന പ്രോഗ്രാമിംഗ്
ഗ്രൂവി കൂടുതലും ഒരു ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് ഭാഷയാണെങ്കിലും, അത് പ്രവർത്തന പ്രോഗ്രാമിങ് സവിശേഷതകളും നൽകുന്നു.
#### പരിസമാപ്തി(Closures)
ഗ്രൂവിയുടെ ഡോക്യുമെന്റേഷൻ പറയുന്നതനുസരിച്ച്: "ഗ്രൂവിയിലെ അടച്ചുപൂട്ടൽ ഒരു 'മാർക്ക് പോയിന്റർ' പോലെ പ്രവർത്തിക്കുന്നു, കോഡ് എഴുതുകയും പ്രവർത്തിക്കുകയും ചെയ്യുക, പിന്നീട് ഒരു പിൽക്കാല ഘട്ടത്തിൽ പ്രവർത്തിക്കുക".ഗ്രൂവിയുടെ ക്ലോസ്സേഴ്സ് സ്വതന്ത്ര വേരിയബിളുകൾ പിന്തുണയ്ക്കുന്നു, അതായത്, അതിനൊപ്പം ഒരു പരിധിവരെ വ്യക്തമായി അടയാളപ്പെടുത്തിയിട്ടില്ലാത്ത വേരിയബിളുകൾ, എന്നാൽ അതിന്റെ പ്രഖ്യാപന പശ്ചാത്തലം, ഭാഗിക പ്രയോഗത്തിൽ നിലനിൽക്കുന്നു(അത് 'കറിയിംഗ്' എന്നാണ് ഉപയോഗിക്കുന്നത്)ഡെലിഗേഷൻ, ഇംപ്ലിസിറ്റ്, ടൈപ്പ്ഡ്, അൺടൈപ്പ്ഡ് പരാമീറ്ററുകൾ മുതലായവ ഇതിനുദാഹരണങ്ങളാണ്.

നിർണ്ണായക തരത്തിലുള്ള ശേഖരങ്ങളിൽ പ്രവർത്തിക്കുമ്പോൾ, ക്ലോസ്സേഴ്സ് ഒരു ഓപ്പറേഷനിലേക്ക് കടക്കുന്നു എന്ന് ശേഖരത്തിൽ നിന്ന് അനുമാനിക്കാം:

```groovy
list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

/* 
 * Non-zero numbers are coerced to true, so when it % 2 == 0 (even), it is false.
 * The type of the implicit "it" parameter can be inferred as an Integer by the IDE.
 * It could also be written as:
 * list.findAll { Integer i -> i % 2 }
 * list.findAll { i -> i % 2 }
 */
def odds = list.findAll { it % 2 }

assert odds == [1, 3, 5, 7, 9]
```

ഒരു കൂട്ടം എക്സ്പ്രഷനുകൾ ഒരു നിർവ്വഹണത്തെക്കുറിച്ച് പരാമർശിക്കാതെ ഒരു ക്ലോഷർ ബ്ളോക്കിലാണ് എഴുതിയിട്ടുള്ളത് പിന്നീട് പ്രതികരിക്കാനുള്ള വസ്തുവിനെ ഡെലിഗേഷനിലൂടെ ഉപയോഗിക്കും.

```groovy
// This block of code contains expressions without reference to an implementation
def operations = {
  declare 5
  sum 4
  divide 3
  print
}
```


```groovy
/* 
 * This class will handle the operations that can be used in the closure above. Another class
 * could be declared having the same methods, but using, for example, webservice operations
 * in the calculations.
 */
class Expression {
  BigDecimal value

  /* 
   * Though an Integer is passed as a parameter, it is coerced into a BigDecimal, as was 
   * defined. If the class had a 'declare(Integer value)' method, it would be used instead.
   */
  def declare(BigDecimal value) {
    this.value = value
  }
  
  def sum(BigDecimal valueToAdd) {
    this.value += valueToAdd
  }
  
  def divide(BigDecimal divisor) {
    this.value /= divisor
  }
  
  def propertyMissing(String property) {
    if (property == "print") println value
  }
}
```


```groovy
// Here is defined who is going to respond the expressions in the block of code above.
operations.delegate = new Expression()
operations()
```


## അവലംബം