Értékek

Az érték egy kifejezés kiértékelésével előállított adat. Ez a szakasz az M nyelv értékeit ismerteti. Minden értéktípushoz tartozik egy literális szintaxis, egy ilyen típusú értékek készlete, az adott értékkészleten definiált operátorok készlete, valamint az újonnan létrehozott értékekhez írt belső típus.

Altípus	Szó
Null	null
Logikai	true    false
Szám	0    1    -1    1.5    2.3e-5
Idő	#time(09,15,00)
Dátum	#date(2013,02,26)
Datetime	#datetime(2013,02,26, 09,15,00)
DateTimeZone	#datetimezone(2013,02,26, 09,15,00, 09,00)
Időtartam	#duration(0,1,30,0)
Szöveg	"hello"
Bináris	#binary("AQID")
Lista	{1, 2, 3}
Rekord	[ A = 1, B = 2 ]
Table	#table({"X","Y"},{{0,1},{1,0}})
Funkció	(x) => x + 1
Típus	type { number }    type table [ A = any, B = text ]

Az alábbi szakaszok részletesen ismertetik az egyes értéktípusokat. A típusok és a típusleírók formálisan a típusok között vannak definiálva. A függvényértékek a Functionsben vannak definiálva. Az alábbi szakaszok felsorolják az egyes értékfajtákhoz definiált operátorokat, és példákat mutatnak be. Az operátor szemantikájának teljes definíciója az Operátorok területen található.

Null

A null érték egy érték hiányának, illetve határozatlan vagy ismeretlen állapotú értéknek a megjelenítésére szolgál. A függvény null értéket ír a literál nullhasználatával. A null értékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x > y	Nagyobb mint
x >= y	Nagyobb vagy egyenlő
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x = y	Egyenlő
x <> y	Nem egyenlő
x ?? y	Coalesce

Az érték natív típusa null a belső típus null.

Logikai

Logikai érték a logikai műveletekhez igaz vagy hamis értékkel rendelkezik. A logikai érték a literálok true és falsea . A logikai értékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x > y	Nagyobb mint
x >= y	Nagyobb vagy egyenlő
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x = y	Egyenlő
x <> y	Nem egyenlő
x or y	Feltételes logikai VAGY
x ?? y	Coalesce
x and y	Feltételes logikai ÉS
not x	Logikai NEM

A logikai értékek (true és false) natív típusa a belső típus logical.

Szám

Numerikus és aritmetikai műveletekhez számértéket használunk. Az alábbi példák számkonstansokra mutatnak be példákat:

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)

Egy szám legalább a dupla pontosságával jelenik meg (de nagyobb pontosságot is megtarthat). A kettős ábrázolás az [I Enterprise kiadás E 754-2008] alatt meghatározott bináris lebegőpontos aritmetika I Enterprise kiadás E 64 bites dupla pontosságú szabványával egybeesik. (A A kettős ábrázolás körülbelül 5,0 x 10³²⁴ és 1,7 x 10³⁰⁸ közötti dinamikus tartományt biztosít 15-16 számjegy pontossággal.)

A következő különleges értékek számértéknek is tekinthetők:

• Pozitív nulla és negatív nulla. A legtöbb esetben a pozitív nulla és a negatív nulla ugyanúgy viselkedik, mint az egyszerű nulla érték, de bizonyos műveletek megkülönböztetik a kettőt.

• Pozitív végtelen (#infinity) és negatív végtelen (-#infinity). A végteleneket olyan műveletek állítják elő, mint a nem nulla szám nullával való osztása. Például 1.0 / 0.0 pozitív végtelent ad, és -1.0 / 0.0 negatív végtelent ad.

• A Nem-a-Szám érték (#nan), gyakran rövidítve NaN. A naN-okat érvénytelen lebegőpontos műveletek állítják elő, például a nullát nullával osztják el.

A bináris matematikai műveleteket pontosság használatával hajtjuk végre. A pontosság határozza meg azt a tartományt, amelyre az operandusok kerekítve vannak, és azt a tartományt, amelyben a műveletet végrehajtják. Explicit pontosság hiányában az ilyen műveleteket dupla pontosság használatával hajtják végre.

• Ha egy matematikai művelet eredménye túl kicsi a célformátumhoz, a művelet eredménye pozitív nulla vagy negatív nulla lesz.

• Ha egy matematikai művelet eredménye túl nagy a célformátumhoz, a művelet eredménye pozitív végtelenné vagy negatív végtelenné válik.

• Ha egy matematikai művelet érvénytelen, a művelet eredménye NaN lesz.

• Ha egy lebegőpontos művelet egyik vagy mindkét operandusa NaN, a művelet eredménye NaN lesz.

A számértékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x > y	Nagyobb mint
x >= y	Nagyobb vagy egyenlő
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x = y	Egyenlő
x <> y	Nem egyenlő
x + y	Összeg
x - y	Különbség
x * y	Termék
x / y	Hányados
x ?? y	Coalesce
+x	Unary plus
-x	Tagadás

A számértékek natív típusa a belső típus number.

Idő

Az időértékek a napidő átlátszatlan ábrázolását tárolják. Az idő éjfél óta a kullancsok számaként van kódolva, ami a 24 órás idő alatt eltelt 100 nanoszekundumos kullancsok számát számítja. Az éjfél óta engedélyezett kullancsok maximális száma 23:59:59.99999999 óra.

Bár az időkhöz nincs konstans szintaxis, több szabványos kódtárfüggvény is rendelkezésre áll az összeállításukhoz. Az időpontok a belső függvény #timehasználatával is létrehozhatók:

#time(hour, minute, second)

A következőknek meg kell tartaniuk, vagy hiba lép fel az okkóddal Expression.Error :

0 ≤ óra ≤ 24
0 ≤ perc ≤ 59
0 ≤ második ≤ 59

Ezenkívül, ha óra = 24, akkor a percnek és a másodpercnek nullának kell lennie.

Az időértékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x >= y	Nagyobb vagy egyenlő
x > y	Nagyobb mint
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x ?? y	Coalesce

A következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandus dátum legyen:

Operátor	Bal operandus	Jobb operandus	Értelmezés
x + y	time	duration	Dátum eltolása időtartam szerint
x + y	duration	time	Dátum eltolása időtartam szerint
x - y	time	duration	Dátum eltolása nem módosított időtartammal
x - y	time	time	Dátumok közötti időtartam
x & y	date	time	Egyesített dátum/idő

Az időértékek natív típusa a belső típus time.

Date

A dátumértékek egy adott nap átlátszatlan ábrázolását tárolják. A dátumot a korszak óta eltelt napok számaként kódoljuk, a Gergely-naptárban 0001. január 1-től kezdődően. A korszak óta eltelt napok maximális száma 3652058, amely 9999. december 31-nek felel meg.

Bár a dátumok nem konstans szintaxist adnak meg, több szabványos kódtárfüggvény is rendelkezésre áll az összeállításukhoz. A dátumok a belső függvény #datehasználatával is létrehozhatók:

#date(year, month, day)

A következőknek meg kell tartaniuk, vagy hiba lép fel az okkóddal Expression.Error :

1 ≤ év ≤ 9999
1 ≤ hónap ≤ 12
1 ≤ nap ≤ 31

Emellett a napnak érvényesnek kell lennie a kiválasztott hónapra és évre.

A dátumértékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x >= y	Nagyobb vagy egyenlő
x > y	Nagyobb mint
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x ?? y	Coalesce

A következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandus dátum legyen:

Operátor	Bal operandus	Jobb operandus	Értelmezés
x + y	date	duration	Dátum eltolása időtartam szerint
x + y	duration	date	Dátum eltolása időtartam szerint
x - y	date	duration	Dátum eltolása nem módosított időtartammal
x - y	date	date	Dátumok közötti időtartam
x & y	date	time	Egyesített dátum/idő

A dátumértékek natív típusa a belső típus date.

Dátum/idő

A dátum/idő érték dátumot és időt is tartalmaz.

Bár a dátumidőkhöz nincs konstans szintaxis, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. A datetime-ok a belső függvény #datetimehasználatával is létrehozhatók:

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

A kifejezés.hiba okkóddal a következőnek kell tartania vagy hibát kell tartalmaznia: 1 ≤ év ≤ 9999
1 ≤ hónap ≤ 12
1 ≤ nap ≤ 31
0 ≤ óra ≤ 23
0 ≤ perc ≤ 59
0 ≤ második ≤ 59

Emellett a napnak érvényesnek kell lennie a kiválasztott hónapra és évre.

A dátum/idő értékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x >= y	Nagyobb vagy egyenlő
x > y	Nagyobb mint
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x ?? y	Coalesce

A következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandus dátumidő legyen:

Operátor	Bal operandus	Jobb operandus	Értelmezés
x + y	datetime	duration	Dátum/idő eltolás időtartam szerint
x + y	duration	datetime	Dátum/idő eltolás időtartam szerint
x - y	datetime	duration	Dátum/idő eltolás negatív időtartammal
x - y	datetime	datetime	Dátum/idő közötti időtartam

A datetime értékek natív típusa a belső típus datetime.

DateTimeZone

A datetimezone érték dátumot és időzónát tartalmaz. Az időzónák az UTC-től számított percek számának eltolásaként lesznek kódolva, amely megszámolja, hogy a dátumidő időrészét hány percnek kell eltolnia az egyetemes koordinált időtől (UTC). Az UTC-től minimálisan eltolt percek száma -840, amely -14:00 utc-eltolást vagy az UTC-nél tizennély órával korábbi UTC-eltolást jelent. Az UTC-től eltolt percek maximális száma 840, amely 14:00 UTC-eltolásnak felel meg.

Bár a datetimezoneshez nincs konstansszintaxis, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. A datetimezonok a belső függvény #datetimezonehasználatával is létrehozhatók:

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

A következőknek meg kell tartaniuk, vagy hiba lép fel az okkóddal Expression.Error :

1 ≤ év ≤ 9999
1 ≤ hónap ≤ 12
1 ≤ nap ≤ 31
0 ≤ óra ≤ 23
0 ≤ perc ≤ 59
0 ≤ második ≤ 59
-14 ≤ eltolási idő ≤ 14
-59 ≤ eltolási perc ≤ 59

Ezenkívül a napnak érvényesnek kell lennie a kiválasztott hónapra és évre, és ha eltolás-óra = 14, akkor eltolás-perc <= 0, és ha eltolás-óra = -14, akkor eltolási perc >= 0.

A datetimezone értékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x >= y	Nagyobb vagy egyenlő
x > y	Nagyobb mint
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x ?? y	Coalesce

A következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandus dátum/időzón legyen:

Operátor	Bal operandus	Jobb operandus	Értelmezés
x + y	datetimezone	duration	Datetimezone eltolás időtartam szerint
x + y	duration	datetimezone	Datetimezone eltolás időtartam szerint
x - y	datetimezone	duration	Datetimezone eltolása nem meghatározott időtartammal
x - y	datetimezone	datetimezone	Dátum/időzónák közötti időtartam

A datetimezone értékek natív típusa a belső típus datetimezone.

Időtartam

Az időtartamértékek egy 100 nanoszekundumos idővonal két pontja közötti távolság átlátszatlan ábrázolását tárolják. Az időtartam nagysága lehet pozitív vagy negatív, a pozitív értékek pedig az előrehaladás előrehaladtát jelzik az időben, a negatív értékek pedig az idő előrehaladtával. Az időtartamban tárolható minimális érték -9 223 372 036 854 775 808 kullancs, vagy 10 675 199 nap 2 óra 48 perc 05.4775808 másodperc hátrafelé az időben. Az időtartamban tárolható maximális érték 9 223 372 036 854 775 807 kullancs, vagy 10 675 199 nap 2 óra 48 perc 05.4775807 másodperces időrés.

Bár az időtartamok nem konstans szintaxist adnak meg, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. Az időtartamok a belső függvény #durationhasználatával is létrehozhatók:

#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

Az időtartamértékeken a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x >= y	Nagyobb vagy egyenlő
x > y	Nagyobb mint
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x ?? y	Coalesce

Emellett a következő operátorok lehetővé teszik, hogy az egyik vagy mindkét operandusuk időtartamérték legyen:

Operátor	Bal operandus	Jobb operandus	Értelmezés
x + y	datetime	duration	Dátum/idő eltolás időtartam szerint
x + y	duration	datetime	Dátum/idő eltolás időtartam szerint
x + y	duration	duration	Időtartamok összege
x - y	datetime	duration	Dátum/idő eltolás negatív időtartammal
x - y	datetime	datetime	Dátum/idő közötti időtartam
x - y	duration	duration	Időtartamok különbsége
x * y	duration	number	Időtartam n-szerese
x * y	number	duration	Időtartam n-szerese
x / y	duration	number	Időtartam töredéke

Az időtartamértékek natív típusa a belső típus duration.

SMS

A szöveges érték Unicode-karakterek sorozatát jelöli. A szöveges értékek a következő nyelvhelyességnek megfelelő konstans formátumúak:

_text-literál:
      " szövegkonstans karakterek_opt"
szövegkonstans karakterek:
      szöveg-literál-karakter szöveg-literál-karakter_opt
szövegkonstans karakter:
      egy szöveges karakter
      karakter-escape-sequence
      dupla idézőjel-escape-sequence
egy szöveges karakter:
      Bármely karakter, kivéve " (U+0022) vagy # (U+0023) után ( (U+0028)
dupla idézőjel-escape-sorozat:
      "" (U+0022, U+0022)

Az alábbi példa egy szöveges értékre mutat be:

"ABC" // the text value ABC

A szövegértékeken a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x >= y	Nagyobb vagy egyenlő
x > y	Nagyobb mint
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x & y	Összeláncolás
x ?? y	Coalesce

A szöveges értékek natív típusa a belső típus text.

Bináris

A bináris értékek bájtok sorozatát jelölik.

Bár a bináris értékekhez nincs konstans szintaxis, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. A bináris értékek a belső függvény #binaryhasználatával is létrehozhatók.

Az alábbi példa bináris értéket hoz létre bájtok listájából:

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

A bináris értékeken a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x >= y	Nagyobb vagy egyenlő
x > y	Nagyobb mint
x < y	Kisebb mint
x <= y	Kisebb vagy egyenlő
x ?? y	Coalesce

A bináris értékek natív típusa a belső bináris típus.

List

A listaérték olyan érték, amely számbavételkor értéksorozatot hoz létre. A listák által előállított értékek bármilyen értéket tartalmazhatnak, beleértve a listát is. A listák az inicializálási szintaxissal hozhatók létre az alábbiak szerint:

listakifejezés:
      { item-list_opt }
elemlista:
      Cikk
      elemlista,
Cikk:
      Kifejezés
      kifejezés..

Az alábbi példa egy listakifejezésre , amely egy három szöveges értékkel rendelkező listát határoz meg: "A", "B"és "C".

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

Az érték "A" a lista első eleme, az érték "C" pedig a lista utolsó eleme.

• A lista elemei csak a hozzáférésük után lesznek kiértékelve.
• Bár a listaszintaxis használatával létrehozott listaértékek elemeket hoznak létre az elemlistában megjelenő sorrendben, a kódtárfüggvényekből visszaadott listák általában eltérő készletet vagy eltérő számú értéket eredményeznek minden egyes számbavételkor.

Ha egész számsorozatot szeretne felvenni egy listába, az a..b űrlap a következő módon használható:

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

A lista elemeinek száma( más néven listaszám) a List.Count függvény használatával határozható meg.

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

A listák gyakorlatilag végtelen számú elemből állhatnak; List.Count az ilyen listák nem definiáltak, és vagy hibát jeleznek, vagy nem fejeződnek be.

Ha egy lista nem tartalmaz elemeket, akkor üres listának nevezzük. Az üres lista a következőképpen íródik:

{}  // empty list

A listákhoz a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x & y	Concatenate
x ?? y	Coalesce

Például:

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

A listaértékek natív típusa a belső típus list, amely az elem típusát anyadja meg.

Rekord

A rekordérték a mezők rendezett sorozata. A mező egy mezőnévből áll, amely egy szöveges érték, amely egyedileg azonosítja a rekordon belüli mezőt, és egy mezőértéket. A mező értéke bármilyen típusú lehet, beleértve a rekordot is. A rekordok inicializálási szintaxissal hozhatók létre, az alábbiak szerint:

rekordkifejezés:
      [mezőlista_opt]
mezőlista:
      mező
      mezőlista,
Mező:
      mezőnév=kifejezés
mezőnév:
      generalized-identifier
      idézett azonosító

Az alábbi példa egy értéket tartalmazó x mezővel és egy értékkel 12elnevezett y mezővel rendelkező rekordot hoz létre.

[ x = 1, y = 2 ]

Az alábbi példa egy beágyazott rekordértékkel rendelkező mezővel rendelkező a rekordot hoz létre. A beágyazott rekordban egy érték 2nevű b mező található.

[ a = [ b = 2 ] ]

Rekordkifejezések kiértékelésekor a következők érvényesek:

• Az egyes mezőnevekhez rendelt kifejezés a társított mező értékének meghatározására szolgál.

• Ha a mezőnévhez rendelt kifejezés kiértékelésekor értéket hoz létre, akkor ez lesz az eredményül kapott rekord mezőjének értéke.

• Ha a mezőnévhez rendelt kifejezés hibát jelez a kiértékeléskor, akkor a rendszer rögzíti a hibát a mezővel együtt, valamint a felmerült hibaértéket. A mező későbbi elérése hibát okoz a rögzített hibaértékkel.

• A kifejezés kiértékelése a szülőkörnyezethez hasonló környezetben csak olyan változókkal történik, amelyek a rekord minden mezőjének értékének felelnek meg, kivéve az inicializálandót.

• A rekordban lévő értékeket a program csak a megfelelő mező eléréséig értékeli ki.

• A rekordban lévő értékek kiértékelése legfeljebb egyszer történik.

• A kifejezés eredménye egy üres metaadatrekordot tartalmazó rekordérték.

• A rekordon belüli mezők sorrendjét a rekord-initializer-kifejezésben megjelenő sorrend határozza meg.

• Minden megadott mezőnévnek egyedinek kell lennie a rekordon belül, vagy hiba. A nevek összehasonlítása sorszámos összehasonlítással történik.

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

A mezők nélküli rekordokat üres rekordnak nevezzük, és a következőképpen íródik:

[] // empty record

Bár egy rekord mezőinek sorrendje nem jelentős egy mező elérésekor vagy két rekord összehasonlításakor, más kontextusokban is jelentős, például a rekord mezőinek számbavételekor.

Ugyanez a két rekord eltérő eredményeket ad a mezők lekértésekor:

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

A rekord mezőinek száma a Record.FieldCount függvény használatával határozható meg. Például:

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

A rekord inicializálási szintaxisa [ ]mellett a rekordok értéklistából, mezőnevekből vagy rekordtípusból is létrehozhatóak. Például:

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

A fentiek egyenértékűek a következő értékeket:

[ a = 1, b = 2 ]

A rekordértékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x & y	Összefűzés
x ?? y	Coalesce

Az alábbi példák a fenti operátorokat szemléltetik. Vegye figyelembe, hogy a rekordegyesítés a jobb operandus mezőit használja a bal operandus mezőinek felülbírálásához, ha átfedés van a mezőnevekben.

[ 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

A rekordértékek natív típusa a belső típus record, amely a mezők nyitott üres listáját adja meg.

Tábla

A táblaérték a sorok rendezett sorozata. A sor oszlopértékek rendezett sorozata. A táblázat típusa határozza meg a tábla összes sorának hosszát, a tábla oszlopainak nevét, a tábla oszlopainak típusait és a tábla kulcsainak szerkezetét (ha van ilyen).

Bár a táblákhoz nincs konstans szintaxis, a rendszer számos szabványos kódtárfüggvényt biztosít az összeállításukhoz. A táblák a belső függvény #tablehasználatával is létrehozhatók.

Az alábbi példa egy táblázatot hoz létre az oszlopnevek és a sorok listájából. Az eredményként kapott táblázat két oszlopot type any és három sort tartalmaz.

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

#table teljes táblázattípus megadására is használható:

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

Itt az új táblaérték táblázattípussal rendelkezik, amely oszlopneveket és oszloptípusokat határoz meg.

A táblaértékekhez a következő operátorok vannak definiálva:

Operátor	Eredmény
x = y	Egyenlő
x <> y	Nem egyenlő
x & y	Összeláncolás
x ?? y	Coalesce

A táblázatösszefűzés a hasonló nevű oszlopokat igazítja, és kitölti null azokat az oszlopokat, amelyek csak az egyik operandus táblában jelennek meg. Az alábbi példa táblázatösszefűzést szemléltet:

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

A	B	C#
1	2	null
null	3	4

A táblaértékek natív típusa egy egyéni táblatípus (amely a belső típusból tableszármazik), amely felsorolja az oszlopneveket, megadja az összes oszloptípust, és nincs kulcsa. (Ugrás a Táblázattípusok a táblázattípusok részleteihez.)

Function

A függvényértékek olyan értékek, amelyek argumentumokat képeznek le egyetlen értékre. A függvényértékek részleteit a Functions ismerteti.

Típus

A típusérték olyan érték, amely más értékeket sorol be. A típusértékek részleteit a Típusok című témakörben találja.