ഉദാഹരണത്തിന്, ഐക്കണിലെ എക്സ്പ്രഷനുകൾ പലപ്പോഴും ഒരൊറ്റ മൂല്യം നൽകുന്നു,x < 5 ൻറെ മൂല്യം 5 ൽ കുറവാണെങ്കിൽ അല്ലെങ്കിൽ പരാജയപ്പെടുകയാണെങ്കിൽx < 5വിലയിരുത്തുകയും വിജയിക്കുകയും ചെയ്യും. എന്നിരുന്നാലും താഴെ പറയുന്ന ഉദാഹരണങ്ങളിൽ അനേകം എക്സ്പ്രഷനുകൾ വിജയിക്കുകയോ പരാജയപ്പെടുകയോ ചെയ്യുന്നില്ല എന്ന വസ്തുതയിൽ ആശ്രയിച്ച്, അതേ സമയം തന്നെ മൂല്യങ്ങൾ തിരികെ നൽകുന്നു. ഇത് എല്ലാത്തിനും മാതൃകകളിലേക്ക് നയിക്കുന്നു; മൂല്യങ്ങൾ തുടർന്നും പരാജയപ്പെടുവോളം എല്ലാ കാരണങ്ങളും തുടരുന്നു.

ഇത് ജനറേറ്ററായി അറിയപ്പെടുന്ന ഐക്കണിലെ ഒരു പ്രധാന ആശയമാണ്. ജനറേറ്ററുകൾ അധികമായി ഭാഷയിലുള്ള ലൂപ്പ് പ്രവർത്തനം ഡ്രൈവ് ചെയ്യുന്നു, പക്ഷെ കൂടുതൽ നേരിട്ട് ചെയ്യുന്നു; പ്രോഗ്രാമർ ഒരു ലൂപ്പ് എഴുതുന്നില്ല, തുടർന്ന് മൂല്യങ്ങൾ പിൻവലിച്ച് താരതമ്യം ചെയ്യുന്നു, ഐക്കൺ എല്ലാം നിങ്ങൾക്കായി ചെയ്യും.

ഐക്കണിൻറെ പ്രതീകത്തിനുള്ളിൽ, ഫലത്തിൻറ‌െ ശ്രേണിയിൽ ഒരു പദപ്രയോഗം അല്ലെങ്കിൽ പ്രവർത്തനത്തിൻറെ വിലയിരുത്തൽ നടത്തുന്നു. എക്സ്പ്രഷൻ അല്ലെങ്കിൽ ഫങ്ഷൻ ഉപയോഗിച്ച് സൃഷ്ടിക്കാൻ സാധ്യമായ എല്ലാ മൂല്യങ്ങളും ഒരു സീക്വൻസിനുണ്ട്. ഫലത്തിൻറെ സീക്വൻസ് തീർന്നിരിക്കുമ്പോൾ (ഉദാഹരണത്തിന്, ഫലങ്ങളുടെ പരിധിക്കുള്ളിൽ കൂടുതൽ മൂല്യങ്ങൾ ഇല്ല), എക്സ്പ്രഷൻ അല്ലെങ്കിൽ പ്രവർത്തനം പരാജയപ്പെടുന്നു. ഐക്കണിൻറെ ലക്ഷ്യം മൂല്യനിർണ്ണയം അല്ലെങ്കിൽ വ്യക്തമായും ഓരോ ഭാഗവും വഴി ഐക്കണിലെ ലക്ഷ്യം നേടുക വഴി റിസൾട്ട് ലഭിക്കുന്നതാണ്.

ഐക്കണിൽ നിരവധി ജനറേറ്റർ-നിർമ്മാതാക്കൾ ഉൾപ്പെടുന്നു. 
എതെങ്കിലും ഒന്ന് പരാജയപ്പെടുന്നതുവരെ ആൾട്ടർനേറ്റീവ് സിൻറാക്സ് ഒരു ശ്രേണിയിൽ ഇനങ്ങൾ സൃഷ്ടിക്കാൻ അനുവദിക്കുന്നു:

"1", "ഹലോ", "5" എന്നിവ x 5 ന് താഴെയാണെങ്കിൽ റിസൾട്ട് സ‌ൃഷ്ടിക്കാൻ കഴിയും. ആൾട്ടർനേറ്റർമാർ മിക്കപ്പോഴും "അല്ലെങ്കിൽ" എന്ന രീതിയിൽ വായിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്:

x അല്ലെങ്കിൽ 5-നേക്കാൾ ചെറുതാണെങ്കിൽ y യുടെ മൂല്യം എഴുതുന്നു. ഓരോ മൂല്യവും ഇടത്തുനിന്ന് വലത്തേക്ക് ആന്തരികമായി ഐക്കൺ പരിശോധിക്കുന്നു ഒരു വിജയം നേടുന്നതു വരെ അല്ലെങ്കിൽ ലിസ്റ്റ് എംമ്പ്റ്റി ആകുന്നതു വരെ. മാത്രമല്ല അത് പരാജയപ്പെടുന്നു. അകത്തുളള കോളുകൾ പരാജയപ്പെടാത്ത പക്ഷം ഫംഗ്ഷനുകൾ വിളിക്കില്ല എന്ന് ഓർത്തുവെയ്ക്കുക, അങ്ങനെ ഈ ഉദാഹരണം ചുരുക്കാൻ കഴിയും:

മറ്റൊരു ലളിതമായ ജനറേറ്റർ, ആണ് codice_7 എന്നത്, ഇത് പൂർണ്ണസംഖ്യകളുടെ പട്ടിക ഉണ്ടാക്കുന്നു; codice_8 ഈ കോഡിൽ കാണുന്നതെന്താണോ അത് കൃത്യതയോടെ ചെയ്യും. ബാംഗ് സിൻറാക്സ് ഒരു ലിസ്റ്റിലെ എല്ലാ ഇനങ്ങളും സൃഷ്ടിക്കുന്നു; codice_9 എസ്ട്രിങിൻറെ (aString) ഓരോ ക്യാരക്റ്ററും ഒരു പുതിയ വരിയിൽ ഔട്ട്പുട്ട് ചെയ്യും.

ഈ ആശയത്തിൻറെ ശക്തി തെളിയിക്കുന്നതിനായി, സ്ട്രിംഗ് പ്രവർത്തനങ്ങൾ പരിഗണിക്കുന്നു. മിക്ക ഭാഷകളിലും codice_10 അല്ലെങ്കിൽ codice_11 എന്നറിയപ്പെടുന്ന ഒരു ഫംഗ്ഷൻ മറ്റൊരു സ്ട്രിംഗ് ലൊക്കേഷനിൽ മറ്റൊരു സ്ഥാനം നൽകുന്നു. 
പരിഗണിക്കുക:

ഈ കോഡ് "the" എന്ന വാക്കിൻറെ ആദ്യ സംഭവത്തിൻറെ 4-ാം സ്ഥാനത്ത് വരും. "The" എന്ന മറ്റൊരു ഉദാഹരണത്തിൽ ഒരു ഇതര ഫോം ഉപയോഗിക്കണം,

അഞ്ചാമത്തെ സ്ഥാനത്ത് നിന്ന് നോക്കണം എന്ന് 5 ൻറെ അവസാനം പറയുന്നു. "The" യുടെ എല്ലാ സന്ദർഭങ്ങളും എക്സ്ട്രാക്റ്റു ചെയ്യുന്നതിന്, ഒരു ലൂപ്പ് ഉപയോഗിക്കണം ...

ഐക്കണിനു കീഴിൽ codice_10 എന്ന പ്രവർത്തനം ഒരു ജനറേറ്ററാണ്, ഓരോ സമയത്തും സ്ട്രിങ്ങിൻറെ അടുത്ത ഇൻസ്റ്റൻസ് തിരികെയെത്തുകയും, അത് സ്ട്രിംഗിൻറെ അവസാനം കടന്നു കഴിഞ്ഞാൽ, അവസാനം പരാജയപ്പെടുന്നതിനുമുമ്പ് അത് പുനരാരംഭിക്കും. ഐക്കണിൻറെ അതേ കോഡ് എഴുതാം:

"the" എന്ന സ്ഥാനത്ത് 5 ആണെങ്കിൽ, സ്ഥാനം മാത്രം തിരികെ നൽകും, താരതമ്യപ്പെടുത്തൽ പരാജയപ്പെടുകയാണെങ്കിൽ, codice_13 കോഡ് മുമ്പ് പാസ് ചെയ്യാൻ കഴിയാത്തതിനാൽ പരാജയപ്പെട്ടു. പരിഗണിക്കപ്പെടേണ്ട ഈ കോഡിന് ഒരു ചെറിയ "ട്രിക്ക്" ഉണ്ട്: താരതമ്യങ്ങൾ വലതു കൈ ഫലങ്ങൾ നൽകുന്നു, അതിനാൽ താരതമ്യത്തിൻറെ വലതുവശത്തെ കണ്ടെത്തൽ പ്രധാനമാണ്. 5 വലത് ഭാഗത്ത് വയ്ക്കുകയാണെ ങ്കിൽ, 5 എഴുതപ്പെടും. ജനറേറ്ററുകൾ വഴി ലൂപ്പുചെയ്യുന്നതി നായി ഐക്കൺ നിരവധി നിയന്ത്രണ സംവിധാനങ്ങൾ ചേർക്കുന്നു. ഓരോ codice_14 ഓപ്പറേറ്റർക്കും സമാനമായ സമയത്ത് codice_15, ഒരു ജനറേറ്ററിനാൽ തിരിച്ചുകിട്ടുന്ന എല്ലാ ഇനങ്ങളിലൂടെയും വീണ്ടും ലൂപ്പിംഗ് ചെയ്ത് പരാജയത്തിൽ കലാശിക്കുന്നു:

ഈ കേസിൽ വൈയിൽ ലൂപ്(while-loop)ന് പകരം codice_14എന്ന കോഡ് എന്തുകൊണ്ട് ഉപയോഗിക്കുന്നു? കാരണംcodice_15ആദ്യ ഫലം വിലയിരുത്തുക, എന്നാൽ codice_14എല്ലാ ഫലങ്ങളും നൽകുന്നു.codice_14 എന്ന കോഡിൽ ഓരോ വാക്യഘടനയും സ്മോൾടോക്കിനു കീഴിലുള്ള ബ്ലോക്കുകൾ പോലെയുള്ള ഒരു ഫങ്ഷനിൽ ഫംങ്ഷനിലേക്ക് മൂല്യം നൽകുന്നു. ഉദാഹരണത്തിന് മുകളിൽ പറഞ്ഞ ലൂപ്പ് ഇങ്ങനെ വീണ്ടും എഴുതാൻ സാധിക്കും:
codice_20 കീവേഡ് ഉപയോഗിച്ച് ഉപയോക്താവിന് പുതിയ ജനറേറ്ററുകൾ എളുപ്പത്തിൽ നിർമ്മിക്കാൻ കഴിയും:

പാറ്റേൺ കണ്ടെത്തുന്നതിനായി TheString-ൽ ഈ ഉദാഹരണം ശ്രദ്ധിക്കുന്നു. ഒരെണ്ണം കണ്ടെത്തിയപ്പോൾ, അതിൻറെ സ്ഥാനം ഓഡ്(odd) ആണ്,codice_20 എന്ന കോഡിൻറെ സ്ഥാനം ഫങ്ഷനിൽ തിരികെയെത്തുന്നു. അവിടെ ആന്തരിക ജനറേറ്ററിലും, അടുത്ത ഇറേറ്ററിൽ എവിടെയാണോ നിർത്തിയത് അവിടെ നിന്നാണ് അത് പോകാൻ അനുവദിക്കുന്നത്, codice_22, കോഡിൽ നിന്ന് വ്യത്യസ്തമായി, ആന്തരിക ജനറേറ്ററുകളിൽ codice_20 രേഖപ്പെടുത്തുന്നു, അടുത്ത ആവർത്തനത്തിൽ വിട്ട് കളഞ്ഞത് എവിടെയാണോ അത് എടുക്കാൻ അനുവദിക്കുന്നു.

ജനറേറ്ററുകൾ
ലക്ഷ്യം നടപ്പിലാക്കുക
സ്ട്രിംഗുകൾ
അടിസ്ഥാന വാക്യഘടന