Erlang 21

queue




erlang

queue

मॉड्यूल

पंक्ति

मॉड्यूल सारांश

एफआईएफओ कतारों के लिए सार डेटा प्रकार।

विवरण

यह मॉड्यूल एक कुशल तरीके से FIFO कतारों को प्रदान करता है।

यदि तर्क गलत प्रकार के हैं, तो सभी कार्य कारण के कारण विफल हो जाते हैं, उदाहरण के लिए, कतार तर्क कतार नहीं हैं, अनुक्रमणिका पूर्णांक नहीं हैं, और सूची तर्क सूची नहीं हैं। अनुचित सूचियाँ आंतरिक दुर्घटनाओं का कारण बनती हैं। एक कतार के लिए सीमा से बाहर का सूचकांक भी कारण के साथ विफलता का कारण badarg

कुछ कार्य, जहाँ उल्लेख किया गया है, एक खाली कतार के लिए कारण के साथ विफल।

इस मॉड्यूल द्वारा उपयोग की जाने वाली कतार का प्रतिनिधित्व करने वाले डेटा को अन्य मॉड्यूल द्वारा अपारदर्शी माना जाता है। प्रारूप का ज्ञान ग्रहण करने वाला कोई भी कोड पतली बर्फ पर चल रहा है।

सभी परिचालनों में एक परिशोधन O (1) चल रहा है, filter/2 को छोड़कर, join/2 , len/1 , member/2 , split/2 , जिनमें O (n) है कतार संचालन द्वारा निर्मित कचरे की मात्रा को कम करने के लिए एक कतार का आकार कम करने के लिए, कतारों में स्पष्ट लंबाई की जानकारी नहीं होती है, और इसीलिए len/1 O (n) है। यदि इस विशेष ऑपरेशन के लिए बेहतर प्रदर्शन आवश्यक है, तो कॉलर के लिए लंबाई पर नज़र रखना आसान है।

कतार डबल-एंडेड हैं। कतार की मानसिक तस्वीर लोगों (वस्तुओं) की एक पंक्ति है जो अपनी बारी का इंतजार कर रही है। कतार के सामने उस आइटम के साथ अंत होता है जिसने सबसे लंबे समय तक इंतजार किया है। कतार पीछे अंत एक आइटम है जब यह इंतजार करना शुरू होता है। अगर किसी सूची की मानसिक तस्वीर का उपयोग करने के बजाय, सामने वाले को सिर और पीछे को पूंछ कहा जाता है।

सामने की तरफ प्रवेश करना और पीछे की तरफ बाहर निकलना कतार पर उलटा काम है।

इस मॉड्यूल में इंटरफ़ेस फ़ंक्शंस के तीन सेट हैं: "ओरिजिनल एपीआई", "एक्सटेंडेड एपीआई" और "ओकासाकी एपीआई"।

"मूल एपीआई" और "विस्तारित एपीआई" दोनों वस्तुओं की प्रतीक्षा रेखा की मानसिक तस्वीर का उपयोग करते हैं। दोनों के पास रिवर्स ऑपरेशन "_r" है।

"मूल API" आइटम निष्कासन फ़ंक्शन हटाए गए आइटम और परिणामी कतार दोनों के साथ यौगिक शब्द लौटाता है। "विस्तारित एपीआई" में वैकल्पिक कार्य शामिल होते हैं जो कम कूड़े का निर्माण करते हैं और केवल कतार के निरीक्षण के लिए कार्य करते हैं। इसके अलावा "ओकासाकी एपीआई" फ़ंक्शन कम कचरा बनाते हैं।

"ओकासाकी एपीआई" क्रिस ओकासाकी द्वारा "विशुद्ध रूप से कार्यात्मक डेटा संरचनाओं" से प्रेरित है। यह सूची के रूप में कतारों का संबंध है। यह एपीआई कई अजीब और परिहार्य के रूप में माना जाता है। उदाहरण के लिए, कई रिवर्स ऑपरेशंस में शाब्दिक रूप से उल्टे नाम हैं, कुछ अधिक पठनीय लेकिन शायद कम समझने योग्य उपनामों के साथ।

मूल एपीआई

जानकारी का प्रकार

queue(Item)

जैसा कि new/0 द्वारा लौटाया गया है।

queue() = queue (term())

निर्यात

फ़िल्टर (मज़ा, Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

प्रकार

एक क्यू Q2 लौटाता है जो Q1 में सभी वस्तुओं पर Fun(Item) कॉल करने का परिणाम है, आगे से पीछे तक।

यदि Fun(Item) true , तो Item को परिणाम कतार में कॉपी किया जाता है। यदि यह false , तो Item की प्रतिलिपि नहीं बनाई गई है। यदि यह एक सूची लौटाता है, तो सूची तत्वों को परिणाम कतार में Item बजाय डाला जाता है।

तो, Fun(Item) वापस करना [Item] इसलिए शब्दार्थ है कि वह वापस लौटने के बराबर true , बस लौटते समय [] शब्दशः false वापसी करने के बराबर है। लेकिन एक सूची को वापस करने से परमाणु वापस करने से अधिक कचरा बनता है।

from_list (L :: [आइटम]) -> queue (आइटम)

उसी क्रम में L में आइटम वाली एक कतार लौटाता है; सूची का मुख्य आइटम कतार का अगला आइटम बन जाता है।

में (आइटम, Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

पंक्ति Q1 के पीछे में Item सम्मिलित करता है Q1 । परिणामी कतार Q2 लौटाता है।

in_r (आइटम, Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

क्यू Q1 के सामने की ओर Item सम्मिलित करता है। परिणामी कतार Q2 लौटाता है।

is_empty (Q :: queue ) -> बूलियन ()

टेस्ट यदि Q खाली है और यदि ऐसा true तो true है, अन्यथा नहीं।

is_queue (शब्द :: शब्द ()) -> बूलियन ()

टेस्ट यदि Term एक कतार है और यदि ऐसा true तो true है, अन्यथा false

शामिल हों (Q1 :: queue (आइटम), Q2 :: queue (आइटम)) -> Q3 :: queue (आइटम)

क्यू Q3 लौटाता है जो क्यू Q1 और Q2 में Q1 साथ शामिल होने का परिणाम है।

len (Q :: queue ) -> पूर्णांक ()> = 0

कतार Q की लंबाई की गणना और रिटर्न करता है।

सदस्य (आइटम, क्यू :: queue (आइटम)) -> बूलियन ()

true अगर Item Q में किसी तत्व से मेल खाता है, अन्यथा false

नया () -> queue

एक खाली कतार देता है।

बाहर (Q1 :: queue (आइटम)) ->
{{मान, आइटम}, Q2 :: queue (आइटम)} |
{रिक्त, Q1 :: queue (आइटम)}

क्यू Q1 के सामने आइटम हटाता है Q1 । रिटर्न टपल {{value, Item}, Q2} , जहां Item को हटा दिया गया आइटम है और Q2 परिणामस्वरूप कतार है। यदि Q1 रिक्त है, तो tuple {empty, Q1} वापस किया जाता है।

out_r (Q1 :: queue (आइटम)) ->
{{मान, आइटम}, Q2 :: queue (आइटम)} |
{रिक्त, Q1 :: queue (आइटम)}

पंक्ति Q1 के पीछे आइटम हटाता है। रिटर्न टपल {{value, Item}, Q2} , जहां आइटम हटाए गए आइटम है और Q2 नई कतार है। यदि Q1 रिक्त है, तो tuple {empty, Q1} वापस किया जाता है।

रिवर्स (Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

एक क्यू Q2 को रिवर्स ऑर्डर में Q1 की वस्तुओं से युक्त देता है।

विभाजन (एन :: पूर्णांक) (=> 0, Q1 :: queue (आइटम)) ->
{Q2 :: queue (आइटम), Q3 :: queue (आइटम)}

दो में Q1 है। N फ्रंट आइटम को Q2 और बाकी को Q3 में रखा गया है।

to_list (Q :: queue (आइटम)) -> [आइटम]

उसी क्रम में कतार में मौजूद वस्तुओं की सूची लौटाता है; कतार का अगला भाग सूची का प्रमुख बन जाता है।

विस्तारित एपीआई

निर्यात

ड्रॉप (Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

क्यू Q2 करता है जो Q1 से फ्रंट आइटम को हटाने का परिणाम है।

Q1 empty होने पर कारण empty होने की Q1

drop_r (Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

क्यू Q2 करता है जो Q1 से रियर आइटम को हटाने का परिणाम है।

Q1 empty होने पर कारण empty होने की Q1

get (Q :: queue (आइटम)) -> आइटम

कतार Q के सामने Item वापस करता है।

Q empty होने पर कारण के साथ विफल।

get_r (Q :: queue (आइटम)) -> आइटम

कतार Q के पीछे की ओर Item लौटाता है।

Q empty होने पर कारण के साथ विफल।

झांकना (Q :: queue (आइटम)) -> खाली | {मान, आइटम}

रिटर्न टपल {value, Item} , जहां Item Q का फ्रंट आइटम है, या Q empty तो खाली है।

झांकना_ (क्यू :: queue (आइटम)) -> खाली | {मान, आइटम}

रिटर्न टपल {value, Item} , जहां Item Q का रियर आइटम है, या Q empty तो खाली है।

ओकासाकी एपीआई

निर्यात

विपक्ष (आइटम, Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

क्यू Q1 के सिर पर Item सम्मिलित करता है Q1 । नई कतार Q2 लौटाता है।

डेह (क्यू :: queue (आइटम)) -> आइटम

Q की पूंछ आइटम लौटाता है।

Q empty होने पर कारण के साथ विफल।

सिर (क्यू :: queue (आइटम)) -> आइटम

कतार Q के सिर से Item लौटाता है।

Q empty होने पर कारण के साथ विफल।

init (Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

क्यू Q2 करता है जो Q1 से पूंछ आइटम को हटाने का परिणाम है।

Q1 empty होने पर कारण empty होने की Q1

lait (Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

क्यू Q2 करता है जो Q1 से पूंछ आइटम को हटाने का परिणाम है।

Q1 empty होने पर कारण empty होने की Q1

lait/1 नाम एक गलत वर्तनी है - अब इसका उपयोग न करें।

अंतिम (Q :: queue (आइटम)) -> आइटम

Q की पूंछ आइटम लौटाता है।

Q empty होने पर कारण के साथ विफल।

liat (Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

क्यू Q2 करता है जो Q1 से पूंछ आइटम को हटाने का परिणाम है।

Q1 empty होने पर कारण empty होने की Q1

स्नोक (Q1 :: queue (आइटम), आइटम) -> Q2 :: queue (आइटम)

कतार Q1 के पूंछ आइटम के रूप में Item सम्मिलित करता है। नई कतार Q2 लौटाता है।

पूंछ (Q1 :: queue (आइटम)) -> Q2 :: queue (आइटम)

एक क्यू Q2 लौटाता है जो Q1 से हेड आइटम को हटाने का परिणाम है।

Q1 empty होने पर कारण empty होने की Q1