Värden

Ett värde är data som skapas genom att utvärdera ett uttryck. I det här avsnittet beskrivs de olika typerna av värden på M-språket. Varje typ av värde associeras med en literalsyntax, en uppsättning värden som är av den typen, en uppsättning operatorer som definierats över den uppsättningen värden och en inbyggd typ som är tillskriven nyligen konstruerade värden.

Variant	Literal
Null	null
Logisk	true    false
Antal	0    1    -1    1.5    2.3e-5
Tid	#time(09,15,00)
Datum	#date(2013,02,26)
DateTime	#datetime(2013,02,26, 09,15,00)
DateTimeZone	#datetimezone(2013,02,26, 09,15,00, 09,00)
Varaktighet	#duration(0,1,30,0)
Text	"hello"
Binär	#binary("AQID")
Lista	{1, 2, 3}
Post	[ A = 1, B = 2 ]
Tabell	#table({"X","Y"},{{0,1},{1,0}})
Funktion	(x) => x + 1
Typ	type { number }    type table [ A = any, B = text ]

Följande avsnitt beskriver varje värdetyp i detalj. Typer och typaskription definieras formellt i Typer. Funktionsvärden definieras i Functions. I följande avsnitt visas de operatorer som definierats för varje värdetyp och ger exempel. Den fullständiga definitionen av operatorsemantik följer i Operatorer.

Null

Ett null-värde används för att representera frånvaron av ett värde, eller ett värde med obestämd eller okänt tillstånd. Ett null-värde skrivs med hjälp av literalen null. Följande operatorer definieras för null-värden:

Operator	Result
x > y	Större än
x >= y	Större än eller lika med
x < y	Mindre än
x <= y	Mindre än eller lika med
x = y	Equal
x <> y	Not equal
x ?? y	Coalesce

Den interna typen av null värdet är den inbyggda typen null.

Logiskt

Ett logiskt värde används för booleska åtgärder som har värdet true eller false. Ett logiskt värde skrivs med hjälp av literalerna true och false. Följande operatorer definieras för logiska värden:

Operator	Result
x > y	Större än
x >= y	Större än eller lika med
x < y	Mindre än
x <= y	Mindre än eller lika med
x = y	Equal
x <> y	Not equal
x or y	Villkorsstyrd logisk OR
x ?? y	Coalesce
x and y	Villkorsstyrd logisk AND
not x	Logiskt INTE

Den interna typen av både logiska värden (true och false) är den inbyggda typen logical.

Antal

Ett talvärde används för numeriska och aritmetiska åtgärder. Följande är exempel på tallitraler:

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)

Ett tal representeras med minst precisionen för en Double (men kan behålla mer precision). Dubbelrepresentationen är kongruent med IEEE 64-bitars dubbelprecisionsstandard för binär flyttalsaritmetik definierad i [IEEE 754-2008]. (Den Dubbel representation har ett ungefärligt dynamiskt intervall från 5,0 x 10³²⁴ till 1,7 x 10³⁰⁸ med en precision på 15–16 siffror.)

Följande specialvärden anses också vara talvärden :

• Positiv noll och negativ nolla. I de flesta situationer fungerar positiv noll och negativ noll identiskt som det enkla värdet noll, men vissa åtgärder skiljer mellan de två.

• Positiv oändlighet (#infinity) och negativ oändlighet (-#infinity). Infinities produceras av sådana åtgärder som att dividera ett tal som inte är noll med noll. Till exempel 1.0 / 0.0 ger positiv oändlighet och -1.0 / 0.0 ger negativ oändlighet.

• Värdet Not-a-Number (#nan), ofta förkortat NaN. NaN skapas av ogiltiga flyttalsåtgärder, till exempel att dividera noll med noll.

Binära matematiska åtgärder utförs med hjälp av en precision. Precisionen avgör den domän som operanderna avrundas till och domänen där åtgärden utförs. I avsaknad av en uttryckligen angiven precision utförs sådana åtgärder med dubbel precision.

• Om resultatet av en matematisk åtgärd är för litet för målformatet blir resultatet av åtgärden positiv noll eller negativ nolla.

• Om resultatet av en matematisk åtgärd är för stort för målformatet blir resultatet av åtgärden positiv oändlighet eller negativ oändlighet.

• Om en matematisk åtgärd är ogiltig blir resultatet av åtgärden NaN.

• Om en eller båda operanderna i en flyttalsåtgärd är NaN blir resultatet av åtgärden NaN.

Följande operatorer definieras för talvärden:

Operator	Result
x > y	Större än
x >= y	Större än eller lika med
x < y	Mindre än
x <= y	Mindre än eller lika med
x = y	Equal
x <> y	Not equal
x + y	Sum
x - y	Differens
x * y	Produkt
x / y	Kvot
x ?? y	Coalesce
+x	Unary plus
-x	Negation

Den interna typen av talvärden är den inbyggda typen number.

Tid

Ett tidsvärde lagrar en ogenomskinlig representation av tid på dagen. En tid kodas som antalet fästingar sedan midnatt, vilket räknar antalet tick på 100 nanosekunder som har förflutit på en 24-timmarsklocka. Det maximala antalet tick sedan midnatt motsvarar 23:59:59,99999999 timmar.

Även om det inte finns någon literalsyntax för tider tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Tider kan också konstrueras med hjälp av den inbyggda funktionen #time:

#time(hour, minute, second)

Följande måste innehålla eller ett fel med orsakskoden Expression.Error genereras:

0 ≤ timme ≤ 24
0 ≤ minut ≤ 59
0 ≤ andra ≤ 59

Dessutom måste minut och sekund vara noll om timme = 24.

Följande operatorer definieras för tidsvärden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Större än eller lika med
x > y	Större än
x < y	Mindre än
x <= y	Mindre än eller lika med
x ?? y	Coalesce

Följande operatorer tillåter att en eller båda av deras operander är ett datum:

Operator	Vänster operand	Höger operand	Innebörd
x + y	time	duration	Datumförskjutning efter varaktighet
x + y	duration	time	Datumförskjutning efter varaktighet
x - y	time	duration	Datumförskjutning efter negerad varaktighet
x - y	time	time	Varaktighet mellan datum
x & y	date	time	Sammanfogad datetime

Den interna typen av tidsvärden är den inbyggda typen time.

Datum

Ett datumvärde lagrar en ogenomskinlig representation av en viss dag. Ett datum kodas som ett antal dagar sedan epoken, från och med den 1 januari 0001 common era i den gregorianska kalendern. Det maximala antalet dagar sedan epoken är 3652058, motsvarande 31 december 9999.

Även om det inte finns någon literal syntax för datum tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Datum kan också konstrueras med hjälp av den inbyggda funktionen #date:

#date(year, month, day)

Följande måste innehålla eller ett fel med orsakskoden Expression.Error genereras:

1 ≤ år ≤ 9999
1 ≤ månad ≤ 12
1 ≤ dag ≤ 31

Dessutom måste dagen vara giltig för den valda månaden och året.

Följande operatorer definieras för datumvärden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Större än eller lika med
x > y	Större än
x < y	Mindre än
x <= y	Mindre än eller lika med
x ?? y	Coalesce

Följande operatorer tillåter att en eller båda av deras operander är ett datum:

Operator	Vänster operand	Höger operand	Innebörd
x + y	date	duration	Datumförskjutning efter varaktighet
x + y	duration	date	Datumförskjutning efter varaktighet
x - y	date	duration	Datumförskjutning efter negerad varaktighet
x - y	date	date	Varaktighet mellan datum
x & y	date	time	Sammanfogad datetime

Den interna typen av datumvärden är den inbyggda typen date.

Datum/tid

Ett datetime-värde innehåller både ett datum och en tid.

Även om det inte finns någon literalsyntax för datetimes tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Datetimes kan också konstrueras med hjälp av den inbyggda funktionen #datetime:

#datetime(year, month, day, hour, minute, second)

Följande måste innehålla eller ett fel med orsakskoden Expression.Error is raised: 1 ≤ year ≤ 9999
1 ≤ månad ≤ 12
1 ≤ dag ≤ 31
0 ≤ timme ≤ 23
0 ≤ minut ≤ 59
0 ≤ andra ≤ 59

Dessutom måste dagen vara giltig för den valda månaden och året.

Följande operatorer definieras för datetime-värden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Större än eller lika med
x > y	Större än
x < y	Mindre än
x <= y	Mindre än eller lika med
x ?? y	Coalesce

Följande operatorer tillåter att en eller båda av deras operander är en datetime:

Operator	Vänster operand	Höger operand	Innebörd
x + y	datetime	duration	Datetime-förskjutning efter varaktighet
x + y	duration	datetime	Datetime-förskjutning efter varaktighet
x - y	datetime	duration	Datetime-förskjutning efter negerad varaktighet
x - y	datetime	datetime	Varaktighet mellan datetimes

Den interna typen av datetime-värden är den inbyggda typen datetime.

DateTimeZone

Ett datetimezone-värde innehåller en datetime och en tidszon. En tidszon kodas som ett antal minuters förskjutning från UTC, vilket räknar antalet minuter som tidsdelen av datetime ska förskjutas från UNIVERSAL Coordinated Time (UTC). Det minsta antalet minuter som förskjuts från UTC är -840, vilket representerar en UTC-förskjutning på -14:00 eller fjorton timmar tidigare än UTC. Det maximala antalet minuter förskjutning från UTC är 840, vilket motsvarar en UTC-förskjutning på 14:00.

Även om det inte finns någon literal syntax för datetimezones tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Datetimezones kan också konstrueras med hjälp av den inbyggda funktionen #datetimezone:

#datetimezone(
       year, month, day,
       hour, minute, second,
       offset-hours, offset-minutes)

Följande måste innehålla eller ett fel med orsakskoden Expression.Error genereras:

1 ≤ år ≤ 9999
1 ≤ månad ≤ 12
1 ≤ dag ≤ 31
0 ≤ timme ≤ 23
0 ≤ minut ≤ 59
0 ≤ andra ≤ 59
-14 ≤ förskjutningstimmar ≤ 14
-59 ≤ förskjutningsminuter ≤ 59

Dessutom måste dagen vara giltig för den valda månaden och året, och om offset-hours = 14, sedan offset-minutes <= 0 och, om offset-hours = -14, sedan offset-minutes >= 0.

Följande operatorer definieras för datetimezone-värden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Större än eller lika med
x > y	Större än
x < y	Mindre än
x <= y	Mindre än eller lika med
x ?? y	Coalesce

Följande operatorer tillåter att en eller båda av deras operander är en datetimezone:

Operator	Vänster operand	Höger operand	Innebörd
x + y	datetimezone	duration	Datetimezone-förskjutning efter varaktighet
x + y	duration	datetimezone	Datetimezone-förskjutning efter varaktighet
x - y	datetimezone	duration	Datetimezone-förskjutning efter negerad varaktighet
x - y	datetimezone	datetimezone	Varaktighet mellan datetimezones

Den interna typen av datetimezone-värden är den inbyggda typen datetimezone.

Varaktighet

Ett varaktighetsvärde lagrar en ogenomskinlig representation av avståndet mellan två punkter på en tidslinje som mäts med tick på 100 nanosekunder. Varaktighetens omfattning kan vara antingen positiv eller negativ, med positiva värden som anger förlopp framåt i tiden och negativa värden som anger förloppet bakåt i tiden. Det minsta värde som kan lagras under en varaktighet är -9 223 372 036 854 775 808 tick eller 10 675 199 dagar 2 timmar 48 minuter 05,4775808 sekunder bakåt i tiden. Det maximala värdet som kan lagras under en varaktighet är 9 223 372 036 854 775 807 tick, eller 10 675 199 dagar 2 timmar 48 minuter 05,4775807 sekunder framåt i tiden.

Även om det inte finns någon literalsyntax för varaktigheter tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Varaktigheter kan också konstrueras med hjälp av den inbyggda funktionen #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öljande operatorer definieras för varaktighetsvärden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Större än eller lika med
x > y	Större än
x < y	Mindre än
x <= y	Mindre än eller lika med
x ?? y	Coalesce

Dessutom tillåter följande operatorer att en eller båda av deras operander är ett varaktighetsvärde:

Operator	Vänster operand	Höger operand	Innebörd
x + y	datetime	duration	Datetime-förskjutning efter varaktighet
x + y	duration	datetime	Datetime-förskjutning efter varaktighet
x + y	duration	duration	Summa av varaktigheter
x - y	datetime	duration	Datetime-förskjutning efter negerad varaktighet
x - y	datetime	datetime	Varaktighet mellan datetimes
x - y	duration	duration	Skillnad mellan varaktigheter
x * y	duration	number	N gånger en varaktighet
x * y	number	duration	N gånger en varaktighet
x / y	duration	number	Del av en varaktighet

Den interna typen av varaktighetsvärden är den inbyggda typen duration.

Text

Ett textvärde representerar en sekvens med Unicode-tecken. Textvärden har en literal form som överensstämmer med följande grammatik:

_text-literal:
      " text-literal-characters_opt "
text-literal-characters:
      text-literal-character text-literal-characters_opt
text-literal-character:
      single-text-character
      character-escape-sequence
      double-quote-escape-sequence
single-text-character:
      Alla tecken utom " (U+0022) eller # (U+0023) följt av ( (U+0028)
double-quote-escape-sequence:
      "" (U+0022, U+0022)

Följande är ett exempel på ett textvärde :

"ABC" // the text value ABC

Följande operatorer definieras för textvärden :

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Större än eller lika med
x > y	Större än
x < y	Mindre än
x <= y	Mindre än eller lika med
x & y	Sammanfogning
x ?? y	Coalesce

Den interna typen av textvärden är den inbyggda typen text.

Binära

Ett binärt värde representerar en sekvens med byte.

Även om det inte finns någon literal syntax för binära värden tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Binära värden kan också konstrueras med hjälp av den inbyggda funktionen #binary.

I följande exempel skapas ett binärt värde från en lista med byte:

#binary( {0x00, 0x01, 0x02, 0x03} )

Följande operatorer definieras för binära värden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Större än eller lika med
x > y	Större än
x < y	Mindre än
x <= y	Mindre än eller lika med
x ?? y	Coalesce

Den interna typen av binära värden är den inbyggda typen binär.

List

Ett listvärde är ett värde som skapar en sekvens med värden när de räknas upp. Ett värde som skapas av en lista kan innehålla alla typer av värden, inklusive en lista. Listor kan skapas med hjälp av initieringssyntaxen enligt följande:

listuttryck:
      { alternativ för objektlista}
item-list:
      sak
      objektobjektlista ,
sak:
      uttryck
      uttrycksuttryck..

Följande är ett exempel på ett listuttryck som definierar en lista med tre textvärden: "A", "B"och "C".

{"A", "B", "C"}

Värdet "A" är det första objektet i listan och värdet "C" är det sista objektet i listan.

• Objekten i en lista utvärderas inte förrän de har använts.
• Även om listvärden som skapas med hjälp av listsyntaxen skapar objekt i den ordning de visas i objektlistan, kan listor som returneras från biblioteksfunktioner i allmänhet generera en annan uppsättning eller ett annat antal värden varje gång de räknas upp.

Om du vill inkludera en sekvens med heltal i en lista kan formuläret a..b användas:

{ 1, 5..9, 11 }     // { 1, 5, 6, 7, 8, 9, 11 }

Antalet objekt i en lista, som kallas listantal, kan fastställas med hjälp av List.Count funktionen .

List.Count({true, false})  // 2 
List.Count({})             // 0

En lista kan i praktiken ha ett oändligt antal objekt. List.Count för sådana listor är odefinierat och kan antingen orsaka ett fel eller inte avslutas.

Om en lista inte innehåller några objekt kallas den för en tom lista. En tom lista skrivs som:

{}  // empty list

Följande operatorer definieras för listor:

Operator	Result
x = y	Equal
x <> y	Not equal
x & y	Concatenate
x ?? y	Coalesce

Till exempel:

{1, 2} & {3, 4, 5}   // {1, 2, 3, 4, 5} 
{1, 2} = {1, 2}      // true 
{2, 1} <> {1, 2}     // true

Den interna typen av listvärden är den inbyggda typen list, som anger en objekttyp av any.

Post

Ett postvärde är en ordnad sekvens med fält. Ett fält består av ett fältnamn, vilket är ett textvärde som unikt identifierar fältet i posten och ett fältvärde. Fältvärdet kan vara vilken typ av värde som helst, inklusive post. Poster kan konstrueras med hjälp av initieringssyntaxen enligt följande:

record-expression:
      [ val av fältlista ]
fältlista:
      fält
      fältfältlista,
fält:
      fältnamnsuttryck=
field-name:
      generalized-identifier
      quoted-identifier

I följande exempel skapas en post med ett fält med namnet x med värdet 1, och ett fält med namnet y med värdet 2.

[ x = 1, y = 2 ]

I följande exempel skapas en post med a fältet med namnet a med ett kapslat postvärde. Den kapslade posten har ett fält med namnet b med värdet 2.

[ a = [ b = 2 ] ]

Följande gäller vid utvärdering av ett postuttryck:

• Uttrycket som tilldelas varje fältnamn används för att fastställa värdet för det associerade fältet.

• Om uttrycket som tilldelas ett fältnamn genererar ett värde när det utvärderas blir det värdet för fältet för den resulterande posten.

• Om uttrycket som tilldelats ett fältnamn genererar ett fel när det utvärderas registreras det faktum att ett fel uppstod med fältet tillsammans med det felvärde som uppstod. Efterföljande åtkomst till fältet gör att ett fel genereras på nytt med det registrerade felvärdet.

• Uttrycket utvärderas i en miljö som den överordnade miljön endast med variabler sammanfogade i som motsvarar värdet för varje fält i posten, förutom den som initieras.

• Ett värde i en post utvärderas inte förrän motsvarande fält har använts.

• Ett värde i en post utvärderas högst en gång.

• Resultatet av uttrycket är ett postvärde med en tom metadatapost.

• Ordningen på fälten i posten definieras av den ordning som de visas i postinitieringsuttrycket.

• Varje fältnamn som anges måste vara unikt i posten, eller så är det ett fel. Namn jämförs med hjälp av en ordningstalsjämförelse.

    [ x = 1, x = 2 ] // error: field names must be unique 
    [ X = 1, x = 2 ] // OK

En post utan fält kallas för en tom post och skrivs på följande sätt:

[] // empty record

Även om ordningen på fälten i en post inte är betydande vid åtkomst till ett fält eller jämförelse av två poster, är det viktigt i andra sammanhang, till exempel när fälten i en post räknas upp.

Samma två poster ger olika resultat när fälten hämtas:

Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ] 
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]

Antalet fält i en post kan fastställas med hjälp av Record.FieldCount funktionen . Till exempel:

Record.FieldCount([ x = 1, y = 2 })  // 2 
Record.FieldCount([])                // 0

Förutom att använda syntaxen [ ]för postinitiering kan poster konstrueras från en lista med värden och en lista med fältnamn eller en posttyp. Till exempel:

Record.FromList({1, 2}, {"a", "b"})

Ovanstående motsvarar:

[ a = 1, b = 2 ]

Följande operatorer definieras för postvärden:

Operator	Result
x = y	Equal
x <> y	Not equal
x & y	Slå ihop
x ?? y	Coalesce

Följande exempel illustrerar operatorerna ovan. Observera att sammanslagning av poster använder fälten från den högra operanden för att åsidosätta fält från den vänstra operanden, om det skulle finnas en överlappning i fältnamnen.

[ 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 interna typen av postvärden är den inbyggda typen record, som anger en öppen tom lista med fält.

Register

Ett tabellvärde är en ordnad sekvens med rader. En rad är en ordnad sekvens med kolumnvärden. Tabellens typ avgör längden på alla rader i tabellen, namnen på tabellens kolumner, typerna av tabellens kolumner och strukturen för tabellens nycklar (om någon).

Även om det inte finns någon literalsyntax för tabeller tillhandahålls flera standardbiblioteksfunktioner för att konstruera dem. Tabeller kan också konstrueras med hjälp av den inbyggda funktionen #table.

I följande exempel skapas en tabell från en lista med kolumnnamn och en lista med rader. Den resulterande tabellen innehåller två kolumner med type any och tre rader.

#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})

#table kan också användas för att ange en fullständig tabelltyp:

#table(
    type table [Digit = number, Name = text],  
    {{1,"one"}, {2,"two"}, {3,"three"}} 
    )

Här har det nya tabellvärdet en tabelltyp som anger kolumnnamn och kolumntyper.

Följande operatorer definieras för tabellvärden:

Operator	Result
x = y	Equal
x <> y	Not equal
x & y	Sammanfogning
x ?? y	Coalesce

Tabellsammanfogning justerar kolumner med samma namn och fyller i null för kolumner som endast visas i en av operandtabellerna. I följande exempel visas tabellsammanfogning:

  #table({"A","B"}, {{1,2}}) 
& #table({"B","C"}, {{3,4}})

A	B	C
1	2	null
null	3	4

Den interna typen av tabellvärden är en anpassad tabelltyp (härledd från den inbyggda typen table) som visar kolumnnamnen, anger att alla kolumntyper ska vara valfria och inte har några nycklar. (Gå till Tabelltyper för information om tabelltyper.)

Funktion

Ett funktionsvärde är ett värde som mappar en uppsättning argument till ett enda värde. Information om funktionsvärden beskrivs i Functions.

Typ

Ett typvärde är ett värde som klassificerar andra värden. Information om typvärden beskrivs i Typer.