आपका स्वागत है! मैं आपके जावास्क्रिप्ट प्रोग्रामिंग भाषा - पीएल ट्यूटोरियल को लागू करने के लिए गाइड के मेरे अनुवाद का दूसरा हिस्सा आपके सामने प्रस्तुत करता हूं।

अनुवादक से

हम अपनी प्रोग्रामिंग भाषा - λ भाषा (मूल - λanguage में) बनाएंगे। निर्माण की प्रक्रिया में, हम कई दिलचस्प तकनीकों का उपयोग करेंगे, जैसे कि पुनरावर्ती वंश, नियंत्रण हस्तांतरण शैली, और बुनियादी अनुकूलन तकनीक। दुभाषिया के दो संस्करण बनाए जाएंगे - नियमित और सीपीएस दुभाषियों, जावास्क्रिप्ट में ट्रांस-कंपाइलर।

मूल के लेखक मिहाई Bazon , प्रसिद्ध UglifyJS पुस्तकालय (जेएस कोड को कम करने और प्रारूपित करने का एक उपकरण) के लेखक हैं।

PS इंटरप्रेटर और कंपाइलर में एक बग है: a() && b() या a() || b() a() || b() दोनों भागों को हमेशा निष्पादित किया जाता है। यह, निश्चित रूप से, गलत है क्योंकि a() && ऑपरेटर के लिए गलत है, या उसके लिए गलत नहीं है || , तब b() का मान b() कोई भूमिका नहीं निभाता है। इसे ठीक करना मुश्किल नहीं है।

सरल दुभाषिया

पिछले भाग में, हमने 3 फ़ंक्शन लिखे: InputStream , TokenStream और parse । कोड से एएसटी प्राप्त करने के लिए, हम निम्नलिखित कोड का उपयोग करते हैं:

 var ast = parse(TokenStream(InputStream(code))); 

एक दुभाषिया लिखना एक परसर की तुलना में आसान है: हम बस पेड़ पर पुनरावृत्ति करते हैं और भावों को उनके सामान्य क्रम में निष्पादित करते हैं।

संदर्भ ( Environment )

उचित कोड निष्पादन के लिए, हमें एक संदर्भ की आवश्यकता है - एक वस्तु जो किसी दिए गए स्थान में सभी चर को समाहित करती है। इसे evaluate समारोह के तर्क के रूप में पारित किया जाएगा।

हर बार जब हम lambda नोड में प्रवेश करते हैं, तो हमें संदर्भ - फ़ंक्शन तर्कों में नए चर जोड़ना चाहिए। यदि तर्क बाहरी ब्लॉक से चर को ओवरलैप करता है, तो हमें फ़ंक्शन से बाहर निकलने के बाद चर के पुराने मूल्य को पुनर्स्थापित करना होगा।

इसका सबसे आसान तरीका प्रोटोटाइप जावास्क्रिप्ट विरासत का उपयोग करना है। जब हम एक नया फ़ंक्शन दर्ज करते हैं, तो हम एक नया संदर्भ बनाते हैं, बाहरी संदर्भ को इसके प्रोटोटाइप के रूप में सेट करते हैं, और फ़ंक्शन को नए संदर्भ में कॉल करते हैं। इसके लिए धन्यवाद, हमारे पास कुछ भी नहीं है - बाहरी संदर्भ में इसके सभी चर रहेंगे।

यहाँ Environment वस्तु का कार्यान्वयन है:

 function Environment(parent) { this.vars = Object.create(parent ? parent.vars : null); this.parent = parent; } Environment.prototype = { extend: function() { return new Environment(this); }, lookup: function(name) { var scope = this; while (scope) { if (Object.prototype.hasOwnProperty.call(scope.vars, name)) return scope; scope = scope.parent; } }, get: function(name) { if (name in this.vars) return this.vars[name]; throw new Error("Undefined variable " + name); }, set: function(name, value) { var scope = this.lookup(name); //          if (!scope && this.parent) throw new Error("Undefined variable " + name); return (scope || this).vars[name] = value; }, def: function(name, value) { return this.vars[name] = value; } }; 

Environment वस्तु का एक parent क्षेत्र है जो बाहरी संदर्भ को इंगित करता है। यह वैश्विक संदर्भ के लिए null होगा। इसमें एक vars फ़ील्ड है जिसमें सभी चर हैं जो इस संदर्भ से संबंधित हैं। एक वैश्विक संदर्भ के लिए, यह तुरंत एक खाली वस्तु ( Object.create(null) ) और गैर-वैश्विक एक के लिए मूल संदर्भ ( Object.create(parent.vars) ) के चर की एक प्रति के Object.create(parent.vars) ।

इसकी कई विधियाँ हैं:

• extend() - वर्तमान संदर्भ की प्रतिलिपि बनाएँ।
• lookup(name) - वह संदर्भ खोजें जिसमें चर नाम का name परिभाषित किया गया हो।
• get(name) - एक वैरिएबल नाम का मान प्राप्त name । यदि चर को परिभाषित नहीं किया गया है तो एक अपवाद फेंकता है।
• set(name, value) - एक चर का मान सेट करें। यह विधि उस संदर्भ की तलाश करती है जिसमें चर को परिभाषित किया गया है। यदि इसे परिभाषित नहीं किया गया है, और हम एक वैश्विक संदर्भ में नहीं हैं, तो एक अपवाद फेंक दिया जाएगा।
• def(name, value) - वर्तमान संदर्भ में एक चर बनाता है (या ओवरलैप करता है या ओवरराइड करता है)।

फ़ंक्शन का evaluate करें

अब जब हमारे पास Environment वस्तु है, तो हम मुख्य समस्या को हल करने के लिए आगे बढ़ सकते हैं। यह फ़ंक्शन एक बड़ा switch ब्लॉक होगा, जो प्रसारित नोड के प्रकार के आधार पर कुछ कार्रवाई करेगा:

 function evaluate(exp, env) { switch (exp.type) { 

शाब्दिक अर्थ के लिए, हम केवल इसका मूल्य लौटाते हैं:

  case "num": case "str": case "bool": return exp.value; 

चर संदर्भ से लिया जाता है (वैरिएबल का नाम value फील्ड में निहित है):

  case "var": return env.get(exp.value); 

असाइन करने के लिए, हमें यह सुनिश्चित करना चाहिए कि बाईं ओर हमारे पास चर (नोड var ) का नाम है। यदि नहीं, तो हम केवल एक अपवाद को फेंक देते हैं (हम चर के अलावा किसी अन्य चीज़ को असाइनमेंट का समर्थन नहीं करते हैं)। अगला, हम env.set का उपयोग करके चर का मान सेट करते हैं। ध्यान दें कि evaluate लिए पुनरावर्ती कॉल का उपयोग करके अभिव्यक्ति के दाईं ओर गणना की जानी चाहिए:

  case "assign": if (exp.left.type != "var") throw new Error("Cannot assign to " + JSON.stringify(exp.left)); return env.set(exp.left.value, evaluate(exp.right, env)); 

प्रकार के binary नोड के लिए binary हमें दोनों ऑपरेंड के लिए ऑपरेटर को लागू करना होगा। हम बाद में apply_op फ़ंक्शन apply_op । इसके अलावा, हम अभिव्यक्ति के दोनों हिस्सों के लिए evaluate कहते हैं:

  case "binary": return apply_op(exp.operator, evaluate(exp.left, env), evaluate(exp.right, env)); 

एक प्रकार का lambda एक सामान्य जावास्क्रिप्ट क्लोजर लौटाएगा, इसलिए इसे जावास्क्रिप्ट से भी एक नियमित फ़ंक्शन की तरह कहा जा सकता है। मैंने make_lambda फ़ंक्शन जोड़ा, जिसे मैं बाद में दिखाऊंगा:

  case "lambda": return make_lambda(env, exp); 

if नोड if निष्पादन काफी सरल है: पहले हम स्थिति का मूल्य पाते हैं। यदि यह गलत नहीं है, तो then शाखा का मान लौटाएं। अन्यथा, यदि कोई else शाखा है, तो उसका मूल्य, या false :

  case "if": var cond = evaluate(exp.cond, env); if (cond !== false) return evaluate(exp.then, env); return exp.else ? evaluate(exp.else, env) : false; 

prog नोड अभिव्यक्ति का एक क्रम है। हम केवल क्रम में सभी अभिव्यक्तियों को निष्पादित करते हैं और बाद के मूल्य को लेते हैं (खाली अनुक्रम का मूल्य false ):

  case "prog": var val = false; exp.prog.forEach(function(exp){ val = evaluate(exp, env) }); return val; 

एक प्रकार की call नोड के लिए call हमें एक फ़ंक्शन को कॉल करना होगा। इससे पहले, हम फ़ंक्शन के मूल्य को स्वयं ढूंढेंगे, सभी तर्कों के मूल्यों को खोजें और apply का उपयोग करके फ़ंक्शन को कॉल करें:

  case "call": var func = evaluate(exp.func, env); return func.apply(null, exp.args.map(function(arg){ return evaluate(arg, env); })); 

हम यहां कभी नहीं पहुंचेंगे, लेकिन अगर हम पार्सर में एक नया नोड प्रकार जोड़ते हैं और इसे दुभाषिया में जोड़ना भूल जाते हैं:

  default: throw new Error("I don't know how to evaluate " + exp.type); } } 

यह दुभाषिया का मुख्य हिस्सा था। ऊपर, हमने दो कार्यों का उपयोग किया था जिन्हें हमने अभी तक लागू नहीं किया है, तो चलिए शुरू करते हैं:

apply_op :

 function apply_op(op, a, b) { function num(x) { if (typeof x != "number") throw new Error("Expected number but got " + x); return x; } function div(x) { if (num(x) == 0) throw new Error("Divide by zero"); return x; } switch (op) { case "+" : return num(a) + num(b); case "-" : return num(a) - num(b); case "*" : return num(a) * num(b); case "/" : return num(a) / div(b); case "%" : return num(a) % div(b); case "&&" : return a !== false && b; case "||" : return a !== false ? a : b; case "<" : return num(a) < num(b); case ">" : return num(a) > num(b); case "<=" : return num(a) <= num(b); case ">=" : return num(a) >= num(b); case "==" : return a === b; case "!=" : return a !== b; } throw new Error("Can't apply operator " + op); } 

यह ऑपरेटर प्रकार और तर्क प्राप्त करता है। सरल और सहज switch । जावास्क्रिप्ट के विपरीत, जो कि किसी भी मूल्य पर ले सकते हैं, जैसे चर, यहां तक ​​कि उन लोगों के लिए जो कोई मतलब नहीं है। हमें यह आवश्यक है कि अंकगणित के संचालकों की संख्या संख्या हो और वे विभाजन को शून्य न होने दें। स्ट्रिंग्स के लिए हम बाद में कुछ लेकर आएंगे।

make_lambda :

 function make_lambda(env, exp) { function lambda() { var names = exp.vars; var scope = env.extend(); for (var i = 0; i < names.length; ++i) scope.def(names[i], i < arguments.length ? arguments[i] : false); return evaluate(exp.body, scope); } return lambda; } 

जैसा कि आप ऊपर देख सकते हैं, यह एक नियमित जावास्क्रिप्ट फ़ंक्शन देता है जो पारित संदर्भ और एएसटी फ़ंक्शन का उपयोग करता है। सभी कार्य केवल तब किए जाते हैं जब फ़ंक्शन स्वयं कहा जाता है: एक संदर्भ बनाया जाता है, तर्क निर्धारित किए जाते हैं (यदि वे पर्याप्त नहीं हैं, तो वे false हो जाते हैं)। फिर फ़ंक्शन बॉडी को बस एक नए संदर्भ में निष्पादित किया जाता है।

मूल कार्य

जैसा कि आप देख सकते हैं, हमारे पास अपनी भाषा से जावास्क्रिप्ट के साथ बातचीत करने का कोई तरीका नहीं था। मैं print और println फ़ंक्शन का उपयोग करता था, लेकिन मैंने उन्हें कहीं भी परिभाषित नहीं किया। हमें उन्हें जावास्क्रिप्ट में लिखने और उन्हें वैश्विक संदर्भ में जोड़ने की आवश्यकता है।

यहाँ इस तरह के कोड का एक उदाहरण है:

 //  -   var code = "sum = lambda(x, y) x + y; print(sum(2, 3));"; // ,  parse  TokenStream,      InputStream var ast = parse(TokenStream(InputStream(code))); //    var globalEnv = new Environment(); //  ""  "print" globalEnv.def("print", function(txt){ console.log(txt); }); //  evaluate(ast, globalEnv); //  5 

पूरा कोड

आप वह सभी कोड डाउनलोड कर सकते हैं जो हमने इस समय लिखा है। इसे NodeJS का उपयोग करके लॉन्च किया जा सकता है। बस मानक स्ट्रीम में कोड पास करें:

 echo 'sum = lambda(x, y) x + y; println(sum(2, 3));' | node lambda-eval1.js 

कोड उदाहरण

हमारी प्रोग्रामिंग भाषा, हालांकि सरल, सैद्धांतिक रूप से किसी भी समस्या को हल कर सकती है जिसे कंप्यूटर द्वारा हल किया जा सकता है। ऐसा इसलिए है क्योंकि कुछ दोस्त मुझसे कहीं ज्यादा होशियार होंगे - अलोंजो चर्च और एलन ट्यूरिंग - एक बार यह साबित हो गया कि λ-पथरी (लैम्ब्डा कैलकुलस) एक ट्यूरिंग मशीन के बराबर है, और हमारी λ-language औजार λ-पथरी है।

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

चक्र

यदि हमारे पास पुनरावर्तन है तो लूप्स कोई समस्या नहीं है। मैंने पहले से ही पुनरावर्तन के शीर्ष पर लागू लूप का एक उदाहरण दिखाया है। चलिए फिर कोशिश करते हैं।

 print_range = λ(a, b) if a <= b { print(a); if a + 1 <= b { print(", "); print_range(a + 1, b); } else println(""); }; print_range(1, 10); 

लेकिन यहाँ हमें एक समस्या है: यदि हम पुनरावृत्तियों की संख्या बढ़ाते हैं, तो कहते हैं, 1000 तक। उदाहरण के लिए, मुझे 600 के बाद "अधिकतम कॉल स्टैक आकार" से अधिक त्रुटि हुई। ऐसा इसलिए होता है क्योंकि दुभाषिया पुनरावर्ती है और पुनरावर्ती अधिकतम गहराई तक पहुँचता है।

यह एक गंभीर समस्या है, लेकिन एक समाधान है। मैं पुनरावृत्ति (या while ) के for नए निर्माण जोड़ना चाहूंगा, लेकिन चलो उनके बिना करने की कोशिश करते हैं। पुनरावृत्ति सुंदर दिखती है, तो चलो इसे छोड़ दें। हम बाद में देखेंगे कि इस सीमा के आसपास कैसे पहुंचें।

डेटा संरचनाएं (इसकी कमी)

हमारी λ भाषा में तीन प्रकार के डेटा हैं: संख्या, तार और बूलियन प्रकार। ऐसा लग सकता है कि आप जटिल प्रकार, जैसे कि सरणियाँ, या वस्तुएँ नहीं बना सकते हैं। लेकिन यह एक टाट नहीं है, हमारे पास एक और प्रकार है: फ़ंक्शन। यह पता चला है कि अगर हम λ-पथरी का पालन करते हैं, तो हम विरासत सहित किसी भी डेटा संरचना को ऑब्जेक्ट सहित बना सकते हैं।

मैं इसे सूचियों के उदाहरण पर दिखाऊंगा। आइए कल्पना करें कि हमारे पास एक cons फ़ंक्शन है जो एक ऑब्जेक्ट बनाता है जिसमें दो मान होते हैं। चलो इस ऑब्जेक्ट को "सेल" या "जोड़ी" कहते हैं। हम "कार" और "cdr" मूल्यों में से एक का नाम लेंगे। सिर्फ इसलिए कि उन्हें लिस्प में बुलाया जाता है। अब, यदि हमारे पास एक वस्तु "सेल" है, तो हम फ़ंक्शन car और cdr का उपयोग करके इसके मान प्राप्त कर सकते हैं:

 x = cons(10, 20); print(car(x)); #  10 print(cdr(x)); #  20 

अब हम आसानी से एक सूची को परिभाषित कर सकते हैं:

एक सूची एक जोड़ी है जिसमें `कार` में पहला तत्व है और शेष तत्व` सीडीआर` में हैं। लेकिन `cdr` में केवल एक मान हो सकता है! यह मान एक सूची होगी। एक सूची एक जोड़ी है जिसमें `कार` में पहला तत्व है और शेष तत्व` सीडीआर` में हैं। लेकिन `cdr` में केवल एक मान हो सकता है! यह मान एक सूची होगी। [...]

यह एक पुनरावर्ती डेटा प्रकार है। लेकिन एक समस्या बनी हुई है: आपको कब रुकना है? तार्किक रूप से, हमें रोकना चाहिए जब cdr एक खाली सूची है। लेकिन एक खाली सूची क्या है? ऐसा करने के लिए, "NIL" नामक एक नई ऑब्जेक्ट जोड़ें। इसका उपयोग युगल के रूप में किया जा सकता है (हम इस पर car और cdr उपयोग कर सकते हैं, लेकिन उनका परिणाम स्वयं ही NIL होगा)। अब आइए 1, 2, 3, 4, 5 आइटमों की एक सूची बनाएं:

 x = cons(1, cons(2, cons(3, cons(4, cons(5, NIL))))); print(car(x)); # 1 print(car(cdr(x))); # 2  Lisp  . cadr print(car(cdr(cdr(x)))); # 3 caddr print(car(cdr(cdr(cdr(x))))); # 4 cadddr print(car(cdr(cdr(cdr(cdr(x)))))); # 5     . 

यह भयानक लग रहा है जब इसके लिए कोई विशेष वाक्यविन्यास नहीं है। लेकिन मैं सिर्फ यह दिखाना चाहता था कि यह मौजूदा λ भाषा सुविधाओं का उपयोग करके किया जा सकता है। यहाँ कार्यान्वयन है:

 cons = λ(a, b) λ(f) f(a, b); car = λ(cell) cell(λ(a, b) a); cdr = λ(cell) cell(λ(a, b) b); NIL = λ(f) f(NIL, NIL); 

जब मैंने पहली बार cons / car / cdr को इस तरह से देखा, तो मुझे आश्चर्य हुआ कि if (लेकिन यह अजीब है कि यह मूल λ-पथरी में नहीं है) इस बात की जरूरत नहीं है। बेशक, कोई प्रोग्रामिंग भाषा इस तरह से नहीं करती है, क्योंकि यह बेहद अक्षम है, लेकिन यह λ-calculi को कम सुंदर नहीं बनाता है। एक स्पष्ट भाषा में, यह कोड निम्नलिखित कार्य करता है:

• cons फ़ंक्शन दो मान लेता है ( a और b ) और उन्हें रखने वाले फ़ंक्शन को वापस करता है। यह फ़ंक्शन जोड़ी का बहुत ही उद्देश्य है। वह एक तर्क लेती है और इसे जोड़ी के दोनों मूल्यों के लिए कहती है।
• car फ़ंक्शन पास किए गए तर्क को कॉल करता है, एक फ़ंक्शन को पास करता है जो पहला तर्क देता है।
• cdr फ़ंक्शन car फ़ंक्शन के समान है, लेकिन एकमात्र अंतर यह है कि पारित फ़ंक्शन दूसरा तर्क देता है।
• NIL फ़ंक्शन समान रूप से काम करता है, लेकिन NIL के बराबर दो मानों के साथ एक जोड़ी देता है।

 cons = λ(a, b) λ(f) f(a, b); car = λ(cell) cell(λ(a, b) a); cdr = λ(cell) cell(λ(a, b) b); NIL = λ(f) f(NIL, NIL); x = cons(1, cons(2, cons(3, cons(4, cons(5, NIL))))); println(car(x)); # 1 println(car(cdr(x))); # 2 println(car(cdr(cdr(x)))); # 3 println(car(cdr(cdr(cdr(x))))); # 4 println(car(cdr(cdr(cdr(cdr(x)))))); # 5 

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

 foreach = λ(list, f) if list != NIL { f(car(list)); foreach(cdr(list), f); }; foreach(x, println); 

और यहाँ एक और एक है जो संख्याओं की एक सूची बनाता है:

 range = λ(a, b) if a <= b then cons(a, range(a + 1, b)) else NIL; #     1  8 foreach(range(1, 8), λ(x) println(x * x)); 

ऊपर सूचीबद्ध की गई सूचियाँ अपरिवर्तनीय हैं (सूची बनने के बाद हम car या cdr नहीं बदल सकते हैं)। अधिकांश लिस्प के पास एक जोड़ी बदलने के लिए कार्य हैं। स्कीम में उन्हें set-car! कहा जाता है set-car! / set-cdr! । आम लिस्प में, rplaca / rplacd । इस बार हम योजना से नामों का उपयोग करते हैं:

 cons = λ(x, y) λ(a, i, v) if a == "get" then if i == 0 then x else y else if i == 0 then x = v else y = v; car = λ(cell) cell("get", 0); cdr = λ(cell) cell("get", 1); set-car! = λ(cell, val) cell("set", 0, val); set-cdr! = λ(cell, val) cell("set", 1, val); #  NIL     NIL = cons(0, 0); set-car!(NIL, NIL); set-cdr!(NIL, NIL); ## : x = cons(1, 2); println(car(x)); # 1 println(cdr(x)); # 2 set-car!(x, 10); set-cdr!(x, 20); println(car(x)); # 10 println(cdr(x)); # 20 

इससे पता चलता है कि हम परिवर्तनशील डेटा संरचनाओं को लागू कर सकते हैं। मैं गहराई में नहीं जाऊंगा कि यह कैसे काम करता है, यह कोड से स्पष्ट है।

हम आगे बढ़ सकते हैं और वस्तुओं को लागू कर सकते हैं, लेकिन सिंटैक्स में बदलाव के बिना ऐसा करना मुश्किल होगा। एक अन्य तरीका है कि टोकनर / पार्सर में एक नया वाक्यविन्यास लागू करना और दुभाषिया में उनके प्रसंस्करण को जोड़ना। सभी प्रमुख प्रोग्रामिंग भाषाएं ऐसा करती हैं, और सामान्य प्रदर्शन प्राप्त करना आवश्यक है। हम लेख के अगले भाग में नया वाक्यविन्यास जोड़ेंगे।

[अनुवादक से: यदि आप लैम्बडा कैलकुलस में रुचि रखते हैं, तो इस विषय के लिए समर्पित हैबे पर एक अच्छा लेख है: जावास्क्रिप्ट में लैम्ब्डा कैलकुलस ।]

नई वाक्य रचना

हमारी λ भाषा में काफी कुछ वाक्यात्मक निर्माण हैं। उदाहरण के लिए, नया चर जोड़ने का कोई सीधा तरीका नहीं है। जैसा कि मैंने पहले कहा, हमें IIFE का उपयोग करना चाहिए, इसलिए यह कुछ इस तरह दिखता है:

 (λ(x, y){ (λ(z){ ## it gets worse when one of the vars depends on another print(x + y + z); })(x + y); })(2, 3); 

हम let कीवर्ड जोड़ देंगे। यह हमें कुछ इस तरह लिखने की अनुमति देगा:

 let (x = 2, y = 3, z = x + y) print(x + y + z); 

let ब्लॉक में प्रत्येक वेरिएबल के लिए, पिछले वेरिएबल्स उसी ब्लॉक से भी उपलब्ध होने चाहिए। इसलिए, ऊपर दिया गया कोड निम्नलिखित के बराबर होगा:

 (λ(x){ (λ(y){ (λ(z){ print(x + y + z); })(x + y); })(3); })(2); 

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

हालाँकि, हमें पार्सर को वैसे भी बदलना होगा। आइए एक नया "लेट" नोड जोड़ें क्योंकि इसे और अधिक कुशलता से व्याख्या की जा सकती है (क्लोजर बनाने और उन्हें तुरंत कॉल करने की आवश्यकता नहीं है, हमें केवल संदर्भ को कॉपी और बदलने की आवश्यकता है)।

इसके अलावा, हम "लेट नेम" के लिए समर्थन जोड़ेंगे, जो स्कीम में था। यह छोरों को बनाना आसान बनाता है:

 print(let loop (n = 10) if n > 0 then n + loop(n - 1) else 0); 

यह एक "पुनरावर्ती" लूप है जो 10 + 9 + ... + 0. का योग गिनाता है। पहले हमें इसे इस तरह करना होगा:

 print((λ(loop){ loop = λ(n) if n > 0 then n + loop(n - 1) else 0; loop(10); })()); 

इसके अलावा, इसे आसान बनाने के लिए, हम "एक नाम के साथ फ़ंक्शन" का सिंटैक्स जोड़ेंगे। यह इस तरह दिखेगा:

 print((λ loop (n) if n > 0 then n + loop(n - 1) else 0) (10)); 

संशोधन जो इसके लिए किए जाने की आवश्यकता है:

• lambda कीवर्ड के बाद वैकल्पिक नाम के लिए समर्थन। यदि यह मौजूद है, तो हमें वर्तमान संदर्भ में एक चर जोड़ना होगा जो फ़ंक्शन को इंगित करेगा। यह वास्तव में जावास्क्रिप्ट में एक नाम के साथ कार्य करता है।
• नए let कीवर्ड के लिए सपोर्ट। इसके बाद एक वैकल्पिक नाम और इस रूप में चर परिभाषाओं की एक सूची (संभवतः खाली) आती है: foo = EXPRESSION , अल्पविराम द्वारा अलग। let एक्सप्रेशन का शरीर एक एकल अभिव्यक्ति है (जो निश्चित रूप से, अभिव्यक्ति का एक क्रम हो सकता है)।

पार्सर बदल जाता है

सबसे पहले, टोकनर में एक छोटा सा परिवर्तन, कीवर्ड की सूची में कीवर्ड जोड़ें:

 var keywords = " let if then else lambda λ true false "; 

parse_lambda फ़ंक्शन को बदलें parse_lambda यह एक वैकल्पिक नाम पढ़े:

 function parse_lambda() { return { type: "lambda", name: input.peek().type == "var" ? input.next().value : null, //   vars: delimited("(", ")", ",", parse_varname), body: parse_expression() }; } 

अब एक ऐसा फंक्शन जोड़ते हैं जो let एक्सप्रेशन देता है:

 function parse_let() { skip_kw("let"); if (input.peek().type == "var") { var name = input.next().value; var defs = delimited("(", ")", ",", parse_vardef); return { type: "call", func: { type: "lambda", name: name, vars: defs.map(function(def){ return def.name }), body: parse_expression(), }, args: defs.map(function(def){ return def.def || FALSE }) }; } return { type: "let", vars: delimited("(", ")", ",", parse_vardef), body: parse_expression(), }; } 

यह दो मामलों को संभालता है। यदि टाइप करने के बाद एक प्रकार का टोकन है, तो यह एक नाम के साथ है। इसके अलावा, हम delimited फ़ंक्शन का उपयोग करते हुए परिभाषाओं की सूची पढ़ते हैं, क्योंकि वे कोष्ठक में हैं और अल्पविराम द्वारा अलग किए गए हैं, और हम parse_vardef फ़ंक्शन का उपयोग करते हैं, जो नीचे दिखाया गया है। अगला, हम एक प्रकार की call का नोड लौटाते call , जिसे तुरंत एक फ़ंक्शन का नाम दिया जाता है (IIFE)। फ़ंक्शन के तर्कों को चर द्वारा परिभाषित किया जाता है, और call नोड मानों को तर्क के रूप में पारित करेगा। और, ज़ाहिर है, फ़ंक्शन का शरीर parse_expression() का उपयोग करके पढ़ा जाता है।

यदि यह एक सरल let , तो हम vars और body फील्ड के साथ एक प्रकार का नोड लौटाते हैं। vars फ़ील्ड में निम्न प्रारूप में चर का एक सरणी होता है: { name: VARIABLE, def: AST } , जो निम्नलिखित फ़ंक्शन द्वारा पार्स किए जाते हैं:

 function parse_vardef() { var name = parse_varname(), def; if (is_op("=")) { input.next(); def = parse_expression(); } return { name: name, def: def }; } 

इसके अलावा, आपको parse_atom फ़ंक्शन में एक नए प्रकार की अभिव्यक्ति के लिए एक चेक जोड़ने की आवश्यकता है:

 //      parse_if if (is_kw("let")) return parse_let(); 

दुभाषिया परिवर्तन

चूंकि हमने एएसटी की संरचना को "क्रैकिंग" करने के बजाय इसे पुराने प्रकार के नोड्स में बदलने का फैसला किया है, इसलिए हमें इंटरप्रेटर में नए लॉजिक की प्रोसेसिंग को जोड़ना होगा।

वैकल्पिक फ़ंक्शन नाम के लिए समर्थन जोड़ने के लिए, हम make_lambda फ़ंक्शन को संशोधित करते हैं:

 function make_lambda(env, exp) { if (exp.name) { //  env = env.extend(); //  env.def(exp.name, lambda); //  } //  function lambda() { var names = exp.vars; var scope = env.extend(); for (var i = 0; i < names.length; ++i) scope.def(names[i], i < arguments.length ? arguments[i] : false); return evaluate(exp.body, scope); } return lambda; } 

यदि फ़ंक्शन का कोई नाम है, तो जब हम क्लोजर बनाते हैं, तो हम संदर्भ की एक प्रति बनाते हैं, और फ़ंक्शन को संदर्भ में जोड़ते हैं। बाकी वही रहता है।

और अंत में, नोड के प्रकार को संसाधित करने के let , हम निम्न मामले को दुभाषिया में जोड़ते हैं:

 case "let": exp.vars.forEach(function(v){ var scope = env.extend(); scope.def(v.name, v.def ? evaluate(v.def, env) : false); env = scope; }); return evaluate(exp.body, env); 

ध्यान दें कि प्रत्येक चर के लिए एक नया संदर्भ बनाया जाता है जिसमें एक नया चर जोड़ा जाता है। उसके बाद, हम केवल अंतिम संदर्भ में शरीर को निष्पादित करते हैं।

उदाहरण

 println(let loop (n = 100) if n > 0 then n + loop(n - 1) else 0); let (x = 2, y = x + 1, z = x + y) println(x + y + z); #   ..     let # print(x + y + z); let (x = 10) { let (x = x * 2, y = x * x) { println(x); ## 20 println(y); ## 400 }; println(x); ## 10 }; 

— .

. , , , . JavaScript λ.

:

 globalEnv.def("fibJS", function fibJS(n){ if (n < 2) return n; return fibJS(n - 1) + fibJS(n - 2); }); globalEnv.def("time", function(fn){ var t1 = Date.now(); var ret = fn(); var t2 = Date.now(); println("Time: " + (t2 - t1) + "ms"); return ret; }); 

time , , , .

 fib = λ(n) if n < 2 then n else fib(n - 1) + fib(n - 2); print("fib(10): "); time( λ() println(fib(10)) ); print("fibJS(10): "); time( λ() println(fibJS(10)) ); println("---"); 

, Google Chrome, n (27), λ , , JS 4 . , , .

λ JavaScript. , for / while ; JS. ? JS , .

, , JavaScript, , JavaScript.

, , . , .

निष्कर्ष

, . , - ; , , ? — JavaScript. , JavaScript — ? , , JavaScript, , , . JavaScript ( , ).

, , Lisp — : //. , , .. Lisp . Lisp let , , Lisp.

: JavaScript. भाग 3: सीपीएस दुभाषिया