Elixir 1.7

List




elixir

List

कार्य जो (लिंक्ड) सूचियों पर काम करते हैं।

Enumerable प्रोटोकॉल को लागू करने वाली सूचियों के लिए प्रदान किए गए कई फ़ंक्शन, Enum मॉड्यूल में पाए जाते हैं।

इसके अतिरिक्त, सूची के लिए निम्न कार्य और ऑपरेटर Kernel में पाए जाते हैं:

Elixir में सूचियाँ वर्ग कोष्ठक के बीच निर्दिष्ट की जाती हैं:

iex> [1, "two", 3, :four]
[1, "two", 3, :four]

++/2 का उपयोग करके दो सूचियों को समाप्‍त और घटाया जा सकता है ++/2 और --/2 ऑपरेटर:

iex> [1, 2, 3] ++ [4, 5, 6]
[1, 2, 3, 4, 5, 6]
iex> [1, true, 2, false, 3, true] -- [true, false]
[1, 2, 3, true]

एलिक्सिर में सूचियाँ प्रभावी रूप से जुड़ी हुई सूचियाँ हैं, जिसका अर्थ है कि वे आंतरिक रूप से उन जोड़ियों में प्रतिनिधित्व करती हैं जिनमें सिर और सूची की पूंछ होती है:

iex> [head | tail] = [1, 2, 3]
iex> head
1
iex> tail
[2, 3]

इसी प्रकार, हम केवल ऐसी जोड़ियों (जिन्हें कंस सेल्स कहा जाता है) का उपयोग करके सूची [1, 2, 3] लिख सकते हैं:

iex> [1 | [2 | [3 | []]]]
[1, 2, 3]

कुछ सूचियाँ, जिन्हें अनुचित सूचियाँ कहा जाता है, अंतिम सूची सेल में दूसरे तत्व के रूप में एक खाली सूची नहीं है:

iex> [1 | [2 | [3 | 4]]]
[1, 2, 3 | 4]

हालांकि अनुचित सूचियों को आमतौर पर टाला जाता है, लेकिन उनका उपयोग कुछ विशेष परिस्थितियों में किया जाता है जैसे कि आयोडेटा और चार्डेटा इकाइयां ( IO मॉड्यूल देखें)।

उनके विपक्ष सेल आधारित प्रतिनिधित्व के कारण, किसी तत्व को सूची में शामिल करना हमेशा तेज़ (निरंतर समय) होता है, जबकि संलग्न होना धीमा हो जाता है क्योंकि सूची आकार (रैखिक समय) में बढ़ती है:

iex> list = [1, 2, 3]
iex> [0 | list] # fast
[0, 1, 2, 3]
iex> list ++ [4] # slow
[1, 2, 3, 4]

Additonally, एक सूची की लंबाई प्राप्त करना और इसे अनुक्रमणिका द्वारा एक्सेस करना रैखिक समय संचालन है। नकारात्मक सूचकांक भी समर्थित हैं, लेकिन वे कहते हैं कि सूची को दो बार पुनरावृत्त किया जाएगा, एक बार उचित सूचकांक की गणना करने के लिए और दूसरी बार ऑपरेशन करने के लिए।

Charlists

यदि कोई सूची गैर-नकारात्मक पूर्णांकों से बनी है, तो इसे चारलिस्ट भी कहा जा सकता है। अमृत ​​एकल चार्टर्स को परिभाषित करने के लिए एकल उद्धरण का उपयोग करता है:

iex> 'héllo'
[104, 233, 108, 108, 111]

विशेष रूप से, यदि वे केवल ASCII- प्रिंट करने योग्य कोडपॉइंट होते हैं, तो एकल उद्धरणों में वापस छपे जा सकते हैं:

iex> 'abc'
'abc'

इस व्यवहार के पीछे तर्क यह है कि एरलंग पुस्तकालयों का बेहतर समर्थन किया जाए, जो कि एलिक्जिर स्ट्रिंग्स के बजाय टेक्स्ट को चार्लिस्ट के रूप में वापस कर सकते हैं। ऐसे कार्यों का एक उदाहरण Application.loaded_applications/0 :

Application.loaded_applications
#=>  [{:stdlib, 'ERTS  CXC 138 10', '2.6'},
#=>   {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
#=>   {:elixir, 'elixir', '1.0.0'},
#=>   {:kernel, 'ERTS  CXC 138 10', '4.1'},
#=>   {:logger, 'logger', '1.0.0'}]

एक सूची की जाँच की जा सकती है अगर वह ascii_printable?/2 साथ मुद्रण योग्य ascii ascii_printable?/2

सारांश

कार्य

ascii_printable?/2

जाँचता है कि क्या कोई सूची केवल मुद्रण योग्य ASCII वर्णों से बनी एक सूची है

हटाएं (सूची, आइटम)

list से दिए गए item को हटाता है। आइटम के बिना एक नई सूची देता है

delete_at (सूची, सूचकांक)

निर्दिष्ट index पर मूल्य को हटाकर एक नई सूची तैयार करता है

डुप्लिकेट (एलएम, एन)

किसी सूची में दिए गए तत्व n दोहराता है

first(list)

list में पहला तत्व लौटाता है या list खाली होने पर nil है

flatten(list)

नेस्टेड सूचियों की दी गई list को समतल करता है

समतल (सूची, पूंछ)

नेस्टेड सूचियों की दी गई list को समतल करता है। सूची सूची को चपटा सूची के अंत में जोड़ा जाएगा

तह (सूची, एसीसी, मज़ा)

एक समारोह के साथ बाईं ओर से दी गई सूची को कम कर देता है। एक संचायक की आवश्यकता है

तह (सूची, एसीसी, मज़ा)

फ़ंक्शन के साथ दाईं ओर से दी गई सूची को सिलवटों (कम कर देता है)। एक संचायक की आवश्यकता है

सम्मिलित_त (सूची, सूचकांक, मूल्य)

निर्दिष्ट index पर सम्मिलित value सूची लौटाता है

कीडलीट (सूची, कुंजी, स्थिति)

Tuples की एक list प्राप्त करता है और पहली tuple को हटाता है जहां position में आइटम दी गई key मेल खाता है। नई सूची लौटाता है

की-फ़ाइटेन (सूची, कुंजी, स्थिति, डिफ़ॉल्ट \\ nil)

Tuples की सूची प्राप्त करता है और पहली tuple लौटाता है, जहाँ tuple में position दी गई key से मिलती है

कीमम्बर? (सूची, कुंजी, स्थिति)

टपल की सूची प्राप्त करता है और यदि कोई टूपल है, जहां टपल में दिए गए आइटम से दी गई key मिलान होता है

कीरप्लेस (सूची, कुंजी, स्थिति, नया_टुपल)

टुपल्स की एक सूची प्राप्त करता है और यदि मौजूद है तो position द्वारा key द्वारा पहचाने गए आइटम को बदल देता है

कुंजियाँ (सूची, स्थिति)

Tuples की एक सूची प्राप्त करता है और tuples की position में आइटम को सॉर्ट करता है। सॉर्ट स्थिर है

कीस्टोर (सूची, कुंजी, स्थिति, नया_टुपल)

टुपल्स की एक list प्राप्त करता है और position key द्वारा पहचाने गए आइटम को बदलता है

कीटेक (सूची, कुंजी, स्थिति)

Tuples की list प्राप्त करता है और पहली tuple लौटाता है जहाँ tuple में position दी गई key मेल खाती है, साथ ही साथ tuple के बिना list भी मिलती है।

last(list)

यदि list खाली है तो list में अंतिम तत्व या nil लौटाता है

myers_difference (सूची 1, सूची 2)

एक कीवर्ड सूची देता है जो एक संपादित स्क्रिप्ट का प्रतिनिधित्व करता है

pop_at (सूची, सूचकांक, डिफ़ॉल्ट \\ nil)

index में निर्दिष्ट index में मान लौटाता है और हटाता है

प्रतिस्थापन_ सूची (सूची, सूचकांक, मूल्य)

निर्दिष्ट index पर एक प्रतिस्थापित मूल्य के साथ एक सूची लौटाता है

start_with? (सूची, उपसर्ग)

यदि दी गई prefix सूची के साथ list शुरू होती true तो यह true ; अन्यथा false लौट आता false

to_atom(charlist)

एक चार्लम को एक परमाणु में परिवर्तित करता है

to_existing_atom(charlist)

एक मौजूदा परमाणु में एक चारलिस्ट को परिवर्तित करता है। यदि परमाणु मौजूद नहीं है, तो एक ArgumentError उठाता है

to_float(charlist)

उस फ्लोट को लौटाता है जिसका टेक्स्ट प्रतिनिधित्व charlist

to_integer(charlist)

एक पूर्णांक देता है जिसका पाठ प्रतिनिधित्व charlist

to_integer (चारलिस्ट, आधार)

एक पूर्णांक देता है जिसका पाठ प्रतिनिधित्व बेस base में charlist है

to_string(list)

एक स्ट्रिंग में कोडपॉइंट्स, सूचियों या स्ट्रिंग्स का प्रतिनिधित्व करने वाले पूर्णांकों की एक सूची प्रदान करता है

to_tuple(list)

एक सूची को एक टुपल में परिवर्तित करता है

update_at (सूची, सूचकांक, मज़ा)

निर्दिष्ट index पर एक अद्यतन मूल्य के साथ एक सूची लौटाता है

wrap(term)

यदि यह सूची नहीं है तो किसी सूची में term समाप्त हो जाते हैं

zip(list_of_lists)

हर सूची से सूची में तत्व तत्व list_of_lists

कार्य

ascii_printable? (सूची, काउंटर \\: अनंत) (1.6.0 के बाद से)

जाँचता है कि क्या कोई सूची केवल मुद्रण योग्य ASCII वर्णों से बनी एक सूची है।

Elixir में एक मुद्रण योग्य चारलिस्ट में केवल ASCII वर्ण होते हैं।

एक दूसरे तर्क के रूप में एक वैकल्पिक limit लेता है। ascii_printable?/2 केवल limit तक सूची की ascii_printable?/2 जाँच करता limit

उदाहरण

iex> List.ascii_printable?('abc')
true

iex> List.ascii_printable?('abc' ++ [0])
false

iex> List.ascii_printable?('abc' ++ [0], 2)
true

अनुचित सूचियाँ प्रिंट करने योग्य नहीं हैं, भले ही वे केवल अस्सी वर्ण की हों:

iex> List.ascii_printable?('abc' ++ ?d)
false

हटाएं (सूची, आइटम)

delete(list(), any()) :: list()

list से दिए गए item को हटाता है। आइटम के बिना एक नई सूची देता है।

यदि item list में एक से अधिक बार होता है, तो बस पहली घटना को हटा दिया जाता है।

उदाहरण

iex> List.delete([:a, :b, :c], :a)
[:b, :c]

iex> List.delete([:a, :b, :b, :c], :b)
[:a, :b, :c]

delete_at (सूची, सूचकांक)

delete_at(list(), integer()) :: list()

निर्दिष्ट index पर मूल्य को हटाकर एक नई सूची तैयार करता है।

नकारात्मक सूचकांक list के अंत से एक ऑफसेट का संकेत देते हैं। यदि index सीमा से बाहर है, तो मूल list वापस आ जाती है।

उदाहरण

iex> List.delete_at([1, 2, 3], 0)
[2, 3]

iex> List.delete_at([1, 2, 3], 10)
[1, 2, 3]

iex> List.delete_at([1, 2, 3], -1)
[1, 2]

डुप्लिकेट (एलएम, एन)

duplicate(elem, non_neg_integer()) :: [elem] when elem: var

किसी सूची में दिए गए तत्व n दोहराता है।

उदाहरण

iex> List.duplicate("hello", 3)
["hello", "hello", "hello"]

iex> List.duplicate([1, 2], 2)
[[1, 2], [1, 2]]

पहले (सूची)

first([elem]) :: nil | elem when elem: var

list में पहला तत्व लौटाता है या list खाली होने पर nil है।

उदाहरण

iex> List.first([])
nil

iex> List.first([1])
1

iex> List.first([1, 2, 3])
1

समतल (सूची)

flatten(deep_list) :: list() when deep_list: [any() | deep_list]

नेस्टेड सूचियों की दी गई list को समतल करता है।

उदाहरण

iex> List.flatten([1, [[2], 3]])
[1, 2, 3]

समतल (सूची, पूंछ)

flatten(deep_list, [elem]) :: [elem]
when deep_list: [elem | deep_list], elem: var

नेस्टेड सूचियों की दी गई list को समतल करता है। सूची सूची को चपटा सूची के अंत में जोड़ा जाएगा।

उदाहरण

iex> List.flatten([1, [[2], 3]], [4, 5])
[1, 2, 3, 4, 5]

तह (सूची, एसीसी, मज़ा)

foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var

एक समारोह के साथ बाईं ओर से दी गई सूची को कम कर देता है। एक संचायक की आवश्यकता है।

उदाहरण

iex> List.foldl([5, 5], 10, fn x, acc -> x + acc end)
20

iex> List.foldl([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
2

तह (सूची, एसीसी, मज़ा)

foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var

फ़ंक्शन के साथ दाईं ओर से दी गई सूची को सिलवटों (कम कर देता है)। एक संचायक की आवश्यकता है।

उदाहरण

iex> List.foldr([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
-2

सम्मिलित_त (सूची, सूचकांक, मूल्य)

insert_at(list(), integer(), any()) :: list()

निर्दिष्ट index पर सम्मिलित value सूची लौटाता है।

ध्यान दें कि सूची की लंबाई पर index छाया हुआ है। नकारात्मक सूचकांक list के अंत से एक ऑफसेट का संकेत देते हैं।

उदाहरण

iex> List.insert_at([1, 2, 3, 4], 2, 0)
[1, 2, 0, 3, 4]

iex> List.insert_at([1, 2, 3], 10, 0)
[1, 2, 3, 0]

iex> List.insert_at([1, 2, 3], -1, 0)
[1, 2, 3, 0]

iex> List.insert_at([1, 2, 3], -10, 0)
[0, 1, 2, 3]

कीडलीट (सूची, कुंजी, स्थिति)

keydelete([tuple()], any(), non_neg_integer()) :: [tuple()]

Tuples की एक list प्राप्त करता है और पहली tuple को हटाता है जहां position में आइटम दी गई key मेल खाता है। नई सूची लौटाता है।

उदाहरण

iex> List.keydelete([a: 1, b: 2], :a, 0)
[b: 2]

iex> List.keydelete([a: 1, b: 2], 2, 1)
[a: 1]

iex> List.keydelete([a: 1, b: 2], :c, 0)
[a: 1, b: 2]

की-फ़ाइटेन (सूची, कुंजी, स्थिति, डिफ़ॉल्ट \\ nil)

keyfind([tuple()], any(), non_neg_integer(), any()) :: any()

Tuples की सूची प्राप्त करता है और पहली tuple लौटाता है, जहाँ tuple में position दी गई key से मिलती है।

उदाहरण

iex> List.keyfind([a: 1, b: 2], :a, 0)
{:a, 1}

iex> List.keyfind([a: 1, b: 2], 2, 1)
{:b, 2}

iex> List.keyfind([a: 1, b: 2], :c, 0)
nil

कीमम्बर? (सूची, कुंजी, स्थिति)

keymember?([tuple()], any(), non_neg_integer()) :: boolean()

टुपल्स की एक सूची प्राप्त करता है और अगर वहाँ एक टुपल है, जहां टुपल में position दी गई key मेल खाती है, तो सही है।

उदाहरण

iex> List.keymember?([a: 1, b: 2], :a, 0)
true

iex> List.keymember?([a: 1, b: 2], 2, 1)
true

iex> List.keymember?([a: 1, b: 2], :c, 0)
false

कीरप्लेस (सूची, कुंजी, स्थिति, नया_टुपल)

keyreplace([tuple()], any(), non_neg_integer(), tuple()) :: [tuple()]

टुपल्स की एक सूची प्राप्त करता है और यदि मौजूद है तो position द्वारा key द्वारा पहचाने गए आइटम को बदल देता है।

उदाहरण

iex> List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3})
[a: 3, b: 2]

कुंजियाँ (सूची, स्थिति)

keysort([tuple()], non_neg_integer()) :: [tuple()]

Tuples की एक सूची प्राप्त करता है और tuples की position में आइटम को सॉर्ट करता है। सॉर्ट स्थिर है।

उदाहरण

iex> List.keysort([a: 5, b: 1, c: 3], 1)
[b: 1, c: 3, a: 5]

iex> List.keysort([a: 5, c: 1, b: 3], 0)
[a: 5, b: 3, c: 1]

कीस्टोर (सूची, कुंजी, स्थिति, नया_टुपल)

keystore([tuple()], any(), non_neg_integer(), tuple()) :: [tuple(), ...]

टुपल्स की एक list प्राप्त करता है और position key द्वारा पहचाने गए आइटम को बदलता है।

यदि आइटम मौजूद नहीं है, तो इसे list के अंत में जोड़ा जाता है।

उदाहरण

iex> List.keystore([a: 1, b: 2], :a, 0, {:a, 3})
[a: 3, b: 2]

iex> List.keystore([a: 1, b: 2], :c, 0, {:c, 3})
[a: 1, b: 2, c: 3]

कीटेक (सूची, कुंजी, स्थिति)

keytake([tuple()], any(), non_neg_integer()) :: {tuple(), [tuple()]} | nil

Tuples की एक list प्राप्त करता है और पहली tuple लौटाता है जहाँ tuple में position में तत्व दिए गए key मेल खाता है, साथ ही साथ tuple के बिना list भी मिलती है।

यदि ऐसा कोई टपल नहीं मिला, तो nil वापस कर दिया जाएगा।

उदाहरण

iex> List.keytake([a: 1, b: 2], :a, 0)
{{:a, 1}, [b: 2]}

iex> List.keytake([a: 1, b: 2], 2, 1)
{{:b, 2}, [a: 1]}

iex> List.keytake([a: 1, b: 2], :c, 0)
nil

पिछले (सूची)

last([elem]) :: nil | elem when elem: var

यदि list खाली है तो list में अंतिम तत्व या nil लौटाता है।

उदाहरण

iex> List.last([])
nil

iex> List.last([1])
1

iex> List.last([1, 2, 3])
3

myers_difference (सूची 1, सूची 2) (1.4.0 से)

myers_difference(list(), list()) :: [{:eq | :ins | :del, list()}]

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

ई। मायर्स द्वारा एल्गोरिथ्म को "एन ओ (एनडी) डिफरेंस एलगोरिदम एंड इट्स वेरिएशन" पेपर में रेखांकित किया गया है।

एक संपादन स्क्रिप्ट एक कीवर्ड सूची है। प्रत्येक कुंजी सूची 2 के समान होने के लिए list1 करीब लाने के लिए "संपादन क्रिया" का वर्णन list2 ; एक कुंजी हो सकती है :eq :ins , या :del । प्रत्येक मान list1 या list2 से एक list2 जिसे डाला जाना चाहिए (यदि इसी कुंजी :ins ), हटाए गए (यदि संबंधित कुंजी है :del ), या अकेले छोड़ दिया जाए (यदि संबंधित कुंजी है :eq ) क्रम में list1 सूची 2 के करीब होना।

उदाहरण

iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
[eq: [1], del: [4], eq: [2, 3], ins: [4]]

pop_at (सूची, सूचकांक, डिफ़ॉल्ट \\ nil) (1.4.0 के बाद से)

pop_at(list(), integer(), any()) :: {any(), list()}

index में निर्दिष्ट index में मान लौटाता है और हटाता है।

नकारात्मक सूचकांक list के अंत से एक ऑफसेट का संकेत देते हैं। यदि index सीमा से बाहर है, तो मूल list वापस आ जाती है।

उदाहरण

iex> List.pop_at([1, 2, 3], 0)
{1, [2, 3]}
iex> List.pop_at([1, 2, 3], 5)
{nil, [1, 2, 3]}
iex> List.pop_at([1, 2, 3], 5, 10)
{10, [1, 2, 3]}
iex> List.pop_at([1, 2, 3], -1)
{3, [1, 2]}

प्रतिस्थापन_ सूची (सूची, सूचकांक, मूल्य)

replace_at(list(), integer(), any()) :: list()

निर्दिष्ट index पर एक प्रतिस्थापित मूल्य के साथ एक सूची लौटाता है।

नकारात्मक सूचकांक list के अंत से एक ऑफसेट का संकेत देते हैं। यदि index सीमा से बाहर है, तो मूल list वापस आ जाती है।

उदाहरण

iex> List.replace_at([1, 2, 3], 0, 0)
[0, 2, 3]

iex> List.replace_at([1, 2, 3], 10, 0)
[1, 2, 3]

iex> List.replace_at([1, 2, 3], -1, 0)
[1, 2, 0]

iex> List.replace_at([1, 2, 3], -10, 0)
[1, 2, 3]

start_with? (सूची, उपसर्ग) (1.5.0 से)

starts_with?([], [...]) :: false
starts_with?(list(), []) :: true
starts_with?(list(), list()) :: boolean()

यदि दी गई prefix सूची के साथ list शुरू होती true तो यह true ; अन्यथा false लौट आता false

यदि prefix एक खाली सूची है, तो यह true

उदाहरण

iex> List.starts_with?([1, 2, 3], [1, 2])
true

iex> List.starts_with?([1, 2], [1, 2, 3])
false

iex> List.starts_with?([:alpha], [])
true

iex> List.starts_with?([], [:alpha])
false

to_atom (charlist)

to_atom(charlist()) :: atom()

एक चार्लम को एक परमाणु में परिवर्तित करता है।

वर्तमान में एलिक्सिर चार्लिस्ट्स के रूपांतरण का समर्थन नहीं करता है जिसमें यूनिकोड कोडप्वाइंट 0xFF से अधिक है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> List.to_atom('elixir')
:elixir

to_existing_atom (charlist)

to_existing_atom(charlist()) :: atom()

एक मौजूदा परमाणु में एक चारलिस्ट को परिवर्तित करता है। यदि परमाणु मौजूद नहीं है, तो एक ArgumentError उठाता है।

वर्तमान में एलिक्सिर चार्लिस्ट्स के रूपांतरण का समर्थन नहीं करता है जिसमें यूनिकोड कोडप्वाइंट 0xFF से अधिक है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> _ = :my_atom
iex> List.to_existing_atom('my_atom')
:my_atom

iex> List.to_existing_atom('this_atom_will_never_exist')
** (ArgumentError) argument error

to_float (charlist)

to_float(charlist()) :: float()

उस फ्लोट को लौटाता है जिसका टेक्स्ट प्रतिनिधित्व charlist

संकलक द्वारा झुका हुआ।

उदाहरण

iex> List.to_float('2.2017764e+0')
2.2017764

to_integer (charlist)

to_integer(charlist()) :: integer()

एक पूर्णांक देता है जिसका पाठ प्रतिनिधित्व charlist

संकलक द्वारा झुका हुआ।

उदाहरण

iex> List.to_integer('123')
123

to_integer (चारलिस्ट, आधार)

to_integer(charlist(), 2..36) :: integer()

एक पूर्णांक देता है जिसका पाठ प्रतिनिधित्व बेस base में charlist है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> List.to_integer('3FF', 16)
1023

to_string (सूची)

to_string(:unicode.charlist()) :: String.t()

एक स्ट्रिंग में कोडपॉइंट्स, सूचियों या स्ट्रिंग्स का प्रतिनिधित्व करने वाले पूर्णांकों की एक सूची प्रदान करता है।

ध्यान दें कि यह फ़ंक्शन UTF-8 कोडपॉइंट्स का प्रतिनिधित्व करने वाले पूर्णांकों की एक सूची की अपेक्षा करता है। यदि आपके पास बाइट्स की सूची है, तो आपको इसके बजाय का उपयोग करना होगा :binary मॉड्यूल

उदाहरण

iex> List.to_string([0x00E6, 0x00DF])
"æß"

iex> List.to_string([0x0061, "bc"])
"abc"

iex> List.to_string([0x0064, "ee", ['p']])
"deep"

to_tuple (सूची)

to_tuple(list()) :: tuple()

एक सूची को एक टुपल में परिवर्तित करता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> List.to_tuple([:share, [:elixir, 163]])
{:share, [:elixir, 163]}

update_at (सूची, सूचकांक, मज़ा)

update_at([elem], integer(), (elem -> any())) :: list() when elem: var

निर्दिष्ट index पर एक अद्यतन मूल्य के साथ एक सूची लौटाता है।

नकारात्मक सूचकांक list के अंत से एक ऑफसेट का संकेत देते हैं। यदि index सीमा से बाहर है, तो मूल list वापस आ जाती है।

उदाहरण

iex> List.update_at([1, 2, 3], 0, &(&1 + 10))
[11, 2, 3]

iex> List.update_at([1, 2, 3], 10, &(&1 + 10))
[1, 2, 3]

iex> List.update_at([1, 2, 3], -1, &(&1 + 10))
[1, 2, 13]

iex> List.update_at([1, 2, 3], -10, &(&1 + 10))
[1, 2, 3]

लपेट (शब्द)

wrap(term) :: [term, ...] when term: any()
wrap(list) :: list when list: maybe_improper_list()
wrap(nil) :: []

यदि यह सूची नहीं है तो किसी सूची में term समाप्त हो जाते हैं।

यदि term पहले से ही एक सूची है, तो वह सूची वापस कर देता है। यदि term nil , तो यह एक खाली सूची देता है।

उदाहरण

iex> List.wrap("hello")
["hello"]

iex> List.wrap([1, 2, 3])
[1, 2, 3]

iex> List.wrap(nil)
[]

जिप (list_of_lists)

zip([list()]) :: [tuple()]

हर सूची से सूची में तत्व तत्व list_of_lists

जैसे ही कोई सूची समाप्त होती है, ज़िपिंग समाप्त हो जाती है।

उदाहरण

iex> List.zip([[1, 2], [3, 4], [5, 6]])
[{1, 3, 5}, {2, 4, 6}]

iex> List.zip([[1, 2], [3], [5, 6]])
[{1, 3, 5}]