Elixir 1.7

Enum




elixir

Enum

Enumerables के साथ काम करने के लिए एल्गोरिदम का एक सेट प्रदान करता है।

एलिक्जिर में, एक एन्यूमरेबल कोई भी डेटा प्रकार है जो Enumerable प्रोटोकॉल को लागू करता है। List s ( [1, 2, 3] ), Map s ( %{foo: 1, bar: 2} ) और Range s ( 1..3 ) सामान्य डेटा प्रकार हैं जिनका उपयोग enumerables के रूप में किया जाता है:

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

iex> Enum.sum([1, 2, 3])
6

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

iex> Enum.sum(1..3)
6

iex> map = %{"a" => 1, "b" => 2}
iex> Enum.map(map, fn {k, v} -> {k, v * 2} end)
[{"a", 2}, {"b", 4}]

हालाँकि, कई अन्य MapSet भाषा में मौजूद हैं, जैसे कि MapSet s और File.stream!/3 द्वारा लौटाए गए डेटा प्रकार File.stream!/3 जो एक फ़ाइल को ट्रैवर्स किए जाने की अनुमति देता है जैसे कि वह एक एन्यूमरेबल था।

इस मॉड्यूल में कार्य रैखिक समय में काम करते हैं। इसका मतलब यह है कि, जितना बड़ा एन्यूमरेबल होगा, वांछित ऑपरेशन करने में उतना ही अधिक समय लगेगा। यह Enum.map/2 जैसे संचालन पर Enum.map/2 । आखिरकार, यदि हम हर तत्व को किसी सूची पर, लंबी सूची, जितना अधिक तत्वों को हम आगे बढ़ाना चाहते हैं, उतने अधिक समय तक ले जाना चाहते हैं।

इस रैखिक व्यवहार को भी count/1 , member?/2 , at/2 और इसी तरह के संचालन पर उम्मीद की जानी चाहिए। जबकि अमृत ऐसे ऑपरेशनों के लिए डेटा प्रकार प्रदान करने की अनुमति देता है, आपको यह हमेशा उपलब्ध होने की उम्मीद नहीं करनी चाहिए, क्योंकि Enum मॉड्यूल बड़ी संख्या में डेटा प्रकारों के साथ काम करने के लिए है और सभी डेटा प्रकार अनुकूलित व्यवहार प्रदान नहीं कर सकते हैं।

अंत में, ध्यान दें कि Enum मॉड्यूल में कार्य उत्सुक हैं: जैसे ही वे लागू होंगे, वे एन्यूमरेबल को पार कर लेंगे। यह विशेष रूप से खतरनाक है जब अनंत एनुमरैबल्स के साथ काम करना। ऐसे मामलों में, आपको Stream मॉड्यूल का उपयोग करना चाहिए, जो आपको आलसी व्यक्त करने की अनुमति देता है, बिना ट्रैवर्सिंग संग्रह के, और संभवतः अनंत संग्रह के साथ काम कर सकता है। उदाहरण और प्रलेखन के लिए Stream मॉड्यूल देखें।

सारांश

प्रकार

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

कार्य

सभी (असंख्य, मजेदार \\ fn x -> x अंत)

अगर दी गई fun सभी योग्य वस्तुओं पर सत्य का मूल्यांकन करती है, तो वापस लौटता है

कोई भी (असंख्य, मजेदार \\ fn x -> x अंत)

यदि प्रदत्त fun किसी वस्तु पर सत्य का मूल्यांकन करता true तो वापस लौटाता true

पर (असंख्य, सूचकांक, डिफ़ॉल्ट \\ nil)

दिए गए index पर तत्व ढूँढता है (शून्य-आधारित)

chunk_by (असंख्य, मजेदार)

हर तत्व पर अलग-अलग विभाजन होते हैं जिसके लिए fun एक नया मूल्य देता है

chunk_every (गणना योग्य, गणना)

शॉर्टकट को chunk_every(enumerable, count, count) करने chunk_every(enumerable, count, count)

chunk_every (गणना योग्य, गणना, चरण, बचे हुए \\ [])

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

chunk_ORE (गणना योग्य, एसीसी, chunk_fun, after_fun)

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

concat(enumerables)

प्रगणकों की गणना करने योग्य को देखते हुए, प्रगणकों को एक सूची में सम्‍मिलित करता है

समतल (बाएं, दाएं)

बायीं ओर बोधगम्य के साथ दायीं ओर असंख्य को समेटता है

count/1

प्रगणित का आकार लौटाता है

गिनती (असंख्य, मजेदार)

उन मदों की संख्या को गणना में लौटाता है जिनके लिए fun एक सत्य मूल्य देता है

dedup(enumerable)

Enumerable को एन्यूमरेट करता है, एक सूची लौटाता है जहां सभी लगातार डुप्लिकेट किए गए तत्व एक ही तत्व से ढह जाते हैं

dedup_by (असंख्य, मजेदार)

Enumerable को एन्यूमरेट करता है, एक सूची लौटाता है जहां सभी लगातार डुप्लिकेट किए गए तत्व एक ही तत्व से ढह जाते हैं

ड्रॉप (गणना करने योग्य, राशि)

एन्युमरबल से आइटम्स की amount को गिराता है

drop_every (enumerable, nth)

पहले तत्व के साथ शुरू होने वाली गणना में प्रत्येक nth आइटम की सूची लौटाता है

ड्रॉप_वर्ड (असंख्य, मजेदार)

एनामेबल की शुरुआत में आइटम गिराता है जबकि fun एक सत्य मूल्य देता है

प्रत्येक (असंख्य, मजेदार)

असंख्य में प्रत्येक आइटम के लिए दिए गए fun को आमंत्रित करता है

empty?(enumerable)

निर्धारित करता है कि गणना करने योग्य खाली है या नहीं

प्राप्त करें (गणना करने योग्य, अनुक्रमणिका)

दिए गए index पर तत्व ढूँढता है (शून्य-आधारित)

लाने (असंख्य, सूचकांक)

दिए गए index पर तत्व ढूँढता है (शून्य-आधारित)

फ़िल्टर (असंख्य, मज़ेदार)

फाइल करने योग्य, यानी केवल उन तत्वों को लौटाता है जिनके लिए fun एक सत्य मूल्य देता है

खोजें (असंख्य, डिफ़ॉल्ट \\ शून्य, मजेदार)

वह पहला आइटम लौटाता है जिसके लिए fun एक सत्य मूल्य देता है। यदि ऐसा कोई आइटम नहीं मिला है, तो default लौटता default

find_index (enumerable, fun)

find/3 लिए समान find/3 , लेकिन तत्व के बजाय तत्व के सूचकांक (शून्य-आधारित) को वापस करता है

find_value (enumerable, default \\ nil, fun)

find/3 लिए समान है, लेकिन तत्व के बजाय फ़ंक्शन मंगलाचरण का मान लौटाता है

फ्लैट_मैप (असंख्य, मजेदार)

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

flat_map_reduce (enumerable, acc, fun)

नक्शे और एक कम कर देता है, दिए गए परिणामों को समतल करता है (केवल एक स्तर गहरा)

group_by (enumerable, key_fun, value_fun \\ fn x -> x end)

key_fun को key_fun आधार पर समूहों में key_fun

प्रतिच्छेदन (गणना करने योग्य, तत्व)

एन्यूमरेशन के प्रत्येक तत्व के बीच में इंटरपर्स element

में (असंख्य, संग्रहणीय)

दिए गए enumerable करने enumerable को एक collectable में सम्मिलित करता है

में (असंख्य, संग्रहणीय, परिवर्तन)

रूपांतरण समारोह के अनुसार एक collectable में दिए गए enumerable करता है

ज्वाइन (असंख्य, जॉइनर \\ "")

एक विभाजक के रूप में joiner का उपयोग करके बाइनरी में दी गई गणना को सम्मिलित करता है

नक्शा (असंख्य, मज़ेदार)

एक सूची लौटाता है, जहाँ प्रत्येक वस्तु, enumerable की प्रत्येक संगत वस्तु पर fun करने का परिणाम है

map_every (enumerable, nth, fun)

पहले तत्व से शुरू होने वाले, enumerable प्रत्येक nth आइटम पर fun निवेश के परिणामों की एक सूची देता है

map_join (असंख्य, योजक \\ "", मैपर)

नक्शे और दिए गए गणना में शामिल होने योग्य को एक पास में जोड़ देता है

map_reduce (असंख्य, एसीसी, मज़ा)

किसी संचयकर्ता को रखने के लिए, प्रत्येक आइटम को दिए गए फ़ंक्शन को एक तत्व में कम करने के लिए आमंत्रित करता है

अधिकतम (असंख्य, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

एर्लैंग के टर्म ऑर्डर के अनुसार गणना करने योग्य अधिकतम तत्व देता है

max_by (enumerable, fun, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

दिए गए फ़ंक्शन द्वारा गणना के अनुसार गणना में अधिकतम तत्व देता है

member?/2

जाँचता है कि element भीतर मौजूद है या नहीं

मिनट (असंख्य, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

एर्लैंग के टर्म ऑर्डर के अनुसार गणना करने योग्य में न्यूनतम तत्व देता है

min_by (enumerable, fun, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

दिए गए फ़ंक्शन द्वारा गणना के अनुसार गणना करने योग्य न्यूनतम तत्व देता है

min_max (enumerable, खाली_fallback \\ fn -> उठाना (Enum.EmptyError) अंत)

एर्लैंग के टर्म ऑर्डर के अनुसार कम से कम और अधिकतम तत्वों के साथ एक टपल लौटाता है

min_max_by (enumerable, fun, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

दिए गए फ़ंक्शन द्वारा गणना के अनुसार गणना में न्यूनतम और अधिकतम तत्वों के साथ एक टपल लौटाता है

random(enumerable)

एक enumerable का एक यादृच्छिक तत्व देता है

कम करना (असंख्य, मजेदार)

संचयकर्ता के साथ enumerable करने enumerable प्रत्येक तत्व के लिए fun आमंत्रित करता है

कम (असंख्य, एसीसी, मज़ा)

संचयकर्ता के साथ enumerable करने enumerable प्रत्येक तत्व के लिए fun आमंत्रित करता है

को कम करने के लिए (enumerable, एसीसी, मज़ा)

जब तक fun वापस नहीं fun तब तक कम कर देता है {:halt, term}

अस्वीकार (असंख्य, मजेदार)

उन तत्वों की एक सूची लौटाता है, जिनके लिए फ़ंक्शन fun को छोड़कर एक सत्य मान लौटाया जाता है

reverse(enumerable)

उल्टे क्रम में enumerable करने enumerable तत्वों की सूची देता है

रिवर्स (गणना करने योग्य, पूंछ)

तत्वों को enumerable में उलट देता है, tail जोड़ता है, और इसे एक सूची के रूप में वापस करता है

रिवर्स_स्लाइज़ (गणना योग्य, प्रारंभ, गिनती)

count तत्वों के माध्यम से आरंभिक स्थिति से रेंज में गणना करने वाले को उलट देता है

स्कैन (असंख्य, मज़ेदार)

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

स्कैन (असंख्य, एसीसी, मज़ा)

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

shuffle(enumerable)

enumerable तत्वों के साथ एक सूची देता है

टुकड़ा (असंख्य, arg)

दिए गए गणना की एक सबसेट सूची, range.first से लेकर range.first तक range.last

टुकड़ा (असंख्य, शुरू, राशि)

यदि उपलब्ध हो तो तत्वों की amount के साथ start स्थिति से, दी गई सूची की एक सबसेट सूची लौटाता है

sort(enumerable)

एर्लैंग के टर्म ऑर्डर के अनुसार गणना करने योग्य

सॉर्ट (असंख्य, मजेदार)

दिए गए फ़ंक्शन द्वारा प्रगणनीय को सॉर्ट करता है

Sort_by (गणना करने योग्य, मैपर, सॉर्टर \\ और <= / 2)

प्रदान किए गए sorter फ़ंक्शन के अनुसार गणना करने योग्य के मैप किए गए परिणामों को सॉर्ट करता है

विभाजन (गणना करने योग्य, गणना)

count तत्वों को दो enumerable में विभाजित करता है, पहले तत्वों को count

स्प्लिट_वर्ड (असंख्य, मजेदार)

तत्व की स्थिति में दो हिस्सों में बंटवारा होता है, जिसके लिए fun पहली बार false

स्प्लिट_विथ (एन्युमरेबल, फन)

दिए गए फ़ंक्शन fun अनुसार दो सूचियों में enumerable करने enumerable

sum(enumerable)

सभी तत्वों का योग लौटाता है

लेना (प्राप्य, राशि)

गणना करने योग्य से पहली amount आइटम लेता है

take_every (enumerable, nth)

पहले तत्व से शुरू होने वाले, enumerable में प्रत्येक nth आइटम की सूची देता है

take_random (गणना करने योग्य, गणना)

enumerable से यादृच्छिक वस्तुओं की count

take_ward (गणना करने योग्य, मजेदार)

Enumerable की शुरुआत से आइटम लेता है जबकि fun एक सत्य मूल्य देता है

to_list(enumerable)

एक सूची में enumerable करता है

uniq(enumerable)

सभी डुप्लिकेट तत्वों को हटाते हुए, गणना करने enumerable

uniq_by (enumerable, fun)

गणना करने के लिए तत्वों को हटा दें, जिसके लिए फ़ंक्शन fun डुप्लिकेट आइटम लौटाता है

unzip(enumerable)

Enum.zip/2 विपरीत; एन्यूमरबल से एक दो-तत्व टुपल्स निकालता है और उन्हें एक साथ समूहित करता है

with_index (असंख्य, ऑफसेट \\ 0)

अपनी अनुक्रमणिका के साथ एक टुपल में लिपटे प्रत्येक तत्व के साथ गणना करने योग्य रिटर्न देता है

zip(enumerables)

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

zip (enumerable1, enumerable2)

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

प्रकार

एसीसी ()

acc() :: any()

चूक()

default() :: any()

तत्व ()

element() :: any()

इंडेक्स ()

index() :: integer()

टी ()

t() :: Enumerable.t()

कार्य

सभी (असंख्य, मजेदार \\ fn x -> x अंत)

all?(t(), (element() -> as_boolean(term()))) :: boolean()

अगर दी गई fun सभी योग्य वस्तुओं पर सत्य का मूल्यांकन करती है, तो वापस लौटता है।

यह पहले आह्वान पर चलना बंद कर देता है जो false या nil

उदाहरण

iex> Enum.all?([2, 4, 6], fn x -> rem(x, 2) == 0 end)
true

iex> Enum.all?([2, 3, 4], fn x -> rem(x, 2) == 0 end)
false

यदि कोई फ़ंक्शन नहीं दिया जाता है, तो यह जांचने के लिए चूक करता है कि क्या गणना योग्य सभी आइटम सत्य मान हैं।

iex> Enum.all?([1, 2, 3])
true

iex> Enum.all?([1, nil, 3])
false

कोई भी (असंख्य, मजेदार \\ fn x -> x अंत)

any?(t(), (element() -> as_boolean(term()))) :: boolean()

यदि प्रदत्त fun किसी वस्तु पर सत्य का मूल्यांकन करता true तो वापस लौटाता true

यह पहले आह्वान पर पुनरावृत्ति को रोकता है जो एक सत्य मूल्य (न तो false और न ही nil ) लौटाता है।

उदाहरण

iex> Enum.any?([2, 4, 6], fn x -> rem(x, 2) == 1 end)
false

iex> Enum.any?([2, 3, 4], fn x -> rem(x, 2) == 1 end)
true

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

iex> Enum.any?([false, false, false])
false

iex> Enum.any?([false, true, false])
true

पर (असंख्य, सूचकांक, डिफ़ॉल्ट \\ nil)

at(t(), index(), default()) :: element() | default()

दिए गए index (शून्य-आधारित) में तत्व को ढूँढता है।

यदि index सीमा से बाहर है, तो default से लौटता है।

एक नकारात्मक index पारित किया जा सकता है, जिसका अर्थ है कि enumerable करने enumerable एक बार गणना की जाती है और index को अंत से गिना जाता है (जैसे -1 अंतिम तत्व पाता है)।

उदाहरण

iex> Enum.at([2, 4, 6], 0)
2

iex> Enum.at([2, 4, 6], 2)
6

iex> Enum.at([2, 4, 6], 4)
nil

iex> Enum.at([2, 4, 6], 4, :none)
:none

chunk_by (असंख्य, मजेदार)

chunk_by(t(), (element() -> any())) :: [list()]

हर तत्व पर अलग-अलग विभाजन होते हैं जिसके लिए fun एक नया मूल्य देता है।

सूचियों की सूची लौटाता है।

उदाहरण

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

chunk_every (गणना करने योग्य, गिनती) (1.5.0 के बाद से)

chunk_every(t(), pos_integer()) :: [list()]

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

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

chunk_every(t(), pos_integer(), pos_integer(), t() | :discard) :: [list()]

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

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

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

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

उदाहरण

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

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

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

iex> Enum.chunk_every([1, 2, 3, 4], 3, 3, [])
[[1, 2, 3], [4]]

iex> Enum.chunk_every([1, 2, 3, 4], 10)
[[1, 2, 3, 4]]

iex> Enum.chunk_every([1, 2, 3, 4, 5], 2, 3, [])
[[1, 2], [4, 5]]

chunk_ORE (गणना योग्य, एसीसी, chunk_fun, after_fun) (1.5.0 के बाद से)

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

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

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> Enum.chunk_while(1..10, [], chunk_fun, after_fun)
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]

concat (enumerables)

concat(t()) :: t()

प्रगणकों की गणना करने योग्य को देखते हुए, प्रगणकों को एक सूची में सम्‍मिलित करता है।

उदाहरण

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

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

समतल (बाएं, दाएं)

concat(t(), t()) :: t()

बायीं ओर बोधगम्य के साथ दायीं ओर असंख्य को समेटता है।

यह फ़ंक्शन सूची के लिए Kernel.++/2 ऑपरेटर के समान परिणाम उत्पन्न करता है।

उदाहरण

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

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

गिनती (गणनीय)

count(t()) :: non_neg_integer()

प्रगणित का आकार लौटाता है।

उदाहरण

iex> Enum.count([1, 2, 3])
3

गिनती (असंख्य, मजेदार)

count(t(), (element() -> as_boolean(term()))) :: non_neg_integer()

उन मदों की संख्या को गणना में लौटाता है जिनके लिए fun एक सत्य मूल्य देता है।

उदाहरण

iex> Enum.count([1, 2, 3, 4, 5], fn x -> rem(x, 2) == 0 end)
2

dedup (गणनीय)

dedup(t()) :: list()

Enumerable को एन्यूमरेट करता है, एक सूची लौटाता है जहां सभी लगातार डुप्लिकेट किए गए तत्व एक ही तत्व से ढह जाते हैं।

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

यदि आप आदेश की परवाह किए बिना सभी डुप्लिकेट तत्वों को हटाना चाहते हैं, तो uniq(enumerable)

उदाहरण

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

iex> Enum.dedup([1, 1, 2, 2.0, :three, :three])
[1, 2, 2.0, :three]

dedup_by (असंख्य, मजेदार)

dedup_by(t(), (element() -> term())) :: list()

Enumerable को एन्यूमरेट करता है, एक सूची लौटाता है जहां सभी लगातार डुप्लिकेट किए गए तत्व एक ही तत्व से ढह जाते हैं।

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

उदाहरण

iex> Enum.dedup_by([{1, :a}, {2, :b}, {2, :c}, {1, :a}], fn {x, _} -> x end)
[{1, :a}, {2, :b}, {1, :a}]

iex> Enum.dedup_by([5, 1, 2, 3, 2, 1], fn x -> x > 2 end)
[5, 1, 3, 2]

ड्रॉप (गणना करने योग्य, राशि)

drop(t(), integer()) :: list()

एन्युमरबल से आइटम्स की amount को गिराता है।

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

उदाहरण

iex> Enum.drop([1, 2, 3], 2)
[3]

iex> Enum.drop([1, 2, 3], 10)
[]

iex> Enum.drop([1, 2, 3], 0)
[1, 2, 3]

iex> Enum.drop([1, 2, 3], -1)
[1, 2]

drop_every (enumerable, nth)

drop_every(t(), non_neg_integer()) :: list()

पहले तत्व के साथ शुरू होने वाली गणना में प्रत्येक nth आइटम की सूची लौटाता है।

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

हर nth आइटम को निर्दिष्ट करने वाला दूसरा तर्क एक गैर-नकारात्मक पूर्णांक होना चाहिए।

उदाहरण

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

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

iex> Enum.drop_every([1, 2, 3], 1)
[]

ड्रॉप_वर्ड (असंख्य, मजेदार)

drop_while(t(), (element() -> as_boolean(term()))) :: list()

एनामेबल की शुरुआत में आइटम गिराता है जबकि fun एक सत्य मूल्य देता है।

उदाहरण

iex> Enum.drop_while([1, 2, 3, 2, 1], fn x -> x < 3 end)
[3, 2, 1]

प्रत्येक (असंख्य, मजेदार)

each(t(), (element() -> any())) :: :ok

असंख्य में प्रत्येक आइटम के लिए दिए गए fun को आमंत्रित करता है।

रिटर्न :ok

उदाहरण

Enum.each(["some", "example"], fn(x) -> IO.puts x end)
"some"
"example"
#=> :ok

खाली? (गणनीय)

empty?(t()) :: boolean()

निर्धारित करता है कि गणना करने योग्य खाली है या नहीं।

अगर प्रतिफल खाली है, तो true है, अन्यथा false

उदाहरण

iex> Enum.empty?([])
true

iex> Enum.empty?([1, 2, 3])
false

प्राप्त करें (गणना करने योग्य, अनुक्रमणिका)

fetch!(t(), index()) :: element() | no_return()

दिए गए index (शून्य-आधारित) में तत्व को ढूँढता है।

यदि दी गई index की सीमा के बाहर है, तो OutOfBoundsError उठाता है।

उदाहरण

iex> Enum.fetch!([2, 4, 6], 0)
2

iex> Enum.fetch!([2, 4, 6], 2)
6

iex> Enum.fetch!([2, 4, 6], 4)
** (Enum.OutOfBoundsError) out of bounds error

लाने (असंख्य, सूचकांक)

fetch(t(), index()) :: {:ok, element()} | :error

दिए गए index (शून्य-आधारित) में तत्व को ढूँढता है।

रिटर्न {:ok, element} अगर मिला है, अन्यथा :error

एक नकारात्मक index पारित किया जा सकता है, जिसका अर्थ है कि enumerable करने enumerable एक बार गणना की जाती है और index को अंत से गिना जाता है (जैसे -1 अंतिम तत्व प्राप्त करता है)।

उदाहरण

iex> Enum.fetch([2, 4, 6], 0)
{:ok, 2}

iex> Enum.fetch([2, 4, 6], -3)
{:ok, 2}

iex> Enum.fetch([2, 4, 6], 2)
{:ok, 6}

iex> Enum.fetch([2, 4, 6], 4)
:error

फ़िल्टर (असंख्य, मज़ेदार)

filter(t(), (element() -> as_boolean(term()))) :: list()

फाइल करने योग्य, यानी केवल उन तत्वों को लौटाता है जिनके लिए fun एक सत्य मूल्य देता है।

यह भी देखें reject/2 जो सभी तत्वों को त्यागता है जहां फ़ंक्शन एक सत्य मूल्य है।

उदाहरण

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

ध्यान रखें कि filter एक ही समय में एक तत्व को फ़िल्टर करने और बदलने में सक्षम नहीं है। यदि आप ऐसा करना चाहते हैं, तो flat_map/2 का उपयोग करने पर विचार करें। उदाहरण के लिए, यदि आप पूर्णांक को दर्शाने वाले सभी तारों को परिवर्तित करना चाहते हैं और अमान्य पास को एक पास में छोड़ देते हैं:

strings = ["1234", "abc", "12ab"]
Enum.flat_map(strings, fn string ->
  case Integer.parse(string) do
    {int, _rest} -> [int] # transform to integer
    :error -> [] # skip the value
  end
end)

खोजें (असंख्य, डिफ़ॉल्ट \\ शून्य, मजेदार)

find(t(), default(), (element() -> any())) :: element() | default()

वह पहला आइटम लौटाता है जिसके लिए fun एक सत्य मूल्य देता है। यदि ऐसा कोई आइटम नहीं मिला है, तो default लौटता default

उदाहरण

iex> Enum.find([2, 4, 6], fn x -> rem(x, 2) == 1 end)
nil

iex> Enum.find([2, 4, 6], 0, fn x -> rem(x, 2) == 1 end)
0

iex> Enum.find([2, 3, 4], fn x -> rem(x, 2) == 1 end)
3

find_index (enumerable, fun)

find_index(t(), (element() -> any())) :: non_neg_integer() | nil

find/3 लिए समान find/3 , लेकिन तत्व के बजाय तत्व के सूचकांक (शून्य-आधारित) को वापस करता है।

उदाहरण

iex> Enum.find_index([2, 4, 6], fn x -> rem(x, 2) == 1 end)
nil

iex> Enum.find_index([2, 3, 4], fn x -> rem(x, 2) == 1 end)
1

find_value (enumerable, default \\ nil, fun)

find_value(t(), any(), (element() -> any())) :: any() | nil

find/3 लिए समान है, लेकिन तत्व के बजाय फ़ंक्शन मंगलाचरण का मान लौटाता है।

उदाहरण

iex> Enum.find_value([2, 4, 6], fn x -> rem(x, 2) == 1 end)
nil

iex> Enum.find_value([2, 3, 4], fn x -> rem(x, 2) == 1 end)
true

iex> Enum.find_value([1, 2, 3], "no bools!", &is_boolean/1)
"no bools!"

फ्लैट_मैप (असंख्य, मजेदार)

flat_map(t(), (element() -> t())) :: list()

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

यह फ़ंक्शन एक नई गणना करता है जो एक साथ enumerable प्रत्येक तत्व पर fun आह्वान का परिणाम जोड़कर बनाया गया है; वैचारिक रूप से, यह map/2 और concat(enumerables) संयोजन के समान है।

उदाहरण

iex> Enum.flat_map([:a, :b, :c], fn x -> [x, x] end)
[:a, :a, :b, :b, :c, :c]

iex> Enum.flat_map([{1, 3}, {4, 6}], fn {x, y} -> x..y end)
[1, 2, 3, 4, 5, 6]

iex> Enum.flat_map([:a, :b, :c], fn x -> [[x]] end)
[[:a], [:b], [:c]]

flat_map_reduce (enumerable, acc, fun)

flat_map_reduce(t(), acc, fun) :: {[any()], any()}
when fun: (element(), acc -> {t(), acc} | {:halt, acc}), acc: any()

नक्शे और दिए गए परिणामों (केवल एक स्तर गहरा) को समतल करते हुए, एक enumerable कम कर देता है।

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

उदाहरण

iex> enumerable = 1..100
iex> n = 3
iex> Enum.flat_map_reduce(enumerable, 0, fn x, acc ->
...>   if acc < n, do: {[x], acc + 1}, else: {:halt, acc}
...> end)
{[1, 2, 3], 3}

iex> Enum.flat_map_reduce(1..5, 0, fn x, acc -> {[[x]], acc + x} end)
{[[1], [2], [3], [4], [5]], 15}

group_by (enumerable, key_fun, value_fun \\ fn x -> x end)

group_by(t(), (element() -> any()), (element() -> any())) :: map()

key_fun को key_fun आधार पर समूहों में key_fun

परिणाम एक नक्शा है जहां प्रत्येक कुंजी key_fun द्वारा दी गई है और प्रत्येक मान value_fun द्वारा दिए गए तत्वों की एक सूची है। प्रत्येक सूची के भीतर तत्वों का क्रम गणना से संरक्षित है। हालाँकि, सभी मानचित्रों की तरह, परिणामी नक्शा अनियंत्रित है।

उदाहरण

iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1)
%{3 => ["ant", "cat"], 5 => ["dingo"], 7 => ["buffalo"]}

iex> Enum.group_by(~w{ant buffalo cat dingo}, &String.length/1, &String.first/1)
%{3 => ["a", "c"], 5 => ["d"], 7 => ["b"]}

प्रतिच्छेदन (गणना करने योग्य, तत्व)

intersperse(t(), element()) :: list()

एन्यूमरेशन के प्रत्येक तत्व के बीच में इंटरपर्स element

जटिलता: O (n)।

उदाहरण

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

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

iex> Enum.intersperse([], 0)
[]

में (असंख्य, संग्रहणीय)

into(Enumerable.t(), Collectable.t()) :: Collectable.t()

दिए गए enumerable करने enumerable को एक collectable में सम्मिलित करता है।

उदाहरण

iex> Enum.into([1, 2], [0])
[0, 1, 2]

iex> Enum.into([a: 1, b: 2], %{})
%{a: 1, b: 2}

iex> Enum.into(%{a: 1}, %{b: 2})
%{a: 1, b: 2}

iex> Enum.into([a: 1, a: 2], %{})
%{a: 2}

में (असंख्य, संग्रहणीय, परिवर्तन)

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

रूपांतरण समारोह के अनुसार एक collectable में दिए गए enumerable करता है।

उदाहरण

iex> Enum.into([2, 3], [3], fn x -> x * 3 end)
[3, 6, 9]

iex> Enum.into(%{a: 1, b: 2}, %{c: 3}, fn {k, v} -> {k, v * 2} end)
%{a: 2, b: 4, c: 3}

ज्वाइन (असंख्य, जॉइनर \\ "")

join(t(), String.t()) :: String.t()

एक विभाजक के रूप में joiner का उपयोग करके बाइनरी में दी गई गणना को सम्मिलित करता है।

यदि joiner को पास नहीं किया जाता है, तो यह खाली बाइनरी में चूक करता है।

गणना करने योग्य सभी वस्तुओं को एक द्विआधारी के लिए परिवर्तनीय होना चाहिए, अन्यथा एक त्रुटि उठाई जाती है।

उदाहरण

iex> Enum.join([1, 2, 3])
"123"

iex> Enum.join([1, 2, 3], " = ")
"1 = 2 = 3"

नक्शा (असंख्य, मज़ेदार)

map(t(), (element() -> any())) :: list()

एक सूची लौटाता है, जहाँ प्रत्येक वस्तु, असंख्य की प्रत्येक संगत वस्तु पर fun करने का परिणाम है।

मानचित्रों के लिए, फ़ंक्शन एक महत्वपूर्ण-मूल्य टपल की अपेक्षा करता है।

उदाहरण

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

iex> Enum.map([a: 1, b: 2], fn {k, v} -> {k, -v} end)
[a: -1, b: -2]

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

map_every(t(), non_neg_integer(), (element() -> any())) :: list()

पहले तत्व से शुरू होने वाले, enumerable प्रत्येक nth आइटम पर fun निवेश के परिणामों की एक सूची देता है।

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

हर nth आइटम को निर्दिष्ट करने वाला दूसरा तर्क एक गैर-नकारात्मक पूर्णांक होना चाहिए।

यदि nth 0 , तो enumerable को सीधे सूची में परिवर्तित कर दिया जाता है, बिना fun कभी लागू नहीं किया जाता है।

उदाहरण

iex> Enum.map_every(1..10, 2, fn x -> x + 1000 end)
[1001, 2, 1003, 4, 1005, 6, 1007, 8, 1009, 10]

iex> Enum.map_every(1..10, 3, fn x -> x + 1000 end)
[1001, 2, 3, 1004, 5, 6, 1007, 8, 9, 1010]

iex> Enum.map_every(1..5, 0, fn x -> x + 1000 end)
[1, 2, 3, 4, 5]

iex> Enum.map_every([1, 2, 3], 1, fn x -> x + 1000 end)
[1001, 1002, 1003]

map_join (असंख्य, योजक \\ "", मैपर)

map_join(t(), String.t(), (element() -> String.Chars.t())) :: String.t()

नक्शे और दिए गए गणना में शामिल होने योग्य को एक पास में जोड़ देता है।

joiner या तो बाइनरी या एक सूची हो सकता है और परिणाम joiner के समान होगा। यदि joiner को पास नहीं किया जाता है, तो यह एक खाली बाइनरी में चूक करता है।

mapper को लागू करने से लौटे सभी आइटम को एक बाइनरी में परिवर्तित किया जाना चाहिए, अन्यथा एक त्रुटि उठाई जाती है।

उदाहरण

iex> Enum.map_join([1, 2, 3], &(&1 * 2))
"246"

iex> Enum.map_join([1, 2, 3], " = ", &(&1 * 2))
"2 = 4 = 6"

map_reduce (असंख्य, एसीसी, मज़ा)

map_reduce(t(), any(), (element(), any() -> {any(), any()})) ::
  {any(), any()}

किसी संचयकर्ता को रखने के लिए, प्रत्येक आइटम को दिए गए फ़ंक्शन को एक तत्व में कम करने के लिए आमंत्रित करता है।

एक टपल लौटाता है जहां पहला तत्व मैप करने योग्य है और दूसरा अंतिम संचयकर्ता है।

फ़ंक्शन, fun , दो तर्क प्राप्त करता है: पहला एक तत्व है, और दूसरा एक संचायक है। fun {result, accumulator} के रूप में दो तत्वों के साथ एक टपल लौटना चाहिए।

मानचित्रों के लिए, पहला टपल तत्व एक {key, value} tuple होना चाहिए।

उदाहरण

iex> Enum.map_reduce([1, 2, 3], 0, fn x, acc -> {x * 2, x + acc} end)
{[2, 4, 6], 6}

अधिकतम (असंख्य, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

max(t(), (() -> empty_result)) :: element() | empty_result | no_return()
when empty_result: any()

एर्लैंग के टर्म ऑर्डर के अनुसार गणना करने योग्य अधिकतम तत्व देता है।

यदि कई तत्वों को अधिकतम माना जाता है, तो जो पहले पाया गया था वह वापस आ गया है।

प्रदान किए गए empty_fallback फ़ंक्शन को कॉल करता है और यदि empty_fallback enumerable है तो उसका मान लौटाता है। डिफ़ॉल्ट empty_fallback बढ़ाता है।

उदाहरण

iex> Enum.max([1, 2, 3])
3

iex> Enum.max([], fn -> 0 end)
0

यह फ़ंक्शन इस तथ्य का उपयोग करता है कि एर्लैंग के शब्द क्रम का अर्थ है कि तुलना संरचनात्मक है और शब्दार्थ नहीं है। उदाहरण के लिए:

iex> Enum.max([~D[2017-03-31], ~D[2017-04-01]])
~D[2017-03-31]

ऊपर के उदाहरण में, max/1 अप्रैल 1 के बजाय 31 मार्च को लौटा क्योंकि संरचनात्मक तुलना वर्ष से पहले दिन की तुलना करती है। इसे max_by/1 का उपयोग करके और उन संरचनाओं पर भरोसा करके संबोधित किया जा सकता है जहां सबसे महत्वपूर्ण अंक पहले आते हैं। इस विशेष मामले में, हम वर्ष, महीने और दिन के क्षेत्रों के साथ टपल प्रतिनिधित्व प्राप्त करने के लिए Date.to_erl/1 का उपयोग कर सकते हैं:

iex> Enum.max_by([~D[2017-03-31], ~D[2017-04-01]], &Date.to_erl/1)
~D[2017-04-01]

दो में से अधिकतम मूल्य का चयन करने के लिए Kernel.max/2 . Kernel.max/2 का उपयोग करें।

max_by (enumerable, fun, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

max_by(t(), (element() -> any()), (() -> empty_result)) ::
  element() | empty_result | no_return()
when empty_result: any()

दिए गए फ़ंक्शन द्वारा गणना के अनुसार गणना में अधिकतम तत्व देता है।

यदि कई तत्वों को अधिकतम माना जाता है, तो जो पहले पाया गया था वह वापस आ गया है।

प्रदान किए गए empty_fallback फ़ंक्शन को कॉल करता है और यदि empty_fallback enumerable है तो उसका मान लौटाता है। डिफ़ॉल्ट empty_fallback बढ़ाता है।

उदाहरण

iex> Enum.max_by(["a", "aa", "aaa"], fn x -> String.length(x) end)
"aaa"

iex> Enum.max_by(["a", "aa", "aaa", "b", "bbb"], &String.length/1)
"aaa"

iex> Enum.max_by([], &String.length/1, fn -> nil end)
nil

सदस्य (गणना करने योग्य, तत्व)

member?(t(), element()) :: boolean()

जाँचता है कि element भीतर मौजूद है या नहीं।

मैच ( ===/2 ) ऑपरेटर के साथ सदस्यता का परीक्षण किया जाता है।

उदाहरण

iex> Enum.member?(1..10, 5)
true
iex> Enum.member?(1..10, 5.0)
false

iex> Enum.member?([1.0, 2.0, 3.0], 2)
false
iex> Enum.member?([1.0, 2.0, 3.0], 2.000)
true

iex> Enum.member?([:a, :b, :c], :d)
false

मिनट (असंख्य, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

min(t(), (() -> empty_result)) :: element() | empty_result | no_return()
when empty_result: any()

एर्लैंग के टर्म ऑर्डर के अनुसार गणना करने योग्य में न्यूनतम तत्व देता है।

यदि कई तत्वों को न्यूनतम माना जाता है, तो जो पहले पाया गया था वह वापस आ गया है।

प्रदान किए गए empty_fallback फ़ंक्शन को कॉल करता है और यदि empty_fallback enumerable है तो उसका मान लौटाता है। डिफ़ॉल्ट empty_fallback बढ़ाता है।

उदाहरण

iex> Enum.min([1, 2, 3])
1

iex> Enum.min([], fn -> 0 end)
0

यह फ़ंक्शन इस तथ्य का उपयोग करता है कि एर्लैंग के शब्द क्रम का अर्थ है कि तुलना संरचनात्मक है और शब्दार्थ नहीं है। उदाहरण के लिए:

iex> Enum.min([~D[2017-03-31], ~D[2017-04-01]])
~D[2017-04-01]

ऊपर दिए गए उदाहरण में, min/1 31 मार्च के बजाय 1 अप्रैल को लौटा क्योंकि संरचनात्मक तुलना वर्ष से एक दिन पहले थी। इसे min_by/1 का उपयोग करके और उन संरचनाओं पर निर्भर करके संबोधित किया जा सकता है जहां सबसे महत्वपूर्ण अंक पहले आते हैं। इस विशेष मामले में, हम वर्ष, महीने और दिन के क्षेत्रों के साथ टपल प्रतिनिधित्व प्राप्त करने के लिए Date.to_erl/1 का उपयोग कर सकते हैं:

iex> Enum.min_by([~D[2017-03-31], ~D[2017-04-01]], &Date.to_erl/1)
~D[2017-03-31]

दो में से न्यूनतम मान चुनने के लिए Kernel.min/2 का उपयोग करें।

min_by (enumerable, fun, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

min_by(t(), (element() -> any()), (() -> empty_result)) ::
  element() | empty_result | no_return()
when empty_result: any()

दिए गए फ़ंक्शन द्वारा गणना के अनुसार गणना करने योग्य न्यूनतम तत्व देता है।

यदि कई तत्वों को न्यूनतम माना जाता है, तो जो पहले पाया गया था वह वापस आ गया है।

प्रदान किए गए empty_fallback फ़ंक्शन को कॉल करता है और यदि empty_fallback enumerable है तो उसका मान लौटाता है। डिफ़ॉल्ट empty_fallback बढ़ाता है।

उदाहरण

iex> Enum.min_by(["a", "aa", "aaa"], fn x -> String.length(x) end)
"a"

iex> Enum.min_by(["a", "aa", "aaa", "b", "bbb"], &String.length/1)
"a"

iex> Enum.min_by([], &String.length/1, fn -> nil end)
nil

min_max (enumerable, खाली_fallback \\ fn -> उठाना (Enum.EmptyError) अंत)

min_max(t(), (() -> empty_result)) ::
  {element(), element()} | empty_result | no_return()
when empty_result: any()

एर्लैंग के टर्म ऑर्डर के अनुसार कम से कम और अधिकतम तत्वों के साथ एक टपल लौटाता है।

यदि कई तत्वों को अधिकतम या न्यूनतम माना जाता है, तो जो पहले पाया गया था वह वापस आ गया है।

प्रदान किए गए empty_fallback फ़ंक्शन को कॉल करता है और यदि empty_fallback enumerable है तो उसका मान लौटाता है। डिफ़ॉल्ट empty_fallback बढ़ाता है।

उदाहरण

iex> Enum.min_max([2, 3, 1])
{1, 3}

iex> Enum.min_max([], fn -> {nil, nil} end)
{nil, nil}

min_max_by (enumerable, fun, खाली_फॉलबैक \\ fn -> उठाना (Enum.EmptyError) अंत)

min_max_by(t(), (element() -> any()), (() -> empty_result)) ::
  {element(), element()} | empty_result | no_return()
when empty_result: any()

दिए गए फ़ंक्शन द्वारा गणना के अनुसार गणना में न्यूनतम और अधिकतम तत्वों के साथ एक टपल लौटाता है।

यदि कई तत्वों को अधिकतम या न्यूनतम माना जाता है, तो जो पहले पाया गया था वह वापस आ गया है।

प्रदान किए गए empty_fallback फ़ंक्शन को कॉल करता है और यदि empty_fallback enumerable है तो उसका मान लौटाता है। डिफ़ॉल्ट empty_fallback बढ़ाता है।

उदाहरण

iex> Enum.min_max_by(["aaa", "bb", "c"], fn x -> String.length(x) end)
{"c", "aaa"}

iex> Enum.min_max_by(["aaa", "a", "bb", "c", "ccc"], &String.length/1)
{"a", "aaa"}

iex> Enum.min_max_by([], &String.length/1, fn -> {nil, nil} end)
{nil, nil}

यादृच्छिक (गणनीय)

random(t()) :: element() | no_return()

एक enumerable का एक यादृच्छिक तत्व देता है।

को जन्म देती है Enum.EmptyError , तो enumerable खाली है।

यह फ़ंक्शन यादृच्छिक मान की गणना करने के लिए Erlang के :rand मॉड्यूल का उपयोग करता है । एक अलग यादृच्छिक एल्गोरिदम या एक अलग बीज सेट करने के लिए इसके प्रलेखन की जाँच करें।

कार्यान्वयन जलाशय के नमूने एल्गोरिथ्म पर आधारित है। यह मानता है कि लौटाया जा रहा नमूना स्मृति में फिट हो सकता है; इनपुट के पास enumerable यह नहीं है, क्योंकि यह सिर्फ एक बार ट्रेस किया गया है।

यदि किसी फ़ंक्शन को किसी श्रेणी में पास किया जाता है, तो यह फ़ंक्शन पूरी सीमा को ट्रेस किए बिना (इस प्रकार निरंतर समय और निरंतर मेमोरी में निष्पादित) सीमा सीमाओं के बीच एक यादृच्छिक मान उठाएगा।

उदाहरण

# Although not necessary, let's seed the random algorithm
iex> :rand.seed(:exsplus, {101, 102, 103})
iex> Enum.random([1, 2, 3])
2
iex> Enum.random([1, 2, 3])
1
iex> Enum.random(1..1_000)
776

कम करना (असंख्य, मजेदार)

reduce(t(), (element(), any() -> any())) :: any()

संचायक fun के साथ प्रत्येक तत्व के लिए आमंत्रित enumerable करता है।

को जन्म देती है Enum.EmptyError , तो enumerable खाली है।

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

चूंकि एन्यूमरबल के पहले तत्व को संचायक के प्रारंभिक मूल्य के रूप में उपयोग किया जाता है, इसलिए fun केवल उस n - 1 समय को निष्पादित किया जाएगा जहां n गणना करने योग्य की लंबाई है। यह फ़ंक्शन उन तत्वों के लिए निर्दिष्ट फ़ंक्शन को नहीं कहेगा जो एक-तत्व लंबे हैं।

यदि आप संचायक के लिए किसी अन्य मान का उपयोग करना चाहते हैं, तो उपयोग करें Enum.reduce/3

उदाहरण

iex> Enum.reduce([1, 2, 3, 4], fn x, acc -> x * acc end)
24

कम (असंख्य, एसीसी, मज़ा)

reduce(t(), any(), (element(), any() -> any())) :: any()

संचायक fun के साथ प्रत्येक तत्व के लिए आमंत्रित enumerable करता है।

संचायक का प्रारंभिक मूल्य है acc । फ़ंक्शन को संचयकर्ता के साथ गणना करने वाले प्रत्येक तत्व के लिए लागू किया जाता है। फ़ंक्शन द्वारा लौटाया गया परिणाम अगले पुनरावृत्ति के लिए संचायक के रूप में उपयोग किया जाता है। फ़ंक्शन अंतिम संचायक लौटाता है।

उदाहरण

iex> Enum.reduce([1, 2, 3], 0, fn x, acc -> x + acc end)
6

बिल्डिंग ब्लॉक के रूप में कम करें

कम करना (कभी-कभी कहा जाता है fold ) कार्यात्मक प्रोग्रामिंग में एक बुनियादी बिल्डिंग ब्लॉक है। Enum मॉड्यूल में लगभग सभी कार्यों को कम करने के शीर्ष पर लागू किया जा सकता है। वे कार्य अक्सर अन्य परिचालनों पर निर्भर करते हैं, जैसे कि Enum.reverse/1 , जिन्हें रनटाइम द्वारा अनुकूलित किया जाता है।

उदाहरण के लिए, हम लागू कर सकता है map/2 के मामले में reduce/3 इस प्रकार है:

def my_map(enumerable, fun) do
  enumerable
  |> Enum.reduce([], fn(x, acc) -> [fun.(x) | acc] end)
  |> Enum.reverse
end

ऊपर के उदाहरण में, Enum.reduce/3 प्रत्येक कॉल के परिणाम को fun रिवर्स ऑर्डर में एक सूची में संचित करता है , जिसे कॉल करके अंत में सही ढंग से ऑर्डर किया गया है Enum.reverse/1

कार्यों को लागू करना map/2 , filter/2 और अन्य लोगों की शक्ति को समझने के लिए एक अच्छा व्यायाम है Enum.reduce/3 । जब कोई ऑपरेशन Enum मॉड्यूल में किसी भी फ़ंक्शन द्वारा व्यक्त नहीं किया जा सकता है , तो डेवलपर्स सबसे अधिक संभावना का सहारा लेंगे reduce/3

को कम करने के लिए (enumerable, एसीसी, मज़ा)

reduce_while(
  t(),
  any(),
  (element(), any() -> {:cont, any()} | {:halt, any()})
) :: any()

fun रिटर्न तक एन्यूमरेबल को कम करता है {:halt, term}

के लिए वापसी मूल्य होने fun की उम्मीद है

  • {:cont, acc} acc नए संचायक या के रूप में कमी जारी रखने के लिए
  • {:halt, acc} कमी को रोकने के लिए और acc इस फ़ंक्शन के रिटर्न मान के रूप में लौटें

उदाहरण

iex> Enum.reduce_while(1..100, 0, fn x, acc ->
...>   if x < 3, do: {:cont, acc + x}, else: {:halt, acc}
...> end)
3

अस्वीकार (असंख्य, मजेदार)

reject(t(), (element() -> as_boolean(term()))) :: list()

enumerable उन तत्वों की एक सूची लौटाता है , जिनके लिए फ़ंक्शन fun एक सत्य मान देता है।

यह भी देखें filter/2

उदाहरण

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

रिवर्स (गणनीय)

reverse(t()) :: list()

enumerable रिवर्स ऑर्डर में तत्वों की सूची लौटाता है ।

उदाहरण

iex> Enum.reverse([1, 2, 3])
[3, 2, 1]

रिवर्स (गणना करने योग्य, पूंछ)

reverse(t(), t()) :: list()

तत्वों को उलट देता है enumerable , जोड़ता है tail , और इसे एक सूची के रूप में वापस करता है।

यह एक अनुकूलन है enumerable |> Enum.reverse() |> Enum.concat(tail)

उदाहरण

iex> Enum.reverse([1, 2, 3], [4, 5, 6])
[3, 2, 1, 4, 5, 6]

रिवर्स_स्लाइज़ (गणना योग्य, प्रारंभ, गिनती)

reverse_slice(t(), non_neg_integer(), non_neg_integer()) :: list()

तत्वों के start माध्यम से प्रारंभिक स्थिति से श्रेणी में प्रतिवर्ती को उलट देता है count

यदि count बाकी गणना योग्य के आकार से अधिक है, तो यह फ़ंक्शन बाकी गणना योग्य को उलट देगा।

उदाहरण

iex> Enum.reverse_slice([1, 2, 3, 4, 5, 6], 2, 4)
[1, 2, 6, 5, 4, 3]

स्कैन (असंख्य, मज़ेदार)

scan(t(), (element(), any() -> any())) :: list()

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

उदाहरण

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

स्कैन (असंख्य, एसीसी, मज़ा)

scan(t(), any(), (element(), any() -> any())) :: list()

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

उदाहरण

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

फेरबदल (गणनीय)

shuffle(t()) :: list()

enumerable फेरबदल के तत्वों के साथ एक सूची देता है ।

यह फ़ंक्शन यादृच्छिक मान की गणना करने के लिए Erlang के :rand मॉड्यूल का उपयोग करता है । एक अलग यादृच्छिक एल्गोरिदम या एक अलग बीज सेट करने के लिए इसके प्रलेखन की जाँच करें।

उदाहरण

# Although not necessary, let's seed the random algorithm
iex> :rand.seed(:exsplus, {1, 2, 3})
iex> Enum.shuffle([1, 2, 3])
[2, 1, 3]
iex> Enum.shuffle([1, 2, 3])
[2, 3, 1]

टुकड़ा (असंख्य, arg) (1.6.0 से)

slice(t(), Range.t()) :: list()

गणनीय दिया, से का एक सबसेट सूची रिटर्न range.first के लिए range.last पदों।

यह देखते हुए enumerable , यह तत्व स्थिति तक तत्वों को गिराता है range.first , फिर तत्वों को तत्व स्थिति range.last (समावेशी) तक ले जाता है ।

पदों को सामान्यीकृत किया जाता है, जिसका अर्थ है कि नकारात्मक पदों को अंत से गिना जाएगा (उदाहरण -1 के लिए गणना करने योग्य का अंतिम तत्व)। यदि range.last सीमा से बाहर है, तो इसे अंतिम तत्व की स्थिति के रूप में सौंपा गया है।

यदि सामान्य range.first स्थिति दी गई गणना की सीमा से बाहर है, या यह एक सामान्य range.last स्थिति से अधिक है , तो [] वापस कर दिया जाता है।

उदाहरण

iex> Enum.slice(1..100, 5..10)
[6, 7, 8, 9, 10, 11]

iex> Enum.slice(1..10, 5..20)
[6, 7, 8, 9, 10]

# last five elements (negative positions)
iex> Enum.slice(1..30, -5..-1)
[26, 27, 28, 29, 30]

# last five elements (mixed positive and negative positions)
iex> Enum.slice(1..30, 25..-1)
[26, 27, 28, 29, 30]

# out of bounds
iex> Enum.slice(1..10, 11..20)
[]

# range.first is greater than range.last
iex> Enum.slice(1..10, 6..5)
[]

टुकड़ा (असंख्य, शुरू, राशि)

slice(t(), index(), non_neg_integer()) :: list()

यदि उपलब्ध हो तो तत्वों के start साथ स्थिति से, दी गई सूची की एक सबसेट सूची लौटाता है amount

यह देखते हुए enumerable , यह तत्व की स्थिति तक तत्वों को गिराता है start , फिर amount तत्वों की गणना करता है।

यदि start सीमा से बाहर है, तो यह वापस आ जाता है []

यदि लंबाई amount से अधिक है enumerable , तो यह संभव के रूप में कई तत्वों को लौटाता है। यदि amount शून्य है, तो [] वापस कर दिया जाता है।

उदाहरण

iex> Enum.slice(1..100, 5, 10)
[6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# amount to take is greater than the number of elements
iex> Enum.slice(1..10, 5, 100)
[6, 7, 8, 9, 10]

iex> Enum.slice(1..10, 5, 0)
[]

# out of bound start position
iex> Enum.slice(1..10, 10, 5)
[]

# out of bound start position (negative)
iex> Enum.slice(1..10, -11, 5)
[]

प्रकार (गणनीय)

sort(t()) :: list()

एर्लैंग के टर्म ऑर्डर के अनुसार गणना करने योग्य।

मर्ज सॉर्ट एल्गोरिथ्म का उपयोग करता है।

उदाहरण

iex> Enum.sort([3, 2, 1])
[1, 2, 3]

सॉर्ट (असंख्य, मजेदार)

sort(t(), (element(), element() -> boolean())) :: list()

दिए गए फ़ंक्शन द्वारा प्रगणनीय को सॉर्ट करता है।

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

उदाहरण

iex> Enum.sort([1, 2, 3], &(&1 >= &2))
[3, 2, 1]

छँटाई एल्गोरिथ्म स्थिर होगा जब तक कि दिए गए फ़ंक्शन रिटर्न true को समान मान के लिए देता है :

iex> Enum.sort(["some", "kind", "of", "monster"], &(byte_size(&1) <= byte_size(&2)))
["of", "some", "kind", "monster"]

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

iex> Enum.sort(["some", "kind", "of", "monster"], &(byte_size(&1) < byte_size(&2)))
["of", "kind", "some", "monster"]

Sort_by (गणना करने योग्य, मैपर, सॉर्टर \\ और <= / 2)

sort_by(
  t(),
  (element() -> mapped_element),
  (mapped_element, mapped_element -> boolean())
) :: list()
when mapped_element: element()

प्रदान किए गए sorter फ़ंक्शन के अनुसार गणना करने योग्य के मैप किए गए परिणामों को सॉर्ट करता है।

यह फ़ंक्शन प्रदान किए गए mapper फ़ंक्शन का उपयोग करके enumerable के प्रत्येक तत्व को मैप करता है। गणना करने योग्य तत्वों को sorter फ़ंक्शन का उपयोग करके मैप किए गए तत्वों द्वारा सॉर्ट किया जाता है , जो कि चूक करता है Kernel.<=/2

sort_by/3 इस से अलग sort/2 है कि यह केवल प्रत्येक तुलना में प्रत्येक तत्व के लिए एक बार के बजाय गणना करने योग्य में प्रत्येक तत्व के लिए तुलना मूल्य की गणना करता है। यदि समान फ़ंक्शन को दोनों तत्वों पर बुलाया जा रहा है, तो यह उपयोग करने के लिए अधिक कॉम्पैक्ट भी है sort_by/3

उदाहरण

के डिफ़ॉल्ट sorter का उपयोग Kernel.<=/2 :

iex> Enum.sort_by(["some", "kind", "of", "monster"], &byte_size/1)
["of", "some", "kind", "monster"]

sorter आदेश को ओवरराइड करने के लिए एक कस्टम का उपयोग करना :

iex> Enum.sort_by(["some", "kind", "of", "monster"], &byte_size/1, &>=/2)
["monster", "some", "kind", "of"]

कई गुणों द्वारा क्रमबद्ध करना - पहले आकार से, फिर पहले अक्षर से (यह इस तथ्य का लाभ उठाता है कि ट्यूपल्स की तुलना तत्व-बाय-एलिमेंट से की जाती है):

iex> Enum.sort_by(["some", "kind", "of", "monster"], &{byte_size(&1), String.first(&1)})
["of", "kind", "some", "monster"]

विभाजन (गणना करने योग्य, गणना)

split(t(), integer()) :: {list(), list()}

विभाजन enumerable दो enumerables में, छोड़ने के count पहले एक में तत्वों।

यदि count एक ऋणात्मक संख्या है, तो यह गणना के पीछे से गणना के शुरू होने तक शुरू होती है।

ध्यान रखें कि एक नकारात्मक का count अर्थ है enumerable दो बार गणना की जाएगी: एक बार स्थिति की गणना करने के लिए, और वास्तविक विभाजन करने के लिए दूसरी बार।

उदाहरण

iex> Enum.split([1, 2, 3], 2)
{[1, 2], [3]}

iex> Enum.split([1, 2, 3], 10)
{[1, 2, 3], []}

iex> Enum.split([1, 2, 3], 0)
{[], [1, 2, 3]}

iex> Enum.split([1, 2, 3], -1)
{[1, 2], [3]}

iex> Enum.split([1, 2, 3], -5)
{[], [1, 2, 3]}

स्प्लिट_वर्ड (असंख्य, मजेदार)

split_while(t(), (element() -> as_boolean(term()))) :: {list(), list()}

पहली बार fun लौटने वाले तत्व की स्थिति में दो में बंटने योग्य विभाजन false

उदाहरण

iex> Enum.split_while([1, 2, 3, 4], fn x -> x < 3 end)
{[1, 2], [3, 4]}

स्प्लिट_विथ (इन्युमरेबल, फन) (1.4.0 से)

split_with(t(), (element() -> any())) :: {list(), list()}

विभाजन enumerable को देखते हुए समारोह के अनुसार दो सूचियों में fun

प्रत्येक तत्व के साथ एक ही तर्क में enumerable कॉल करके दो सूचियों में दिए गए को विभाजित करता है । सभी तत्वों में से युक्त पहली सूची के साथ एक टपल देता है जो लागू करने के लिए एक truthy मान दिया है, और सभी तत्व है जो के लिए आवेदन के साथ एक दूसरी सूची एक falsy मूल्य (लौटे या )। fun enumerable enumerable fun fun false nil

लौटी हुई सूचियों में दोनों तत्व समान सापेक्ष क्रम में हैं क्योंकि वे मूल गणना योग्य थे (यदि इस तरह की गणना करने योग्य आदेश दिया गया था, उदाहरण के लिए, एक सूची); नीचे दिए गए उदाहरण देखें।

उदाहरण

iex> Enum.split_with([5, 4, 3, 2, 1, 0], fn x -> rem(x, 2) == 0 end)
{[4, 2, 0], [5, 3, 1]}

iex> Enum.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn {_k, v} -> v < 0 end)
{[b: -2, d: -3], [a: 1, c: 1]}

iex> Enum.split_with(%{a: 1, b: -2, c: 1, d: -3}, fn {_k, v} -> v > 50 end)
{[], [a: 1, b: -2, c: 1, d: -3]}

iex> Enum.split_with(%{}, fn {_k, v} -> v > 50 end)
{[], []}

योग (गणनीय)

sum(t()) :: number()

सभी तत्वों का योग लौटाता है।

ArithmeticError यदि enumerable कोई गैर-संख्यात्मक मान है, तो उठाता है ।

उदाहरण

iex> Enum.sum([1, 2, 3])
6

लेना (प्राप्य, राशि)

take(t(), integer()) :: list()

amount गणना करने योग्य से पहला आइटम लेता है ।

यदि कोई ऋणात्मक amount दिया जाता है, तो amount अंतिम मान लिया जाएगा। enumerable उचित सूचकांक प्राप्त करने के लिए एक बार गणना की जाएगी और शेष गणना अंत से की जाती है।

उदाहरण

iex> Enum.take([1, 2, 3], 2)
[1, 2]

iex> Enum.take([1, 2, 3], 10)
[1, 2, 3]

iex> Enum.take([1, 2, 3], 0)
[]

iex> Enum.take([1, 2, 3], -1)
[3]

take_every (enumerable, nth)

take_every(t(), non_neg_integer()) :: list()

nth पहले तत्व से शुरू होने वाले, गणना में प्रत्येक आइटम की सूची लौटाता है ।

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

हर nth आइटम को निर्दिष्ट करने वाला दूसरा तर्क एक गैर-नकारात्मक पूर्णांक होना चाहिए।

उदाहरण

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

iex> Enum.take_every(1..10, 0)
[]

iex> Enum.take_every([1, 2, 3], 1)
[1, 2, 3]

take_random (गणना करने योग्य, गणना)

take_random(t(), non_neg_integer()) :: list()

count से यादृच्छिक आइटम लेता है enumerable

ध्यान दें कि यह फ़ंक्शन enumerable यादृच्छिक सबलिस्ट प्राप्त करने के लिए पूरे मार्ग को पार कर जाएगा ।

random(enumerable) कार्यान्वयन और यादृच्छिक बीज पर नोट्स के लिए देखें ।

उदाहरण

# Although not necessary, let's seed the random algorithm
iex> :rand.seed(:exsplus, {1, 2, 3})
iex> Enum.take_random(1..10, 2)
[5, 4]
iex> Enum.take_random(?a..?z, 5)
'ipybz'

take_ward (गणना करने योग्य, मजेदार)

take_while(t(), (element() -> as_boolean(term()))) :: list()

fun एक सत्य मूल्य देता है, जबकि enumerable की शुरुआत से आइटम लेता है ।

उदाहरण

iex> Enum.take_while([1, 2, 3], fn x -> x < 3 end)
[1, 2]

to_list (गणनीय)

to_list(t()) :: [element()]

enumerable एक सूची में परिवर्तित करता है।

उदाहरण

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

uniq (गणनीय)

uniq(t()) :: list()

enumerable सभी डुप्लिकेट तत्वों को हटाते हुए , गणना करता है ।

उदाहरण

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

uniq_by (enumerable, fun)

uniq_by(t(), (element() -> term())) :: list()

डुप्लिकेट आइटम वापस enumerable किस फ़ंक्शन के लिए तत्वों को निकालकर, गणना करता है fun

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

प्रत्येक तत्व की पहली घटना रखी जाती है।

उदाहरण

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

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

unzip (गणनीय)

unzip(t()) :: {[element()], [element()]}

के विपरीत Enum.zip/2 ; एन्यूमरबल से एक दो-तत्व टुपल्स निकालता है और उन्हें एक साथ समूहित करता है।

यह दो-तत्व टुपल्स वाली वस्तुओं के साथ एक enumerable लेता है और दो सूचियों के साथ एक टपल लौटाता है, जिनमें से प्रत्येक क्रमशः प्रत्येक ट्यूपल के पहले और दूसरे तत्व द्वारा बनता है।

यह फ़ंक्शन तब तक विफल रहता है जब तक enumerable कि प्रत्येक ट्यूपल में ठीक दो तत्वों के साथ ट्यूपल्स की सूची में परिवर्तित नहीं किया जा सकता है ।

उदाहरण

iex> Enum.unzip([{:a, 1}, {:b, 2}, {:c, 3}])
{[:a, :b, :c], [1, 2, 3]}

iex> Enum.unzip(%{a: 1, b: 2})
{[:a, :b], [1, 2]}

with_index (असंख्य, ऑफसेट \\ 0)

with_index(t(), integer()) :: [{element(), index()}]

अपनी अनुक्रमणिका के साथ एक टुपल में लिपटे प्रत्येक तत्व के साथ गणना करने योग्य रिटर्न देता है।

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

उदाहरण

iex> Enum.with_index([:a, :b, :c])
[a: 0, b: 1, c: 2]

iex> Enum.with_index([:a, :b, :c], 3)
[a: 3, b: 4, c: 5]

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

zip(t()) :: t()
zip([t()]) :: t()

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

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

उदाहरण

iex> Enum.zip([[1, 2, 3], [:a, :b, :c], ["foo", "bar", "baz"]])
[{1, :a, "foo"}, {2, :b, "bar"}, {3, :c, "baz"}]

iex> Enum.zip([[1, 2, 3, 4, 5], [:a, :b, :c]])
[{1, :a}, {2, :b}, {3, :c}]

zip (enumerable1, enumerable2)

zip(t(), t()) :: [{any(), any()}]

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

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

उदाहरण

iex> Enum.zip([1, 2, 3], [:a, :b, :c])
[{1, :a}, {2, :b}, {3, :c}]

iex> Enum.zip([1, 2, 3, 4, 5], [:a, :b, :c])
[{1, :a}, {2, :b}, {3, :c}]

Original text