Elixir 1.7

Stream




elixir

Stream

स्ट्रीम बनाने और बनाने के लिए कार्य।

धाराएँ संयोजनीय हैं, आलसी एनुमेरबेल्स (एन्यूमरैबल्स पर एक परिचय के लिए, Enum मॉड्यूल देखें)। गणना के दौरान एक-एक करके वस्तुओं को उत्पन्न करने वाली कोई भी गणना योग्य धारा कहलाती है। उदाहरण के लिए, एलिक्सिर Range एक धारा है:

iex> range = 1..5
1..5
iex> Enum.map(range, &(&1 * 2))
[2, 4, 6, 8, 10]

ऊपर के उदाहरण में, जैसा कि हमने सीमा पर मैप किया था, गणना के दौरान एक-एक करके तत्वों की गणना की जा रही थी। Stream मॉड्यूल हमें अपनी गणना को ट्रिगर किए बिना, रेंज को मैप करने की अनुमति देता है:

iex> range = 1..3
iex> stream = Stream.map(range, &(&1 * 2))
iex> Enum.map(stream, &(&1 + 1))
[3, 5, 7]

ध्यान दें कि हमने एक सीमा के साथ शुरू किया था और फिर हमने एक धारा बनाई जो प्रत्येक आइटम को सीमा में 2 से गुणा करने के लिए है। इस बिंदु पर, कोई गणना नहीं की गई थी। केवल जब Enum.map/2 कहा जाता है, तो हम वास्तव में रेंज में प्रत्येक आइटम पर गणना करते हैं, इसे 2 से गुणा करते हैं और 1. जोड़ते हैं। हम कहते हैं कि Stream में फ़ंक्शन आलसी हैं और Enum में फ़ंक्शन उत्सुक हैं

उनके आलस्य के कारण, धाराएँ बड़े (या अनंत) संग्रह के साथ काम करते समय उपयोगी होती हैं। जब एनम के साथ कई कार्यों का Enum , मध्यवर्ती सूचियां बनाई जाती हैं, जबकि Stream गणनाओं का एक नुस्खा बनाता है जिसे बाद के क्षण में निष्पादित किया जाता है। आइए एक और उदाहरण देखें:

1..3
|> Enum.map(&IO.inspect(&1))
|> Enum.map(&(&1 * 2))
|> Enum.map(&IO.inspect(&1))
1
2
3
2
4
6
#=> [2, 4, 6]

ध्यान दें कि हमने पहले सूची में प्रत्येक आइटम को मुद्रित किया, फिर प्रत्येक तत्व को 2 से गुणा किया और अंत में प्रत्येक नए मूल्य को मुद्रित किया। इस उदाहरण में, सूची को तीन बार एन्यूमरेट किया गया था। आइए धाराओं के साथ एक उदाहरण देखें:

stream = 1..3
|> Stream.map(&IO.inspect(&1))
|> Stream.map(&(&1 * 2))
|> Stream.map(&IO.inspect(&1))
Enum.to_list(stream)
1
2
2
4
3
6
#=> [2, 4, 6]

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

इसका मतलब है कि जब हमने पहले कहा था कि स्ट्रीम कंपोजेबल, आलसी एनुमरबेल हैं। ध्यान दें कि हम Stream.map/2 कई बार कॉल कर सकते हैं, प्रभावी रूप से धाराओं की रचना कर सकते हैं और उन्हें आलसी रख सकते हैं। गणना केवल तब की जाती है जब आप Enum मॉड्यूल से कोई फ़ंक्शन कहते हैं।

धाराएँ बनाना

एलिक्सिर के मानक पुस्तकालय में कई कार्य हैं जो धाराएँ लौटाते हैं, कुछ उदाहरण हैं:

  • IO.stream/2 - धाराएँ इनपुट लाइनें, एक-एक करके
  • URI.query_decoder/1 - एक क्वेरी स्ट्रिंग, जोड़ी द्वारा जोड़ी को डिकोड करता है

यह मॉड्यूल स्ट्रीम बनाने के लिए कई सुविधा फ़ंक्शंस प्रदान करता है, जैसे कि Stream.cycle/1 , Stream.unfold/2 , Stream.resource/3 और अधिक।

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

सारांश

प्रकार

acc()
default()
element()
index()

कार्य

chunk_by (enum, fun)

एनाम को बफ़रिंग तत्वों द्वारा चुनता है जिसके लिए fun समान मूल्य देता है

chunk_every (enum, count)

शॉर्टकट को chunk_every(enum, count, count)

chunk_every (enum, count, step, leftover \\ [])

count प्रत्येक आइटम में, जहां प्रत्येक नया हिस्सा गणना करने योग्य तत्वों को शुरू करता है

chunk_ORE (enum, acc, chunk_fun, after_fun)

जब हर चंक्स उत्सर्जित होता है, तो enum को ठीक दाने वाले नियंत्रण में रखें

concat(enumerables)

एक स्ट्रीम बनाता है जो एक एन्यूमरेबल में प्रत्येक एनुमरेट को एनुमरेट करता है

समतल (पहला, दूसरा)

एक धारा बनाता है जो पहले तर्क को मानता है, उसके बाद दूसरा

cycle(enumerable)

एक ऐसी धारा बनाता है जो दी गई गणना के माध्यम से, असीम रूप से चक्रित होती है

dedup(enum)

एक धारा बनाता है जो केवल तत्वों का उत्सर्जन करता है यदि वे पिछले उत्सर्जित तत्व से अलग हैं

dedup_by (एनम, मज़ा)

एक धारा बनाता है जो केवल तत्वों का उत्सर्जन करता है यदि तत्व पर fun कॉल करने का परिणाम अंतिम उत्सर्जित तत्व पर fun कॉल करने के परिणाम (संग्रहीत) से भिन्न होता है

ड्रॉप (एनम, एन)

लाजिली एनुमरबल से अगली n वस्तुओं को गिराती है

drop_every (एनम, एनटी)

एक स्ट्रीम बनाता है जो हर nth आइटम को एन्यूमरेबल से ड्राप करता है

ड्रॉप_वर्ड (एनम, मस्ती)

दिए गए फ़ंक्शन एक सत्य मान देता है, जबकि आलसी एन्युमरेबल के तत्वों को गिरा देता है

प्रत्येक (एनम, मज़ा)

प्रत्येक आइटम के लिए दिए गए फ़ंक्शन को निष्पादित करता है

फ़िल्टर (एनम, मज़ा)

एक स्ट्रीम बनाता है जो एन्यूमरेशन पर दिए गए फ़ंक्शन के अनुसार तत्वों को फ़िल्टर करता है

फ्लैट_मैप (एनम, मैपर)

दी गई fun पर दिए गए नक्शे और परिणाम को समतल करता है

प्रतिच्छेदन (असंख्य, प्रतिच्छेदन_करण)

गूढ़ता के प्रत्येक तत्व के बीच अंतर को Lazly intersperses

interval(n)

एक ऐसी धारा बनाता है जो मिलीसेकंड में दी गई अवधि n बाद एक मान का उत्सर्जन करता है

(enum, collectable, transform \\ fn x -> x end)

साइड-इफेक्ट के रूप में दिए गए संग्रहणीय में स्ट्रीम मानों को इंजेक्ट करता है

iterate (start_value, next_fun)

मानों का एक क्रम उत्सर्जित करता है, start_value शुरू start_value । पिछले मान पर next_fun कॉल करके लगातार मान उत्पन्न किए जाते हैं

नक्शा (एनम, मज़ा)

एक स्ट्रीम बनाता है जो गणन पर दिए गए फ़ंक्शन को लागू करेगा

map_every (enum, nth, fun)

एक स्ट्रीम बनाता है जो दी गई फ़ंक्शन को एन्यूमरेबल से हर nth आइटम पर लागू करेगा

अस्वीकार (एनम, मज़ा)

एक स्ट्रीम बनाता है जो गणन पर दिए गए फ़ंक्शन के अनुसार तत्वों को अस्वीकार कर देगा

repeatedly(generator_fun)

बार-बार generator_fun को कॉल करके उत्पन्न स्ट्रीम को लौटाता है

संसाधन (start_fun, next_fun, after_fun)

दिए गए संसाधन के लिए मानों का एक क्रम उत्सर्जित करता है

run(stream)

दी गई धारा को चलाता है

स्कैन (एनम, मज़ा)

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

स्कैन (एनम, एसीसी, फन)

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

ले (enum, count)

आलसी अगली count वस्तुओं को एन्यूमरेबल से लेता है और एन्यूमरेशन को रोकता है

take_every (एनम, nth)

एक स्ट्रीम बनाता है जो हर nth आइटम को एन्यूमरेबल से लेता है

take_ward (enum, मजेदार)

दिए गए फ़ंक्शन एक सत्य मान देता है, जबकि Lazly enumerable के तत्वों को लेता है

timer(n)

एक ऐसी धारा बनाता है जो n मिलीसेकंड के बाद एक मान का उत्सर्जन करता है

परिवर्तन (एनम, एसीसी, रिड्यूसर)

किसी मौजूदा स्ट्रीम को बदल देता है

रूपांतर (enum, start_fun, reducer, after_fun)

फ़ंक्शन-आधारित प्रारंभ और समाप्त के साथ एक मौजूदा स्ट्रीम को ट्रांसफ़ॉर्म करता है

सामने आया (next_acc, next_fun)

दिए गए संचायक के लिए मानों का एक क्रम उत्सर्जित करता है

uniq(enum)

एक धारा बनाता है जो केवल तत्वों का उत्सर्जन करता है यदि वे अद्वितीय हैं

uniq_by (enum, fun)

एक स्ट्रीम बनाता है जो केवल तत्वों का उत्सर्जन करता है यदि वे अद्वितीय हैं, तो उन तत्वों को हटाकर जिनके लिए फ़ंक्शन fun ने डुप्लिकेट आइटम वापस किए

with_index (enum, ऑफसेट \\ 0)

एक स्ट्रीम बनाता है जहां एन्यूमरेबल में प्रत्येक आइटम को उसके सूचकांक के साथ एक टुपल में लपेटा जाएगा

zip(enumerables)

जुमलों के परिमित संग्रह से संबंधित तत्वों को टुपल्स की एक धारा में जोड़ देता है

ज़िप (बाएं, दाएं)

होंठों को एक साथ दो संग्रह, आलसी

प्रकार

एसीसी ()

acc() :: any()

चूक()

default() :: any()

तत्व ()

element() :: any()

इंडेक्स ()

index() :: non_neg_integer()

कार्य

chunk_by (enum, fun)

chunk_by(Enumerable.t(), (element() -> any())) :: Enumerable.t()

एनाम को बफ़रिंग तत्वों द्वारा चुनता है जिसके लिए fun समान मूल्य देता है।

तत्व केवल तभी उत्सर्जित होते हैं जब fun एक नया मूल्य देता है या enum खत्म करता है।

उदाहरण

iex> stream = Stream.chunk_by([1, 2, 2, 3, 4, 4, 6, 7, 7], &(rem(&1, 2) == 1))
iex> Enum.to_list(stream)
[[1], [2, 2], [3], [4, 4, 6], [7, 7]]

chunk_every (enum, count) (1.5.0 से)

chunk_every(Enumerable.t(), pos_integer()) :: Enumerable.t()

शॉर्टकट को chunk_every(enum, count, count)

chunk_every (enum, count, step, leftover \\ []) (1.5.0 के बाद से)

chunk_every(
  Enumerable.t(),
  pos_integer(),
  pos_integer(),
  Enumerable.t() | :discard
) :: Enumerable.t()

count आइटमों में count करने योग्य को प्रवाहित करता है, जिसमें प्रत्येक में count सामान होते हैं, जहां प्रत्येक नया हिस्सा गणना करने योग्य तत्वों में step शुरू करता है।

step वैकल्पिक है और, यदि पारित नहीं हुआ है, तो count करने के लिए चूक, यानी चंक्स ओवरलैप नहीं होते हैं।

यदि अंतिम चंक में चंक को भरने के लिए count तत्व नहीं हैं, तो चंक में भरने के लिए तत्वों को leftover से लिया जाता है। यदि leftover हिस्से में चंक को भरने के लिए पर्याप्त तत्व नहीं हैं, तो एक आंशिक चंक को count तत्वों से कम के साथ वापस किया count है।

यदि :discard को leftover भाग में दिया जाता है, तो अंतिम चंक को तब तक छोड़ दिया जाता है जब तक कि उसके पास तत्वों की count न हो।

उदाहरण

iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 2) |> Enum.to_list()
[[1, 2], [3, 4], [5, 6]]

iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard) |> Enum.to_list()
[[1, 2, 3], [3, 4, 5]]

iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, [7]) |> Enum.to_list()
[[1, 2, 3], [3, 4, 5], [5, 6, 7]]

iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 3, []) |> Enum.to_list()
[[1, 2, 3], [4, 5, 6]]

chunk_ORE (enum, acc, chunk_fun, after_fun) (1.5.0 से)

chunk_while(
  Enumerable.t(),
  acc(),
  (element(), acc() ->
     {:cont, chunk, acc()} | {:cont, acc()} | {:halt, acc()}),
  (acc() -> {:cont, chunk, acc()} | {:cont, acc()})
) :: Enumerable.t()
when chunk: any()

जब हर चंक्स उत्सर्जित होता है, तो enum को ठीक दाने वाले नियंत्रण में रखें।

chunk_fun वर्तमान तत्व और संचायक को प्राप्त करता है और उसे दिए गए chunk_fun को बाहर chunk_fun लिए {:cont, element, acc} को वापस करना चाहिए और संचायक या {:cont, acc} साथ जारी रखना चाहिए ताकि किसी भी chunk का उत्सर्जन न हो और वापसी संचायक के साथ जारी रहे।

after_fun का आह्वान तब किया जाता है जब पुनरावृत्ति की जाती है और उसे {:cont, element, acc} या {:cont, acc} को भी लौटाना चाहिए।

उदाहरण

iex> chunk_fun = fn item, acc ->
...>   if rem(item, 2) == 0 do
...>     {:cont, Enum.reverse([item | acc]), []}
...>   else
...>     {:cont, [item | acc]}
...>   end
...> end
iex> after_fun = fn
...>   [] -> {:cont, []}
...>   acc -> {:cont, Enum.reverse(acc), []}
...> end
iex> stream = Stream.chunk_while(1..10, [], chunk_fun, after_fun)
iex> Enum.to_list(stream)
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]

concat (enumerables)

concat(Enumerable.t()) :: Enumerable.t()

एक स्ट्रीम बनाता है जो एक एन्यूमरेबल में प्रत्येक एनुमरेट को एनुमरेट करता है।

उदाहरण

iex> stream = Stream.concat([1..3, 4..6, 7..9])
iex> Enum.to_list(stream)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

समतल (पहला, दूसरा)

concat(Enumerable.t(), Enumerable.t()) :: Enumerable.t()

एक धारा बनाता है जो पहले तर्क को मानता है, उसके बाद दूसरा।

उदाहरण

iex> stream = Stream.concat(1..3, 4..6)
iex> Enum.to_list(stream)
[1, 2, 3, 4, 5, 6]

iex> stream1 = Stream.cycle([1, 2, 3])
iex> stream2 = Stream.cycle([4, 5, 6])
iex> stream = Stream.concat(stream1, stream2)
iex> Enum.take(stream, 6)
[1, 2, 3, 1, 2, 3]

चक्र (गणनीय)

cycle(Enumerable.t()) :: Enumerable.t()

एक ऐसी धारा बनाता है जो दी गई गणना के माध्यम से, असीम रूप से चक्रित होती है।

उदाहरण

iex> stream = Stream.cycle([1, 2, 3])
iex> Enum.take(stream, 5)
[1, 2, 3, 1, 2]

dedup (enum)

dedup(Enumerable.t()) :: Enumerable.t()

एक धारा बनाता है जो केवल तत्वों का उत्सर्जन करता है यदि वे पिछले उत्सर्जित तत्व से अलग हैं।

इस फ़ंक्शन को केवल अंतिम उत्सर्जित तत्व को संग्रहीत करने की आवश्यकता है।

तत्वों की तुलना ===/2 उपयोग से की जाती है।

उदाहरण

iex> Stream.dedup([1, 2, 3, 3, 2, 1]) |> Enum.to_list()
[1, 2, 3, 2, 1]

dedup_by (एनम, मज़ा)

dedup_by(Enumerable.t(), (element() -> term())) :: Enumerable.t()

एक धारा बनाता है जो केवल तत्वों का उत्सर्जन करता है यदि तत्व पर fun कॉल करने का परिणाम अंतिम उत्सर्जित तत्व पर fun कॉल करने के (संग्रहीत) परिणाम से भिन्न होता है।

उदाहरण

iex> Stream.dedup_by([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end) |> Enum.to_list()
[{1, :x}, {2, :y}, {1, :x}]

ड्रॉप (एनम, एन)

drop(Enumerable.t(), non_neg_integer()) :: Enumerable.t()

लाजिली एनुमरबल से अगली n वस्तुओं को गिराती है।

यदि एक नकारात्मक n दिया जाता है, तो यह संग्रह से अंतिम n आइटम को छोड़ देगा। ध्यान दें कि जिस तंत्र द्वारा इसे लागू किया गया है वह किसी भी आइटम के उत्सर्जन में देरी करेगा जब तक कि n अतिरिक्त आइटम एनम द्वारा उत्सर्जित नहीं किया गया हो।

उदाहरण

iex> stream = Stream.drop(1..10, 5)
iex> Enum.to_list(stream)
[6, 7, 8, 9, 10]

iex> stream = Stream.drop(1..10, -5)
iex> Enum.to_list(stream)
[1, 2, 3, 4, 5]

drop_every (एनम, एनटी)

drop_every(Enumerable.t(), non_neg_integer()) :: Enumerable.t()

एक स्ट्रीम बनाता है जो हर nth आइटम को एन्यूमरेबल से ड्राप करता है।

पहला आइटम हमेशा गिरा दिया जाता है, जब तक कि nth 0 न हो।

nth एक गैर-नकारात्मक पूर्णांक होना चाहिए।

उदाहरण

iex> stream = Stream.drop_every(1..10, 2)
iex> Enum.to_list(stream)
[2, 4, 6, 8, 10]

iex> stream = Stream.drop_every(1..1000, 1)
iex> Enum.to_list(stream)
[]

iex> stream = Stream.drop_every([1, 2, 3, 4, 5], 0)
iex> Enum.to_list(stream)
[1, 2, 3, 4, 5]

ड्रॉप_वर्ड (एनम, मस्ती)

drop_while(Enumerable.t(), (element() -> as_boolean(term()))) :: Enumerable.t()

दिए गए फ़ंक्शन एक सत्य मान देता है, जबकि आलसी एन्युमरेबल के तत्वों को गिरा देता है।

उदाहरण

iex> stream = Stream.drop_while(1..10, &(&1 <= 5))
iex> Enum.to_list(stream)
[6, 7, 8, 9, 10]

प्रत्येक (एनम, मज़ा)

each(Enumerable.t(), (element() -> term())) :: Enumerable.t()

प्रत्येक आइटम के लिए दिए गए फ़ंक्शन को निष्पादित करता है।

एक धारा में साइड इफेक्ट (जैसे प्रिंटिंग) जोड़ने के लिए उपयोगी है।

उदाहरण

iex> stream = Stream.each([1, 2, 3], fn x -> send(self(), x) end)
iex> Enum.to_list(stream)
iex> receive do: (x when is_integer(x) -> x)
1
iex> receive do: (x when is_integer(x) -> x)
2
iex> receive do: (x when is_integer(x) -> x)
3

फ़िल्टर (एनम, मज़ा)

filter(Enumerable.t(), (element() -> as_boolean(term()))) :: Enumerable.t()

एक स्ट्रीम बनाता है जो एन्यूमरेशन पर दिए गए फ़ंक्शन के अनुसार तत्वों को फ़िल्टर करता है।

उदाहरण

iex> stream = Stream.filter([1, 2, 3], fn x -> rem(x, 2) == 0 end)
iex> Enum.to_list(stream)
[2]

फ्लैट_मैप (एनम, मैपर)

flat_map(Enumerable.t(), (element() -> Enumerable.t())) :: Enumerable.t()

दी गई fun पर दिए गए नक्शे और परिणाम को समतल करता है।

यह फ़ंक्शन एक साथ enumerable प्रत्येक तत्व पर fun को लागू करने के परिणामस्वरूप निर्मित एक नई धारा देता है।

उदाहरण

iex> stream = Stream.flat_map([1, 2, 3], fn x -> [x, x * 2] end)
iex> Enum.to_list(stream)
[1, 2, 2, 4, 3, 6]

iex> stream = Stream.flat_map([1, 2, 3], fn x -> [[x]] end)
iex> Enum.to_list(stream)
[[1], [2], [3]]

प्रतिच्छेदन (गणना करने योग्य, प्रतिच्छेदन_करण) (1.6.0 के बाद से)

intersperse(Enumerable.t(), any()) :: Enumerable.t()

गूढ़ता के प्रत्येक तत्व के बीच अंतर को Lazly intersperses।

उदाहरण

iex> Stream.intersperse([1, 2, 3], 0) |> Enum.to_list()
[1, 0, 2, 0, 3]

iex> Stream.intersperse([1], 0) |> Enum.to_list()
[1]

iex> Stream.intersperse([], 0) |> Enum.to_list()
[]

अंतराल (एन)

interval(non_neg_integer()) :: Enumerable.t()

एक ऐसी धारा बनाता है जो मिलीसेकंड में दी गई अवधि n बाद एक मान का उत्सर्जन करता है।

उत्सर्जित मान 0 से शुरू होने वाला एक बढ़ता हुआ काउंटर है। यह ऑपरेशन हर बार किसी नए आइटम के स्ट्रीम होने पर दिए गए अंतराल से कॉलर को ब्लॉक करेगा।

संख्याओं के अनुक्रम को उत्पन्न करने के लिए इस फ़ंक्शन का उपयोग न करें। यदि कॉलर प्रक्रिया को अवरुद्ध करना आवश्यक नहीं है, तो इसके बजाय Stream.iterate(0, & &1 + 1) उपयोग करें।

उदाहरण

iex> Stream.interval(10) |> Enum.take(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

(enum, collectable, transform \\ fn x -> x end)

into(Enumerable.t(), Collectable.t(), (term() -> term())) :: Enumerable.t()

साइड-इफेक्ट के रूप में दिए गए संग्रहणीय में स्ट्रीम मानों को इंजेक्ट करता है।

इस फ़ंक्शन का उपयोग अक्सर run(stream) साथ किया जाता है क्योंकि किसी भी मूल्यांकन में देरी होती है जब तक कि स्ट्रीम निष्पादित नहीं होती है। एक उदाहरण के लिए run(stream) देखें।

iterate (start_value, next_fun)

iterate(element(), (element() -> element())) :: Enumerable.t()

मानों का एक क्रम उत्सर्जित करता है, start_value शुरू start_value । पिछले मान पर next_fun कॉल करके लगातार मान उत्पन्न किए जाते हैं।

उदाहरण

iex> Stream.iterate(0, &(&1 + 1)) |> Enum.take(5)
[0, 1, 2, 3, 4]

नक्शा (एनम, मज़ा)

map(Enumerable.t(), (element() -> any())) :: Enumerable.t()

एक स्ट्रीम बनाता है जो गणन पर दिए गए फ़ंक्शन को लागू करेगा।

उदाहरण

iex> stream = Stream.map([1, 2, 3], fn x -> x * 2 end)
iex> Enum.to_list(stream)
[2, 4, 6]

map_every (enum, nth, fun) (1.4.0 से)

map_every(Enumerable.t(), non_neg_integer(), (element() -> any())) ::
  Enumerable.t()

एक स्ट्रीम बनाता है जो दी गई फ़ंक्शन को एन्यूमरेबल से हर nth आइटम पर लागू करेगा।

पहला आइटम हमेशा दिए गए फ़ंक्शन को दिया जाता है।

nth एक गैर-नकारात्मक पूर्णांक होना चाहिए।

उदाहरण

iex> stream = Stream.map_every(1..10, 2, fn x -> x * 2 end)
iex> Enum.to_list(stream)
[2, 2, 6, 4, 10, 6, 14, 8, 18, 10]

iex> stream = Stream.map_every([1, 2, 3, 4, 5], 1, fn x -> x * 2 end)
iex> Enum.to_list(stream)
[2, 4, 6, 8, 10]

iex> stream = Stream.map_every(1..5, 0, fn x -> x * 2 end)
iex> Enum.to_list(stream)
[1, 2, 3, 4, 5]

अस्वीकार (एनम, मज़ा)

reject(Enumerable.t(), (element() -> as_boolean(term()))) :: Enumerable.t()

एक स्ट्रीम बनाता है जो गणन पर दिए गए फ़ंक्शन के अनुसार तत्वों को अस्वीकार कर देगा।

उदाहरण

iex> stream = Stream.reject([1, 2, 3], fn x -> rem(x, 2) == 0 end)
iex> Enum.to_list(stream)
[1, 3]

बार-बार (generator_fun)

repeatedly((() -> element())) :: Enumerable.t()

बार-बार generator_fun को कॉल करके उत्पन्न स्ट्रीम को लौटाता है।

उदाहरण

# Although not necessary, let's seed the random algorithm
iex> :rand.seed(:exsplus, {1, 2, 3})
iex> Stream.repeatedly(&:rand.uniform/0) |> Enum.take(3)
[0.40502929729990744, 0.45336720247823126, 0.04094511692041057]

संसाधन (start_fun, next_fun, after_fun)

resource(
  (() -> acc()),
  (acc() -> {[element()], acc()} | {:halt, acc()}),
  (acc() -> term())
) :: Enumerable.t()

दिए गए संसाधन के लिए मानों का एक क्रम उत्सर्जित करता है।

transform/3 समान लेकिन आरंभिक संचित मूल्य की गणना lazily start_fun माध्यम से की start_fun और गणना के अंत में (सफलता और असफलता दोनों मामलों में) start_fun को निष्पादित करता है।

अगला next_fun साथ (प्रारंभिक मूल्य जो start_fun द्वारा लौटाया जा रहा परिणाम है) start_fun सफल मान उत्पन्न किया जाता है और इसे एक ट्यूपल को start_fun चाहिए जिसमें उत्सर्जित होने वाली वस्तुओं की सूची और अगला संचयक होता है। यदि यह वापस हो जाता है, तो एन्यूमरेशन समाप्त हो जाता है {:halt, acc}

जैसा कि नाम कहते हैं, यह फ़ंक्शन संसाधनों से मूल्यों को स्ट्रीम करने के लिए उपयोगी है।

उदाहरण

Stream.resource(fn -> File.open!("sample") end,
                fn file ->
                  case IO.read(file, :line) do
                    data when is_binary(data) -> {[data], file}
                    _ -> {:halt, file}
                  end
                end,
                fn file -> File.close(file) end)

रन (धारा)

run(Enumerable.t()) :: :ok

दी गई धारा को चलाता है।

यह तब उपयोगी होता है जब साइड इफेक्ट्स के लिए एक स्ट्रीम को चलाने की आवश्यकता होती है, और इसके रिटर्न परिणाम में कोई दिलचस्पी नहीं होती है।

उदाहरण

किसी फ़ाइल को खोलें, सभी # % बदलें और मेमोरी में पूरी फ़ाइल लोड किए बिना किसी अन्य फ़ाइल पर स्ट्रीम करें:

File.stream!("/path/to/file")
|> Stream.map(&String.replace(&1, "#", "%"))
|> Stream.into(File.stream!("/path/to/other/file"))
|> Stream.run()

जब तक हम Enum फ़ंक्शंस में से एक को कॉल या run(stream) नहीं करते, तब तक कोई गणना नहीं की जाएगी।

स्कैन (एनम, मज़ा)

scan(Enumerable.t(), (element(), acc() -> any())) :: Enumerable.t()

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

उदाहरण

iex> stream = Stream.scan(1..5, &(&1 + &2))
iex> Enum.to_list(stream)
[1, 3, 6, 10, 15]

स्कैन (एनम, एसीसी, फन)

scan(Enumerable.t(), acc(), (element(), acc() -> any())) :: Enumerable.t()

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

उदाहरण

iex> stream = Stream.scan(1..5, 0, &(&1 + &2))
iex> Enum.to_list(stream)
[1, 3, 6, 10, 15]

ले (enum, count)

take(Enumerable.t(), integer()) :: Enumerable.t()

आलसी अगली count वस्तुओं को एन्यूमरेबल से लेता है और एन्यूमरेशन को रोकता है।

यदि कोई नकारात्मक count दी जाती है, तो अंतिम count मान लिया जाएगा। इस तरह, संग्रह पूरी तरह से स्मृति में 2 * count तत्वों तक रखने के लिए 2 * count जाती है। एक बार संग्रह के अंत तक पहुंचने के बाद, अंतिम count तत्वों को निष्पादित किया जाएगा। इसलिए, एक अनंत संग्रह पर एक नकारात्मक count का उपयोग करके कभी वापस नहीं आएगा।

उदाहरण

iex> stream = Stream.take(1..100, 5)
iex> Enum.to_list(stream)
[1, 2, 3, 4, 5]

iex> stream = Stream.take(1..100, -5)
iex> Enum.to_list(stream)
[96, 97, 98, 99, 100]

iex> stream = Stream.cycle([1, 2, 3]) |> Stream.take(5)
iex> Enum.to_list(stream)
[1, 2, 3, 1, 2]

take_every (एनम, nth)

take_every(Enumerable.t(), non_neg_integer()) :: Enumerable.t()

एक स्ट्रीम बनाता है जो हर nth आइटम को एन्यूमरेबल से लेता है।

पहला आइटम हमेशा शामिल होता है, जब तक कि nth 0 न हो।

nth एक गैर-नकारात्मक पूर्णांक होना चाहिए।

उदाहरण

iex> stream = Stream.take_every(1..10, 2)
iex> Enum.to_list(stream)
[1, 3, 5, 7, 9]

iex> stream = Stream.take_every([1, 2, 3, 4, 5], 1)
iex> Enum.to_list(stream)
[1, 2, 3, 4, 5]

iex> stream = Stream.take_every(1..1000, 0)
iex> Enum.to_list(stream)
[]

take_ward (enum, मजेदार)

take_while(Enumerable.t(), (element() -> as_boolean(term()))) :: Enumerable.t()

दिए गए फ़ंक्शन एक सत्य मान देता है, जबकि Lazly enumerable के तत्वों को लेता है।

उदाहरण

iex> stream = Stream.take_while(1..100, &(&1 <= 5))
iex> Enum.to_list(stream)
[1, 2, 3, 4, 5]

टाइमर (एन)

timer(non_neg_integer()) :: Enumerable.t()

एक ऐसी धारा बनाता है जो n मिलीसेकंड के बाद एक मान का उत्सर्जन करता है।

उत्सर्जित मूल्य 0 । यह ऑपरेशन तब तक कॉलर को ब्लॉक करेगा जब तक कि आइटम स्ट्रीम नहीं हो जाता।

उदाहरण

iex> Stream.timer(10) |> Enum.to_list()
[0]

परिवर्तन (एनम, एसीसी, रिड्यूसर)

transform(Enumerable.t(), acc, fun) :: Enumerable.t()
when fun: (element(), acc -> {Enumerable.t(), acc} | {:halt, acc}), acc: any()

किसी मौजूदा स्ट्रीम को बदल देता है।

यह एक संचायक और एक फ़ंक्शन की उम्मीद करता है जो प्रत्येक स्ट्रीम आइटम और एक संचायक प्राप्त करता है, और नए संचयकर्ता के साथ एक नया स्ट्रीम (अक्सर एक सूची) युक्त एक टपल लौटना चाहिए या इसके साथ एक ट्यूपल :halt पहले तत्व के रूप में :halt और दूसरा के बाद संचायक।

नोट: यह फ़ंक्शन Enum.flat_map_reduce/3 सूची और संचायक दोनों को छोड़कर Enum.flat_map_reduce/3 समान है, जबकि यह केवल एक ही स्ट्रीम लौटाता है।

उदाहरण

Stream.transform/3 उपयोगी है क्योंकि इसका उपयोग इस मॉड्यूल में परिभाषित कई कार्यों को लागू करने के लिए आधार के रूप में किया जा सकता है। उदाहरण के लिए, हम Stream.take(enum, n) को निम्नानुसार लागू कर सकते हैं:

iex> enum = 1..100
iex> n = 3
iex> stream = Stream.transform(enum, 0, fn i, acc ->
...>   if acc < n, do: {[i], acc + 1}, else: {:halt, acc}
...> end)
iex> Enum.to_list(stream)
[1, 2, 3]

रूपांतर (enum, start_fun, reducer, after_fun)

transform(Enumerable.t(), (() -> acc), fun, (acc -> term())) :: Enumerable.t()
when fun: (element(), acc -> {Enumerable.t(), acc} | {:halt, acc}), acc: any()

फ़ंक्शन-आधारित प्रारंभ और समाप्त के साथ एक मौजूदा स्ट्रीम को ट्रांसफ़ॉर्म करता है।

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

इस फ़ंक्शन को Stream.resource/3 साथ Stream.transform/3 संयोजन के रूप में देखा जा सकता है।

सामने आया (next_acc, next_fun)

unfold(acc(), (acc() -> {element(), acc()} | nil)) :: Enumerable.t()

दिए गए संचायक के लिए मानों का एक क्रम उत्सर्जित करता है।

पिछले next_fun साथ next_fun को कॉल करके लगातार मान उत्पन्न किए जाते हैं और इसे वर्तमान मूल्य और अगले संचायक के साथ एक टपल लौटना चाहिए। अगर nil वापस आ जाता है तो एन्यूमरेशन खत्म हो जाता है।

उदाहरण

iex> Stream.unfold(5, fn
...>   0 -> nil
...>   n -> {n, n - 1}
...> end) |> Enum.to_list()
[5, 4, 3, 2, 1]

uniq (enum)

uniq(Enumerable.t()) :: Enumerable.t()

एक धारा बनाता है जो केवल तत्वों का उत्सर्जन करता है यदि वे अद्वितीय हैं।

ध्यान रखें कि, यह जानने के लिए कि कोई तत्व अद्वितीय है या नहीं, इस फ़ंक्शन को धारा द्वारा उत्सर्जित सभी अद्वितीय मूल्यों को संग्रहीत करने की आवश्यकता है। इसलिए, यदि धारा अनंत है, तो संग्रहीत वस्तुओं की संख्या असीम रूप से बढ़ेगी, कभी भी कचरा एकत्र नहीं किया जाएगा।

उदाहरण

iex> Stream.uniq([1, 2, 3, 3, 2, 1]) |> Enum.to_list()
[1, 2, 3]

uniq_by (enum, fun)

uniq_by(Enumerable.t(), (element() -> term())) :: Enumerable.t()

एक स्ट्रीम बनाता है जो केवल तत्वों का उत्सर्जन करता है यदि वे अद्वितीय हैं, तो उन तत्वों को हटाकर जिनके लिए फ़ंक्शन fun ने डुप्लिकेट आइटम वापस किए।

फ़ंक्शन fun हर तत्व को एक शब्द में मैप करता है, जिसका उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या दो तत्व डुप्लिकेट हैं।

ध्यान रखें कि, यह जानने के लिए कि कोई तत्व अद्वितीय है या नहीं, इस फ़ंक्शन को धारा द्वारा उत्सर्जित सभी अद्वितीय मूल्यों को संग्रहीत करने की आवश्यकता है। इसलिए, यदि धारा अनंत है, तो संग्रहीत वस्तुओं की संख्या असीम रूप से बढ़ेगी, कभी भी कचरा एकत्र नहीं किया जाएगा।

उदाहरण

iex> Stream.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) |> Enum.to_list()
[{1, :x}, {2, :y}]

iex> Stream.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], fn {_, y} -> y end) |> Enum.to_list()
[a: {:tea, 2}, c: {:coffee, 1}]

with_index (enum, ऑफसेट \\ 0)

with_index(Enumerable.t(), integer()) :: Enumerable.t()

एक स्ट्रीम बनाता है जहां एन्यूमरेबल में प्रत्येक आइटम को उसके सूचकांक के साथ एक टुपल में लपेटा जाएगा।

यदि एक offset दिया जाता है, तो हम शून्य से बदले दिए गए ऑफसेट से अनुक्रमित करेंगे।

उदाहरण

iex> stream = Stream.with_index([1, 2, 3])
iex> Enum.to_list(stream)
[{1, 0}, {2, 1}, {3, 2}]

iex> stream = Stream.with_index([1, 2, 3], 3)
iex> Enum.to_list(stream)
[{1, 3}, {2, 4}, {3, 5}]

zip (enumerables) (1.4.0 के बाद से)

zip(Enumerable.t()) :: Enumerable.t()
zip([Enumerable.t()]) :: Enumerable.t()

जुमलों के परिमित संग्रह से संबंधित तत्वों को टुपल्स की एक धारा में जोड़ देता है।

दिए गए संग्रह में कोई भी गणना पूरी होते ही ज़िपिंग समाप्त हो जाती है।

उदाहरण

iex> concat = Stream.concat(1..3, 4..6)
iex> cycle = Stream.cycle(["foo", "bar", "baz"])
iex> Stream.zip([concat, [:a, :b, :c], cycle]) |> Enum.to_list()
[{1, :a, "foo"}, {2, :b, "bar"}, {3, :c, "baz"}]

ज़िप (बाएं, दाएं)

zip(Enumerable.t(), Enumerable.t()) :: Enumerable.t()

होंठों को एक साथ दो संग्रह, आलसी।

जंपिंग खत्म होने के बाद जैसे ही कोई एन्यूमरेबल पूरा होता है।

उदाहरण

iex> concat = Stream.concat(1..3, 4..6)
iex> cycle = Stream.cycle([:a, :b, :c])
iex> Stream.zip(concat, cycle) |> Enum.to_list()
[{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]