Elm Language
सूचियाँ और Iteration

टिप्पणियों

रेंज द्वारा एक सूची बनाना

> range = [1..5]
[1,2,3,4,5] : List number
>
> negative = [-5..3]
[-5,-4,-3,-2,-1,0,1,2,3] : List number

> range = List.range 1 5
[1,2,3,4,5] : List number
>
> negative = List.range -5 3
[-5,-4,-3,-2,-1,0,1,2,3] : List number

इस सिंटैक्स द्वारा बनाए गए रंग हमेशा समावेशी होते हैं और चरण हमेशा 1 होता है ।

एक सूची बनाना

> listOfNumbers = [1,4,99]
[1,4,99] : List number
>
> listOfStrings = ["Hello","World"]
["Hello","World"] : List String
>
> emptyList = []   -- can be anything, we don't know yet
[] : List a
>

हुड के तहत, List ( लिंक की गई सूची ) का निर्माण :: फ़ंक्शन ("कॉन्स" कहा जाता है) द्वारा किया जाता है, जो दो तर्क लेता है: एक तत्व, जिसे सिर के रूप में जाना जाता है, और (संभवतः खाली) सूची को पूर्व निर्धारित किया जाता है।

> withoutSyntaxSugar = 1 :: []
[1] : List number
>
> longerOne = 1 :: 2 :: 3 :: []
[1,2,3] : List number
>
> nonemptyTail = 1 :: [2]
[1,2] : List number
>

List केवल एक प्रकार का मान ले सकती है, इसलिए [1,"abc"] कुछ संभव नहीं है। यदि आपको इसकी आवश्यकता है, तो ट्यूपल्स का उपयोग करें।

> notAllowed = [1,"abc"]
==================================== ERRORS ====================================

-- TYPE MISMATCH --------------------------------------------- repl-temp-000.elm

The 1st and 2nd elements are different types of values.

8|              [1,"abc"]
               ^^^^^
The 1st element has this type:

    number

But the 2nd is:

    String

Hint: All elements should be the same type of value so that we can iterate
through the list without running into unexpected values.


> 

तत्व प्राप्त करना

> ourList = [1,2,3,4,5]
[1,2,3,4,5] : List number
>
> firstElement = List.head ourList
Just 1 : Maybe Int
>
> allButFirst = List.tail ourList
Just [2,3,4,5] : Maybe (List Int)

Maybe इस प्रकार में लपेटना निम्न परिदृश्य के कारण होता है:

खाली सूची के लिए List.head क्या लौटना चाहिए? (याद रखें, एल्म के पास अपवाद या अशक्तियाँ नहीं हैं।)

> headOfEmpty = List.head []
Nothing : Maybe Int
>
> tailOfEmpty = List.tail []
Nothing : Maybe (List Int)
>
> tailOfAlmostEmpty = List.tail [1] -- warning ... List is a *linked list* :)
Just [] : Maybe (List Int)

किसी सूची के प्रत्येक तत्व को बदलना

List.map : (a -> b) -> List a -> List b एक उच्च-क्रम फ़ंक्शन है जो सूची के प्रत्येक तत्व में एक-पैरामीटर फ़ंक्शन को लागू करता है, संशोधित मूल्यों के साथ एक नई सूची लौटाता है।

import String

ourList : List String
ourList = 
    ["wubba", "lubba", "dub", "dub"]

lengths : List Int
lengths = 
    List.map String.length ourList
-- [5,5,3,3]

slices : List String
slices =
    List.map (String.slice 1 3) ourList
-- ["ub", "ub", "ub", "ub"]

यदि आपको उन तत्वों के सूचकांक को जानने की आवश्यकता है जिन्हें आप List.indexedMap : (Int -> a -> b) -> List a -> List b उपयोग कर सकते हैं List.indexedMap : (Int -> a -> b) -> List a -> List b :

newList : List String
newList =
    List.indexedMap (\index element -> String.concat [toString index, ": ", element]) ourList
-- ["0: wubba","1: lubba","2: dub","3: dub"] 

किसी सूची को छानना

List.filter : (a -> Bool) -> List a -> List a उच्च-क्रम फ़ंक्शन है जो बूलियन के लिए किसी भी मान से एक-पैरामीटर फ़ंक्शन लेता है, और उस फ़ंक्शन को किसी दिए गए सूची के प्रत्येक तत्व पर लागू करता है, केवल उन तत्वों को रखना जिनके लिए फ़ंक्शन True है। वह फ़ंक्शन जो List.filter को अपने पहले पैरामीटर के रूप में लेता है, उसे अक्सर एक विधेय के रूप में संदर्भित किया जाता है।

import String

catStory : List String
catStory = 
    ["a", "crazy", "cat", "walked", "into", "a", "bar"]

-- Any word with more than 3 characters is so long!
isLongWord : String -> Bool
isLongWord string =
    String.length string > 3

longWordsFromCatStory : List String
longWordsFromCatStory = 
    List.filter isLongWord catStory

elm-repl में इसका मूल्यांकन करें:

> longWordsFromCatStory
["crazy", "walked", "into"] : List String
>
> List.filter (String.startsWith "w") longWordsFromCatStory
["walked"] : List String

एक सूची पर पैटर्न मिलान

हम किसी भी अन्य डेटा प्रकार जैसी सूचियों पर मेल कर सकते हैं, हालांकि वे कुछ अद्वितीय हैं, जिसमें सूची बनाने के लिए निर्माता infix फ़ंक्शन :: (उदाहरण देखें कि कैसे काम करता है पर अधिक के लिए एक सूची बनाना ।)

matchMyList : List SomeType -> SomeOtherType
matchMyList myList = 
    case myList of
        [] -> 
            emptyCase

        (theHead :: theRest) ->
            doSomethingWith theHead theRest

हम सूची में जितने चाहें उतने तत्व शामिल कर सकते हैं:

hasAtLeast2Elems : List a -> Bool
hasAtLeast2Elems myList =
    case myList of
        (e1 :: e2 :: rest) -> 
            True
    
        _ -> 
            False

hasAtLeast3Elems : List a -> Bool
hasAtLeast3Elems myList =
    case myList of
        (e1 :: e2 :: e3 :: rest) -> 
            True
    
        _ -> 
            False

सूची से nth तत्व प्राप्त करना

List "रैंडम एक्सेस" का समर्थन नहीं करती है, जिसका अर्थ है कि पहले तत्व की तुलना में सूची से पांचवां तत्व प्राप्त करने, कहने में अधिक काम लगता है, और परिणामस्वरूप कोई List.get nth list फ़ंक्शन नहीं है। एक को शुरुआत से ही सभी तरह से जाना है ( 1 -> 2 -> 3 -> 4 -> 5 )।

यदि आपको रैंडम एक्सेस की आवश्यकता है, तो आपको Array तरह रैंडम एक्सेस डेटा स्ट्रक्चर्स के साथ बेहतर परिणाम (और प्रदर्शन) मिल सकते हैं, जहाँ पहला तत्व लेने पर काम की मात्रा उतनी ही होती है, जितना कि 1000 वां। (जटिलता ओ (1))।

फिर भी, nth तत्व प्राप्त करना संभव है (लेकिन हतोत्साहित) :

get : Int -> List a -> Maybe a
get nth list =
    list
        |> List.drop (nth - 1)
        |> List.head

fifth : Maybe Int
fifth = get 5 [1..10]
--    = Just 5

nonexistent : Maybe Int
nonexistent = get 5 [1..3]
--          = Nothing

फिर, यह काफी अधिक काम लेता है जितना बड़ा nth तर्क है।

एक सूची को एक मूल्य पर कम करना

एल्म में, कम करने के कार्यों "परतों" कहा जाता है, और वहाँ "गुना" ऊपर मूल्यों के लिए दो मानक तरीके हैं: छोड़ दिया है, से foldl , और सही से, foldr ।

> List.foldl (+) 0 [1,2,3]
6 : number

foldl और foldr तर्क हैं:

• समारोह को कम करने : newValue -> accumulator -> accumulator
• संचायक प्रारंभ मूल्य
• कम करने के लिए सूची

कस्टम फ़ंक्शन के साथ एक और उदाहरण:

type alias Counts =
    { odd : Int
    , even : Int
    }

addCount : Int -> Counts -> Counts
addCount num counts =
    let
        (incOdd, incEven) =
            if num `rem` 2 == 0
                then (0,1)
                else (1,0)
    in
        { counts
            | odd = counts.odd + incOdd
            , even = counts.even + incEven
        }

> List.foldl
      addCount
      { odd = 0, even = 0 }
      [1,2,3,4,5]
{ odd = 3, even = 2 } : Counts

कार्यक्रम के ऊपर पहला उदाहरण इस प्रकार है:

List.foldl (+) 0 [1,2,3]
3 + (2 + (1 + 0))
3 + (2 + 1)
3 + 3
6

List.foldr (+) 0 [1,2,3]
1 + (2 + (3 + 0))
1 + (2 + 3)
1 + 5
6

कम्यूटेटिव फंक्शन जैसे (+) के मामले में वास्तव में कोई अंतर नहीं है।

लेकिन देखें कि क्या होता है (::) :

List.foldl (::) [] [1,2,3]
3 :: (2 :: (1 :: []))
3 :: (2 :: [1])
3 :: [2,1]
[3,2,1]

List.foldr (::) [] [1,2,3]
1 :: (2 :: (3 :: []))
1 :: (2 :: [3])
1 :: [2,3]
[1,2,3]

मान दोहराकर सूची बनाना

> List.repeat 3 "abc"
["abc","abc","abc"] : List String

आप किसी भी मूल्य List.repeat दे सकते हैं:

> List.repeat 2 {a = 1, b = (2,True)}
[{a = 1, b = (2,True)}, {a = 1, b = (2,True)}]
  : List {a : Int, b : (Int, Bool)}

एक सूची को क्रमबद्ध करना

डिफ़ॉल्ट रूप से, List.sort बढ़ते क्रम में सॉर्ट करता है।

> List.sort [3,1,5]
[1,3,5] : List number

List.sort को सूची तत्वों की comparable करने की आवश्यकता है। इसका मतलब है कि: String , Char , number ( Int और Float ), List की comparable या टपल के comparable ।

> List.sort [(5,"ddd"),(4,"zzz"),(5,"aaa")]
[(4,"zzz"),(5,"aaa"),(5,"ddd")] : List ( number, String )

> List.sort [[3,4],[2,3],[4,5],[1,2]]
[[1,2],[2,3],[3,4],[4,5]] : List (List number)

आप की सूची क्रमबद्ध नहीं कर सकते Bool साथ या वस्तुओं List.sort । इसके लिए एक सूची को कस्टम तुलनित्र के साथ क्रमबद्ध करना देखें।

> List.sort [True, False]
-- error, can't compare Bools

कस्टम तुलनित्र के साथ सूची को क्रमबद्ध करना

List.sortWith आपको किसी भी आकृति के डेटा के साथ सूचियों को क्रमबद्ध करने की अनुमति देता है - आप इसे एक तुलनात्मक फ़ंक्शन के साथ आपूर्ति करते हैं।

compareBools : Bool -> Bool -> Order
compareBools a b =
    case (a,b) of
        (False, True) ->
            LT

        (True, False) ->
            GT

        _ ->
            EQ
        
> List.sortWith compareBools [False, True, False, True]
[False, False, True, True] : List Bool

किसी सूची को उलट देना

नोट: यह List की प्रकृति के कारण बहुत कुशल नहीं है (नीचे टिप्पणियां देखें)। बेहतर होगा कि सूची का निर्माण शुरू से ही "सही" तरीके से करें और फिर उसे उल्टा कर दें।

> List.reverse [1,3,5,7,9]
[9,7,5,3,1] : List number

एक सूची को अवरोही क्रम में क्रमबद्ध करना

compare फ़ंक्शन के साथ डिफ़ॉल्ट रूप से List.sort क्रम में बढ़ते क्रम में।

अवरोही क्रम में क्रमबद्ध करने के दो तरीके हैं: एक कुशल और एक अक्षम।

1. कुशल तरीका : List.sortWith और एक अवरोही तुलनात्मक कार्य।

descending a b =
    case compare a b of
      LT -> GT
      EQ -> EQ
      GT -> LT

> List.sortWith descending [1,5,9,7,3]
[9,7,5,3,1] : List number

2. अयोग्य तरीका (हतोत्साहित!) : List.sort और फिर List.reverse ।

> List.reverse (List.sort [1,5,9,7,3])
[9,7,5,3,1] : List number

एक सूची को एक व्युत्पन्न मान द्वारा क्रमबद्ध करना

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

> List.sortBy String.length ["longest","short","medium"]
["short","medium","longest"] : List String
-- because the lengths are: [7,5,6]

यह भी रिकॉर्ड एक्सेसर्स के साथ अच्छी तरह से काम करता है:

people =
    [ { name = "John", age = 43 }
    , { name = "Alice", age = 30 }
    , { name = "Rupert", age = 12 }
    ]

> List.sortBy .age people
[ { name = "Rupert", age = 12 }
, { name = "Alice", age = 30 }
, { name = "John", age = 43 }
] : List {name: String, age: number}

> List.sortBy .name people
[ { name = "Alice", age = 30 }
, { name = "John", age = 43 }
, { name = "Rupert", age = 12 }
] : List {name: String, age: number}