Elm Language
Insamling av data: Tuples, register och ordböcker

tupler

Tuples är ordnade listor över värden av vilken typ som helst.

(True, "Hello!", 42)

Det är omöjligt att ändra strukturen på en Tuple eller uppdatera värdet.

Tuples i Elm anses vara en primitiv datatyp, vilket innebär att du inte behöver importera några moduler för att använda Tuples.

Åtkomst till värden

Grundläggande modul har två hjälpfunktioner för åtkomst till värden på en Tuple med en längd av två ( a, b ) utan att använda mönstermatchning:

fst (True, "Hello!") -- True
snd (True, "Hello!") -- "Hello!"

Tillgångsvärden för tupler med större längd görs genom mönsterjustering.

Mönstermatchning

Tuples är extremt användbara i kombination med mönstermatchning:

toggleFlag: (Sting, Bool) -> (Sting, Bool)
toggleFlag (name, flag) =
    (name, not flag)

Anmärkningar om Tuples

Tuples innehåller mindre än sju värden av comparable datatyp

ordböcker

Ordböcker implementeras i ett Dict-kärnbibliotek .

En ordbok som kartlägger unika nycklar till värden. Nycklarna kan vara av alla jämförbara typer. Detta inkluderar Int, Float, Time, Char, String och tuples eller listor med jämförbara typer.

Infoga, ta bort och fråga operationer tar alla O (log n) tid.

Till skillnad från Tuples and Records kan ordböcker ändra sin struktur, med andra ord är det möjligt att lägga till och ta bort nycklar.

Det är möjligt att uppdatera ett värde med en nyckel.

Det är också möjligt att komma åt eller uppdatera ett värde med dynamiska tangenter.

Åtkomst till värden

Du kan hämta ett värde från en ordbok genom att använda en Dict.get funktion.

Dict.get av Dict.get :

get : comparable -> Dict comparable v -> Maybe v

Det kommer alltid att returnera Maybe v , eftersom det är möjligt att försöka få ett värde med en icke-existerande nyckel.

import Dict

initialUsers =
      Dict.fromList [ (1, "John"), (2, "Brad") ]

getUserName id =
  initialUsers
  |> Dict.get id
  |> Maybe.withDefault "Anonymous"
  
getUserName 2 -- "Brad"
getUserName 0 -- "Anonymous"

Uppdatera värden

Uppdateringsoperationen i en ordlista utförs med hjälp av Maybe.map , eftersom den begärda nyckeln kan vara frånvarande.

import Dict

initialUsers =
  Dict.fromList [ (1, "John"), (2, "Brad") ]

updatedUsers =
  Dict.update 1 (Maybe.map (\name -> name ++ " Johnson")) initialUsers

Maybe.withDefault "No user" (Dict.get 1 updatedUsers) -- "John Johnson"

Uppgifter

Record är en uppsättning nyckelvärdespar.

greeter =
    { isMorning: True
    , greeting: "Good morning!"
    }

Det är omöjligt att komma åt ett värde med en icke-existerande nyckel.

Det är omöjligt att dynamiskt modifiera Records struktur.

Med poster kan du bara uppdatera värden med konstanta nycklar.

Åtkomst till värden

Värden kan inte nås med hjälp av en dynamisk nyckel för att förhindra möjliga körningsfel:

isMorningKeyName =
    "isMorning "


greeter[isMorningKeyName] -- Compiler error
greeter.isMorning -- True

Den alternativa syntaxen för åtkomst till värdet gör att du kan extrahera värdet medan du rör dig genom posten:

greeter
    |> .greeting
    |> (++) " Have a nice day!" -- "Good morning! Have a nice day!"

Utökande typer

Ibland vill du att signaturen för en parameter begränsar de posttyper du skickar till funktioner. Att utöka posttyper gör idén om supertyper onödig. Följande exempel visar hur detta koncept kan implementeras:

type alias Person =
    { name : String
    }


type alias Animal =
    { name : String
    }


peter : Person
peter =
    { name = "Peter" }


dog : Animal
dog =
    { name = "Dog" }


getName : { a | name : String } -> String
getName livingThing =
    livingThing.name


bothNames : String
bothNames =
    getName peter ++ " " ++ getName dog

Vi kan till och med ta utökande poster ett steg längre och göra något som:

type alias Named a = { a | name : String }
type alias Totalled a = { a | total : Int }


totallyNamed : Named ( Totalled { age : Int })
totallyNamed =
  { name = "Peter Pan"
  , total = 1337
  , age = 14
  }

Vi har nu sätt att överföra dessa partiella typer i funktioner:

changeName : Named a -> String -> Named a
changeName a newName =
  { a | name = newName }
  
cptHook = changeName totallyNamed "Cpt. Hook" |> Debug.log "who?"

Uppdatera värden

Elm har en speciell syntax för Record-uppdateringar:

model =
    { id: 1
    , score: 0
    , name: "John Doe"
    }


update model =
    { model
       | score = model.score + 100
       | name = "John Johnson"
    }