Værdier
En værdi er data, der oprettes ved at evaluere et udtryk. I dette afsnit beskrives typerne af værdier på M-sproget. Hver type værdi er knyttet til en konstantsyntaks, et sæt værdier, der er af denne type, et sæt operatorer, der er defineret for det pågældende værdisæt, og en indbygget type, der er tilskrevet nyligt oprettede værdier.
Kind | Literal |
---|---|
Nul | null |
Logisk | true false |
Tal | 0 1 -1 1.5 2.3e-5 |
Time | #time(09,15,00) |
Dato | #date(2013,02,26) |
DateTime | #datetime(2013,02,26, 09,15,00) |
DateTimeZone | #datetimezone(2013,02,26, 09,15,00, 09,00) |
Varighed | #duration(0,1,30,0) |
Tekst | "hello" |
Binær | #binary("AQID") |
Liste | {1, 2, 3} |
Post | [ A = 1, B = 2 ] |
Tabel | #table({"X","Y"},{{0,1},{1,0}}) |
Funktion | (x) => x + 1 |
Skriv | type { number } type table [ A = any, B = text ] |
I følgende afsnit beskrives hver værdi af typen i detaljer. Typer og typebeskrivelse defineres formelt i Typer. Funktionsværdier er defineret i Functions. I følgende afsnit vises de operatorer, der er defineret for hver værdi, og der vises eksempler. Den fulde definition af operatorens semantik følger i Operatorer.
En null-værdi bruges til at repræsentere fraværet af en værdi eller en værdi af ubestemt eller ukendt tilstand. En null-værdi skrives ved hjælp af konstantværdien null
. Følgende operatorer er defineret for null-værdier:
Operator | Resultat |
---|---|
x > y |
Større end |
x >= y |
Større end eller lig med |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x = y |
Lig med |
x <> y |
Ikke lig med |
x ?? y |
Coalesce |
Den oprindelige type af værdien null
er den indbyggede type null
.
En logisk værdi bruges til booleske handlinger, der har værdien true eller false. En logisk værdi skrives ved hjælp af konstanterne true
og false
. Følgende operatorer er defineret for logiske værdier:
Operator | Resultat |
---|---|
x > y |
Større end |
x >= y |
Større end eller lig med |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x = y |
Lig med |
x <> y |
Ikke lig med |
x or y |
Betinget logisk OR |
x ?? y |
Coalesce |
x and y |
Betinget logisk AND |
not x |
Logisk NOT |
Den oprindelige type af både logiske værdier (true
og false
) er den indbyggede type logical
.
En talværdi bruges til numeriske og aritmetiske handlinger. Følgende er eksempler på talkonstanter:
3.14 // Fractional number
-1.5 // Fractional number
1.0e3 // Fractional number with exponent
123 // Whole number
1e3 // Whole number with exponent
0xff // Whole number in hex (255)
Et tal repræsenteres med mindst præcisionen af et dobbelt reelt tal (men kan bevare mere præcision). Dobbeltrepræsentationen er i overensstemmelse med IEEE 64-bit dobbelt præcisionsstandarden for binært flydende tal aritmetik defineret i [IEEE 754-2008]. (Den Dobbelt repræsentation har et omtrentligt dynamisk område fra 5,0 x 10324 til 1,7 x 10308 med en præcision på 15-16 cifre.)
Følgende specialværdier anses også for at være talværdier :
Positivt nul og negativt nul. I de fleste situationer fungerer positivt nul og negativt nul identisk som den simple værdi nul, men visse handlinger skelner mellem de to.
Positiv uendelighed (
#infinity
) og negativ uendelighed (-#infinity
). Uendeligheder produceres af sådanne handlinger som at dividere et tal, der ikke er nul, med nul. Giver f.eks1.0 / 0.0
. positiv uendelighed og-1.0 / 0.0
giver negativ uendelighed.Not-a-Number-værdien (
#nan
), ofte forkortet NaN. NaN'er er produceret af ugyldige flydende talhandlinger, f.eks. ved at dividere nul med nul.
Binære matematiske handlinger udføres ved hjælp af en Præcision. Præcisionen bestemmer det domæne, som operanderne afrundes til, og det domæne, hvor handlingen udføres. Hvis der ikke er angivet en eksplicit præcision, udføres disse handlinger ved hjælp af dobbelt præcision.
Hvis resultatet af en matematisk handling er for lille til destinationsformatet, bliver resultatet af handlingen positivt nul eller negativt nul.
Hvis resultatet af en matematisk handling er for stort til destinationsformatet, bliver resultatet af handlingen positiv uendelighed eller negativ uendelighed.
Hvis en matematisk handling er ugyldig, bliver resultatet af handlingen NaN.
Hvis en eller begge operander for en handling med flydende tal er NaN, bliver resultatet af handlingen NaN.
Følgende operatorer er defineret for talværdier:
Operator | Resultat |
---|---|
x > y |
Større end |
x >= y |
Større end eller lig med |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x = y |
Lig med |
x <> y |
Ikke lig med |
x + y |
Sum |
x - y |
Difference |
x * y |
Produkt |
x / y |
Kvotient |
x ?? y |
Coalesce |
+x |
Monadisk plus |
-x |
Negation |
Den oprindelige type af talværdier er den indbyggede type number
.
En klokkeslætsværdi gemmer en uigennemsigtig repræsentation af klokkeslæt på dagen. Et klokkeslæt kodes som antallet af akser siden midnat, hvilket tæller antallet af 100-nanosekunder akser, der er gået på et 24-timers ur. Det maksimale antal akser siden midnat svarer til 23:59:59.9999999 timer.
Selvom der ikke er nogen konstantsyntaks for gange, leveres der flere standardbiblioteksfunktioner til at konstruere dem. Klokkeslæt kan også oprettes ved hjælp af den indbyggede funktion #time
:
#time(hour, minute, second)
Følgende skal være i venteposition, eller der udløses en fejl med årsagskoden Expression.Error
:
0 ≤ time ≤ 24
0 ≤ minut ≤ 59 minutter
0 ≤ anden ≤ 59
Hvis time = 24, skal minut og sekund desuden være nul.
Følgende operatorer er defineret for klokkeslætsværdier:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x >= y |
Større end eller lig med |
x > y |
Større end |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x ?? y |
Coalesce |
Følgende operatorer tillader, at en eller begge operander er en dato:
Operator | Venstre operand | Højre operand | Betydning |
---|---|---|---|
x + y |
time |
duration |
Datoforskydning efter varighed |
x + y |
duration |
time |
Datoforskydning efter varighed |
x - y |
time |
duration |
Datoforskydning efter negeret varighed |
x - y |
time |
time |
Varighed mellem datoer |
x & y |
date |
time |
Flettet datetime |
Den oprindelige type af klokkeslætsværdier er den indbyggede type time
.
En datoværdi gemmer en uigennemsigtig repræsentation af en bestemt dag. En dato kodes som et antal dage siden epoken fra den 1. januar 0001 Common Era i den gregorianske kalender. Det maksimale antal dage siden epoken er 3652058, svarende til den 31. december 9999.
Selvom der ikke er nogen konstantsyntaks for datoer, leveres der flere standardbiblioteksfunktioner til at konstruere dem. Datoer kan også oprettes ved hjælp af den indbyggede funktion #date
:
#date(year, month, day)
Følgende skal være i venteposition, eller der udløses en fejl med årsagskoden Expression.Error
:
1 ≤ år ≤ 9999
1 ≤ måned ≤ 12
1 ≤ dag ≤ 31
Desuden skal dagen være gyldig for den valgte måned og det valgte år.
Følgende operatorer er defineret for datoværdier:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x >= y |
Større end eller lig med |
x > y |
Større end |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x ?? y |
Coalesce |
Følgende operatorer tillader, at en eller begge operander er en dato:
Operator | Venstre operand | Højre operand | Betydning |
---|---|---|---|
x + y |
date |
duration |
Datoforskydning efter varighed |
x + y |
duration |
date |
Datoforskydning efter varighed |
x - y |
date |
duration |
Datoforskydning efter negeret varighed |
x - y |
date |
date |
Varighed mellem datoer |
x & y |
date |
time |
Flettet datetime |
Den oprindelige type datoværdier er den indbyggede type date
.
En datetime-værdi indeholder både en dato og et klokkeslæt.
Selvom der ikke er nogen konstantsyntaks for datetimes, leveres der flere standardbiblioteksfunktioner til at konstruere dem. Datetimes kan også oprettes ved hjælp af den indbyggede funktion #datetime
:
#datetime(year, month, day, hour, minute, second)
Følgende skal være i venteposition, eller der udløses en fejl med årsagskoden Expression.Error: 1 ≤ år ≤ 9999
1 ≤ måned ≤ 12
1 ≤ dag ≤ 31
0 ≤ time ≤ 23
0 ≤ minut ≤ 59 minutter
0 ≤ anden ≤ 59
Desuden skal dagen være gyldig for den valgte måned og det valgte år.
Følgende operatorer er defineret for datetime-værdier:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x >= y |
Større end eller lig med |
x > y |
Større end |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x ?? y |
Coalesce |
Følgende operatorer tillader, at en eller begge operander er en datetime:
Operator | Venstre operand | Højre operand | Betydning |
---|---|---|---|
x + y |
datetime |
duration |
Datetime-forskydning efter varighed |
x + y |
duration |
datetime |
Datetime-forskydning efter varighed |
x - y |
datetime |
duration |
Datetime-forskydning efter negeret varighed |
x - y |
datetime |
datetime |
Varighed mellem datetimes |
Den oprindelige type af datetime-værdier er den indbyggede type datetime
.
En datetimezone-værdi indeholder en datetime og en tidszone. En tidszone kodes som et antal minutters forskydning fra UTC, som tæller antallet af minutter, hvor klokkeslætsdelen af datetime skal forskydes fra UTC (Universal Coordinated Time). Det mindste antal minutter, der forskydes fra UTC , er -840, hvilket repræsenterer en UTC-forskydning på -14:00 eller fjorten timer tidligere end UTC. Det maksimale antal minutter, der forskydes fra UTC , er 840, svarende til en UTC-forskydning på 14:00.
Selvom der ikke er nogen konstantsyntaks for datetimezones, leveres der flere standardbiblioteksfunktioner til at konstruere dem. Datetimezones kan også oprettes ved hjælp af den indbyggede funktion #datetimezone
:
#datetimezone(
year, month, day,
hour, minute, second,
offset-hours, offset-minutes)
Følgende skal være i venteposition, eller der udløses en fejl med årsagskoden Expression.Error
:
1 ≤ år ≤ 9999
1 ≤ måned ≤ 12
1 ≤ dag ≤ 31
0 ≤ time ≤ 23
0 ≤ minut ≤ 59 minutter
0 ≤ anden ≤ 59
-14 ≤ forskydningstimer ≤ 14
-59 ≤ forskydningsminutter ≤ 59
Desuden skal dagen være gyldig for den valgte måned og det valgte år, og hvis forskydningstimer = 14, skal forskydningsminutter <= 0 og, hvis forskydningstimer = -14, derefter forskydningsminutter >= 0.
Følgende operatorer er defineret for datetimezone-værdier:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x >= y |
Større end eller lig med |
x > y |
Større end |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x ?? y |
Coalesce |
Følgende operatorer tillader, at en eller begge operander er en datetimezone:
Operator | Venstre operand | Højre operand | Betydning |
---|---|---|---|
x + y |
datetimezone |
duration |
Datetimezone-forskydning efter varighed |
x + y |
duration |
datetimezone |
Datetimezone-forskydning efter varighed |
x - y |
datetimezone |
duration |
Datetimezone-forskydning efter negeret varighed |
x - y |
datetimezone |
datetimezone |
Varighed mellem datetimezones |
Den oprindelige type af datetimezone-værdier er den indbyggede type datetimezone
.
En varighedsværdi gemmer en uigennemsigtig repræsentation af afstanden mellem to punkter på en tidslinje, der måles med 100-nanosekunder-akser. Størrelsen af en varighed kan være enten positiv eller negativ, hvor positive værdier angiver status fremad i tiden og negative værdier, der angiver status bagud i tiden. Den mindste værdi, der kan gemmes i en varighed , er -9.223.372.036.854.775.808 akser eller 10.675.199 dage 2 timer og 48 minutter 05,4775808 sekunder bagud i tiden. Den maksimale værdi, der kan gemmes i en varighed , er 9.223.372.036.854.775.807 akser eller 10.675.199 dage 2 timer og 48 minutter 05,4775807 sekunder frem i tiden.
Selvom der ikke er nogen konstantsyntaks for varigheder, leveres der flere standardbiblioteksfunktioner til at konstruere dem. Varigheder kan også oprettes ved hjælp af den indbyggede funktion #duration
:
#duration(0, 0, 0, 5.5) // 5.5 seconds
#duration(0, 0, 0, -5.5) // -5.5 seconds
#duration(0, 0, 5, 30) // 5.5 minutes
#duration(0, 0, 5, -30) // 4.5 minutes
#duration(0, 24, 0, 0) // 1 day
#duration(1, 0, 0, 0) // 1 day
Følgende operatorer er defineret for varighedsværdier:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x >= y |
Større end eller lig med |
x > y |
Større end |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x ?? y |
Coalesce |
Desuden tillader følgende operatorer, at en eller begge operander er en varighedsværdi:
Operator | Venstre operand | Højre operand | Betydning |
---|---|---|---|
x + y |
datetime |
duration |
Datetime-forskydning efter varighed |
x + y |
duration |
datetime |
Datetime-forskydning efter varighed |
x + y |
duration |
duration |
Sum af varigheder |
x - y |
datetime |
duration |
Datetime-forskydning efter negeret varighed |
x - y |
datetime |
datetime |
Varighed mellem datetimes |
x - y |
duration |
duration |
Forskel på varigheder |
x * y |
duration |
number |
N gange en varighed |
x * y |
number |
duration |
N gange en varighed |
x / y |
duration |
number |
Brøkdel af en varighed |
Den oprindelige type af varighedsværdier er den indbyggede type duration
.
En tekstværdi repræsenterer en sekvens af Unicode-tegn. Tekstværdier har en konstant form, der er i overensstemmelse med følgende grammatik:
_text-konstant:
"
text-literal-charactersopt "
text-literal-characters:
text-literal-character text-literal-charactersopt
text-literal-character:
enkelt-tekst-tegn
character-escape-sequence
double-quote-escape-sequence
enkelt-tekst-tegn:
Alle tegn undtagen "
(U+0022
) eller #
(U+0023
) efterfulgt af (
(U+0028
)
double-quote-escape-sequence:
""
(U+0022
, U+0022
)
Følgende er et eksempel på en tekstværdi :
"ABC" // the text value ABC
Følgende operatorer er defineret for tekstværdier :
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x >= y |
Større end eller lig med |
x > y |
Større end |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x & y |
Sammenkædning |
x ?? y |
Coalesce |
Den oprindelige type tekstværdier er den indbyggede type text
.
En binær værdi repræsenterer en sekvens af byte.
Selvom der ikke er nogen konstantsyntaks for binære værdier, leveres der flere standardbiblioteksfunktioner til at konstruere dem. Binære værdier kan også oprettes ved hjælp af den indbyggede funktion #binary
.
I følgende eksempel konstrueres en binær værdi ud fra en liste over byte:
#binary( {0x00, 0x01, 0x02, 0x03} )
Følgende operatorer er defineret for binære værdier:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x >= y |
Større end eller lig med |
x > y |
Større end |
x < y |
Mindre end |
x <= y |
Mindre end eller lig med |
x ?? y |
Coalesce |
Den oprindelige type binære værdier er den indbyggede type binær.
En listeværdi er en værdi, der opretter en sekvens af værdier, når den optæles. En værdi, der er produceret af en liste, kan indeholde alle typer værdier, herunder en liste. Lister kan oprettes ved hjælp af initialiseringssyntaksen på følgende måde:
list-expression:
{ elementlisteopt }
elementliste:
vare
elementelementliste ,
vare:
udtryk
udtryksudtryk..
Følgende er et eksempel på et listeudtryk, der definerer en liste med tre tekstværdier: "A"
, og ."C"
"B"
{"A", "B", "C"}
Værdien "A"
er det første element på listen, og værdien "C"
er det sidste element på listen.
- Elementerne på en liste evalueres ikke, før de åbnes.
- Mens listeværdier, der er oprettet ved hjælp af listesyntaksen, opretter elementer i den rækkefølge, de vises i elementlisten, kan lister, der returneres fra biblioteksfunktioner, producere et andet sæt eller et andet antal værdier, hver gang de optæles.
Hvis du vil medtage en sekvens af heltal på en liste, kan formularen a..b
bruges:
{ 1, 5..9, 11 } // { 1, 5, 6, 7, 8, 9, 11 }
Antallet af elementer på en liste, der kaldes antallet af lister, kan bestemmes ved hjælp af funktionen List.Count
.
List.Count({true, false}) // 2
List.Count({}) // 0
En liste kan have et uendeligt antal elementer. List.Count
for sådanne lister er udefineret og kan enten udløse en fejl eller ikke afslutte.
Hvis en liste ikke indeholder nogen elementer, kaldes den en tom liste. En tom liste skrives som:
{} // empty list
Følgende operatorer er defineret for lister:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x & y |
Concatenate |
x ?? y |
Coalesce |
Eksempler:
{1, 2} & {3, 4, 5} // {1, 2, 3, 4, 5}
{1, 2} = {1, 2} // true
{2, 1} <> {1, 2} // true
Den oprindelige type listeværdier er den indbyggede type list
, som angiver elementtypen any
.
En postværdi er en sorteret sekvens af felter. Et felt består af et feltnavn, som er en tekstværdi, der entydigt identificerer feltet i posten og en feltværdi. Feltværdien kan være en hvilken som helst værdi, herunder post. Poster kan oprettes ved hjælp af initialiseringssyntaks på følgende måde:
record-expression:
[
field-listopt ]
field-list:
mark
feltfeltliste,
mark:
field-name-udtryk=
field-name:
generalized-identifier
quoted-identifier
I følgende eksempel oprettes en post med et felt med navnet x
med værdien 1
og et felt med navnet y
med værdien 2
.
[ x = 1, y = 2 ]
I følgende eksempel konstrueres en post med et felt med a
navnet a med en indlejret postværdi. Den indlejrede post har et felt med navnet b
med værdien 2
.
[ a = [ b = 2 ] ]
Følgende gælder ved evaluering af et postudtryk:
Det udtryk, der er tildelt hvert feltnavn, bruges til at bestemme værdien af det tilknyttede felt.
Hvis det udtryk, der er tildelt et feltnavn, opretter en værdi, når det evalueres, bliver det værdien af feltet for den resulterende post.
Hvis det udtryk, der er tildelt et feltnavn, udløser en fejl, når det evalueres, registreres det faktum, at der opstod en fejl, sammen med feltet sammen med den fejlværdi, der blev udløst. Efterfølgende adgang til dette felt medfører, at der udløses en fejl igen med den registrerede fejlværdi.
Udtrykket evalueres kun i et miljø som det overordnede miljø med variabler, der er flettet med, og som svarer til værdien for hvert felt i posten, bortset fra det, der initialiseres.
En værdi i en post evalueres ikke, før det tilsvarende felt åbnes.
En værdi i en post evalueres højst én gang.
Resultatet af udtrykket er en postværdi med en tom metadatapost.
Rækkefølgen af felterne i posten er defineret af den rækkefølge, de vises i record-initializer-expression.
Hvert feltnavn, der er angivet, skal være entydigt i posten, eller det er en fejl. Navne sammenlignes ved hjælp af en sammenligning af ordenstal.
[ x = 1, x = 2 ] // error: field names must be unique
[ X = 1, x = 2 ] // OK
En post uden felter kaldes en tom post og skrives på følgende måde:
[] // empty record
Selvom rækkefølgen af felterne i en post ikke er vigtig, når du får adgang til et felt eller sammenligner to poster, er den vigtig i andre kontekster, f.eks. når felterne i en post optæles.
De samme to poster giver forskellige resultater, når felterne hentes:
Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ]
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]
Antallet af felter i en post kan bestemmes ved hjælp af Record.FieldCount
funktionen . Eksempler:
Record.FieldCount([ x = 1, y = 2 }) // 2
Record.FieldCount([]) // 0
Ud over at bruge syntaksen for [ ]
initialisering af poster kan poster oprettes ud fra en liste over værdier og en liste over feltnavne eller en posttype. Eksempler:
Record.FromList({1, 2}, {"a", "b"})
Ovenstående svarer til:
[ a = 1, b = 2 ]
Følgende operatorer er defineret for postværdier:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x & y |
Fletning |
x ?? y |
Coalesce |
Følgende eksempler illustrerer ovenstående operatorer. Bemærk, at postfletning bruger felterne fra højre operand til at tilsidesætte felter fra den venstre operand, hvis der er et overlap i feltnavne.
[ a = 1, b = 2 ] & [ c = 3 ] // [ a = 1, b = 2, c = 3 ]
[ a = 1, b = 2 ] & [ a = 3 ] // [ a = 3, b = 2 ]
[ a = 1, b = 2 ] = [ b = 2, a = 1 ] // true
[ a = 1, b = 2, c = 3 ] <> [ a = 1, b = 2 ] // true
Den oprindelige type postværdier er den indbyggede type record
, som angiver en åben tom liste over felter.
En tabelværdi er en sorteret rækkesekvens. En række er en sorteret sekvens af kolonneværdier. Tabellens type bestemmer længden af alle rækker i tabellen, navnene på tabellens kolonner, typerne af tabellens kolonner og strukturen af tabellens nøgler (hvis der er nogen).
Selvom der ikke er nogen konstantsyntaks for tabeller, leveres der flere standardbiblioteksfunktioner til at konstruere dem. Tabeller kan også oprettes ved hjælp af den indbyggede funktion #table
.
I følgende eksempel oprettes en tabel ud fra en liste over kolonnenavne og en liste over rækker. Den resulterende tabel indeholder to kolonner og type any
tre rækker.
#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})
#table
kan også bruges til at angive en komplet tabeltype:
#table(
type table [Digit = number, Name = text],
{{1,"one"}, {2,"two"}, {3,"three"}}
)
Her har den nye tabelværdi en tabeltype, der angiver kolonnenavne og kolonnetyper.
Følgende operatorer er defineret for tabelværdier:
Operator | Resultat |
---|---|
x = y |
Lig med |
x <> y |
Ikke lig med |
x & y |
Sammenkædning |
x ?? y |
Coalesce |
Tabelsammenkædning justerer kolonner med samme navn og udfyldes null
for kolonner, der kun vises i en af operandtabellerne. I følgende eksempel illustreres tabelsammenkædning:
#table({"A","B"}, {{1,2}})
& #table({"B","C"}, {{3,4}})
A | B | C |
---|---|---|
1 |
2 |
null |
null |
3 |
4 |
Den oprindelige type tabelværdier er en brugerdefineret tabeltype (afledt af den indbyggede type table
), der viser kolonnenavnene, angiver alle kolonnetyper, der skal være nogen, og som ikke har nogen nøgler. (Gå til Tabeltyper til detaljer om tabeltyper.)
En funktionsværdi er en værdi, der knytter et sæt argumenter til en enkelt værdi. Detaljerne om funktionsværdier er beskrevet i Functions.
En typeværdi er en værdi, der klassificerer andre værdier. Oplysningerne om typeværdier er beskrevet i Typer.