Elm Language
Datenerfassung: Tupel, Datensätze und Wörterbücher

Tuples

Tupel sind geordnete Listen von Werten eines beliebigen Typs.

(True, "Hello!", 42)

Es ist nicht möglich, die Struktur eines Tuples zu ändern oder den Wert zu aktualisieren.

Tupel in Elm werden als primitiver Datentyp betrachtet, dh Sie müssen keine Module importieren, um Tupel verwenden zu können.

Auf Werte zugreifen

Das Basics- Modul verfügt über zwei Hilfsfunktionen, um auf Werte eines Tuples mit einer Länge von zwei ( a, b ) zuzugreifen ( a, b ) ohne Mustervergleich zu verwenden:

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

Zugriffswerte von Tupeln mit einer größeren Länge werden durch Mustervergleich erreicht.

Musterabgleich

Tupel sind sehr nützlich in Kombination mit Pattern Matching:

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

Anmerkungen zu Tupeln

Tupel enthalten weniger als 7 Werte eines comparable Datentyps

Wörterbücher

Wörterbücher sind in einer Dict-Kernbibliothek implementiert.

Ein Wörterbuch, das eindeutige Schlüssel zu Werten bildet. Die Schlüssel können alle vergleichbaren Typen sein. Dazu gehören Int, Float, Time, Char, String und Tupel oder Listen vergleichbarer Typen.

Einfüge-, Entfernungs- und Abfrageoperationen dauern alle O (log n).

Im Gegensatz zu Tupeln und Datensätzen können Wörterbücher ihre Struktur ändern, dh es können Schlüssel hinzugefügt und entfernt werden.

Es ist möglich, einen Wert über einen Schlüssel zu aktualisieren.

Es ist auch möglich, mit dynamischen Schlüsseln auf einen Wert zuzugreifen oder ihn zu aktualisieren.

Auf Werte zugreifen

Sie können einen Wert aus einem Wörterbuch mithilfe einer Dict.get Funktion Dict.get .

Typdefinition von Dict.get :

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

Es wird immer Maybe v , da versucht werden kann, einen Wert durch einen nicht vorhandenen Schlüssel abzurufen.

import Dict

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

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

Werte aktualisieren

Der Aktualisierungsvorgang für ein Wörterbuch wird mithilfe von Maybe.map , da der angeforderte Schlüssel möglicherweise nicht vorhanden ist.

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"

Aufzeichnungen

Record ist eine Menge von Schlüssel-Wert-Paaren.

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

Es ist unmöglich, auf einen Wert mit einem nicht vorhandenen Schlüssel zuzugreifen.

Es ist nicht möglich, die Struktur von Record dynamisch zu ändern.

Mit Datensätzen können Sie Werte nur mit konstanten Schlüsseln aktualisieren.

Auf Werte zugreifen

Auf Werte kann nicht mit einem dynamischen Schlüssel zugegriffen werden, um mögliche Laufzeitfehler zu vermeiden:

isMorningKeyName =
    "isMorning "


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

Mit der alternativen Syntax für den Zugriff auf den Wert können Sie den Wert extrahieren, während Sie durch den Datensatz blättern:

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

Typen erweitern

Manchmal möchten Sie, dass die Signatur eines Parameters die Datensatztypen einschränkt, die Sie an Funktionen übergeben. Das Erweitern von Datensatztypen macht die Idee von Supertypen unnötig. Das folgende Beispiel zeigt, wie dieses Konzept implementiert werden kann:

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

Wir könnten sogar noch einen Schritt weiter gehen und so etwas tun:

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
  }

Wir haben jetzt Möglichkeiten, diese partiellen Typen in Funktionen zu übergeben:

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

Werte aktualisieren

Elm hat eine spezielle Syntax für Record-Updates:

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


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