जब किसी क्वोटेशन को अपने आसपास से वैल्यू याद रखनी होती हैं, तो दूसरी भाषाएँ इसे क्लोज़र कहती हैं। ऐसी स्थिति में Factor दो टूल इस्तेमाल करता है: curry शब्द और '[ ] फ्राई सिंटैक्स।
curry: एक वैल्यू कैप्चर करनाcurry (kernel में) एक वैल्यू और एक क्वोटेशन लेता है और उस वैल्यू को अंदर रखकर एक नया क्वोटेशन लौटाता है:
curry ( value quot -- newquot )
3 [ + ] curry .
! => [ 3 + ]
10 3 [ + ] curry call .
! => 13
दो वैल्यू कैप्चर करने के लिए curry को दो बार लगाइए:
2 3 [ + + ] curry curry .
! => [ 2 3 + + ]
compose: दो क्वोटेशन जोड़नाcompose (kernel में) दो क्वोटेशनों को आपस में जोड़ता है:
compose ( quot1 quot2 -- quot )
[ 1 + ] [ 2 * ] compose .
! => [ 1 + 2 * ]
5 [ 1 + ] [ 2 * ] compose call .
! => 12
एक या दो से अधिक कैप्चर के लिए, curry को बार-बार लगाना पढ़ने में कठिन हो जाता है। फ्राई '[ … ] का उपयोग एक या अधिक _ प्लेसहोल्डर के साथ करता है; हर _ को डेटा स्टैक से निकाली गई वैल्यू से क्रम में बदल दिया जाता है:
2 3 '[ _ _ + + ] .
! => [ 2 3 + + ]
curry और फ्राई दोनों क्लोज़र बनते ही अपनी वैल्यू स्टैक से ले लेते हैं। ऊपर की लाइन स्टैक पर कुछ नहीं छोड़ती और [ + + ] curry curry का सीधा विकल्प है।
प्लेसहोल्डर बाएँ से दाएँ स्टैक की वैल्यू से नीचे से ऊपर तक भरे जाते हैं: 2 3 '[ _ _ ] का मतलब [ 2 3 ] है, [ 3 2 ] नहीं।
फ्राई नेस्टेड क्वोटेशन के अंदर तक भी पहुँचता है, जिससे आप कैप्चर की गई वैल्यू को ठीक वहीं रख सकते हैं जहाँ आप उन्हें चाहते हैं:
2 '[ [ _ > ] filter ] { 1 2 3 4 5 } swap call( s -- s ) .
! => { 3 4 5 }
_ अंदर वाले [ … ] के भीतर बैठता है, फिर भी फ्राई उसे भर देता है।
call
जब आप अंत में संग्रहीत क्वोटेशन चलाते हैं, तो call पर उसका स्टैक इफेक्ट घोषित कीजिए ताकि कंपाइलर उसका टाइप-चेक कर सके:
{ 3 4 5 } [ first2 + ] call( p -- n ) .
! => 7
{ 3 4 5 } [ first ] call( p -- n ) .
! => 3
math.vectors वोकैबुलरी समान लंबाई की दो सीक्वेंस को एलिमेंट के हिसाब से मिलाती है। v+ और v* उन्हें जोड़ते या गुणा करते हैं; vmax और vmin हर कंपोनेंट में से बड़ा या छोटा रखते हैं। हर एक दो एलिमेंट वाला ऐरे लौटाता है:
{ 1 1 } { 3 4 } v+ . ! => { 4 5 }
{ 2 5 } { 3 -1 } v* . ! => { 6 -5 }
{ 1 9 } { 4 4 } vmax . ! => { 4 9 }
{ 1 9 } { 4 4 } vmin . ! => { 1 4 }
आपकी डिज़ाइन टीम अपने कुछ लेआउट कामों के लिए CSS ट्रांसफॉर्म से हटकर अब Factor पर जा रही है। बाकी टीम को खुश रखने के लिए आप छोटे-छोटे, दोबारा इस्तेमाल में आने वाले रूपांतरण क्वोटेशन के रूप में बनाएँगे। ऐसा क्वोटेशन एक 2D पॉइंट लेता है और एक 2D पॉइंट लौटाता है।
एक पॉइंट दो एलिमेंट वाला ऐरे होता है, जैसे { x y }।
translate-2d को ऐसा बनाइए जो स्टैक से दो वैल्यू, dx और dy, ले और एक क्वोटेशन लौटाए। यह क्वोटेशन किसी पॉइंट को (dx, dy) से स्थानांतरित करता है।
{ 4 8 } 2 0 translate-2d call( p -- p' ) .
! => { 6 8 }
scale-2d को भी इसी तरह बनाइए। यह एक ऐसा क्वोटेशन लौटाता है जो किसी पॉइंट को (sx, sy) से स्केल करता है।
{ 6 -3 } 2 2 scale-2d call( p -- p' ) .
! => { 12 -6 }
compose-transformations को ऐसा बनाइए जो दो रूपांतरण क्वोटेशन, f और g, ले और एक ही क्वोटेशन लौटाए। यह नया क्वोटेशन पहले f लागू करता है और उसके बाद g।
{ 0 1 } 2 0 translate-2d 2 2 scale-2d compose-transformations
call( p -- p' ) .
! => { 4 2 }
apply-transformation को ऐसा बनाइए जो स्टैक से एक पॉइंट और एक रूपांतरण क्वोटेशन ले और रूपांतरित पॉइंट लौटाए।
{ 4 8 } 2 0 translate-2d apply-transformation .
! => { 6 8 }
transform-points को ऐसा बनाइए जो पॉइंट का एक ऐरे और एक रूपांतरण क्वोटेशन ले, और रूपांतरित पॉइंट का ऐरे लौटाए।
{ { 0 0 } { 1 1 } { 2 2 } } 1 0 translate-2d transform-points .
! => { { 1 0 } { 2 1 } { 3 2 } }
Exercism पर साइन अप कीजिए और Factor को 47 कॉन्सेप्ट163 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।