🧓🏿 👨🏼‍🔧 🎅🏽 प्रोग्रामिंग भाषा जे। शौकिया देखो। भाग 2. टैसीट प्रोग्रामिंग 😩 🥛 ⛹🏼

प्रोग्रामिंग भाषा में पिछला लेख जे। एक शौकिया की नज़र। भाग 1. परिचय

प्रश्न: यदि फ़ंक्शन डेटा बदलते हैं, और ऑपरेटर फ़ंक्शन बदलते हैं, तो ऑपरेटर कौन बदलता है?
उत्तर: केन आइवरसन
चिराग पथिक

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

1. क्रिया

हमारी पहली क्रिया को परिभाषित करें। सुविधा के लिए, हम मान सकते हैं कि एक क्रिया एक फ़ंक्शन है जो डिफ़ॉल्ट रूप से दिए गए तर्कों के साथ है। इंटरप्रेटर जे खोलें, परिचय दें

neg =: -

जहाँ "नकारात्मक" हमारे क्रिया का नाम है, "=:" असाइनमेंट ऑपरेटर है, "-" क्रिया का वास्तविक निकाय है, जिसमें अंतर्निहित क्रिया "-" कहते हैं। अब आइए अपने क्रिया को एक अर्थ में लागू करने की कोशिश करें (यानी, इसे कॉल करें)। उदाहरण के लिए, इकाई के लिए:

  neg 1 _1

जैसा कि आप उदाहरण से देख सकते हैं, परिणाम संख्या "-1" है (जे में, एक अंडरस्कोर का उपयोग नकारात्मक संख्या लिखने के लिए किया जाता है, क्योंकि शून्य का उपयोग अंतर्निहित क्रिया के लिए किया जाता है)।

अब हम एक चर को परिभाषित करते हैं (J में इसे "संज्ञा") "x" कहते हैं और इसे -1 का मान प्रदान करते हैं:

  x =: _1

हम उम्मीद करते हैं कि नकारात्मक x निर्माण हमें वापस लौटा देगा। यह सच है:

  neg x 1

यह कॉल सरल है

  - x 1

एक और उदाहरण:

  x _1 neg -

यानी चर "x" का मान "-1" है, और क्रिया का मूल्य इसका शरीर है। आप "9 !: 3" क्रिया का उपयोग करके स्क्रीन पर प्रदर्शित मूल्यों को बदल सकते हैं।
एक और क्रिया को परिभाषित करें, जो अंतर्निहित क्रिया के लिए एक सरल पर्याय भी होगा:

  twice =: +:

यह क्रिया अपने तर्क के अर्थ को दोगुना कर देती है। यहां आप क्रियाओं के नामकरण में पैटर्न का पता लगा सकते हैं - उदाहरण के लिए, यदि क्रिया "+:" इसके तर्क को दोगुना करती है, तो क्रिया "-" इसके तर्क को आधा कर देती है।

  NB.    x =: _1 NB. ,  «NB.»   . NB.     «Nota Bene»,    « ». twice x _2 twice (neg x) 2

और यहां तक कि:

  twice (-: 2) 2

और ऐसा है

  +: (+: (- 2)) _8

2. मोनाड्स और डाईएड्स

यह खंड हास्केल से संबंधित नहीं है।

क्रियाओं को एक या 2 तर्कों के साथ बुलाया जा सकता है। J के संदर्भ में एक तर्क (ऑपरेंड) के साथ एक क्रिया को एक मोनाड कहा जाता है, और दो तर्कों के साथ - एक राग। बाद के मामले में, तर्क को बाएं और दाएं (क्रमशः पहला और दूसरा तर्क) कहा जाता है। हमारे पहले मठ को याद करें:

  minus =: - minus 1 _1 minus 7 _7

लेकिन जिस क्रिया को हमने परिभाषित किया है उसे दो तर्कों के साथ कहा जा सकता है:

  4 minus 2 2 12 minus 5 7

इस मामले में, क्रिया माइनस का उपयोग एक रंजक के रूप में किया जाता है और, प्रतिस्थापन के परिणामस्वरूप, क्रमशः "4–2" और "12-5" की गणना की जाती है।

दो तर्क अधिकतम हैं जो क्रिया को परिभाषित करने और आह्वान करने में उपयोग किए जा सकते हैं।
कोई सोच सकता है कि अगर जे भाषा ने दो-आयामी वाक्यविन्यास (उदाहरण के लिए, गूढ़ भाषा) का समर्थन किया है, तो तर्क केवल बाईं ओर और दाईं ओर नहीं, बल्कि ऊपर से नीचे तक लिखे जा सकते हैं। सौभाग्य से, केवल लीनियर सिंटैक्स J में समर्थित है।

एक और उदाहरण देने के लिए, हम क्रिया "div" को अंतर्निर्मित क्रिया "%" के पर्याय के रूप में परिभाषित करते हैं। इसके अलावा, "%" एक डिवीजन ऑपरेटर है, अधिक परिचित "/" प्रतीक का उपयोग अन्य कार्यों के लिए किया जाता है (बाद में हम दिखाएंगे कि क्यों)।

  div =: % 1 div 2 0.5 4 div 3 1.3333

इस उदाहरण में, क्रिया को डायड कहा जाता है और क्रमशः 1 को 2 और 4 से 3 से विभाजित करता है। और ध्यान दें कि हालांकि ऑपरेंड पूर्णांक हैं, विभाजन परिणाम एक फ्लोटिंग-पॉइंट संख्या है।

जब एक ऑपरेंड के साथ कॉल किया जाता है, तो क्रिया "%" डिफ़ॉल्ट रूप से यूनिट को इस ऑपरेंड में विभाजित करती है।

  div 2 0.5 div 4 0.25

उपरोक्त अभिव्यक्ति को क्रमशः "1% 2" और "1% 4" लिखा जा सकता है।

उपरोक्त उदाहरण में, भाषा की एक महत्वपूर्ण विशेषता का उपयोग किया जाता है - एक ही क्रिया के मोनड और डियाड कॉल अर्थ में काफी भिन्न कार्य कर सकते हैं। उदाहरण के लिए, क्रियात्मक "*:" राक्षसी मामले में अपने तर्क के वर्ग की गणना करता है, और डायडिक मामले में यह तार्किक ऑपरेशन "नॉट-एंड" करता है:

  *: 3 9 *: 4 16 0 *: 0 1 1 *: 1 0 0 *: 1 1 1 *: 0 1

क्रिया के लिए स्पष्ट रूप से इसके बाएं या दाएं तर्क का उपयोग करने के लिए, क्रिया "[" और "]" का इरादा है। उनमें से पहला अपना बाएं तर्क देता है, दूसरा - दायां। उदाहरण के लिए:

  11 [ 22 11 11 ] 22 22 ] 33 33 [ 44 NB.  ,   ,  [   . 44

हम अपने सामान को निरंतर क्रियाओं "0:", "1:", "2:", ..., "9:" के साथ पूरक करते हैं। उन्हें निरंतर कहा जाता है क्योंकि हम उन्हें जो भी तर्क देते हैं, वे हमेशा उसी मूल्य को वापस करेंगे। "0:" शून्य वापस आ जाएगा, "1:" - एक, आदि। उदाहरण के लिए:

  7 3: 9 3 3: 7 3

3. यूनियनों

आगे मान लीजिए कि एक ही क्रिया के लिए यह आवश्यक है कि एकादशी (एक तर्क के साथ) और डायदिक (दो तर्कों के साथ) कॉल के लिए अलग-अलग व्यवहार को परिभाषित किया जाए। यह एक अच्छी तरह से स्थापित इच्छा है, क्योंकि J एक गतिशील भाषा है, और हमारा कोड दुरुपयोग से सुरक्षित नहीं है। क्रिया के मोनैड और डाइएडिक व्यवहार को अलग करने के लिए, एक विशेष संघ ":" है।

यदि हम कहते हैं कि एक क्रिया एक फ़ंक्शन है जिसमें डिफ़ॉल्ट रूप से एक या दो तर्क होते हैं, और तर्कों का मान या तो एक चर या तात्कालिक मान हो सकता है, तो, इस मामले में, "यूनियन" एक ऐसा फ़ंक्शन है जो दो के रूप में है (और केवल दो) तर्क क्रियाओं को लेते हैं। यूनियनों, साथ ही क्रियाओं, उपयोगकर्ता स्वतंत्र रूप से निर्धारित कर सकता है।

यहां भाषण के कुछ हिस्सों (जे में जैसा कि हम बाद में देखेंगे, वहाँ भी विशेषण हैं) के साथ एक सादृश्य खींचना संभव होगा, लेकिन यह लेखक को लगता है कि इससे अनावश्यक भ्रम पैदा होगा।

आइए हम अपने भिक्षुओं के पास वापस जाएं। संघ के बाईं ओर ":" क्रिया की राक्षसी कॉल दाईं ओर दर्ज की गई है - दाईद। एक उदाहरण:

  v =: 1: : 2: 11 v 22 2 v 11 1

यदि आप क्रिया को "v" को एक रंग (उदाहरण के लिए, "11" और "22") के तर्कों के रूप में कहते हैं, तो आपको अभिव्यक्ति "2:" में संदर्भित किया जाएगा। यदि एक सनक के रूप में (उदाहरण में - "11" तर्क के साथ), तो "1:"। और ये निरंतर क्रियाएं हैं जो हमेशा अपने अर्थ को वापस करती हैं: पहले मामले में "2" और दूसरे में "1"।

अब तक, हमने केवल संख्यात्मक मानों पर काम किया है। इस बार हम स्ट्रिंग्स का उपयोग करते हैं जो सिंगल कोट्स में लिखे गए हैं (जे में डबल कोट्स एक यूनियन हैं)। हम पहले वर्णित क्रिया "v" को फिर से परिभाषित करते हैं:

  v =: 'monadic call' : 'dyadic call' v 11 |domain error 11 v 22 |domain error

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

आप जम्मू में तार के साथ-साथ सरणियों के साथ काम कर सकते हैं (जो हम थोड़ी देर बाद मिलेंगे)। उदाहरण के लिए, संन्यासी कॉल में क्रिया "#" सरणी की लंबाई लौटाती है:

  # 23 1 # '12ab' 4 # '012345' 6 # '' 0

पहले हमने क्रिया को नकारात्मक रूप से परिभाषित किया, जो हमारे तर्क में परिवर्तन को दर्शाता है। हालाँकि, यदि आप इस क्रिया को डायडिक संस्करण में कहते हैं, तो निम्न होगा:

  neg =: - 1 neg 2 _1

यानी प्रतिस्थापन के बाद, हमारी क्रिया ने "1 - 2" के घटाव के रूप में काम किया। यह उचित होगा कि क्रिया के दायरे को केवल मोनाड कॉल तक सीमित किया जाए। जैसा कि पहले उल्लेख किया गया है, जे की गतिशील प्रकृति हमें कार्यक्रम निष्पादन के दौरान समान जांच करने के लिए मजबूर करती है। जैसे, शायद, जे में बाकी सब, ऐसा चेक जितना संभव हो उतना छोटा लिखा जाता है:

  neg =: - : [:

हमने अपने लिए नई क्रिया "[:" का उपयोग किया। "J फॉर सी प्रोग्रामर्स" पुस्तक में, इस क्रिया को "आत्महत्या क्रिया" कहा जाता है क्योंकि जब बुलाया जाता है, तो यह प्रोग्राम को क्रैश करने का कारण बनता है:

  neg 1 _1 1 neg 2 NB.      - - |domain error

ऐसी स्थितियों को पकड़ने के लिए, आप तथाकथित का उपयोग कर सकते हैं। "जाल"। J में शब्द के सामान्य अर्थों में कोई अपवाद नहीं है, इसके बजाय संघ "::" का उपयोग किया जाता है।

संघ "::" अपनी बाईं ओर अभिव्यक्ति को निष्पादित करता है, और यदि यह एक त्रुटि के साथ समाप्त हुआ, तो यह अभिव्यक्ति को दाईं ओर निष्पादित करता है। एक उदाहरण:

  v =: [: :: 3: 1 v 2 3 v 7 3

यह क्रिया हमेशा 3 वापस आएगी, क्योंकि जैसा कि हमने कहा, बाईं ओर की अभिव्यक्ति को पहले निष्पादित किया जाएगा। और बाईं ओर हमने क्रिया-आत्महत्या डाल दी। इसलिए, क्रिया "वी" के प्रत्येक कॉल के साथ संयोजन "::" आत्महत्या को पकड़ता है "[:" और उस क्रिया के सभी तर्कों को पारित करता है जिसे हमने दाईं ओर लिखा था, अर्थात्। क्रिया स्थिरांक "3:"।

3.1। लगातार संघों

अब तक, हमने केवल एकल क्रियाओं का उपयोग किया है। अनुक्रमिक गणना करने के लिए, संघ "@" या विशेष क्रिया "[:" का उपयोग किया जाता है, जो क्रिया की संरचना में पहला तत्व है, छोड़ दिया जाता है और अनुक्रमिक गणना करने की अनुमति देता है:

  ([: +: +:) 10 NB.  (+: (+: 10)) 40 (+: @ +:) 10 NB.  (+: (+: 10)) 40

हमारे संग्रह में अगला संघ "और" है, जिसका सिद्धांत इस प्रकार है।

  u&.vy NB.  v_ uvy x u&.vy NB.  v_ (vx) u (vy). +:&.*: 10 14.1421 %: @: +: (*: 10) NB.    14.1421 %: (+: (*: 10)) NB.   14.1421

जहाँ "v_inversion" का अर्थ क्रिया के "v" के विपरीत होता है। अभिव्यक्ति में "+: &। *:" क्रिया जिसमें से व्युत्क्रम लिया जाता है "*:" (क्योंकि यह संघ के दाईं ओर खड़ा है "&"।)। और क्रिया का उलटा "*:" "%:" है। यानी वर्ग के विपरीत वर्गमूल ले रहा है।

हमारे लिए उपयोगी एक और संघ "&" है, जो क्रिया में एक संज्ञा (ऑपरेंड वैल्यू) को जोड़कर एक डायैडिक कॉल से एक एकादश बनाता है। एक निश्चित धारणा के साथ, हम कह सकते हैं कि इस संघ ने करीने का काम किया है। उदाहरण के लिए:

  inc =: 1&+ NB.  inc 41 42 inc _3 _2 div3 =: %&3 div3 9 3 div3 12 4

हम केवल मोनाड मामले के लिए वेतन वृद्धि को परिभाषित करते हैं:

  inc =: 1&+ : [: inc 1 2 1 inc 2 |domain error: inc | 1 inc 2

4. क्रियाविशेषण

पहले हमने क्रियाविशेषणों का उल्लेख किया था। जे भाषा के संदर्भ में, एक क्रिया विशेषण एक अभिव्यक्ति है जो एक क्रिया को एक तर्क के रूप में लेती है और एक नई क्रिया को एक अलग व्यवहार के साथ बनाती है।

हम विशेषण "~" देते हैं, जो अपने डायडिक कॉल में तर्कों को स्वैप करता है ("xu ~ y" को "yux" के लिए प्रतिस्थापित किया जाता है) और ओपेरा की मोनाडिक कॉल को बदले, ओपेरा की नकल करते हुए ("u ~ y" "yuy" के लिए प्रतिस्थापित किया गया है)।

  % 2 NB.   ,    «1 % 2» 0.5 %~ 2 NB.  «2 % 2» 1 2 % 3 0.666667 2 %~ 3 NB.  «3 % 2» 1.5

सबसे अधिक इस्तेमाल की जाने वाली क्रियाविशेषणों में से एक क्रिया विशेषण ("बीच में") है, जिसे हम सरणियों तक अनुभाग स्थगित कर देंगे।

5. हुक और कांटे

जे के पास कार्यों की संरचना का एक बहुत ही अजीब तरीका है - यदि लगातार 2 क्रियाओं का संकेत दिया जाता है, तो इसका मतलब यह नहीं है कि उन्हें क्रमिक रूप से लागू किया जाएगा। डायडिक और मॉनेडिक कॉल के लिए अलग से उनके अपने विशेष कॉल ऑर्डर होंगे। 2 क्रियाओं के लिए इस तरह की रचना को हुक (हुक) कहा जाता है। क्रिया v को परिभाषित करें, जो क्रिया का हुक कॉल है f और g:

  v =: fg

यदि आप v को कुछ संज्ञा y पर एक सन्यासी कहते हैं:

vy

तब यह कॉल इसके बराबर होगी:

  yf (gy)

यह ध्यान दिया जाना चाहिए कि, क्रिया v के मोनैडिक आह्वान के बावजूद, हुक के तत्वों में से एक (अर्थात् एफ) को केवल ऑपरेंड के बाईं ओर दोहराव के साथ एक रंग के रूप में कहा जाता है।

अगर हम v को कुछ संज्ञाओं x और y पर एक डाईड कहते हैं:

xvy

तब यह कॉल इसके बराबर होगी:

  xf (gy)

आइए हम क्रिया जाली «#» याद करते हैं, जो एक मोनड कॉल में स्ट्रिंग / एरे की लंबाई लौटाती है, और डायड में दाहिने ऑपेरेंड को उतनी बार कॉल करती है जितना कि बाएं ऑपेंड में संकेत मिलता है। एक डाईड परिभाषित करें:

  v =: # #

हम उपरोक्त योजना के अनुसार क्रिया v के डायडिक कॉल का विस्तार करते हैं:

   # (# y)

जैसा कि आप देख सकते हैं, v एक संख्या को ऑपरेंड y, x बार की लंबाई के बराबर कॉपी करता है। उदाहरण के लिए:

  2 v '1234' 4 4

यह माना जा सकता है कि 3 लगातार क्रिया एक हुक से एक हुक है। हालांकि, यह ऐसा नहीं है - इसके बजाय, एक कांटा रचना (तथाकथित कांटा) लागू किया जाता है। तो, कांटा का मोनड कॉल

  (fgh) y

निम्नलिखित कॉल के बराबर:

  (fy) g (hy)

इस तरह की अभिव्यक्ति का एक उदाहरण हमारे लिए पहले से ज्ञात क्रिया है, जो संख्याओं की एक औसत की गणना करता है:

  mean =: +/%# mean 0 1 2 3 4 5 2.5

ऐसी अभिव्यक्ति निम्नलिखित के बराबर है:

  ((+/ @ [ )%(# @ ])) 0 1 2 3 4 5 2.5

एक और कांटा उदाहरण पर विचार करें:

  v =: # # # v '12345' 5 5 5 5 5

जैसा कि आप देख सकते हैं, यह अभिव्यक्ति ऑपरेंड की लंबाई के बराबर एक संख्या को कॉपी करती है, जितनी बार ऑपरेंड की लंबाई।

पिछले क्रिया को कांटे का उपयोग किए बिना फिर से लिखा जा सकता है:

  ((#@]) # (#@])) '12345' 5 5 5 5 5

डायड कॉल पर संज्ञा x और y पर कांटा परिभाषित करें:

  x (fgh) y

जो निम्नलिखित अभिव्यक्ति के बराबर होगा:

  (xfy) g (xhy)

हम अपने पुराने मित्र की सहायता से रंजक कांटे का वर्णन करते हैं - क्रिया का अर्थ है:

  2 mean 3 1.66667 1.66667

हम इस अभिव्यक्ति को प्रकट करेंगे:

  (2 +/ 3) % (2 # 3)

हमें लगता है कि अभिव्यक्ति का दाहिना भाग तीन से 2 गुना अधिक है। और बायाँ बाएँ और दाएँ ऑपरेंड के योग की गणना करता है। इस प्रकार हमें मिलता है:

  5 % 3 3 1.66667 1.66667

यह समझना विशेष रूप से महत्वपूर्ण है कि जे में यदि 4 क्रियाएं निर्दिष्ट की जाती हैं, तो यह अभिव्यक्ति एक कांटा से एक हुक होगी, यदि 5 एक कांटा से एक कांटा है, 6 - एक कांटा से एक कांटा, आदि। यानी भाव "(# # # # # # #)" और "(# (# # (# # # #))" समतुल्य हैं।

हम दिखाते हैं कि गणना के क्रम को बदलने के लिए कोष्ठकों का उपयोग कैसे करें। उदाहरण के लिए:

  (# # #) 3 1

लेकिन

  (# (# #)) 3 1 1 1 1 1 1 1 1 1

अंतिम अभिव्यक्ति निम्नलिखित के बराबर है:

  3 # (3 # (# 3) 3 # 1 1 1 NB.  3   .

आइए कार्यों की संरचना के साथ एक और अधिक जटिल उदाहरण दिखाएं

  (* + - %) 3 8

यह अभिव्यक्ति निम्नलिखित के बराबर है:

  3 * ((+ 3) - (% 3))

5 क्रियाओं का संयोजन इस तरह दिख सकता है:

  (>: * + - %) 3 10.6667