ट्रैक
/
Factor
Factor
/
अभ्यास
/
बोटस्वेन का बिल्ज
बोटस्वेन का बिल्ज

बोटस्वेन का बिल्ज

सीखने का अभ्यास

परिचय

पंप, वाल्व, होज़, इन जैसी कोई भी चीज़ जो ऑपरेटिंग सिस्टम का कोई संसाधन (खुली फाइल, नेटवर्क कनेक्शन) थामे रखती है, उसे काम पूरा हो जाने पर मुक्त करना पड़ता है। Factor का destructors वोकैब इन सबको एक ऐसे फ्रेमवर्क में लपेट देता है जो सफाई की गारंटी देता है, तब भी जब कोई एरर बीच में ही आपका कोड रोक दे।

क्लास और जेनेरिक

एक क्लास disposable का विस्तार करके और dispose* जेनेरिक को लागू करके इस फ्रेमवर्क से जुड़ जाती है:

USING: accessors destructors kernel ;

TUPLE: pump < disposable opened ;

: <pump> ( -- pump )
    pump new-disposable t >>opened ;

M: pump dispose* f >>opened drop ;

new-disposable ( class -- obj ) टपल को बनाता है और उसे फ्रेमवर्क में दर्ज कर देता है। इस तरह बनाने और अगले सेफ पॉइंट के बीच आने वाला एक्सेप्शन संसाधन को लीक नहीं कर सकता। फ्रेमवर्क गारंटी देता है कि हर ऑब्जेक्ट के लिए dispose* ज़्यादा से ज़्यादा एक बार चलता है। बार-बार किए गए dispose कॉल का कोई असर नहीं होता।

बाहरी कॉलर dispose इस्तेमाल करते हैं

dispose          ( obj -- )                ! release; safe to call twice
with-disposal    ( disposable quot -- )    ! scope one resource
with-destructors ( quot -- )               ! open a registry scope
&dispose         ( obj -- obj )            ! dispose on normal *or* failure exit
|dispose         ( obj -- obj )            ! dispose only if the scope unwinds

with-disposal एक ही संसाधन वाला रूप है: यह अंदर वाले कोटेशन के लिए डिस्पोज़ेबल को स्टैक पर रखता है और बाहर निकलते समय उसे मुक्त कर देता है।

USING: destructors io ;

<pump> [
    "pumping" print
] with-disposal
! pump released on the way out — even if `print` had thrown

एक से ज़्यादा संसाधनों के लिए with-destructors स्कोप खोलिए और हर बार लिए गए संसाधन को दर्ज कीजिए। &dispose (ऐम्परसैंड) का मतलब है "बाहर निकलते समय हमेशा संसाधन मुक्त करना, चाहे सफलता मिले या असफलता।" |dispose (पाइप) का मतलब है "सिर्फ़ असफलता पर मुक्त करना", जो तब काम आता है जब सफलता वाला रास्ता संसाधन को ऐसे कॉलर को सौंप देता है जो उसका मालिकाना ले लेगा।

[
    <pump> &dispose
    <pump> &dispose
    ! ... use the pumps ...
] with-destructors
! both pumps released

बिना रजिस्ट्री के सादे try/finally के लिए cleanup (जो continuations में है) निचले स्तर का प्रिमिटिव है, लेकिन with-destructors ही आधुनिक Factor का मुहावरेदार तरीका है।

निर्देश

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

टेस्ट आपको नए पंप लेने के लिए <test-pump> देते हैं। हर पंप में एक opened>> स्लॉट होता है, जिसका मान खुला रहने पर t और मुक्त हो जाने के बाद f होता है।

1. बिल्ज खाली कीजिए

एक पंप को मुक्त करने के लिए drain-bilge बनाइए। किसी एक ही पंप पर drain-bilge दो बार कॉल करने पर भी कोई नुकसान नहीं होना चाहिए। यह काम फ्रेमवर्क आपके लिए खुद कर लेता है।

<test-pump> dup drain-bilge opened>> .   ! => f

2. पंप-आउट रूटीन

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

<test-pump> [ drop ] pump-out   ! pump released

3. पूरी शिफ्ट का रूटीन

shift-routine बनाइए, जो दो पंप और एक क्वोटेशन लेता है। एक डिस्ट्रक्टर स्कोप खोलिए, दोनों पंपों को हर हाल में मुक्त होने के लिए दर्ज कीजिए, और फिर क्वोटेशन को कॉल कीजिए। क्वोटेशन सामान्य रूप से पूरा हो या एरर फेंके, दोनों पंप मुक्त हो जाते हैं।

क्वोटेशन को इनपुट के रूप में दोनों पंप स्टैक पर मिलते हैं।

<test-pump> <test-pump> [ 2drop ] shift-routine
! both pumps released

4. रिस्की पंप-आउट

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

अगर क्वोटेशन सफल होता है, तो पंप खुला ही रहता है। अगर क्वोटेशन एरर फेंकता है, तो पंप मुक्त हो जाता है और एक्सेप्शन आगे बढ़ जाता है।

<test-pump> [ drop ] risky-pump-out                ! stays open
<test-pump> [ drop "boom" throw ] risky-pump-out   ! pump released, throws

5. अपना डिस्पोज़ेबल: वाल्व

टूलकिट को एक बिल्कुल नए डिस्पोज़ेबल, यानी valve, के साथ पूरा कीजिए। ट्यूपल आपके लिए पहले से घोषित है:

TUPLE: valve < disposable is-open ;
  • <valve> ( -- valve ) बनाइए, जो new-disposable से एक नया वाल्व बनाता है और is-open को t पर सेट करता है।
  • M: valve dispose* लागू कीजिए, जो is-open को f कर देता है।
<valve> is-open>> .                ! => t
<valve> dup dispose is-open>> .    ! => f
GitHub के ज़रिए संपादित करें यह लिंक एक नई विंडो या टैब में खुलता है
Factor Exercism

बोटस्वेन का बिल्ज शुरू करने के लिए तैयार हैं?

Exercism पर साइन अप कीजिए और Factor को 47 कॉन्सेप्ट163 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।