Elm Language
Gegevens verzamelen: Tuples, Records en Woordenboeken

tuples

Tuples zijn geordende zoeklijsten van elk type.

(True, "Hello!", 42)

Het is onmogelijk om de structuur van een Tuple te wijzigen of de waarde bij te werken.

Tuples in Elm worden beschouwd als een primitief gegevenstype, wat betekent dat u geen modules hoeft te importeren om Tuples te gebruiken.

Toegang tot waarden

Basics module heeft twee hulpfuncties voor toegang waarden van een tupel met een lengte van twee ( a, b ) zonder patroonherkenning:

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

Toegangswaarden van tupels met een grotere lengte worden gedaan door patroonafstemming.

Patroonaanpassing

Tuples zijn uiterst nuttig in combinatie met patroonvergelijking:

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

Opmerkingen over Tuples

Tuples bevatten minder dan 7 waarden van comparable gegevenstype

Woordenboeken

Woordenboeken worden geïmplementeerd in een Dict- kernbibliotheek.

Een woordenboek dat unieke sleutels toewijst aan waarden. De toetsen kunnen van elk vergelijkbaar type zijn. Dit omvat Int, Float, Time, Char, String en tupels of lijsten van vergelijkbare typen.

Invoegen, verwijderen en querybewerkingen duren allemaal O (log n) tijd.

In tegenstelling tot Tuples en Records kunnen woordenboeken hun structuur wijzigen, met andere woorden, het is mogelijk om sleutels toe te voegen en te verwijderen.

Het is mogelijk om een waarde met een sleutel bij te werken.

Het is ook mogelijk om met dynamische sleutels toegang te krijgen tot een waarde of deze bij te werken.

Toegang tot waarden

U kunt een waarde uit een woordenboek Dict.get functie Dict.get .

Dict.get van Dict.get :

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

Het zal altijd Maybe v terugkeren, omdat het mogelijk is om te proberen een waarde te krijgen met een niet-bestaande sleutel.

import Dict

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

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

Waarden bijwerken

De Maybe.map van een woordenboek wordt uitgevoerd met behulp van Maybe.map , omdat de gevraagde sleutel mogelijk ontbreekt.

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"

archief

Record is een set sleutel / waarde-paren.

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

Het is onmogelijk om toegang te krijgen tot een waarde met een niet-bestaande sleutel.

Het is onmogelijk om de structuur van Record dynamisch te wijzigen.

Met records kunt u alleen waarden bijwerken met constante toetsen.

Toegang tot waarden

Waarden zijn niet toegankelijk met een dynamische sleutel om mogelijke runtime-fouten te voorkomen:

isMorningKeyName =
    "isMorning "


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

Met de alternatieve syntaxis voor toegang tot de waarde kunt u de waarde extraheren, terwijl u door het record bladert:

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

Typen uitbreiden

Soms wilt u dat de handtekening van een parameter de recordtypen beperkt die u in functies doorgeeft. Het uitbreiden van recordtypen maakt het idee van supertypen overbodig. Het volgende voorbeeld laat zien hoe dit concept kan worden geïmplementeerd:

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

We kunnen zelfs het uitbreiden van records een stap verder brengen en zoiets doen als:

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
  }

We hebben nu manieren om deze gedeeltelijke typen in functies door te geven:

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

Waarden bijwerken

Elm heeft een speciale syntaxis voor Record-updates:

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


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