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

अनुवादक से

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

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

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

सीपीएस दुभाषिया

हमारी λ भाषा में दो कमियां हैं:

• रिकर्सन जेएस स्टैक तक सीमित है, इसलिए हमारे पास लूप करने का सामान्य तरीका नहीं है।
• दुभाषिया धीमा है, इसलिए पुनरावृत्ति बहुत धीमी है।

अब हम इस तथ्य पर ध्यान दिए बिना पहला दोष ठीक करेंगे कि दुभाषिया और भी धीमा हो जाएगा। हम दुभाषिया को "निरंतरता-गुजर शैली" (सीपीएस) शैली में फिर से लिखेंगे।

"निरंतरता हस्तांतरण" क्या है

आप हर समय NodeJS में ऐसा करते हैं:

 fs.readFile("file.txt", "utf8", function CC(error, data){ //   - "" //     'return', // 'readFile'  ,  . }); 

हर कदम पर एक कॉलबैक होता है जिसे आपको जारी रखने की आवश्यकता होने पर कॉल किया जाएगा। निरंतरता हस्तांतरण शैली नियंत्रण हस्तांतरण को "स्पष्ट" बनाती है - आप return , throw , break या continue उपयोग नहीं करते return । कोड में कोई निहित छलांग नहीं है। आप अतुल्यकालिक कार्यों के साथ या इसके for उपयोग नहीं कर सकते हैं। इस मामले में, हमें प्रोग्रामिंग भाषा में उनकी आवश्यकता क्यों है?

एक निरंतरता को प्रेषित करने की शैली में कोड लिखना मुश्किल और आसान है, लेकिन हम केवल उस शैली में दुभाषिया को फिर से लिखेंगे।

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

evaluate फ़ंक्शन को तीन तर्क प्राप्त होंगे: अभिव्यक्ति (एएसटी), संदर्भ (पर्यावरण), और फ़ंक्शन जिसे परिणाम कहा जाता है। यहाँ कोड है, प्रत्येक टुकड़े के लिए एक स्पष्टीकरण है:

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

स्थिरांक के लिए, हम केवल उनका मान लौटाएंगे। लेकिन याद रखें, हमारे पास return नहीं है - इसके बजाय हम केवल कॉलबैक कहते हैं और मूल्य पास करते हैं।

  case "num": case "str": case "bool": callback(exp.value); return; 

var नोड भी सरल है - संदर्भ से चर प्राप्त करें और इसे फ़ंक्शन में पास करें:

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

assign नोड्स के लिए, हमें बाईं अभिव्यक्ति ( right ) का मूल्य प्राप्त करने की आवश्यकता है। ऐसा करने के लिए, हम evaluate कहते हैं, एक फ़ंक्शन को पास करना जो परिणाम प्राप्त करेगा (अभिव्यक्ति के दाईं ओर)। और फिर हम चर को वर्तमान मान में चर सेट करते हुए चर मान के साथ callback कहते हैं:

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

टाइप binary नोड्स के लिए लगभग समान है, लेकिन यहां हमें पहले left क्षेत्र का मूल्य प्राप्त करने की आवश्यकता है, और उसके बाद ही right क्षेत्र का मूल्य। तब हम सिर्फ कॉलबैक कहते हैं, ऑपरेशन के परिणाम को पास करते हुए:

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

let नोड अधिक जटिल दिखता है, लेकिन वास्तव में यह सरल है। हमारे पास कुछ संख्या में चर हैं। उनका def क्षेत्र (प्रारंभिक मूल्य) खाली हो सकता है, जिस स्थिति में हम इसे false सेट करेंगे। लेकिन अगर कोई मूल्य है, तो हमें इसे प्राप्त करने के लिए पुनरावर्ती रूप से evaluate करने की आवश्यकता है।

यदि आपने पहले NodeJS के साथ काम किया है, तो आपने पहले भी कई बार ऐसा किया है। कॉलबैक के कारण, हम इसका उपयोग नहीं कर सकते हैं, इसलिए, हमें इन अभिव्यक्तियों की एक बार में व्याख्या करनी चाहिए ( evaluate फ़ंक्शन को अतुल्यकालिक के रूप में कल्पना करें)। नीचे दिए गए loop फ़ंक्शन (तुरंत कहा जाता है) को संदर्भ और उस परिभाषा की संख्या मिलती है जिसे संसाधित करने की आवश्यकता होती है:

• यदि यह संख्या चर ( vars.length ) की संख्या के बराबर है, तो इसका मतलब है कि हमने पहले से ही सभी अभिव्यक्तियों को परिभाषित किया है ताकि हम अभिव्यक्ति के शरीर को निष्पादित कर सकें। कृपया ध्यान दें कि इस बार हम callback नहीं कहते callback , लेकिन इसे evaluate करने के लिए पास करते हैं, जो तब इसे कॉल करेगा।
• यदि यह संख्या कम है, तो आपको वर्तमान परिभाषा की गणना करने और संदर्भ की प्रतिलिपि बनाने से पहले एक फ़ंक्शन पास करना होगा जो loop(scope, i + 1) कहेगा।
  

    case "let": (function loop(env, i){ if (i < exp.vars.length) { var v = exp.vars[i]; if (v.def) evaluate(v.def, env, function(value){ var scope = env.extend(); scope.def(v.name, value); loop(scope, i + 1); }); else { var scope = env.extend(); scope.def(v.name, false); loop(scope, i + 1); } } else { evaluate(exp.body, env, callback); } })(env, 0); return; 

lambda नोड को पहले की तरह एक अलग फ़ंक्शन में संसाधित किया जाएगा:

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

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

  case "if": evaluate(exp.cond, env, function(cond){ if (cond !== false) evaluate(exp.then, env, callback); else if (exp.else) evaluate(exp.else, env, callback); else callback(false); }); return; 

prog नोड को let नोड के समान समझा जाता है, लेकिन इस अंतर के साथ कि हमें संदर्भ की प्रतिलिपि बनाने या चर को परिभाषित करने की आवश्यकता नहीं है। और फिर, हमारे पास एक loop फ़ंक्शन है जो एक अभिव्यक्ति संख्या लेता है। जब यह prog.length बराबर prog.length , तो हमने सभी अभिव्यक्तियों को पूरा कर लिया है और हम केवल अंतिम अभिव्यक्ति का परिणाम देते हैं (शब्द "वापसी" से मेरा मतलब है कि हम इसके साथ callback कहते हैं)। कृपया ध्यान दें कि हम loop फ़ंक्शन के तर्क के रूप में इसे पारित करके अंतिम मूल्य को याद करते हैं (शुरुआत में यह उस स्थिति के लिए false जब शरीर खाली है):

  case "prog": (function loop(last, i){ if (i < exp.prog.length) evaluate(exp.prog[i], env, function(val){ loop(val, i + 1); }); else { callback(last); } })(false, 0); return; 

एक प्रकार की call हमें func व्याख्या करने की आवश्यकता है और फिर सभी तर्क क्रम में हैं। और फिर, एक loop फ़ंक्शन होता है जो एक ही सिद्धांत पर काम करता है जैसे let या prog , इस अंतर के साथ कि अब यह एक परिणाम के रूप में एक सरणी बनाता है:

  case "call": evaluate(exp.func, env, function(func){ (function loop(args, i){ if (i < exp.args.length) evaluate(exp.args[i], env, function(arg){ args[i + 1] = arg; loop(args, i + 1); }); else { func.apply(null, args); } })([ callback ], 0); }); return; 

ठीक है, मानक समाप्त होना: अगर हमें नहीं पता कि क्या करना है, तो एक अपवाद फेंकें:

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

आप देख सकते हैं कि ऊपर दिया गया प्रत्येक case return कीवर्ड के साथ समाप्त होता है। लेकिन कोई वापसी मूल्य नहीं है - परिणाम हमेशा callback फ़ंक्शन को पास किया जाता है।

नया make_lambda फ़ंक्शन

इस व्याख्याकार में, सभी फ़ंक्शन पहले तर्क के रूप में एक "निरंतरता" प्राप्त करेंगे - परिणाम पारित करने के लिए हमें जिस फ़ंक्शन को कॉल करना होगा। इसके बाद फ़ंक्शन के लिए सामान्य तर्क हैं। यहाँ make_lambda फ़ंक्शन का नया कोड है:

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

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

वैसे, यह एकमात्र स्थान है जिसका उपयोग मैंने लूप के for किया था। ऐसा तब होता है क्योंकि call नोड संसाधित होने पर तर्क मान पहले ही गणना कर लिए जाते हैं।

मूल कार्य

इस दुभाषिया में, मूल कार्यों को पहले तर्क के रूप में callback मिलता है। देशी कार्यों को परिभाषित करते समय हमें यह याद रखना चाहिए। यहाँ नए दुभाषिया के लिए नमूना कोड है:

 var code = "sum = lambda(x, y) x + y; print(sum(2, 3));"; var ast = parse(TokenStream(InputStream(code))); var globalEnv = new Environment(); // define the "print" primitive function globalEnv.def("print", function(callback, txt){ console.log(txt); callback(false); // call the continuation with some return value // if we don't call it, the program would stop // abruptly after a print! }); // run the evaluator evaluate(ast, globalEnv, function(result){ // the result of the entire program is now in "result" }); 

थोड़ा परीक्षण

आइए फिर से फाइबोनैचि संख्याओं की गणना करने का प्रयास करें:

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

लेकिन, यदि हम 27 वें नंबर को खोजने की कोशिश करते हैं, तो हमें स्टैक ओवरफ्लो मिलता है। सामान्य तौर पर, स्टैक अब बहुत तेजी से बढ़ रहा है, इसलिए यह पता चला है कि अब हम फाइबोनैचि संख्या को केवल 12 वें (कम से कम मेरे ब्राउज़र में) गिन सकते हैं। यह बहुत अच्छा नहीं है, इसलिए आपको इसे किसी तरह ठीक करने की आवश्यकता है।

हम ढेर की रक्षा करते हैं

सीपीएस दुभाषिया में, स्टैक बहुत तेजी से बढ़ता है क्योंकि दुभाषिया हमेशा कार्यों को पुनरावर्ती कहता है, कभी भी परिणाम नहीं देता है। हालांकि हम दुभाषिया में return , हमें उनकी आवश्यकता है, लेकिन बहुत गहरी पुनरावृत्ति के मामले में, हम उन तक कभी नहीं पहुंचते हैं।

आइए कल्पना करें कि एक बहुत ही सरल कार्यक्रम के लिए हमारा स्टैक कैसा दिखता है। मैं छद्म कोड दिखाऊंगा और मैंने env नहीं जोड़ा क्योंकि यह यहां कोई भूमिका नहीं निभाता है:

 print(1 + 2 * 3); ## : evaluate( print(1 + 2 * 3), K0 ) evaluate( print, K1 ) K1(print) #  'var',      evaluate( 1 + 2 * 3, K2 ) evaluate( 2 * 3, K3 ) evaluate( 2, K4 ) K4(2) # 2  ,      evaluate( 3, K5 ) #    3,      K5(3) K3(6) #  2*3 evaluate( 1, K6 ) #  ,  K6(1) K2(7) #  1+2*3 print(K0, 7) # ,     'print' K0(false) #  . 'print'  'false'. 

केवल अंतिम कॉल के बाद, बेकार return का एक लंबा क्रम स्टैक को कम करता है। यदि हम एक साधारण प्रोग्राम के लिए बहुत अधिक स्टैक स्पेस का उपयोग करते हैं, तो यह कल्पना करना मुश्किल है कि fib(13) लिए क्या होगा।

ढेर की सुरक्षा

हमारे नए दुभाषिया में, स्टैक की आवश्यकता नहीं है। एक callback में कुछ अभिव्यक्ति होने के बाद सभी को करने की आवश्यकता होती है, जिसे एक तर्क के रूप में पारित किया जाता है। तो यहां हमारे पास एक सवाल है: क्या होगा यदि जावास्क्रिप्ट ने स्टैक को "डंप" करना संभव बना दिया। फिर हम स्टैक को छोड़ सकते हैं, और असीम रूप से गहरी पुनरावृत्ति काम करेगी।

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

नए फ़ंक्शन का उपयोग करते हुए, हम नीचे दिखाए गए अनुसार दुभाषिया को फिर से लिखते हैं। मैं प्रत्येक व्यक्तिगत मामले पर टिप्पणी नहीं करूंगा, पहले बताया गया कोड है, लेकिन GUARD फ़ंक्शन का उपयोग कर रहा है:

 function evaluate(exp, env, callback) { GUARD(evaluate, arguments); switch (exp.type) { case "num": case "str": case "bool": callback(exp.value); return; case "var": callback(env.get(exp.value)); return; case "assign": if (exp.left.type != "var") throw new Error("Cannot assign to " + JSON.stringify(exp.left)); evaluate(exp.right, env, function CC(right){ GUARD(CC, arguments); callback(env.set(exp.left.value, right)); }); return; case "binary": evaluate(exp.left, env, function CC(left){ GUARD(CC, arguments); evaluate(exp.right, env, function CC(right){ GUARD(CC, arguments); callback(apply_op(exp.operator, left, right)); }); }); return; case "let": (function loop(env, i){ GUARD(loop, arguments); if (i < exp.vars.length) { var v = exp.vars[i]; if (v.def) evaluate(v.def, env, function CC(value){ GUARD(CC, arguments); var scope = env.extend(); scope.def(v.name, value); loop(scope, i + 1); }); else { var scope = env.extend(); scope.def(v.name, false); loop(scope, i + 1); } } else { evaluate(exp.body, env, callback); } })(env, 0); return; case "lambda": callback(make_lambda(env, exp)); return; case "if": evaluate(exp.cond, env, function CC(cond){ GUARD(CC, arguments); if (cond !== false) evaluate(exp.then, env, callback); else if (exp.else) evaluate(exp.else, env, callback); else callback(false); }); return; case "prog": (function loop(last, i){ GUARD(loop, arguments); if (i < exp.prog.length) evaluate(exp.prog[i], env, function CC(val){ GUARD(CC, arguments); loop(val, i + 1); }); else { callback(last); } })(false, 0); return; case "call": evaluate(exp.func, env, function CC(func){ GUARD(CC, arguments); (function loop(args, i){ GUARD(loop, arguments); if (i < exp.args.length) evaluate(exp.args[i], env, function CC(arg){ GUARD(CC, arguments); args[i + 1] = arg; loop(args, i + 1); }); else { func.apply(null, args); } })([ callback ], 0); }); return; default: throw new Error("I don't know how to evaluate " + exp.type); } } 

अनाम फ़ंक्शंस के लिए, हमें एक नाम जोड़ना होगा ताकि हम उन्हें GUARD फ़ंक्शन में पास कर सकें। मैंने CC ( current continuation ) नाम का उपयोग किया। आप arguments.callee उपयोग कर सकते हैं। arguments.callee , लेकिन यह एक पुराना एपीआई है।

इसके अलावा, make_lambda में समान परिवर्तन:

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

GUARD कार्यान्वयन बहुत सरल है। कैसे एक गहरी कॉल से बाहर निकलने के लिए? अपवादों का उपयोग करना। ऐसा करने के लिए, एक वैश्विक चर होगा जो यह इंगित करेगा कि हम कितनी अधिक पुनरावृत्ति कर सकते हैं। यदि यह शून्य पर पहुंच जाता है, तो हम Continuation ऑब्जेक्ट को फेंक देते हैं, जिसमें एक निरंतरता होगी - फ़ंक्शन और तर्क:

 var STACKLEN; function GUARD(f, args) { if (--STACKLEN < 0) throw new Continuation(f, args); } function Continuation(f, args) { this.f = f; this.args = args; } 

और अंत में, हमें एक लूप की आवश्यकता है जो Continuation ऑब्जेक्ट्स को पकड़ेगा। हमें इस लूप के माध्यम से दुभाषिए को बुलाना चाहिए ताकि सब कुछ काम करे:

 function Execute(f, args) { while (true) try { STACKLEN = 200; return f.apply(null, args); } catch(ex) { if (ex instanceof Continuation) f = ex.f, args = ex.args; else throw ex; } } 

Execute फ़ंक्शन को कॉल किए जाने वाले फ़ंक्शन और इसके लिए तर्क को स्वीकार करता है। यह एक लूप में काम करता है, लेकिन अगर return बिना स्टैक ओवरफ्लो के काम करता है, तो हम return ध्यान देते हैं, हम तुरंत रुक जाते हैं। जब हम लूप पुनरावृत्ति शुरू करते हैं, तो हर बार रीसेट किया जाता है। 200 मान - अच्छी तरह से फिट बैठता है। जब हम Continuation ऑब्जेक्ट को पकड़ते हैं, तो हम एक नए फ़ंक्शन और तर्कों को प्रतिस्थापित करते हैं, और लूप को जारी रखते हैं। इसके अलावा, एक अपवाद के कारण, ढेर को साफ कर दिया जाता है, ताकि हम जारी रख सकें।

दुभाषिया शुरू करने के लिए, हम अब Execute उपयोग करते हैं:

 Execute(evaluate, [ ast, globalEnv, function(result){ console.log("*** Result:", result); }]); 

कसौटी

अब यह काम करेगा:

 fib = λ(n) if n < 2 then n else fib(n - 1) + fib(n - 2); time( λ() println(fib(20)) ); # 6765, ~300ms 

यह अफ़सोस की बात है, लेकिन यदि आप fib(27) खोजने की कोशिश करते हैं, तो यह नियमित दुभाषिया के रूप में लगभग चार गुना लंबा होगा। लेकिन तब हमारे पास अब अनंत पुनरावृत्ति है:

 sum = λ(n, ret) if n == 0 then ret else sum(n - 1, ret + n); # compute 1 + 2 + ... + 50000 time( λ() println(sum(50000, 0)) ); # 1250025000, ~700ms 

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

अगली कड़ियों

अब जब दुभाषिया निरंतरता को प्रेषित करने की शैली में काम करता है, और सभी कार्य, λ भाषा फ़ंक्शन और देशी JS फ़ंक्शन, परिणाम जारी करने के लिए पहले तर्क के रूप में निरंतरता फ़ंक्शन प्राप्त करते हैं (यह तर्क जावास्क्रिप्ट कार्यों के लिए आवश्यक है, हालांकि यह λ भाषा फ़ंक्शन के लिए अदृश्य है)।

चर callback मतलब पूरे कार्यक्रम की निरंतरता है। वह सब आगे कार्यक्रम करेंगे। हम इस चर को 'वर्तमान निरंतरता' या कोड में k कहेंगे।

साथ ही, यदि हम निरंतरता का कारण नहीं बनते हैं, तो कार्यक्रम बंद हो जाएगा। हम इसे λ भाषा से नहीं कर सकते क्योंकि make_lambda वैसे भी जारी make_lambda है। लेकिन हम इसे एक देशी फ़ंक्शन से कर सकते हैं। मैंने यह दिखाने के लिए एक समारोह बनाया कि यह कैसे काम करता है:

 globalEnv.def("halt", function(k){}); 

यह एक फ़ंक्शन है जो कुछ भी नहीं करता है। वह निरंतरता ( k ) प्राप्त करता है, लेकिन इसे कॉल नहीं करता है:

 println("foo"); halt(); println("bar"); 

निष्कर्ष:

 foo 

यदि आप halt() कॉल को हटाते हैं, तो आउटपुट होगा: foo / bar / ***Result: false (क्योंकि अंतिम println false आती false )। लेकिन halt() यह केवल foo आउटपुट करता है। * अब एक परिणाम भी नहीं है क्योंकि halt() एक निरंतरता का कारण नहीं बनता है और इसलिए, कॉलबैक जिसे हमने evaluate करने के लिए पारित किया evaluate - वह जो स्ट्रिंग ***Result प्रदर्शित करता है, कभी नहीं कहा जाता है। फ़ंक्शन जिसे evaluate कहा evaluate है, यह ध्यान नहीं देता है कि कार्यक्रम बंद हो गया है। NodeJS में, यह पैर में एक गोली होगी।

कल्पना करें कि हमें एक sleepe समारोह की आवश्यकता है जो ब्राउज़र को बंद किए बिना एक कार्यक्रम को रोकता है (इसलिए, बेवकूफ छोरों के बिना)। हम मूल फ़ंक्शन का उपयोग करके इसे आसानी से लागू कर सकते हैं:

 globalEnv.def("sleep", function(k, milliseconds){ setTimeout(function(){ Execute(k, [ false ]); //   ,  'false' }, milliseconds); }); 

थोड़ी सी असावधानी यह है कि हमें Execute का उपयोग करना होगा, क्योंकि setTimeout कॉलबैक का कारण बनेगा, जो तब Continuation फेंकता है, और कोई भी इसे नहीं पकड़ेगा। इसका उपयोग कैसे करें:

 let loop (n = 0) { if n < 10 { println(n); sleep(250); loop(n + 1); } }; println("And we're done"); 

निष्कर्ष:

 0 1 2 3 4 5 6 7 8 9 And we're done ***Result: false 

ध्यान दें, प्रत्येक पंक्ति के बीच थोड़ी देरी है। आप मूल लेख में इस कोड को चलाने का प्रयास कर सकते हैं।

यह पहले से ही कुछ है जिसे आप सामान्य जावास्क्रिप्ट में नहीं कर सकते हैं, निरंतरता के मैनुअल ट्रांसमिशन का उपयोग करने के अलावा (और इसके अलावा, आप इसके for लूप के for उपयोग नहीं कर सकते हैं):

 (function loop(n){ if (n < 10) { console.log(n); setTimeout(function(){ loop(n + 1); }, 250); } else { println("And we're done"); //    } })(0); 

कल्पना करें कि आप ode भाषा में NodeJS API का उपयोग कैसे कर सकते हैं:

 globalEnv.def("readFile", function(k, filename){ fs.readFile(filename, function(err, data){ // error handling is a bit more complex, ignoring for now Execute(k, [ data ]); // hope it's clear why we need the Execute }); }); globalEnv.def("writeFile", function(k, filename, data){ fs.writeFile(filename, data, function(err){ Execute(k, [ false ]); }); }); 

का उपयोग करें:

 copyFile = λ(source, dest) { writeFile(dest, readFile(source)); }; copyFile("foo.txt", "bar.txt"); 

और यह सब एसिंक्रोनस रूप से काम करता है। कोई और अधिक कॉलबैक नरक।

यहाँ एक और दिलचस्प उदाहरण है। मैंने निम्नलिखित मूल कार्य लिखा है:

 globalEnv.def("twice", function(k, a, b){ k(a); k(b); }); 

कार्यक्रम दो तर्क a और b लेता a और प्रत्येक तर्क के लिए एक बार निरंतरता कहता है। आइए इसे कॉल करने का प्रयास करें:

 println(2 + twice(3, 4)); println("Done"); 

निष्कर्ष:

 5 Done ***Result: false 6 Done ***Result: false 

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

सामान्यीकरण: CallCC

जब हम देशी कार्य लिखते थे तो हम आग से खेलते थे। वर्तमान निरंतरता के निष्पादन को बाधित करने के लिए λ भाषा में कोई रास्ता नहीं है। CallCC इस समस्या को हल करने में मदद करेगी। नाम योजना से फ़ंक्शन का संक्षिप्त नाम है - call-with-current-continuation (जिसे आमतौर पर योजना में कॉल / सीसी कहा जाता है)।

 globalEnv.def("CallCC", function(k, f){ f(k, function CC(discarded, ret){ k(ret); }); }); 

यह एक फंक्शन में वर्तमान निरंतरता को दर्शाता है जिसे सीधे λ भाषा से कहा जा सकता है। यह फ़ंक्शन इसकी मूल CallCC निरंतरता को अनदेखा discarded देगा और इसके बजाय उस निरंतरता को कॉल करेगा जो CallCC फ़ंक्शन को दी CallCC ।

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

कार्यान्वयन return

 foo = λ(return){ println("foo"); return("DONE"); println("bar"); }; CallCC(foo); 

निष्कर्ष:

 foo ***Result: DONE 

foo फ़ंक्शन एक तर्क प्राप्त करता है जो जावास्क्रिप्ट से return के समान होता है (लेकिन इसे नियमित फ़ंक्शन कहा जाता है)। यह वर्तमान निरंतरता को छोड़ देता है (जो 'बार' आउटपुट करेगा) और फ़ंक्शन से बाहर निकलता है, दिए गए मूल्य ("पूरा") को वापस करता है। बेशक, यह केवल तभी काम करता है जब आप कॉल फ़ंक्शन का उपयोग करके कॉल को return रूप में जारी रखने के लिए पास करते return । हम इसके लिए एक आवरण बना सकते हैं:

 with-return = λ(f) λ() CallCC(f); foo = with-return(λ(return){ println("foo"); return("DONE"); println("bar"); }); foo(); 

निष्कर्ष:

 foo ***Result: DONE 

इस पद्धति का लाभ यह है कि जब हम foo फोन करते हैं तो हमें CallCC का उपयोग करने की आवश्यकता नहीं होती है। यह अच्छा होगा, निश्चित रूप से, अगर हमें एक तर्क के रूप में return को स्वीकार करने या with-return फ़ंक्शन का उपयोग करने की आवश्यकता नहीं थी, लेकिन भाषा में सीधे से सेनेटिक चीनी जोड़ने का कोई तरीका नहीं है, इसके लिए हमें कम से कम पार्सर (लिस्प के लिए +1) को संशोधित करने की आवश्यकता है।

संक्रमण

उदाहरण के लिए, हमें एक प्रोग्राम लिखने की आवश्यकता है, जो 100 तक के सभी सकारात्मक पूर्णांक के जोड़े को देखेगा, यदि उनका गुणन 84 हो जाता है। यह कोई मुश्किल काम नहीं है और आप इसे हल करने के लिए तुरंत दो नेस्टेड लूपों की कल्पना कर सकते हैं, लेकिन यहां हम एक अलग तरीके से जाते हैं। हम दो कार्य बनाएंगे: guess और fail । पहला नंबर चुनेगा, और दूसरा उसे बताता है "दूसरे नंबर पर प्रयास करें।" हम उन्हें इस तरह उपयोग करेंगे:

 a = guess(1); #  -  >= 1 b = guess(a); #  -  >= a if a * b == 84 { #    : print(a); print(" x "); println(b); }; fail(); #    `guess`     

:

 fail = λ() false; guess = λ(current) { CallCC(λ(k){ let (prevFail = fail) { fail = λ(){ current = current + 1; if current > 100 { fail = prevFail; fail(); } else { k(current); }; }; k(current); }; }); }; a = guess(1); b = guess(a); if a * b == 84 { print(a); print(" x "); println(b); }; fail(); 

, , a , 84 , b , 84 / a . guess : start end — . , .

try catch Common Lisp

— catch throw . :

 f1 = λ() { throw("foo", "EXIT"); print("not reached"); }; println(catch("foo", λ() { f1(); print("not reached"); })); #  EXIT 

• catch(TAG, function) , , TAG ', function .
• throw(TAG, value) , , TAG ' , value .

:

 ##  , 'throw'   . ##       `error`, ##     JavaScript.    . throw = λ(){ println("ERROR: No more catch handlers!"); halt(); }; catch = λ(tag, func){ CallCC(λ(k){ let (rethrow = throw, ret) { ##   ,     . throw = λ(t, val) { throw = rethrow; #   ,   . if t == tag then k(val) else throw(t, val); }; ##      . ret = func(); ##       (  'throw') ##    .   . throw = rethrow; # XXX ##  . ret; }; }); }; 

एक उदाहरण:

 # ... f1 = λ() { throw("foo", "EXIT"); print("not reached"); }; println(catch("foo", λ() { f1(); print("not reached"); })); 

catch , , , . , , , CallCC . , . " " — — . , , , catch / throw , .

. , catch . , throw , , catch , . उदाहरण के लिए:

 exit = false; #  . x = 0; # :   ,   'exit()'  CallCC( λ(k) exit = k ); ## 'exit()'   ... if x == 0 then catch("foo", λ(){ println("in catch"); x = 1; #  exit(); }); println("After catch"); throw("foo", "FOO"); 

निष्कर्ष:

 After catch After catch ERROR: No more catch handlers! 

'After catch' , 'ERROR: No more catch handlers!'. - , 'After catch' , . , '' , catch . , 'XXX' catch , throw , catch .

( , .)

CallCC (, , CallCC ). , — CallCC .

Yield

, , yield :

 foo = with-yield(λ(yield){ yield(1); yield(2); yield(3); "DONE"; }); println(foo()); # 1 println(foo()); # 2 println(foo()); # 3 println(foo()); # DONE 

yield , . , return . , , yield , .

:

 fib = with-yield(λ(yield){ let loop (a = 1, b = 1) { yield(b); loop(b, a + b); }; }); ##   50   let loop (i = 0) { if i < 50 { println(fib()); loop(i + 1); }; }; 

fib . . yield . , , 50 , 50 .

, , , , .

, .

yield , , . , , return . , , yield , yield , . , . :

 with-yield = λ(func) { ## with-yield     λ() { CallCC(λ(kret){ # kret     let (yield) { ##  yield yield = λ(value) { # yield  ,    CallCC(λ(kyld){ # kyld    yield... func = kyld; # ...     kret(value); #  . }); }; ## , ,  ,   yield. func(yield); }; }); }; }; 

yield , . , , , "DONE".

, . , - , , 4 :

 println(foo()); foo(); 

.

№1: yield

, , , , yield ( kyld , , ) :

  yield(2); yield(3); "DONE"; 

yield ? yield , , yield . , . , yield return , :

 with-yield = λ(func) { let (return, yield) { yield = λ(value) { CallCC(λ(kyld){ func = kyld; return(value); # 'return'  ,     }); #        . }; # λ(val) { # CallCC(λ(kret){ # return = kret; # <-  func(val || yield); }); }; }; }; 

, , yield , yield ( ). yield .

, , println(foo()) :

 with-yield = λ(func) { let (return, yield) { yield = λ(value) { CallCC(λ(kyld){ func = kyld; return(value); }); }; λ(val) { CallCC(λ(kret){ return = kret; func(val || yield); }); }; }; }; foo = with-yield(λ(yield){ yield(1); yield(2); yield(3); "DONE"; }); println(foo()); println(foo()); println(foo()); 

, . , print(foo()); foo() . , println(foo()) ? ...

№2: WTF?

. : , foo() . , ? — .

 println(foo()); ## yield 1 <-----------------  ---------------------------+ println(foo()); ## yield 2 | println(foo()); ## yield 3 | println(foo()); ##   "DONE",   foo()  -->--+ 

with-yield :

  func(val || yield); #... 

yield , , #... . , , ( "DONE" ), , "DONE" , . foo() , "DONE" . :

 println(foo()); println("bar"); println(foo()); println(foo()); foo(); 

: 1, bar, 2, 3, DONE, bar, DONE, bar, ... .

func - , . , "no more continuations" :

  val = func(val || yield); func = λ() "NO MORE CONTINUATIONS"; kret(val); 

:

 with-yield = λ(func) { let (return, yield) { yield = λ(value) { CallCC(λ(kyld){ func = kyld; return(value); }); }; λ(val) { CallCC(λ(kret){ return = kret; val = func(val || yield); func = λ() "NO MORE CONTINUATIONS"; kret(val); }); }; }; }; foo = with-yield(λ(yield){ yield(1); yield(2); yield(3); "DONE"; }); println(foo()); println(foo()); println(foo()); println(foo()); 

, :

 1 2 3 DONE NO MORE CONTINUATIONS NO MORE CONTINUATIONS NO MORE CONTINUATIONS ***Result: false 

1, 2, 3, DONE , "NO MORE CONTINUATIONS" . , :

 print("A. "); println(foo()); print("B. "); println(foo()); print("C. "); println(foo()); print("D. "); println(foo()); ##   : A. 1 B. 2 C. 3 D. DONE B. NO MORE CONTINUATIONS C. NO MORE CONTINUATIONS D. NO MORE CONTINUATIONS ***Result: false 

, : , , , , "B." .

, yield , :

 with-yield = λ(func) { let (return, yield) { yield = λ(value) { CallCC(λ(kyld){ func = kyld; return(value); }); }; λ(val) { CallCC(λ(kret){ return = kret; val = func(val || yield); func = λ() "NO MORE CONTINUATIONS"; kret(val); }); }; }; }; fib = with-yield(λ(yield){ let loop (a = 1, b = 1) { yield(b); loop(b, a + b); }; }); ##   50   let loop (i = 0) { if i < 50 { println(fib()); loop(i + 1); }; }; 

 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 4807526976 7778742049 12586269025 20365011074 ***Result: false 

, (, ), " ".

: reset shift

yield : reset shift . " " — , . reset , shift , CallCC .

, reset shift — . reset , shift , reset .

, with-yield :

 with-yield = λ(func) { let (yield) { ## 'yield'  'shift'     ##  'reset'.  ,   ,    ##   'func' — ,   `func()` ##    ,    . yield = λ(val) { shift(λ(k){ func = k; #    val; #    }); }; ##  `with-yield`      ##   'reset',    ,  ##   'yield' ( )    ##    λ(val) { reset( λ() func(val || yield) ); }; } }; 

, reset . , , , reset . , . , .

:

 with-yield = λ(func) { let (yield) { yield = λ(val) { shift(λ(k){ func = k; val; }); }; λ(val) { reset( λ() func(val || yield) ); }; } }; foo = with-yield(λ(yield){ yield(1); yield(2); yield(3); "DONE"; }); println(foo()); #  1 println(foo()); #  2 println(foo()); #  3 println(foo()); #  DONE 

reset shift

, . . . , , , . Scheme ( — Oleg Kiselyov ). .

, ( CallCC ) . :

 var pstack = []; function _goto(f) { f(function KGOTO(r){ var h = pstack.pop(); h(r); }); } globalEnv.def("reset", function(KRESET, th){ pstack.push(KRESET); _goto(th); }); globalEnv.def("shift", function(KSHIFT, f){ _goto(function(KGOTO){ f(KGOTO, function SK(k1, v){ pstack.push(k1); KSHIFT(v); }); }); }); 

, reset , shift _goto , — . . _goto ( KGOTO ). , f ( CallCC ) - KGOTO , . , f , , KGOTO , , .

reset ( KRESET ) _goto(th) . , , , _goto . , , KGOTO KRESET .

, shift KGOTO , KGOTO pstack , SK , , shift ( shift — KSHIFT ). SK — — ( k1 ) . , shift2 , , pstack.push(k1); :

 println(reset(λ(){ 1 + shift( λ(k) k(k(2)) ); })); println(reset(λ(){ 1 + shift2( λ(k) k(k(2)) ); })); 

निष्कर्ष:

 4 3 ***Result: false 

shift ( k ), reset . — 1 shift :

 1 + [?] 

k , ? . — k(k(2)) . 2 , k(2) 3. , k(3) 3 , 4.

shift2 : k(2) .

CallCC

, , CallCC , . , JS, , , . , CallCC , .

— goto , ( ):

 pstack = NIL; goto = false; reset = λ(th) { CallCC(λ(k){ pstack = cons(k, pstack); goto(th); }); }; shift = λ(f) { CallCC(λ(k){ goto(λ(){ f(λ(v){ CallCC(λ(k1){ pstack = cons(k1, pstack); k(v); }); }); }); }); }; let (v = CallCC( λ(k){ goto = k; k(false) } )) { if v then let (r = v(), h = car(pstack)) { pstack = cdr(pstack); h(r); } }; 

— !