Lua
Coroutines

वाक्य - विन्यास

• coroutine.create (फ़ंक्शन) एक coroutine (प्रकार (coroutine) == 'थ्रेड') देता है जिसमें फ़ंक्शन होता है।

• coroutine.resume (co, ...) फिर से शुरू करें, या coroutine शुरू करें। फिर से शुरू करने के लिए दिए गए किसी भी अतिरिक्त तर्क को coroutine.yield () से वापस कर दिया जाता है, जो पहले coroutine को रोक देता है। यदि कॉरआउट शुरू नहीं किया गया था तो अतिरिक्त तर्क फ़ंक्शन के तर्क बन जाते हैं।

• coroutine.yield (...) वर्तमान में चल रहे coroutine में पैदावार देता है। निष्पादन coroutine.resume () के लिए कॉल के बाद वापस उठाता है जिसने उस coroutine को प्रारंभ किया था। पैदावार के लिए दिए गए किसी भी तर्क को कॉरटीन से शुरू किया गया।

• coroutine.status (co) कोरटाइन की स्थिति लौटाता है, जो निम्न हो सकता है:

  • "मृत": कोरटाइन में कार्य समाप्त हो गया है और कोरटाइन को फिर से शुरू नहीं किया जा सकता है
  • "चल रहा है": कोरटाइन फिर से शुरू हो गया है और चल रहा है
  • "सामान्य": कॉरआउट ने एक और कॉरआउट शुरू किया है
  • "निलंबित": कोरटाइन उपज गया है, और फिर से शुरू होने की प्रतीक्षा कर रहा है

• coroutine.wrap (फ़ंक्शन) एक फ़ंक्शन लौटाता है जिसे कॉलआउट कहा जाता है, जो coroutine.create (फ़ंक्शन) द्वारा बनाया गया है।

टिप्पणियों

एक coroutine बनाएं और उपयोग करें

कोरटाइन के साथ बातचीत करने के सभी कार्य कोआउट टेबल में उपलब्ध हैं। एक एकल तर्क के साथ coroutine.create फ़ंक्शन का उपयोग करके एक नया कोरआउट बनाया जाता है: कोड के साथ एक फ़ंक्शन निष्पादित किया जाता है:

thread1 = coroutine.create(function()
            print("honk")
        end)

print(thread1)
-->> thread: 6b028b8c

एक coroutine ऑब्जेक्ट एक नए coroutine का प्रतिनिधित्व करते हुए, टाइप थ्रेड का मान लौटाता है। जब एक नया कोरआउट बनाया जाता है, तो इसकी प्रारंभिक स्थिति निलंबित कर दी जाती है:

print(coroutine.status(thread1))
-->> suspended

एक coroutine को फिर से शुरू करने या शुरू करने के लिए, फ़ंक्शन coroutine.resume का उपयोग किया जाता है, दिया गया पहला तर्क थ्रेड ऑब्जेक्ट है:

coroutine.resume(thread1)
-->> honk

अब कोरटाइन कोड निष्पादित करता है और समाप्त हो जाता है, इसकी स्थिति को मृत में बदल देता है, जिसे फिर से शुरू नहीं किया जा सकता है।

print(coroutine.status(thread1))
-->> dead

Coroutines इसके निष्पादन को निलंबित कर सकता है और बाद में इसे coroutine.yield फ़ंक्शन के लिए धन्यवाद फिर से शुरू कर सकता है:

thread2 = coroutine.create(function()
        for n = 1, 5 do
            print("honk "..n)
            coroutine.yield()
        end
    end)

जैसा कि आप देख सकते हैं, coroutine.yield () लूप के लिए मौजूद है, अब जब हम coroutine को फिर से शुरू करते हैं, तो यह कोड को तब तक निष्पादित करेगा जब तक कि यह coroutine.yield तक नहीं पहुंच जाता:

coroutine.resume(thread2)
-->> honk 1
coroutine.resume(thread2)
-->> honk 2

लूप को खत्म करने के बाद, थ्रेड स्थिति मृत हो जाती है और फिर से शुरू नहीं की जा सकती है। Coroutines भी डेटा के बीच आदान-प्रदान की अनुमति देता है:

thread3 = coroutine.create(function(complement)
    print("honk "..complement)
    coroutine.yield()
    print("honk again "..complement)
end)
coroutine.resume(thread3, "stackoverflow")
-->> honk stackoverflow

यदि कोई अतिरिक्त तर्कों के साथ कोरटाइन को फिर से निष्पादित किया जाता है, तो पूरक अभी भी पहले पुनरारंभ से तर्क देगा, इस मामले में "स्टैकओवरफ़्लो":

coroutine.resume(thread3)
-->> honk again stackoverflow

अंत में, जब कोई कोरटाइन समाप्त होता है, तो इसके फ़ंक्शन द्वारा लौटाए गए सभी मान संबंधित फिर से शुरू होते हैं:

thread4 = coroutine.create(function(a, b)
    local c = a+b
    coroutine.yield()
    return c
end)
coroutine.resume(thread4, 1, 2)
print(coroutine.resume(thread4))
-->> true, 3

पुनरावर्ती कॉल के भीतर गहरे से कॉलिंग थ्रेड पर वापस मानों को पास करने के लिए इस फ़ंक्शन में कॉरआउट्स का उपयोग किया जाता है।

local function Combinations(l, r)
    local ll = #l
    r = r or ll
    local sel = {}
    local function rhelper(depth, last)
        depth = depth or 1
        last = last or 1
        if depth > r then
            coroutine.yield(sel)
        else
            for i = last, ll - (r - depth) do
                sel[depth] = l[i]
                rhelper(depth+1, i+1)
            end
        end
    end
    return coroutine.wrap(rhelper)
end

for v in Combinations({1, 2, 3}, 2) do
    print("{"..table.concat(v, ", ").."}")
end
--> {1, 2}
--> {1, 3}
--> {2, 3}

आलसी मूल्यांकन के लिए कॉरटॉयन्स का भी उपयोग किया जा सकता है।

-- slices a generator 'c' taking every 'step'th output from the generator
-- starting at the 'start'th output to the 'stop'th output
function slice(c, start, step, stop)
    local _
    return coroutine.wrap(function()
        for i = 1, start-1 do
            _ = c()
        end
        for i = start, stop do
            if (i - start) % step == 0 then
                coroutine.yield(c())
            else
                _ = c()
            end
        end
    end)
end


local alphabet = {}
for c = string.byte('a'), string.byte('z') do
    alphabet[#alphabet+1] = string.char(c)
end
-- only yields combinations 100 through 102
-- requires evaluating the first 100 combinations, but not the next 5311633
local s = slice(Combinations(alphabet, 10), 100, 1, 102)
for i in s do
    print(table.concat(i))
end
--> abcdefghpr
--> abcdefghps
--> abcdefghpt

प्रोग्रामिंग इन लुआ में वर्णित के रूप में पाइपिंग निर्माण के लिए कॉरआउट का उपयोग किया जा सकता है। PiL के लेखक, रॉबर्टो Ierusalimschy ने भी जारी रखने की तरह अधिक उन्नत और सामान्य प्रवाह नियंत्रण यांत्रिकी को लागू करने के लिए कोरटाइन का उपयोग करने पर एक पेपर प्रकाशित किया है।