चिह्न (प्रोग्रामिंग भाषा)



Icon लक्ष्य-निर्देशित निष्पादन की अवधारणा के आधार पर एक बहुत उच्च स्तरीय प्रोग्रामिंग भाषा है जिसमें कोड वैध मूल्यों के साथ सफलता या विफलता देता है, यह दर्शाता है कि वापस लौटने के लिए कोई वैध डेटा नहीं है। कोड के किसी दिए गए ब्लॉक की सफलता और विफलता का उपयोग आगे की प्रक्रिया को निर्देशित करने के लिए किया जाता है, जबकि परंपरागत भाषाएं आमतौर पर प्रोग्रामर द्वारा लिखे गए बूलियन तर्क का उपयोग समान सिरों को प्राप्त करने के लिए करती हैं। क्योंकि बुनियादी नियंत्रण संरचनाओं के लिए तर्क अक्सर आइकॉन में निहित होता है, सामान्य कार्यों को कम स्पष्ट कोड के साथ पूरा किया जा सकता है।

आइकॉन को बेल लैब्स छोड़ने के बाद राल्फ ग्रिसवॉल्ड द्वारा डिजाइन किया गया था, जहां वह SNOBOL भाषा में एक प्रमुख योगदानकर्ता थे। SNOBOL एक स्ट्रिंग-प्रोसेसिंग भाषा थी जिसे 1970 के दशक की शुरुआत के मानकों के अनुसार दिनांकित सिंटैक्स माना जाएगा। एरिज़ोना विश्वविद्यालय में जाने के बाद, उन्होंने SL5 में अंतर्निहित SNOBOL अवधारणाओं को और विकसित किया, लेकिन परिणाम को विफल माना। इसने उल्लेखनीय रूप से अपडेट किए गए आइकन को जन्म दिया, जो कि एसएनओबीओएल जैसी भाषाओं के छोटे लेकिन वैचारिक रूप से घने कोड को सी (प्रोग्रामिंग भाषा) या पास्कल (प्रोग्रामिंग भाषा) जैसी ALGOL- प्रेरित भाषाओं के अधिक परिचित सिंटैक्स के साथ मिश्रित करता है।

इसे प्रेरित करने वाली भाषाओं की तरह, आइकॉन के उपयोग का प्राथमिक क्षेत्र स्ट्रिंग (कंप्यूटर विज्ञान) और टेक्स्ट पैटर्न का प्रबंधन है। स्ट्रिंग ऑपरेशंस अक्सर असफल होते हैं, उदाहरण के लिए, दुनिया में खोजना। अधिकांश भाषाओं में, गैर-वैध परिणाम का उपयोग करने से बचने के लिए इसके लिए परीक्षण और ब्रांचिंग की आवश्यकता होती है। Icon में इस प्रकार के अधिकांश परीक्षणों की आवश्यकता नहीं होती है, जिससे प्रोग्रामर द्वारा लिखे गए कोड की मात्रा कम हो जाती है। पर्ल (प्रोग्रामिंग भाषा) जैसी अधिक समर्पित भाषाओं के समान जटिल पैटर्न हैंडलिंग को संक्षिप्त कोड की कुछ पंक्तियों में पूरा किया जा सकता है, लेकिन अन्य ALGOL जैसी भाषाओं के उपयोगकर्ताओं के लिए परिचित अधिक फ़ंक्शन-उन्मुख सिंटैक्स को बनाए रखना।

आइकॉन वस्तु के उन्मुख नहीं है, लेकिन आइडल नामक एक ऑब्जेक्ट-ओरिएंटेड एक्सटेंशन 1996 में विकसित किया गया था जो अंततः यूनिकॉन (प्रोग्रामिंग भाषा) बन गया। इसने अन्य भाषाओं को भी प्रेरित किया, इसके सरल जनक विशेष रूप से प्रभावशाली हैं; आइकॉन के जनरेटर पायथन प्रोग्रामिंग भाषा के लिए एक प्रमुख प्रेरणा थे।

स्नोबोल
SNOBOL1 के रूप में जाना जाने वाला मूल SNOBOL प्रयास, 1962 के पतन में बेल लैब्स प्रोग्रामिंग रिसर्च स्टडीज डिपार्टमेंट में लॉन्च किया गया। यह प्रयास बहुपद सूत्र हेरफेर, प्रतीकात्मक एकीकरण और मार्कोव श्रृंखलाओं का अध्ययन करने के लिए SCL भाषा का उपयोग करने के प्रयास की हताशा की प्रतिक्रिया थी। विभाग के प्रमुख चेस्टर ली द्वारा लिखित SCL धीमी थी और इसमें निम्न-स्तरीय सिंटैक्स था, जिसके परिणामस्वरूप सरल परियोजनाओं के लिए भी कोड की मात्रा बढ़ जाती थी। COMIT भाषा पर संक्षेप में विचार करने के बाद, इवान पोलोन्स्की, राल्फ ग्रिसवॉल्ड और डेविड फार्बर, छह-व्यक्ति विभाग के सभी सदस्यों ने इन समस्याओं को हल करने के लिए अपनी भाषा लिखने का फैसला किया। 1963 की शुरुआत में आईबीएम 7090 पर पहला संस्करण चल रहा था, और गर्मियों तक इसका निर्माण हो चुका था और बेल में इसका इस्तेमाल किया जा रहा था। इसने लगभग तुरंत ही SNOBOL2 का नेतृत्व किया, जिसमें कई अंतर्निहित कार्य और बाहरी असेंबली भाषा कोड से लिंक करने की क्षमता शामिल थी। यह अप्रैल 1964 में जारी किया गया था और ज्यादातर बेल के भीतर इस्तेमाल किया गया था, लेकिन प्रोजेक्ट मैक में भी इसका कुछ उपयोग देखा गया। सिस्टम फ़ंक्शंस की शुरूआत ज्यादातर उपयोगकर्ता फ़ंक्शंस की आवश्यकता को इंगित करने के लिए की जाती है, जो कि SNOBOL3 की प्रमुख विशेषता थी, जिसे जुलाई 1964 में जारी किया गया था। SNOBOL3 की शुरूआत बेल लैब्स कंप्यूटिंग विभाग के भीतर बड़े बदलावों के अनुरूप है, जिसमें नए GE 645 मेनफ्रेम को शामिल करना शामिल है, जिसके लिए SNOBOL के पुनर्लेखन की आवश्यकता होगी। इसके बजाय, टीम ने एक नया संस्करण लिखने का सुझाव दिया जो SNOBOL इंटरमीडिएट लैंग्वेज के लिए SIL नाम की एक आभासी मशीन पर चलेगा, जिससे इसे किसी भी पर्याप्त शक्तिशाली प्लेटफॉर्म पर आसानी से पोर्ट किया जा सकेगा। इस प्रस्ताव को सितंबर 1965 में SNOBOL4 के रूप में स्वीकार किया गया था। इस समय तक, अगस्त 1966 में भाषा के एक महत्वपूर्ण उन्नत संस्करण की योजना सामने आई। 1960 के बाकी हिस्सों में भाषा पर और काम जारी रहा, विशेष रूप से बाद के संस्करण में साहचर्य सरणी प्रकार को जोड़ा गया, जिसे उन्होंने एक तालिका के रूप में संदर्भित किया।

SL5 Icon
की ओर जाता है ग्रिसवॉल्ड ने बेल लैब्स को अगस्त 1971 में एरिजोना विश्वविद्यालय में प्रोफेसर बनने के लिए छोड़ दिया। उन्होंने उस समय SNOBOL4 को एक शोध उपकरण के रूप में पेश किया। 1960 के दशक की शुरुआत में मूल रूप से विकसित भाषा के रूप में, SNOBOL का सिंटैक्स अन्य प्रारंभिक प्रोग्रामिंग भाषाओं जैसे कि FORTRAN और COBOL के निशान रखता है। विशेष रूप से, भाषा स्तंभ-निर्भर है, क्योंकि इनमें से कई भाषाएँ छिद्र पत्रक पर दर्ज की गई थीं जहाँ स्तंभ लेआउट स्वाभाविक है। इसके अतिरिक्त, नियंत्रण संरचनाएं लगभग पूरी तरह से ब्लॉक (प्रोग्रामिंग) के उपयोग के बजाय कोड के आसपास ब्रांचिंग पर आधारित थीं, जो कि ALGOL 60 की शुरुआत के बाद एक अनिवार्य विशेषता बन रही थी। जब तक वह एरिजोना में चले गए, SNOBOL4 का सिंटैक्स था निराशाजनक रूप से पुराना। ग्रिसवॉल्ड ने SNOBOL की अंतर्निहित सफलता/विफलता अवधारणा को लागू करने का प्रयास पारंपरिक प्रवाह नियंत्रण संरचनाओं जैसे if/then के साथ शुरू किया। यह SNOBOL Language 5 के लिए छोटा SL5 बन गया, लेकिन परिणाम असंतोषजनक था। 1977 में, वह एक नए संस्करण पर विचार करने के लिए भाषा में लौट आए। उन्होंने SL5 में सस्पेंड/रिज्यूमे की सरल अवधारणा के साथ शुरू की गई बहुत शक्तिशाली कार्य प्रणाली को छोड़ दिया और निम्नलिखित सिद्धांतों के साथ SNOBOL4 के प्राकृतिक उत्तराधिकारी के लिए एक नई अवधारणा विकसित की;
 * SNOBOL4 का दार्शनिक और अर्थ संबंधी आधार
 * SL5 वाक्यात्मक आधार
 * SL5 सुविधाएँ, सामान्यीकृत प्रक्रिया तंत्र को छोड़कर

नई भाषा को शुरू में SNOBOL5 के रूप में जाना जाता था, लेकिन चूंकि यह अंतर्निहित अवधारणा को छोड़कर सभी में SNOBOL से काफी अलग थी, एक नया नाम अंततः वांछित था। s को C को श्रद्धांजलि के रूप में मानने के बाद, लेकिन अंततः उस नाम का उपयोग करने वाले टाइपसेटिंग दस्तावेज़ों की समस्याओं के कारण इसे छोड़ दिया गया था। नए नामों की एक श्रृंखला प्रस्तावित की गई और छोड़ दी गई; भाषा के लिए इरविंग, बार्ड और टीएल। यह वह समय था जब ज़ेरॉक्स PARC ने ग्राफिकल यूज़र इंटरफ़ेस पर अपने काम के बारे में प्रकाशित करना शुरू किया और आइकन शब्द कंप्यूटर शब्दकोश में प्रवेश करने लगा। अंत में Icon चुनने से पहले नाम को शुरू में icon में बदलने का निर्णय लिया गया था।

बेसिक सिंटैक्स
आइकॉन भाषा संरचित प्रोग्रामिंग भाषाओं के ALGOL-वर्ग से ली गई है, और इस प्रकार C (प्रोग्रामिंग भाषा) या पास्कल (प्रोग्रामिंग भाषा) के समान सिंटैक्स है। आइकन पास्कल के समान है, का उपयोग करना := असाइनमेंट के लिए सिंटैक्स, procedure कीवर्ड और समान सिंटैक्स। दूसरी ओर, आइकॉन निष्पादन समूहों को संरचित करने के लिए सी-शैली के ब्रेसिज़ का उपयोग करता है, और प्रोग्राम नामक एक प्रक्रिया को चलाकर शुरू होता है main. कई मायनों में आइकॉन अधिकांश स्क्रिप्टिंग भाषाओं (साथ ही SNOBOL और SL5, जिनसे उन्हें लिया गया था) के साथ सुविधाएँ साझा करता है: चर घोषित करने की आवश्यकता नहीं है, प्रकार स्वचालित रूप से डाले जाते हैं, और संख्याओं को स्ट्रिंग्स में परिवर्तित किया जा सकता है और स्वचालित रूप से वापस किया जा सकता है। एक अन्य विशेषता जो कई स्क्रिप्टिंग भाषाओं में आम है, लेकिन सभी में नहीं, एक लाइन-एंडिंग कैरेक्टर की कमी है; आइकॉन में, जो लाइनें अर्धविराम के साथ समाप्त नहीं होती हैं, यदि यह समझ में आता है तो एक निहित अर्धविराम द्वारा समाप्त हो जाती हैं। प्रक्रियाएँ Icon प्रोग्राम के बुनियादी बिल्डिंग ब्लॉक्स हैं। हालांकि वे पास्कल नामकरण का उपयोग करते हैं, वे सी कार्यों की तरह अधिक काम करते हैं और मान वापस कर सकते हैं; कोई नहीं है function चिह्न में कीवर्ड। <वाक्यविन्यास लैंग = आइकन> प्रक्रिया कुछ करो (aString) लिखें (एस्ट्रिंग) अंत 

लक्ष्य-निर्देशित निष्पादन
SNOBOL में प्रमुख अवधारणाओं में से एक यह था कि इसके कार्यों ने जादुई संख्या (प्रोग्रामिंग) या अन्य तकनीकों का उपयोग करने के बजाय सफलता या विफलता को भाषा के आदिम के रूप में लौटाया। उदाहरण के लिए, एक फ़ंक्शन जो किसी अन्य स्ट्रिंग के भीतर सबस्ट्रिंग की स्थिति लौटाता है, अधिकांश भाषा रनटाइम सिस्टम में पाया जाने वाला एक सामान्य रूटीन है; जावास्क्रिप्ट में कोई हैलो, वर्ल्ड! , जिसके साथ पूरा किया जाएगा icon, जो 7 लौटाएगा। यदि कोई बदले में पूछता है icon कोड विफल हो जाएगा, क्योंकि खोज शब्द स्ट्रिंग में प्रकट नहीं होता है। जावास्क्रिप्ट में, अधिकांश भाषाओं की तरह, यह एक जादुई संख्या लौटाकर इंगित किया जाएगा, इस मामले में -1। SNOBOL में इस प्रकार की विफलता एक विशेष मान लौटाती है, fail. SNOBOL का सिंटैक्स ऑपरेशन की सफलता या विफलता पर सीधे संचालित होता है, एक अलग परीक्षण लिखे बिना कोड के लेबल वाले अनुभागों पर कूद जाता है। उदाहरण के लिए, निम्न कोड हैलो, वर्ल्ड प्रिंट करता है! पांच बार: <वाक्यविन्यास हाईलाइट लैंग = स्नोबोल> मैं = 1 लूप आउटपुट = हैलो, दुनिया! मैं = मैं + 1 एलई(आई, 5) : एस(लूप) अंत 
 * हैलो वर्ल्ड प्रिंट करने के लिए SNOBOL प्रोग्राम

लूप करने के लिए, कम-से-या-बराबर ऑपरेटर, LE, को इंडेक्स वेरिएबल I पर कॉल किया जाता है, और यदि यह Sसफल होता है, जिसका अर्थ है कि I 5 से कम है, यह नामित लेबल की शाखा है LOOP और जारी है।

आइकॉन ने सफलता या असफलता के आधार पर प्रवाह नियंत्रण की अवधारणा को बरकरार रखा लेकिन भाषा को और विकसित किया। एक परिवर्तन लेबल का प्रतिस्थापन था GOTO1960 के दशक के उत्तरार्ध में कंप्यूटर उद्योग में व्यापक रूप से संरचित प्रोग्रामिंग शैली को ध्यान में रखते हुए ब्लॉक-उन्मुख संरचनाओं के साथ ब्रांचिंग की तरह। दूसरा कॉल चेन के साथ विफलता को पारित करने की अनुमति देना था ताकि पूरे ब्लॉक सफल हों या पूरी तरह विफल हो जाएं। यह आइकॉन भाषा की एक प्रमुख अवधारणा है। जबकि पारंपरिक भाषाओं में बूलियन लॉजिक के आधार पर सफलता या विफलता का परीक्षण करने के लिए कोड शामिल करना होगा और फिर परिणाम के आधार पर शाखा, ऐसे परीक्षण और शाखाएं आइकन कोड में निहित हैं और स्पष्ट रूप से लिखे जाने की आवश्यकता नहीं है। उदाहरण के लिए, जावा प्रोग्रामिंग भाषा में लिखे गए इस बिट कोड पर विचार करें। यह फ़ंक्शन को कॉल करता है read (पहले खोली गई) फ़ाइल से किसी वर्ण को पढ़ने के लिए, चर को परिणाम निर्दिष्ट करता है a, और तब writeएस का मूल्य a दूसरी फ़ाइल के लिए। नतीजा एक फाइल को दूसरे में कॉपी करना है। read अंततः फ़ाइल से पढ़ने के लिए वर्ण समाप्त हो जाएंगे, संभावित रूप से इसकी पहली कॉल पर, जो निकल जाएगा a एक अनिर्धारित स्थिति में और संभावित कारण write एक शून्य सूचक का अपवाद पैदा करने के लिए। इससे बचने के लिए, read विशेष मान लौटाता है EOF (end-of-file) इस स्थिति में, जिससे बचने के लिए एक स्पष्ट परीक्षण की आवश्यकता होती है writeइसे आईएनजी:

<वाक्यविन्यास प्रकाश लैंग = जावा> जबकि ((ए = पढ़ें )! = ईओएफ) { लिखना एक); } 

इसके विपरीत, चिह्न में read समारोह पाठ की एक पंक्ति देता है या &fail. &fail का केवल एक एनालॉग नहीं है EOF, क्योंकि यह भाषा द्वारा स्पष्ट रूप से समझा जाता है कि संदर्भ के आधार पर प्रसंस्करण बंद करो या असफल मामला करो। Icon में समतुल्य कोड है: <वाक्यविन्यास लैंग = आइकन> जबकि ए := पढ़ें फिर लिखें (ए) 

इसका मतलब है, जब तक पढ़ना विफल नहीं होता है, तब तक कॉल करें, अन्यथा रुकें। जादू संख्या के खिलाफ एक परीक्षण निर्दिष्ट करने की कोई आवश्यकता नहीं है जैसा कि जावा उदाहरण में है, यह निहित है, और परिणामी कोड सरल है। क्योंकि सफलता और असफलता कॉल श्रृंखला के माध्यम से पारित हो जाती है, कोई अन्य कार्यों को एम्बेड कर सकता है और जब नेस्टेड समारोह विफल हो जाता है तो वे बंद हो जाते हैं। उदाहरण के लिए, उपरोक्त कोड को कम किया जा सकता है: <वाक्यविन्यास लैंग = आइकन> लिखते समय (पढ़ें ) 

इस संस्करण में, यदि read विफल रहता है, write विफल रहता है, और while रुक जाता है। आइकॉन की ब्रांचिंग और लूपिंग निर्माण सभी उनके अंदर कोड की सफलता या विफलता पर आधारित हैं, न कि प्रोग्रामर द्वारा प्रदान किए गए मनमाने बूलियन टेस्ट पर। if करता है then ब्लॉक अगर इसका परीक्षण एक मान लौटाता है, और else अगर यह वापस आता है तो ब्लॉक या अगली पंक्ति में चला जाता है &fail. वैसे ही, while अपने ब्लॉक को तब तक कॉल करना जारी रखता है जब तक कि उसे असफल न हो जाए। चिह्न इस अवधारणा को लक्ष्य-निर्देशित निष्पादन के रूप में संदर्भित करता है। अपवाद प्रबंधन की अवधारणा के साथ सफलता और विफलता की अवधारणा की तुलना करना महत्वपूर्ण है; अपवाद असामान्य स्थितियां हैं, अपेक्षित परिणाम नहीं। चिह्न में विफलताएँ अपेक्षित परिणाम हैं; किसी फ़ाइल के अंत तक पहुँचना एक अपेक्षित स्थिति है और अपवाद नहीं है। आइकन में पारंपरिक अर्थों में अपवाद हैंडलिंग नहीं है, हालांकि अपवाद जैसी स्थितियों में अक्सर विफल होता है। उदाहरण के लिए, यदि पढ़ी जा रही फ़ाइल मौजूद नहीं है, read बिना किसी विशेष स्थिति के इंगित किए विफल हो जाता है। पारंपरिक भाषा में, इन अन्य स्थितियों को इंगित करने का कोई स्वाभाविक तरीका नहीं है; अतिरिक्त मैजिक नंबरों का उपयोग किया जा सकता है, लेकिन आमतौर पर एक्सेप्शन हैंडलिंग का उपयोग वैल्यू फेंकने के लिए किया जाता है। उदाहरण के लिए, जावा कोड में लापता फ़ाइल को संभालने के लिए, कोई देख सकता है:

<वाक्यविन्यास प्रकाश लैंग = जावा> कोशिश { जबकि ((ए = पढ़ें )! = ईओएफ) { लिखना एक);  } } पकड़ (अपवाद ई) {   // कुछ और गलत हो गया, लूप से बाहर निकलने के लिए इस कैच का उपयोग करें } 

इस मामले में दो तुलनाओं की आवश्यकता है: एक ईओएफ के लिए और दूसरा अन्य सभी त्रुटियों के लिए। चूंकि जावा तर्क तत्वों के रूप में अपवादों की तुलना करने की अनुमति नहीं देता है, जैसा कि आइकन के तहत, long try/catch इसके बजाय सिंटैक्स का उपयोग किया जाना चाहिए। ट्राई ब्लॉक एक प्रदर्शन जुर्माना भी लगाते हैं, भले ही कोई अपवाद नहीं फेंका गया हो, एक वितरित लागत जिसे आइकन सामान्य रूप से टालता है।

आइकन पारंपरिक बूलियन परीक्षण करने के लिए इसी लक्ष्य-निर्देशित तंत्र का उपयोग करता है, हालांकि सूक्ष्म अंतर के साथ। एक साधारण तुलना जैसे if a < b then write("a is smaller than b") इसका मतलब यह नहीं है, यदि सशर्त अभिव्यक्ति मूल्यांकन का परिणाम सही मान देता है या देता है जैसा कि अधिकांश भाषाओं के तहत होता है; इसके बजाय, इसका मतलब कुछ और है, जैसे सशर्त अभिव्यक्ति, यहाँ < ऑपरेशन, सफल होता है और असफल नहीं होता है। इस मामले में, < यदि तुलना सत्य है तो ऑपरेटर सफल होता है। if }} इसे कॉल करता है then खंड यदि अभिव्यक्ति सफल होती है, या else या अगली पंक्ति विफल होने पर। परिणाम पारंपरिक के समान है यदि / फिर अन्य भाषाओं में देखा जाए, तो if निष्पादित then अगर a मै रुक जाना b. सूक्ष्मता यह है कि समान तुलना अभिव्यक्ति को कहीं भी रखा जा सकता है, उदाहरण के लिए:

<वाक्यविन्यास लैंग = आइकन> लिखें (ए <बी) 

एक और अंतर यह है कि < यदि यह सफल होता है तो संचालिका अपना दूसरा तर्क लौटाती है, जिसका परिणाम इस उदाहरण में का मान होगा b से बड़ा है तो लिखा जा रहा है aअन्यथा कुछ भी नहीं लिखा है। चूंकि यह एक परीक्षण नहीं है, लेकिन एक ऑपरेटर जो एक मूल्य देता है, उन्हें एक साथ जोड़ा जा सकता है जैसे चीजों की अनुमति देता है if a < b < c, एक सामान्य प्रकार की तुलना जिसे अधिकांश भाषाओं में दो असमानताओं के संयोजन के रूप में लिखा जाना चाहिए if (a < b) && (b < c).

लक्ष्य-निर्देशित निष्पादन का एक प्रमुख पहलू यह है कि यदि कोई प्रक्रिया विफल हो जाती है, तो प्रोग्राम को पिछली स्थिति में रिवाइंड करना पड़ सकता है, जिसे बैकट्रैकिंग के रूप में जाना जाता है। उदाहरण के लिए, उस कोड पर विचार करें जो एक चर को एक प्रारंभिक स्थान पर सेट करता है और फिर संचालन करता है जो मूल्य को बदल सकता है - उदाहरण के लिए स्ट्रिंग स्कैनिंग संचालन में यह सामान्य है, जो स्ट्रिंग के माध्यम से एक कर्सर को आगे बढ़ाएगा क्योंकि यह स्कैन करता है। यदि प्रक्रिया विफल हो जाती है, तो यह महत्वपूर्ण है कि उस चर के बाद के किसी भी पाठ को मूल स्थिति में लौटाया जाए, न कि राज्य को क्योंकि यह आंतरिक रूप से हेरफेर किया जा रहा था। इस कार्य के लिए, Icon के पास उत्क्रमणीय असाइनमेंट ऑपरेटर है, <-, और प्रतिवर्ती विनिमय, <->. उदाहरण के लिए, कुछ कोड पर विचार करें जो एक बड़ी स्ट्रिंग के भीतर पैटर्न स्ट्रिंग खोजने का प्रयास कर रहा है:

<वाक्यविन्यास लैंग = आइकन> {  (i:= 10) और (जे: = (मैं <ढूंढें (पैटर्न, इनस्ट्रिंग))) } 

यह कोड हिलने से शुरू होता है i से 10, खोज के लिए प्रारंभिक स्थान। हालांकि, अगर find विफल हो जाता है, ब्लॉक पूरी तरह विफल हो जाएगा, जिसके परिणामस्वरूप मूल्य होता है i एक अवांछनीय साइड इफेक्ट (कंप्यूटर साइंस) के रूप में 10 पर छोड़ा जा रहा है। की जगह i := 10 साथ i <- 10 दर्शाता है कि i ब्लॉक विफल होने पर अपने पिछले मान पर रीसेट किया जाना चाहिए। यह निष्पादन में परमाणु प्रतिबद्धता का एक एनालॉग प्रदान करता है।

जेनरेटर
चिह्न में व्यंजक एकल मान लौटा सकते हैं, उदाहरण के लिए, 5 > x यदि x का मान 5 से कम है, तो मूल्यांकन करेगा और x लौटाएगा, अन्यथा असफल हो जाएगा। हालाँकि, Icon में उन प्रक्रियाओं की अवधारणा भी शामिल है जो सफलता या विफलता को तुरंत वापस नहीं करती हैं, और इसके बजाय हर बार नए मान लौटाती हैं। इन्हें जनरेटर (कंप्यूटर प्रोग्रामिंग) के रूप में जाना जाता है, और ये आइकॉन भाषा का एक महत्वपूर्ण हिस्सा हैं। चिह्न के बोलचाल के भीतर, अभिव्यक्ति या फ़ंक्शन का मूल्यांकन परिणाम अनुक्रम उत्पन्न करता है। एक परिणाम अनुक्रम में सभी संभावित मान होते हैं जो अभिव्यक्ति या फ़ंक्शन द्वारा उत्पन्न किए जा सकते हैं। जब परिणाम अनुक्रम समाप्त हो जाता है, तो अभिव्यक्ति या कार्य विफल हो जाता है।

आइकन किसी भी प्रक्रिया को एक मान या एकाधिक मान वापस करने की अनुमति देता है, जिसे उपयोग करके नियंत्रित किया जाता है fail, return और suspend खोजशब्द। एक ऐसी प्रक्रिया जिसमें इनमें से किसी भी खोजशब्द का अभाव होता है &fail, जो तब होता है जब निष्पादन तक चलता है end एक प्रक्रिया का। उदाहरण के लिए:

<वाक्यविन्यास लैंग = आइकन> प्रक्रिया एफ (एक्स) अगर एक्स> 0 तो { वापसी 1 } अंत 

कॉलिंग f(5) 1 लौटेगा, लेकिन कॉल कर रहा है f(-1) वापसी करेंगे &fail. इससे गैर-स्पष्ट व्यवहार हो सकता है, उदाहरण के लिए, write(f(-1)) कुछ भी आउटपुट नहीं करेगा क्योंकि f विफल रहता है और के संचालन को निलंबित कर देता है write. जनरेटर बनने के लिए एक प्रक्रिया को परिवर्तित करने का उपयोग करता है suspend कीवर्ड, जिसका अर्थ है इस मान को लौटाएं, और जब दोबारा कॉल किया जाए, तो इस बिंदु पर निष्पादन शुरू करें। इस लिहाज से यह कुछ-कुछ स्टेटिक (कीवर्ड) के कॉम्बिनेशन जैसा है|staticसी और में अवधारणा return. उदाहरण के लिए: <वाक्यविन्यास लैंग = आइकन> प्रक्रिया आईटीओजे (i, j)  जबकि मैं <= जे करते हैं { मैं निलंबित मैं +: = 1 }  असफल अंत 

एक जनरेटर बनाता है जो शुरू होने वाली संख्याओं की एक श्रृंखला देता है i और समाप्त ए j, और फिर वापस आ जाता है &fail इसके बाद। suspend i }} निष्पादन रोकता है और का मान लौटाता है i किसी भी राज्य को रीसेट किए बिना। जब एक ही फ़ंक्शन के लिए एक और कॉल किया जाता है, तो निष्पादन उस बिंदु पर पिछले मानों के साथ होता है। इस मामले में, यह प्रदर्शन करने का कारण बनता है i +:= 1, जबकि ब्लॉक की शुरुआत में वापस लूप करें, और फिर अगला मान वापस करें और फिर से सस्पेंड करें। यह तब तक जारी रहता है i <= j विफल रहता है, जिस बिंदु पर यह ब्लॉक से बाहर निकलता है और कॉल करता है fail. यह इटरेटर को आसानी से बनाने की अनुमति देता है। एक अन्य प्रकार का जनरेटर-बिल्डर अल्टरनेटर है, जो बूलियन की तरह दिखता है और संचालित होता है or ऑपरेटर। उदाहरण के लिए:

<वाक्यविन्यास लैंग = आइकन> अगर y <(x | 5) तो लिखें ( y=, y) 

ऐसा प्रतीत होता है कि यदि y x या 5 से छोटा है तो ..., लेकिन वास्तव में जनरेटर के लिए एक छोटा रूप है जो सूची के अंत तक गिरने तक मान देता है। सूची के मूल्यों को संचालन में इंजेक्ट किया जाता है, इस मामले में, <. तो इस उदाहरण में, सिस्टम पहले y <x का परीक्षण करता है, यदि x वास्तव में y से बड़ा है तो यह x का मान लौटाता है, परीक्षण पास हो जाता है, और y का मान इसमें लिखा जाता है then खंड। हालाँकि, यदि x y से बड़ा नहीं है, तो यह विफल हो जाता है, और अल्टरनेटर y <5 का प्रदर्शन करना जारी रखता है। यदि वह परीक्षण पास हो जाता है, तो y लिखा जाता है। यदि y न तो x या 5 से छोटा है, तो अल्टरनेटर परीक्षण से बाहर हो जाता है और विफल हो जाता है if विफल रहता है, और write नहीं किया जाता है। इस प्रकार, y का मान कंसोल पर दिखाई देगा यदि यह x या 5 से छोटा है, जिससे बूलियन का उद्देश्य पूरा होता है or. जब तक उनके मापदंडों का मूल्यांकन सफल नहीं हो जाता, तब तक कार्यों को नहीं बुलाया जाएगा, इसलिए इस उदाहरण को छोटा किया जा सकता है:

<वाक्यविन्यास लैंग = आइकन> लिखें (वाई =, (एक्स | 5)> वाई) 

आंतरिक रूप से, अल्टरनेटर केवल एक नहीं है or और कोई इसका उपयोग मूल्यों की मनमानी सूची बनाने के लिए भी कर सकता है। इसका उपयोग मनमाने मूल्यों पर पुनरावृति करने के लिए किया जा सकता है, जैसे:

<वाक्यविन्यास लैंग = आइकन> हर i := (1|3|4|5|10|11|23) लिखें(i) 

जैसा कि कई प्रोग्रामिंग संदर्भों में आमतौर पर पूर्णांकों की सूची पाई जाती है, आइकन में यह भी शामिल है to तदर्थ पूर्णांक जनरेटर बनाने के लिए कीवर्ड:

<वाक्यविन्यास लैंग = आइकन> हर k := i to j do write(k) 

जिसे छोटा किया जा सकता है:

<वाक्यविन्यास लैंग = आइकन> प्रत्येक लेखन (1 से 10) 

आइकन दृढ़ता से टाइप नहीं किया गया है, इसलिए अल्टरनेटर सूचियों में विभिन्न प्रकार के आइटम हो सकते हैं:

<वाक्यविन्यास लैंग = आइकन> हर i := (1 | hello | x < 5) जरूर लिखें (i) 

यह x के मान के आधार पर 1, हैलो और शायद 5 लिखता है।

इसी तरह संयोजन ऑपरेटर, &, बूलियन के समान फैशन में प्रयोग किया जाता है and ऑपरेटर: <वाक्यविन्यास लैंग = आइकन> हर x := ItoJ(0,10) & x % 2 == 0 लिखो (x) </वाक्यविन्यास हाइलाइट>

यह कोड कॉल करता है ItoJ और 0 का प्रारंभिक मान लौटाता है जो x को असाइन किया गया है। यह तब संयोजन के दाहिने हाथ की ओर करता है, और तब से x % 2 0 के बराबर होता है, यह मान लिखता है। इसके बाद कॉल करता है ItoJ जनरेटर फिर से जो 1 से x असाइन करता है, जो दाईं ओर विफल रहता है और कुछ भी प्रिंट नहीं करता है। परिणाम 0 से 10 तक प्रत्येक सम पूर्णांक की एक सूची है। स्ट्रिंग ऑपरेशंस के साथ उपयोग किए जाने पर जनरेटर की अवधारणा विशेष रूप से उपयोगी और शक्तिशाली होती है, और आइकन के समग्र डिजाइन के लिए एक प्रमुख अंतर्निहित आधार है। इसपर विचार करें indexOf ऑपरेशन कई भाषाओं में पाया गया; यह फ़ंक्शन एक स्ट्रिंग को दूसरे के भीतर ढूंढता है और इसके स्थान की एक अनुक्रमणिका देता है, या एक जादू संख्या नहीं मिलती है। उदाहरण के लिए:

<वाक्यविन्यास प्रकाश लैंग = जावा> s = सारी दुनिया एक मंच है। और सभी पुरुष और महिलाएं केवल खिलाड़ी हैं; मैं = इंडेक्सऑफ (द, एस); लिखना (मैं); </वाक्यविन्यास हाइलाइट>

यह स्ट्रिंग को स्कैन करेगा s, की पहली घटना का पता लगाएं, और उस इंडेक्स को लौटाएं, इस मामले में 4. स्ट्रिंग, हालांकि, स्ट्रिंग के दो उदाहरण हैं, इसलिए दूसरा उदाहरण वापस करने के लिए एक वैकल्पिक सिंटैक्स का उपयोग किया जाता है:

<वाक्यविन्यास प्रकाश लैंग = जावा> जे = इंडेक्सऑफ (द, एस, आई + 1); लिखें (जे); </वाक्यविन्यास हाइलाइट>

यह इसे स्थान 5 से स्कैन करने के लिए कहता है, इसलिए यह हमारे द्वारा पहले पाए गए पहले उदाहरण से मेल नहीं खाएगा। हालाँकि, इसका दूसरा उदाहरण नहीं हो सकता है - पहला भी नहीं हो सकता है- इसलिए रिटर्न वैल्यू फ्रॉम indexOf जादू संख्या -1 के खिलाफ जांच की जानी चाहिए जिसका प्रयोग किसी भी मिलान को इंगित करने के लिए नहीं किया जाता है। एक पूर्ण दिनचर्या जो प्रत्येक उदाहरण के स्थान को प्रिंट करती है वह है:

<वाक्यविन्यास प्रकाश लैंग = जावा> s = सारी दुनिया एक मंच है। और सभी पुरुष और महिलाएं केवल खिलाड़ी हैं; मैं = इंडेक्सऑफ (द, एस); जबकि मैं != -1 { लिखना (मैं); मैं = इंडेक्सऑफ (द, एस, आई + 1); } </वाक्यविन्यास हाइलाइट>

आइकन में, समकक्ष find एक जनरेटर है, इसलिए एक ही पंक्ति के साथ समान परिणाम बनाए जा सकते हैं:

<वाक्यविन्यास लैंग = आइकन> s:=सारी दुनिया एक रंगमंच है। और सभी पुरुष और महिलाएं केवल खिलाड़ी हैं हर लिखना (ढूंढें (द, एस)) </वाक्यविन्यास हाइलाइट>

बेशक ऐसे समय होते हैं जब कोई इनपुट में कुछ बिंदु के बाद एक स्ट्रिंग खोजना चाहता है, उदाहरण के लिए, यदि किसी पाठ फ़ाइल को स्कैन किया जाता है जिसमें पहले चार कॉलम में एक पंक्ति संख्या, एक स्थान और फिर पाठ की एक पंक्ति होती है। लक्ष्य-निर्देशित निष्पादन का उपयोग लाइन नंबरों को छोड़ने के लिए किया जा सकता है:

<वाक्यविन्यास लैंग = आइकन> प्रत्येक लेखन (5 <ढूंढें (द, एस)) </वाक्यविन्यास हाइलाइट>

स्थिति 5 के बाद दिखाई देने पर ही स्थिति वापस की जाएगी; तुलना विफल हो जाएगी अन्यथा, लिखने में असफल हो जाओ, और लेखन नहीं होगा। every }} ऑपरेटर के समान है while, जनरेटर द्वारा लौटाए गए प्रत्येक आइटम के माध्यम से लूपिंग करना और विफलता पर बाहर निकलना: <वाक्यविन्यास लैंग = आइकन> हर k := i to j do   लिखें (कुछ फ़ंक्शन (के)) </वाक्यविन्यास हाइलाइट>

के बीच एक महत्वपूर्ण अंतर है every और while; while विफल होने तक पहले परिणाम का पुनर्मूल्यांकन करता है, जबकि every जनरेटर से अगला मान प्राप्त करता है। every वास्तव में स्मॉलटाक के तहत ब्लॉक के समान फैशन में फ़ंक्शन में मूल्यों को इंजेक्ट करता है। उदाहरण के लिए, उपरोक्त लूप को इस तरह से फिर से लिखा जा सकता है: <वाक्यविन्यास लैंग = आइकन> प्रत्येक लेखन (कुछ फ़ंक्शन (i से j)) </वाक्यविन्यास हाइलाइट>

इस स्थिति में, i से j तक के मानों को इंजेक्ट किया जाएगा someFunction और (संभावित रूप से) आउटपुट की कई पंक्तियाँ लिखें।

संग्रह
आइकन में सूची (सार डेटा प्रकार) सहित कई संग्रह (सार डेटा प्रकार) शामिल हैं, जिन्हें स्टैक (सार डेटा प्रकार) और कतार (सार डेटा प्रकार), साहचर्य सरणी (अन्य भाषाओं में मानचित्र या शब्दकोश के रूप में भी जाना जाता है) के रूप में भी इस्तेमाल किया जा सकता है। सेट (सार डेटा प्रकार) और अन्य। चिह्न इन्हें संरचनाओं के रूप में संदर्भित करता है। संग्रह अंतर्निहित जनरेटर हैं और उन्हें बैंग सिंटैक्स का उपयोग करके आसानी से कॉल किया जा सकता है। उदाहरण के लिए:

<वाक्यविन्यास लैंग = आइकन> लाइनें: = [] # एक खाली सूची बनाएं जबकि लाइन: = पढ़ें मानक इनपुट से {# लूप रीडिंग लाइन करें पुश (लाइनें, लाइन) # सूची में लाइन को पुश करने के लिए स्टैक-जैसे सिंटैक्स का उपयोग करें } जबकि लाइन: = पॉप (लाइनें) { # लूप जबकि लाइनों को सूची से पॉप किया जा सकता है राइट (लाइन) # लाइन आउट लिखें } </वाक्यविन्यास हाइलाइट>

जैसा कि पहले के उदाहरणों में देखा गया है, विफल प्रसार का उपयोग करके, हम परीक्षण और लूप को जोड़ सकते हैं:

<वाक्यविन्यास लैंग = आइकन> लाइनें: = [] # एक खाली सूची बनाएं जबकि पुश (लाइनें, पढ़ें ) # खाली होने तक पुश करें लिखते समय (पॉप (लाइनें)) # खाली होने तक लिखें </वाक्यविन्यास हाइलाइट>

क्योंकि सूची संग्रह एक जनरेटर है, इसे बैंग सिंटैक्स के साथ और सरल बनाया जा सकता है:

<वाक्यविन्यास लैंग = आइकन> पंक्तियां := [] हर धक्का (लाइनें,! और इनपुट) प्रत्येक लेखन (! रेखाएं) </वाक्यविन्यास हाइलाइट>

इस मामले में, धमाका write आइकन को सरणी से एक-एक करके पाठ की एक पंक्ति वापस करने का कारण बनता है और अंत में अंत में विफल हो जाता है। &input का एक जनरेटर-आधारित एनालॉग है read जो मानक इनपुट से एक पंक्ति पढ़ता है, इसलिए !&input फ़ाइल समाप्त होने तक पढ़ना जारी रखता है।

जैसा कि आइकन टाइपलेस है, सूचियों में विभिन्न प्रकार के मान हो सकते हैं:

आइटम में अन्य संरचनाएं शामिल हो सकती हैं। बड़ी सूचियाँ बनाने के लिए, आइकन में शामिल है list जनरेटर; Word की 10 प्रतियों वाली एक सूची बनाता है। अन्य भाषाओं में सरणियों की तरह, आइकन आइटम को स्थिति के अनुसार देखने की अनुमति देता है, उदाहरण के लिए,. ऐरे स्लाइसिंग शामिल है, नई सूचियों को अन्य सूचियों के तत्वों से बनाने की इजाजत देता है, उदाहरण के लिए, aCat := Cats[2:4] aCat नामक एक नई सूची तैयार करता है जिसमें टैबी और 2002 शामिल हैं।

टेबल्स अनिवार्य रूप से पूर्णांकों के बजाय मनमाना सूचकांक कुंजियों के साथ सूचीबद्ध हैं:

<वाक्यविन्यास लैंग = आइकन> प्रतीक : = तालिका (0) प्रतीक [वहाँ]: = 1 प्रतीक [यहाँ]: = 2 </वाक्यविन्यास हाइलाइट>

यह कोड एक टेबल बनाता है जो शून्य को किसी अज्ञात कुंजी के डिफ़ॉल्ट मान के रूप में उपयोग करेगा। यह तब तालिका में दो आइटम जोड़ता है, कुंजियों के साथ वहां और यहां, और मान 1 और 2।

समुच्चय भी सूचियों के समान होते हैं लेकिन इनमें किसी दिए गए मान का केवल एक ही सदस्य होता है। चिह्न शामिल हैं ++ दो सेट के मिलन का उत्पादन करने के लिए, ** चौराहे, और -- के अंतर। आइकन में कई पूर्व-निर्धारित Cset शामिल हैं, एक सेट जिसमें विभिन्न वर्ण हैं। Icon में चार मानक Csets हैं, &ucase, &lcase, &letters, और &digits. सिंगल कोट्स में एक स्ट्रिंग संलग्न करके नए सीसेट बनाए जा सकते हैं, उदाहरण के लिए, vowel := 'aeiou'.

स्ट्रिंग्स
चिह्न में, तार वर्णों की सूची हैं। एक सूची के रूप में, वे जनरेटर हैं और इस प्रकार बैंग सिंटैक्स का उपयोग करके पुनरावृत्त किया जा सकता है:

<वाक्यविन्यास लैंग = आइकन> लिखें (! हैलो, दुनिया!) </वाक्यविन्यास हाइलाइट>

स्ट्रिंग के प्रत्येक वर्ण को एक अलग लाइन पर प्रिंट करेगा।

कोष्ठक के भीतर एक श्रेणी विनिर्देश का उपयोग करके सबस्ट्रिंग को एक स्ट्रिंग से निकाला जा सकता है। एक श्रेणी विनिर्देश एक बिंदु को एक वर्ण, या स्ट्रिंग के एक सरणी टुकड़ा करने के लिए वापस कर सकता है। स्ट्रिंग्स को दाएँ या बाएँ से अनुक्रमित किया जा सकता है। एक स्ट्रिंग के भीतर पदों को वर्णों के बीच परिभाषित किया गया है 1A2B3C4 और दाईं ओर से निर्दिष्ट किया जा सकता है −3A−2B−1C0 उदाहरण के लिए, <वाक्यविन्यास लैंग = आइकन> विकिपीडिया [1] ==> डब्ल्यू विकिपीडिया [3] ==> के विकिपीडिया [0] ==> अ विकिपीडिया [1:3] ==> वाई विकिपीडिया [-2:0] ==> आइए विकिपीडिया [2+:3] ==> iki </वाक्यविन्यास हाइलाइट> जहां अंतिम उदाहरण समाप्ति स्थिति के बजाय लंबाई का उपयोग करके दिखाता है

सबस्क्रिप्टिंग विनिर्देश एक अभिव्यक्ति के भीतर एक मान (कंप्यूटर विज्ञान) #lrvalue के रूप में उपयोग किया जा सकता है। इसका उपयोग स्ट्रिंग्स को किसी अन्य स्ट्रिंग में डालने या स्ट्रिंग के हिस्सों को हटाने के लिए किया जा सकता है। उदाहरण के लिए:

<वाक्यविन्यास लैंग = आइकन> स := एबीसी एस [2]: = 123 s का मान अब a123c है एस: = abcdefg s[3:5] := ABCD s का मान अब abABCDefg है एस: = abcdefg एस [3: 5]: = s का अब abefg का मान है </वाक्यविन्यास हाइलाइट>

स्ट्रिंग स्कैनिंग
स्ट्रिंग्स को संभालने के लिए एक और सरलीकरण स्कैनिंग सिस्टम है, जिसे लागू किया गया है ?, जो स्ट्रिंग पर फ़ंक्शन कॉल करता है:

<वाक्यविन्यास लैंग = आइकन> एस ? लिखें (ढूंढें ) </वाक्यविन्यास हाइलाइट>

चिह्न के बाएँ हाथ की ओर संदर्भित करता है ? विषय के रूप में, और इसे स्ट्रिंग फ़ंक्शंस में पास करता है। स्मरण करो find दो पैरामीटर लेता है, पैरामीटर एक के रूप में खोज पाठ और पैरामीटर दो में खोज करने के लिए स्ट्रिंग। का उपयोग करते हुए ? दूसरा पैरामीटर निहित है और प्रोग्रामर द्वारा निर्दिष्ट नहीं किया जाना चाहिए। सामान्य मामलों में जब अनुक्रम में एक ही स्ट्रिंग पर कई कार्यों को बुलाया जा रहा है, तो यह शैली परिणामी कोड की लंबाई को काफी कम कर सकती है और स्पष्टता में सुधार कर सकती है। आइकन फ़ंक्शन हस्ताक्षर उनकी परिभाषाओं में विषय पैरामीटर की पहचान करते हैं, इसलिए पैरामीटर इस तरह से लूप-इनवेरिएंट कोड मोशन हो सकता है। ? }} केवल सिंटैक्टिक चीनी का एक रूप नहीं है, यह किसी भी निम्नलिखित स्ट्रिंग ऑपरेशंस के लिए एक स्ट्रिंग स्कैनिंग वातावरण भी स्थापित करता है। यह दो आंतरिक चरों पर आधारित है, &subject और &pos; &subject मूल स्ट्रिंग के लिए बस एक सूचक है, जबकि &pos इसके भीतर वर्तमान स्थिति है, या कर्सर। Icon की विभिन्न स्ट्रिंग हेरफेर प्रक्रियाएं इन दो चरों का उपयोग करती हैं, इसलिए उन्हें प्रोग्रामर द्वारा स्पष्ट रूप से आपूर्ति करने की आवश्यकता नहीं है। उदाहरण के लिए:

<वाक्यविन्यास लैंग = आइकन> s := यह एक स्ट्रिंग है एस ? लिखें (विषय = [, और विषय,], स्थिति = [, और स्थिति,]) </वाक्यविन्यास हाइलाइट>

उत्पादन करेगा:

<वाक्यविन्यास लैंग = पाठ> विषय = [यह एक स्ट्रिंग है], स्थिति = [1] </वाक्यविन्यास हाइलाइट>

स्कैन की जा रही स्ट्रिंग के भीतर घूमने के लिए बिल्ट-इन और यूज़र-डिफ़ाइंड फ़ंक्शंस का उपयोग किया जा सकता है। सभी अंतर्निहित कार्य इसके लिए डिफ़ॉल्ट होंगे &subject और &pos स्कैनिंग सिंटैक्स का उपयोग करने की अनुमति देने के लिए। निम्नलिखित कोड सभी रिक्त-सीमांकित शब्दों को एक स्ट्रिंग में लिखेगा:

<वाक्यविन्यास लैंग = आइकन> s := यह एक स्ट्रिंग है एस ? {# स्ट्रिंग स्कैनिंग वातावरण स्थापित करें जबकि पॉज़ नहीं (0) { # स्ट्रिंग के अंत के लिए टेस्ट करें टैब (अनेक ('')) # किसी भी रिक्त स्थान को छोड़ दें शब्द : = टैब (तक ('') | 0) # अगला शब्द अगले रिक्त तक है -या- पंक्ति का अंत लिखें (शब्द) # शब्द लिखें } } </वाक्यविन्यास हाइलाइट>

इस उदाहरण में कई नए कार्य पेश किए गए हैं। pos का वर्तमान मान लौटाता है &pos. यह तुरंत स्पष्ट नहीं हो सकता है कि किसी को इस फ़ंक्शन की आवश्यकता क्यों होगी और केवल के मान का उपयोग न करें &pos सीधे; कारण यह है कि &pos एक चर है और इस प्रकार मूल्य नहीं ले सकता &fail, जो प्रक्रिया pos कर सकना। इस प्रकार pos एक हल्का आवरण प्रदान करता है &pos जो आइकॉन के लक्ष्य-निर्देशित प्रवाह नियंत्रण को हाथ से लिखे बूलियन परीक्षण प्रदान किए बिना आसानी से उपयोग करने की अनुमति देता है &pos. इस मामले में, परीक्षण &pos शून्य है, जो चिह्न के स्ट्रिंग स्थानों की विषम संख्या में, पंक्ति का अंत है। यदि यह शून्य नहीं है, pos रिटर्न &fail, जो इसके साथ उलटा है not और लूप जारी रहता है।

many वर्तमान से शुरू होने वाले प्रदान किए गए Cset पैरामीटर के एक या अधिक उदाहरण ढूंढता है &pos. इस मामले में, यह अंतरिक्ष वर्णों की तलाश कर रहा है, इसलिए इस फ़ंक्शन का परिणाम बाद के पहले गैर-अंतरिक्ष वर्ण का स्थान है &pos. tab चाल &pos उस स्थान पर, फिर से एक संभावना के साथ &fail मामले में, उदाहरण के लिए, many स्ट्रिंग के अंत से गिर जाता है। upto का उल्टा है many; यह प्रदान किए गए सीसेट से तुरंत पहले स्थान लौटाता है, जो उदाहरण के बाद सेट करता है &pos दूसरे के साथ tab. अल्टरनेशन का प्रयोग लाइन के अंत में रुकने के लिए भी किया जाता है।

इस उदाहरण को अधिक उपयुक्त शब्द ब्रेकिंग सीसेट के उपयोग के माध्यम से और अधिक मजबूत बनाया जा सकता है जिसमें अवधि, अल्पविराम और अन्य विराम चिह्न, साथ ही टैब और गैर-ब्रेकिंग रिक्त स्थान जैसे अन्य व्हाइटस्पेस वर्ण शामिल हो सकते हैं। उस सीसेट का उपयोग तब किया जा सकता है many और upto.

एक अधिक जटिल उदाहरण भाषा के भीतर जनरेटर और स्ट्रिंग स्कैनिंग के एकीकरण को प्रदर्शित करता है।

<वाक्यविन्यास लैंग = आइकन> प्रक्रिया मुख्य s := सोम दिसम्बर 8 एस ? लिखें (Mdate | मान्य तिथि नहीं है) अंत प्रक्रिया Mdate स्थिर तिथियां स्थिर दिन प्रारंभिक { दिन := [सोम, मंगल, बुध, तृतीय, शुक्र, शनि, सूर्य] महीने := [जनवरी, फरवरी, मार्च, अप्रैल, मई, जून, जुलाई, अगस्त, सितंबर, अक्टूबर, नवंबर, दिसंबर] } प्रत्येक निलंबन (पुनः मूल्य <- टैब (मिलान (!दिन)) || # एक दिन का मिलान करें                            = || # उसके बाद एक रिक्त स्थान है                             टैब(मैच(!महीने)) || # महीने के बाद                             = || # उसके बाद एक रिक्त स्थान है                             matchdigits(2) # कम से कम 2 अंकों का पालन करें                 ) और (= | pos(0) ) & # या तो रिक्त या स्ट्रिंग का अंत retval # और अंत में स्ट्रिंग वापस करें अंत प्रक्रिया मिलान अंक (एन) सस्पेंड (वी: = टैब (कई (और अंक)) और * वी <= एन) और वी अंत </वाक्यविन्यास हाइलाइट>
 * 1) रिटर्न करने वाले मैचिंग फंक्शन को परिभाषित करें
 * 2) एक स्ट्रिंग जो महीने के एक दिन महीने के दिन से मेल खाती है
 * 1) कुछ शुरुआती मूल्यों को परिभाषित करें
 * 1) मिलान फ़ंक्शन जो एन अंकों की एक स्ट्रिंग देता है

आलोचना
लॉरेंस ट्रैट ने आइकॉन पर अपने वास्तविक दुनिया के अनुप्रयोगों की जांच करने और चिंता के कई क्षेत्रों की ओर इशारा करते हुए एक पेपर लिखा। इनमें से कई व्यावहारिक निर्णय थे जो स्ट्रिंग प्रसंस्करण में अपनी उत्पत्ति से प्राप्त हुए थे लेकिन अन्य क्षेत्रों में उतने मायने नहीं रखते थे। उनमें से:

प्रक्रियाओं के अंत में डिफ़ॉल्ट रूप से विफल होने का निर्णय जनरेटर के संदर्भ में समझ में आता है, लेकिन सामान्य प्रक्रियाओं के मामले में ऐसा कम होता है। ऊपर उल्लिखित उदाहरण पर लौटते हुए, write(f(-1)) आउटपुट नहीं होगा जिसकी उम्मीद की जा सकती है। हालाँकि: <वाक्यविन्यास लैंग = आइकन> एक्स := 10 (अतिरिक्त पंक्तियां) एक्स := च(-1) लिखें (एक्स) </वाक्यविन्यास हाइलाइट> परिणामस्वरूप 10 मुद्रित होंगे। इस तरह की समस्या बिल्कुल स्पष्ट नहीं है क्योंकि एक इंटरैक्टिव डीबगर में भी सभी कोड अभी तक लागू नहीं किए गए हैं x अपेक्षित मूल्य कभी नहीं उठाता। इसे उन गोचरों में से एक के रूप में खारिज किया जा सकता है, जिनके बारे में प्रोग्रामर को किसी भी भाषा में पता होना चाहिए, लेकिन ट्रैट ने विभिन्न प्रकार के आइकन कार्यक्रमों की जांच की और पाया कि अधिकांश प्रक्रियाएं जनरेटर नहीं हैं। इसका मतलब यह है कि आइकॉन का डिफ़ॉल्ट व्यवहार केवल इसके निर्माण के एक छोटे से अल्पसंख्यक द्वारा उपयोग किया जाता है, फिर भी अन्य सभी में संभावित त्रुटियों के एक प्रमुख स्रोत का प्रतिनिधित्व करता है। एक अन्य समस्या बूलियन डेटा प्रकार की कमी है और पारंपरिक बूलियन तर्क। जबकि सफलता/असफल प्रणाली ज्यादातर मामलों में काम करती है जहां अंतिम लक्ष्य मूल्य की जांच करना है, फिर भी यह प्रतीत होता है कि सरल कोड में कुछ अजीब व्यवहार हो सकता है: <वाक्यविन्यास लैंग = आइकन> प्रक्रिया मुख्य अगर सी तो { लिखना (लेना) } अंत </वाक्यविन्यास हाइलाइट> यह कार्यक्रम प्रिंट लिया जाएगा। कारण यह है कि परीक्षा, c, एक मान लौटाता है; वह मान शून्य है, अन्यथा सभी असंबद्ध चरों के लिए डिफ़ॉल्ट मान। शून्य एक मान्य मान है, इसलिए if c सफल होता है। इसे हल करने के लिए, परीक्षण को स्पष्ट करने की आवश्यकता है,, जो स्व-दस्तावेज़ीकरण कोड से अलग हो जाता है - यह अस्पष्ट है कि क्या यह परीक्षण c शून्य है या c मौजूद है।

यह भी देखें

 * कोरूटीन

बाहरी संबंध

 * Icon homepage
 * Oral history interview with Stephen Wampler, Charles Babbage Institute, University of Minnesota. Wampler discusses his work on the development Icon in the late 1970s.
 * Oral history interview with Robert Goldberg, Charles Babbage Institute, University of Minnesota. Goldberg discusses his interaction with Griswold when working on Icon in the classroom at Illinois Institute of Technology.
 * Oral history interview with Kenneth Walker, Charles Babbage Institute, University of Minnesota. Walker describes the work environment of the Icon project, his interactions with Griswold, and his own work on an Icon compiler.
 * The Icon Programming Language page on The Rosetta Code comparative programming tasks project site