Chování operátoru

Článek
12/12/2024

Tato část definuje chování různých operátorů jazyka M.

Priorita operátorů

Pokud výraz obsahuje více operátorů, priorita operátorů řídí pořadí, ve kterém jsou jednotlivé operátory vyhodnoceny. Výraz se například vyhodnotí jako x + y * z proto, x + (y * z) že * operátor má vyšší prioritu než binární + operátor. Priorita operátoru je stanovena definicí přidružené gramatické produkce. Výraz sčítání se například skládá z posloupnosti násobení výrazu odděleného operátory + nebo - operátory, takže operátory a + operátory mají - nižší prioritu * než operátory a / operátory.

K změně výchozího pořadí priority lze použít závorky a produkci výrazů .

parenthesized-expression:
( výraz)

Příklad:

1 + 2 * 3       // 7 
(1 + 2) * 3     // 9

Následující tabulka shrnuje operátory M a uvádí kategorie operátorů v pořadí podle priority od nejvyššího po nejnižší. Operátory ve stejné kategorii mají stejnou prioritu.

Kategorie	Expression	Popis
Primární	já @ já	Výraz identifikátoru
	(x)	Výraz závorek
	x[i]	Vyhledání
	x{y}	Přístup k položce
	x(...)	Vyvolání funkce
	{x, y, ...}	Inicializace seznamu
	[ i = x, ... ]	Inicializace záznamu
	...	Není implementováno
Unární	+ x	Identita
	- x	Negace
	`not` x	Logický operátor negace
Metadata	x`meta`y	Přidružení metadat
Multiplikativní	x * y	Násobení
Multiplikativní	x / y	Oddělení
Aditivní	x + y	Součet
Aditivní	x - y	Odčítání
Relační	x< y	Je menší než
	x > y	Je větší než
	x<= y	Menší než nebo rovno
	x >= y	Větší než nebo rovno
Rovnost	x = y	Je rovno
Rovnost	x<> y	Not equal
Kontrolní výraz typu	x`as`y	Je kompatibilní primitivní typ nebo chyba s možnou hodnotou null.
Shoda typu	x`is`y	Test, jestli kompatibilní primitivní typ s možnou hodnotou null
Logický operátor AND	x`and`y	Zkratové spojení
Logický operátor OR	x`or`y	Zkratová disjunkce
Coalesce	x`??`y	Operátor sjednocení s hodnotou Null

Operátory a metadata

Každá hodnota má přidruženou hodnotu záznamu, která může obsahovat další informace o hodnotě. Tento záznam se označuje jako záznam metadat pro hodnotu. Záznam metadat lze přidružit k jakémukoli druhu hodnoty, a to i null. Výsledkem takového přidružení je nová hodnota s danými metadaty.

Záznam metadat je jenom běžný záznam a může obsahovat všechna pole a hodnoty, které může běžný záznam obsahovat a sám má záznam metadat. Přidružení záznamu metadat k hodnotě je "nerušivé". Nezmění chování hodnoty při vyhodnocování s výjimkou těch, které explicitně kontrolují záznamy metadat.

Každá hodnota má výchozí záznam metadat, i když nebyla zadána. Výchozí záznam metadat je prázdný. Následující příklady ukazují přístup k záznamu metadat textové hodnoty pomocí Value.Metadata standardní funkce knihovny:

Value.Metadata( "Mozart" )   // []

Záznamy metadat se obvykle nezachovají , pokud se hodnota používá s operátorem nebo funkcí, která vytváří novou hodnotu. Pokud jsou například pomocí operátoru & zřetězeny dvě textové hodnoty, metadata výsledné textové hodnoty je prázdný záznam []. Následující výrazy jsou ekvivalentní:

"Amadeus " & ("Mozart" meta [ Rating = 5 ])  
"Amadeus " & "Mozart"

Standardní funkce Value.RemoveMetadata knihovny a Value.ReplaceMetadata lze je použít k odebrání všech metadat z hodnoty a k nahrazení metadat hodnoty (místo sloučení metadat do pravděpodobně existujících metadat).

Jediným operátorem, který vrací výsledky, které přenášejí metadata, je meta operátor.

Rekurzivní operátory strukturálně

Hodnoty mohou být cyklické. Příklad:

let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]

Jazyk M zpracovává cyklické hodnoty tím, že udržuje řadu záznamů, seznamů a tabulek opožděně. Pokus o vytvoření cyklické hodnoty, která nemá prospěch z vložených opožděných strukturovaných hodnot, přináší chybu:

[A=B, B=A] 
// [A = Error.Record("Expression.Error", 
//         "A cyclic reference was encountered during evaluation"), 
//  B = Error.Record("Expression.Error", 
//         "A cyclic reference was encountered during evaluation"), 
// ]

Některé operátory v jazyce M jsou definovány strukturální rekurzí. Rovnost záznamů a seznamů je například definována konjovovanou rovností odpovídajících polí záznamů a seznamů položek.

U necyklických hodnot při použití strukturální rekurze dojde k konečnému rozšíření hodnoty: sdílené vnořené hodnoty se budou opakovaně procházet, ale proces rekurze se vždy ukončí.

Cyklická hodnota má nekonečné rozšíření při použití strukturální rekurze. Sémantika jazyka M neposkytuje žádná zvláštní ubytování pro takové nekonečné rozšíření – pokus o porovnání cyklických hodnot pro rovnost, například, bude obvykle nedostatek prostředků a ukončí výjimečně.

Operátory výběru a projekce

Operátory výběru a projekce umožňují extrahovat data ze seznamu a hodnot záznamů.

Přístup k položce

Hodnotu lze vybrat ze seznamu nebo tabulky na základě nulové pozice v daném seznamu nebo tabulce pomocí výrazu item-access-expression.

item-access-expression:
      item-selection
      optional-item-selection
item-selection:
      primary-expression{item-selector}
optional-item-selection:
      primary-expression{item-selector} ?
item-selector:
      výraz

Výraz item-access-expressionx{y} vrátí:

Pro seznam x a číslo ypoložka seznamu x na pozici y. První položka seznamu se považuje za pořadový index nuly. Pokud požadovaná pozice v seznamu neexistuje, vyvolá se chyba.
Pro tabulku x a číslo y, řádek tabulky x na pozici y. První řádek tabulky se považuje za pořadový index nuly. Pokud požadovaná pozice v tabulce neexistuje, vyvolá se chyba.
Pro tabulku x a záznam yje řádek tabulky x , který odpovídá hodnotám polí záznamu y pro pole s názvy polí, které odpovídají odpovídajícím názvům sloupců tabulky. Pokud v tabulce není žádný jedinečný odpovídající řádek, vyvolá se chyba.

Příklad:

{"a","b","c"}{0}                        // "a" 
{1, [A=2], 3}{1}                        // [A=2] 
{true, false}{2}                        // error 
#table({"A","B"},{{0,1},{2,1}}){0}      // [A=0,B=1] 
#table({"A","B"},{{0,1},{2,1}}){[A=2]}  // [A=2,B=1]  
#table({"A","B"},{{0,1},{2,1}}){[B=3]}  // error 
#table({"A","B"},{{0,1},{2,1}}){[B=1]}  // error

Výraz item-access-také podporuje formulář x{y}?, který vrátí null , když pozice (nebo shoda) y v seznamu nebo tabulce xneexistuje . Pokud existuje více shod pro y, je stále vyvolána chyba.

Příklad:

{"a","b","c"}{0}?                       // "a" 
{1, [A=2], 3}{1}?                       // [A=2] 
{true, false}{2}?                       // null 
#table({"A","B"},{{0,1},{2,1}}){0}?     // [A=0,B=1] 
#table({"A","B"},{{0,1},{2,1}}){[A=2]}? // [A=2,B=1]  
#table({"A","B"},{{0,1},{2,1}}){[B=3]}? // null 
#table({"A","B"},{{0,1},{2,1}}){[B=1]}? // error

Přístup k položce nevynucuje vyhodnocení položek seznamu nebo tabulek, které jsou jiné než položky, ke které se přistupuje. Příklad:

{ error "a", 1, error "c"}{1}  // 1 
{ error "a", error "b"}{1}     // error "b"

Při vyhodnocování operátoru x{y} přístupu k položce platí následující:

Chyby vyvolané při vyhodnocování výrazů x nebo y se šíří.
Výraz x vytvoří seznam nebo hodnotu tabulky.
Výraz y vytvoří číselnou hodnotu, nebo pokud x vytvoří hodnotu tabulky, hodnotu záznamu.
Pokud y vytvoří číselnou hodnotu a hodnota y je záporná, vyvolá se chyba s kódem "Expression.Error" důvodu.
Pokud y vytvoří číselnou hodnotu a hodnota y je větší nebo rovna počtu x, je vyvolána chyba s kódem "Expression.Error" důvodu, pokud se nepoužije volitelný formulář x{y}? operátoru, v takovém případě se vrátí hodnota null .
Pokud x vytvoří hodnotu tabulky a y vytvoří hodnotu záznamu a neobsahuje žádné shody, yxvyvolá se chyba s kódem "Expression.Error" důvodu, pokud se nepoužije volitelný formulář x{y}? operátoru, v takovém případě se hodnota null vrátí.
Pokud x vytvoří hodnotu tabulky a y vytvoří hodnotu záznamu a existuje více shod pro y in x, vyvolá se chyba s kódem "Expression.Error" důvodu.

Během procesu výběru položky se nevyhodnocují žádné položky, které jsou na x pozici y . (U streamovaných seznamů nebo tabulek se položky nebo řádky předcházející dané pozici y přeskočí, což může způsobit jejich vyhodnocení v závislosti na zdroji seznamu nebo tabulky.)

Přístup k poli

Výraz field-access-expression slouží k výběru hodnoty ze záznamu nebo k promítnutí záznamu nebo tabulky do jednoho s menším počtem polí nebo sloupců.

field-access-expression:
      výběr polí
      implicitní výběr cílového pole
      projekce
      implicitní cílová projekce
výběr pole:
      primary-expression field-selector
selektor polí:
      required-field-selector
      optional-field-selector
required-field-selector:
       [ název pole]
optional-field-selector:
       [ název pole] ?
název pole:
      generalizovaný identifikátor
      quoted-identifier
implicit-target-field-selection:
      selektor polí
projekce:
      primární výraz required-projection
      primary-expression optional-projection
požadované projekce:
       [ required-selector-list]
volitelná projekce:
       [ required-selector-list] ?
required-selector-list:
      required-field-selector
      required-selector-list,required-field-selector
implicitní cílová projekce:
      požadované projekce
      volitelná projekce

Nejjednodušší forma přístupu k poli je povinná pro výběr polí. Pomocí operátoru x[y] vyhledá pole v záznamu podle názvu pole. Pokud pole y neexistuje x, vyvolá se chyba. Formulář x[y]? slouží k provedení volitelného výběru pole a vrátí null , pokud požadované pole v záznamu neexistuje.

Příklad:

[A=1,B=2][B]       // 2 
[A=1,B=2][C]       // error 
[A=1,B=2][C]?      // null

Operátory pro požadovanou projekci záznamu a volitelnou projekci záznamů podporují kolektivní přístup k více polím. Operátor x[[y1],[y2],...] prodá záznam do nového záznamu s menším počtem polí (vybraných pomocí y1, y2...). Pokud vybrané pole neexistuje, vyvolá se chyba. Operátor x[[y1],[y2],...]? prodá záznam do nového záznamu s poli vybranými y1hodnotou , y2...; pokud pole chybí, null použije se místo toho. Příklad:

[A=1,B=2][[B]]           // [B=2] 
[A=1,B=2][[C]]           // error 
[A=1,B=2][[B],[C]]?      // [B=2,C=null]

Formuláře [y] a [y]? jsou podporovány jako zkrácený odkaz na identifikátor _ (podtržítko). Následující dva výrazy jsou ekvivalentní:

[A]                 
_[A]

Následující příklad znázorňuje zkrácenou formu přístupu k poli:

let _ = [A=1,B=2] in [A] //1

[[y1],[y2],...] Formulář a [[y1],[y2],...]? jsou také podporovány jako zkratka a následující dva výrazy jsou podobně ekvivalentní:

[[A],[B]]                 
_[[A],[B]]

Zkrácený tvar je zvlášť užitečný v kombinaci s each zkratkou, způsob, jak zavést funkci jednoho parametru s názvem _ (podrobnosti viz zjednodušené deklarace). Obě zkratky společně zjednodušují běžné funkční výrazy vyššího řádu:

List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b]) 
// {[a=1, b=1]}

Výše uvedený výraz je ekvivalentní následujícímu šifrnějšímu dlouhému výrazu:

List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b]) 
// {[a=1, b=1]}

Přístup k poli nevynucuje vyhodnocení jiných polí, než ke které se přistupuje. Příklad:

[A=error "a", B=1, C=error "c"][B]  // 1 
[A=error "a", B=error "b"][B]       // error "b"

Při vyhodnocování operátoru x[y]přístupu k poli , x[y]?, x[[y]], nebo x[[y]]? je vyhodnocen následující:

Chyby vyvolané při vyhodnocování výrazu x se šíří.
Chyby vyvolané při vyhodnocování pole y jsou trvale přidruženy k poli ya následně se rozšíří. Jakýkoli budoucí přístup k poli y vyvolá stejnou chybu.
Výraz x vytvoří záznam nebo hodnotu tabulky nebo dojde k chybě.
Pokud identifikátor y pojmenuje pole, ve kterém neexistuje x, je vyvolána chyba s kódem "Expression.Error" důvodu, pokud není použit volitelný formulář ...? operátoru, v takovém případě se vrátí hodnota null .

Během procesu přístupu k polím se nevyhodnocují žádná pole x s jiným názvem, než y podle kterého se jmenuje.

Operátor metadat

Záznam metadat pro hodnotu se mění pomocí operátoru meta (x meta y).

výraz metadat:
unary-expression
unary-expressionmetaunary-expression

Následující příklad vytvoří textovou hodnotu se záznamem metadat pomocí meta operátoru a pak přistupuje k záznamu metadat výsledné hodnoty pomocí Value.Metadata:

Value.Metadata( "Mozart" meta [ Rating = 5 ] ) 
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating] 
// 5

Při použití operátoru x meta ykombinování metadat platí následující:

Chyby vyvolané při vyhodnocování x výrazů nebo y výrazů se šíří.
Výraz y musí být záznam nebo je vyvolána chyba s kódem "Expression.Error" důvodu.
Výsledný záznam metadat je xzáznam metadat sloučený s y. (Sémantika sloučení záznamů najdete v tématu Sloučení záznamů.)
Výsledná hodnota je hodnota z výrazu x bez jeho metadat s připojeným nově vypočítaným záznamem metadat.

x meta y  
Value.ReplaceMetadata(x, Value.Metadata(x) & y) 
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)

Operátory rovnosti

Operátor = rovnosti slouží k určení, zda jsou dvě hodnoty stejné. Operátor <> nerovnosti se používá k určení, jestli se dvě hodnoty nerovnají.

výraz rovnosti:
      relační výraz
      relational-expression=equality-expression
      relational-expression<>equality-expression

Příklad:

1 = 1            // true 
1 = 2            // false 
1 <> 1           // false 
1 <> 2           // true 
null = true      // false 
null = null      // true

Metadata nejsou součástí porovnání rovnosti nebo nerovnosti. Příklad:

(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true 
(1 meta [ a = 1 ]) = 1                  // true

Při použití operátorů x = yx <> yrovnosti platí následující:

Chyby vyvolané při vyhodnocování x výrazů nebo y výrazů se šíří.
Operátor = má výsledek true , jestli jsou hodnoty stejné, a false jinak.
Operátor <> má výsledek false , jestli jsou hodnoty stejné, a true jinak.
Záznamy metadat nejsou zahrnuty do porovnání.
Pokud hodnoty vytvořené vyhodnocením x výrazů y nejsou stejného typu hodnoty, hodnoty se nerovnají.
Pokud hodnoty vytvořené vyhodnocením x a y výrazem jsou stejného typu hodnoty, existují specifická pravidla pro určení, jestli jsou stejné, jak je definováno níže.
Toto je vždy pravdivé:

    (x = y) = not (x <> y)

Operátory rovnosti jsou definovány pro následující typy:

Hodnota null se rovná pouze sobě.

    null = null    // true 
    null = true    // false 
    null = false   // false

Logické hodnoty true se false rovnají pouze sobě. Příklad:

    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false

Čísla se porovnávají pomocí zadané přesnosti:
- Pokud je #nanněkteré z těchto čísel , nebudou čísla stejná.
- Pokud žádné číslo není #nan, pak se čísla porovnávají pomocí bitového porovnání číselné hodnoty.
- #nan je jediná hodnota, která se nerovná sama sobě.
  
  Příklad:

        1 = 1,              // true 
        1.0 = 1             // true 
        2 = 1               // false 
        #nan = #nan         // false 
        #nan <> #nan        // true

Dvě doby trvání jsou stejné, pokud představují stejný počet 100 nanosekundových tisekund.
Pokud se velikost jejich částí (hodina, minuta, sekunda) rovná dvěma časy.
Pokud jsou velikost jejich částí (rok, měsíc, den) stejná, jsou dvě kalendářní data rovna.
Dvě hodnoty datetime jsou stejné, pokud se velikost jejich částí (rok, měsíc, den, hodina, minuta, sekunda) rovná.
Pokud jsou odpovídající data a časy UTC stejné, jsou dvě zóny datetime rovny. Aby bylo dosaženo odpovídajícího data a času UTC, od komponenty datetimezone se odečte posun hodin a minut.
Dvě textové hodnoty jsou stejné, pokud používáte řadové porovnání nerozlišující velká a malá písmena a nerozlišují jazykovou verzi, mají stejnou délku a stejné znaky na odpovídajících pozicích.
Pokud jsou splněny všechny následující hodnoty, jsou dvě hodnoty seznamu stejné:
- Oba seznamy obsahují stejný počet položek.
- Hodnoty každé poziční položky v seznamech jsou stejné. To znamená, že seznamy musí obsahovat nejen stejné položky, ale i položky musí být ve stejném pořadí.
  
  Příklad:
```
  {1, 2} = {1, 2}     // true 
  {2, 1} = {1, 2}     // false 
  {1, 2, 3} = {1, 2}  // false
```
Pokud jsou splněny všechny následující záznamy, jsou dva záznamy stejné:
- Počet polí je stejný.
- Každý název pole jednoho záznamu se nachází také v druhém záznamu.
- Hodnota každého pole jednoho záznamu se rovná podobnému poli v druhém záznamu.
  
  Příklad:
```
  [ A = 1, B = 2 ] = [ A = 1, B = 2 ]        // true 
  [ B = 2, A = 1 ] = [ A = 1, B = 2 ]        // true 
  [ A = 1, B = 2, C = 3 ] = [ A = 1, B = 2 ] // false 
  [ A = 1 ] = [ A = 1, B = 2 ]               // false
```
Pokud jsou splněny všechny následující podmínky, jsou dvě tabulky stejné:
- Počet sloupců je stejný.
- Každý název sloupce v jedné tabulce se nachází také v druhé tabulce.
- Počet řádků je stejný.
- Každý řádek má stejné hodnoty v odpovídajících buňkách.
  
  Příklad:
```
  #table({"A","B"},{{1,2}}) = #table({"A","B"},{{1,2}}) // true 
  #table({"A","B"},{{1,2}}) = #table({"X","Y"},{{1,2}}) // false 
  #table({"A","B"},{{1,2}}) = #table({"B","A"},{{2,1}}) // true
```
Hodnota funkce se rovná sobě, ale může nebo nemusí být rovna jiné hodnotě funkce. Pokud jsou dvě hodnoty funkce považovány za stejné, budou se při vyvolání chovat stejně.

Dvě dané hodnoty funkce budou mít vždy stejný vztah rovnosti.
Hodnota typu se rovná sobě, ale může nebo nemusí být rovna jiné hodnotě typu. Pokud jsou dvě hodnoty typu považovány za stejné, budou se při dotazování na shodu chovat stejně.

Dvě zadané hodnoty typu budou mít vždy stejný vztah rovnosti.

Relační operátory

Operátory <, >, <=a >= jsou volána relační operátory.

relační výraz:
      additive-expression
      additive-expression<relational-expression
      additive-expression>relational-expression
      additive-expression<=relational-expression
      additive-expression>=relational-expression

Tyto operátory slouží k určení relativní relace řazení mezi dvěma hodnotami, jak je znázorněno v následující tabulce:

Operace	Výsledek
`x < y`	`true` pokud `x` je menší než `y`, `false` jinak
`x > y`	`true` pokud `x` je větší než `y`, `false` jinak
`x <= y`	`true` je-li `x` menší nebo rovna `y`, `false` jinak
`x >= y`	`true` je-li `x` větší nebo rovna `y`, `false` jinak

Příklad:

0 <= 1            // true 
null < 1          // null 
null <= null      // null 
"ab" < "abc"      // true 
#nan >= #nan      // false  
#nan <= #nan      // false

Při vyhodnocování výrazu obsahujícího relační operátory platí následující:

Chyby vyvolané při vyhodnocování výrazů operandu xy se šíří.
Hodnoty vytvořené vyhodnocením xy výrazů musí být binární, datum, datum, datetime, datetimezone, doba trvání, logická hodnota, číslo, null, text nebo časová hodnota. V opačném případě se vyvolá chyba s kódem "Expression.Error" důvodu.
Oba operandy musí být stejného typu hodnoty nebo null. V opačném případě se vyvolá chyba s kódem "Expression.Error" důvodu.
Pokud jsou nulloperandy nebo oba operandy , je null výsledkem hodnota.
Dva binární soubory se porovnávají bajty bajtů.
Dvě kalendářní data jsou porovnána porovnáním jejich částí roku, a pokud jsou stejné, jejich měsíční části a pokud jsou stejné, jejich denní části.
Dvě data a časy se porovnávají porovnáním jejich částí roku, a pokud jsou stejné, jejich části měsíce a, jsou-li stejné, jejich denní části a, pokud jsou stejné, jejich hodinové části a, pokud jsou stejné, jejich minutové části a, pokud jsou stejné, jejich druhé části.
Dvě datatimezone se porovnávají tak, že je normalizujete do UTC odečtením posunu za hodinu/minutu a následným porovnáním jejich součástí data a času.
Dvě doby trvání se porovnávají podle celkového počtu 100 nanosekundových ticků, které představují.
Dvě logické funkce se porovnávají tak, aby true byly považovány za větší než false.
Dvě čísla x a y porovnávají se podle pravidel standardu IEEE 754:
- Pokud je #nanněkterý z operandů , výsledek je false pro všechny relační operátory.
- Pokud žádný operand není #nan, operátory porovnávají hodnoty dvou operandů s plovoucí desetinnou čárkou s ohledem na pořadí, -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ kde min a max jsou nejmenší a největší kladné konečné hodnoty, které lze reprezentovat. Názvy M pro -∞ a +∞ jsou -#infinity a #infinity.
  
  Mezi efekty tohoto řazení patří:
  - Záporné a kladné nuly jsou považovány za stejné.
  - Hodnota -#infinity je považována za menší než všechny ostatní číselné hodnoty, ale rovna jiné -#infinity.
  - Hodnota #infinity je považována za větší než všechny ostatní číselné hodnoty, ale rovna jiné #infinity.
Dva texty se porovnávají pomocí řadových znaků, rozlišujících velká a malá písmena a nerozlišují se jazykové verze.
Dvakrát se porovnávají jejich hodinové části a pokud jsou stejné, jejich minutové části a pokud jsou stejné, jejich druhé části.

Podmíněné logické operátory

Operátory and a or operátory se nazývají podmíněné logické operátory.

logický nebo výraz:
      logical-and-expression
logical-and-expressionorlogical-or-expression
logický výraz:
      is-expression
      is-expressionandlogical-and-expression

Operátor or se vrátí true , pokud je alespoň jeden z jeho operandů true. Pravý operand je vyhodnocen, pokud a pouze pokud levý operand není true.

Operátor and se vrátí false , pokud je alespoň jeden z jeho operandů false. Pravý operand je vyhodnocen, pokud a pouze pokud levý operand není false.

Tabulky pravdy pro operátory or a and operátory jsou uvedeny níže, s výsledkem vyhodnocení levého výrazu operandu na svislé ose a výsledek vyhodnocení správného výrazu operandu na vodorovné ose.

`and`	`true`	`false`	`null`	`error`
`true`	`true`	`false`	`null`	`error`
`false`	`false`	`false`	`false`	`false`
`null`	`null`	`false`	`null`	`error`
`error`	`error`	`error`	`error`	`error`

`or`	`true`	`false`	`null`	`error`
`or`	`true`	`false`	`null`	`error`
`true`	`true`	`true`	`true`	`true`
`false`	`true`	`false`	`null`	`error`
`null`	`true`	`null`	`null`	`error`
`error`	`error`	`error`	`error`	`error`

Při vyhodnocování výrazu obsahujícího podmíněné logické operátory platí následující:

Chyby vyvolané při vyhodnocování x výrazů nebo y výrazů se šíří.
Podmíněné logické operátory jsou definovány nad typy logical a null. Pokud hodnoty operandu nejsou z těchto typů, vyvolá se chyba s kódem "Expression.Error" důvodu.
Výsledkem je logická hodnota.
Ve výrazu x nebo yse výraz y vyhodnotí, pokud a pouze v případě, že x se nevyhodnotí jako true.
Ve výrazu x a yvýraz y bude vyhodnocen, pokud a pouze v případě, že x se nevyhodnocuje na false.

Poslední dvě vlastnosti poskytují podmíněným logickým operátorům jejich "podmíněnou" kvalifikaci; vlastnosti se také označují jako "zkratové obvody". Tyto vlastnosti jsou užitečné při psaní kompaktních strážených predikátů. Například následující výrazy jsou ekvivalentní:

d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false

Aritmetické operátory

Operátory +, -*a / jsou aritmetické operátory.

additive-expression:
      multiplikativní výraz
      additive-expression+multiplicative-expression
      additive-expression-multiplicative-expression
multiplikativní výraz:
      metadata – výraz
      multiplicative-expression*metadata-expression
      multiplicative-expression/metadata-expression

Počet deset. míst

Čísla v jazyce M se ukládají pomocí různých reprezentací, aby se zachovalo co nejvíce informací o číslech pocházejících z různých zdrojů. Čísla jsou převedena pouze z jedné reprezentace na jinou podle potřeby operátory použitými na ně. V jazyce M jsou podporovány dvě přesnosti:

Počet deset. míst	Sémantika
`Precision.Decimal`	128bitové desetinné číslo s rozsahem ±1,0 x 10–28 až ±7,9 x 1028 a 28–29 významných číslic.
`Precision.Double`	Vědecké vyjádření pomocí mantisy a exponentu; odpovídá 64bitové binární dvojité přesnosti IEEE 754 aritmetické normě IEEE 754-2008.

Aritmetické operace se provádějí výběrem přesnosti, převodem obou operandů na danou přesnost (v případě potřeby), provedením skutečné operace a nakonec vrácením čísla ve zvolené přesnosti.

Předdefinované aritmetické operátory (+, -, *, /) používají dvojitou přesnost. Standardní funkce knihovny (Value.Add, Value.Subtract, Value.Multiply, Value.Divide) lze použít k vyžádání těchto operací pomocí konkrétního modelu přesnosti.

Není možný žádný číselný přetečení: #infinity nebo -#infinity představují hodnoty moc velké, aby bylo možné reprezentovat.
Není možný žádný číselný podtečení: 0 a -0 představují hodnoty moc malých, aby bylo možné reprezentovat.
Speciální hodnota #nan IEEE 754 (NaN – Not a Number) se používá k pokrytí aritmeticky neplatných případů, například dělení nuly nulou.
Převod z desetinné na dvojitou přesnost se provádí zaokrouhlením desetinných čísel na nejbližší ekvivalentní dvojitou hodnotu.
Převod z dvojité na desetinnou přesnost se provádí zaokrouhlením dvojitých čísel na nejbližší ekvivalentní desetinnou hodnotu a v případě potřeby přetečením na #infinity nebo -#infinity hodnoty.

operátor sčítání

Interpretace operátoru sčítání (x + y) závisí na druhu hodnoty vyhodnocených výrazů x a y následujícím způsobem:

linka	y	Výsledek	Interpretace
`type number`	`type number`	`type number`	Číselný součet
`type number`	`null`	`null`
`null`	`type number`	`null`
`type duration`	`type duration`	`type duration`	Číselný součet velikostí
`type duration`	`null`	`null`
`null`	`type duration`	`null`
`type` datetime	`type duration`	`type` datetime	Posun data a času podle doby trvání
`type duration`	`type` datetime	`type` datetime
`type` datetime	`null`	`null`
`null`	`type` datetime	`null`

V tabulce typepředstavuje datum a čas libovolnou z type datehodnot , type datetime, type datetimezonenebo type time. Při přidávání doby trvání a hodnoty určitého typu datetime je výsledná hodnota stejného typu.

U jiných kombinací hodnot, než jsou hodnoty uvedené v tabulce, je vyvolána chyba s kódem "Expression.Error" důvodu. Každá kombinace je popsána v následujících částech.

Chyby vyvolané při vyhodnocování jednoho operandu se rozšíří.

Číselný součet

Součet dvou čísel se vypočítá pomocí operátoru sčítání a vytvoří číslo.

Příklad:

1 + 1             // 2 
#nan + #infinity  // #nan

Operátor + sčítání nad čísly používá dvojitou přesnost. Funkci standardní knihovny Value.Add lze použít k určení desetinné přesnosti. Při výpočtu součtu čísel platí následující:

Součet dvojité přesnosti se vypočítá podle pravidel 64bitové binární dvojitéprecize IEEE 754 aritmetické IEEE 754-2008. Následující tabulka uvádí výsledky všech možných kombinací nenulových konečných hodnot, nul, infinit a naN. V tabulce x a y jsou nenulové konečné hodnoty a z je výsledkem x + y. Pokud x a y mají stejnou velikost, ale opačné znaky, z je kladná nula. Pokud x + y je příliš velký, aby byl reprezentován v cílovém typu, z je nekonečno se stejným znaménkem jako x + y.

+	y	+0	0 až	+∞	-∞	Není číslo
x	z	linka	linka	+∞	-∞	Není číslo
+0	y	+0	+0	+∞	-∞	Není číslo
-0	y	+0	0 až	+∞	-∞	Není číslo
+∞	+∞	+∞	+∞	+∞	Není číslo	Není číslo
-∞	-∞	-∞	-∞	Není číslo	-∞	Není číslo
Nan	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo

Součet v desetinné přesnosti se vypočítá bez ztráty přesnosti. Měřítko výsledku je větší z měřítka dvou operandů.

Součet dob trvání

Součet dvou dob trvání je doba trvání představující součet počtu 100nanosekundů, které představují doby trvání. Příklad:

#duration(2,1,0,15.1) + #duration(0,1,30,45.3) 
// #duration(2, 2, 31, 0.4)

Posun data a času podle doby trvání

Datum doba trvání x lze přidat pomocí y výpočtu nového x + y, jehož vzdálenost od lineární časové osy je přesně velikost x. V tomto případě je datetime zkratka pro libovolný z Date, DateTime, DateTimeZonenebo Time a nenulový výsledek bude stejného typu. Posun data a času podle doby trvání se dá vypočítat takto:

Pokud jsou zadány dny datetime od hodnoty epochy, vytvořte nový datetime s následujícími informačními prvky:
- Vypočítejte nové dny od epochy odpovídající rozdělení velikosti y počtem 100 nanosekundových klíštěte v období 24 hodin, zkrátí se desetinná část výsledku a přičte tuto hodnotu ke dnům x od epochy.
- Vypočítejte nová klíště od půlnoci, která odpovídá přidání velikosti y k od půlnoci x, modulo počet 100 nanosekundových ticků v 24hodinovém období. Pokud x nezadá hodnotu pro ticks od půlnoci, předpokládá se hodnota 0.
- Zkopírujte hodnotu x pro minuty posunu od UTC beze změny.
Pokud není zadána hodnota datetime od hodnoty epochy, vytvořte nový datetime se zadanými následujícími informačními prvky:
- Vypočítejte nová klíště od půlnoci, která odpovídá přidání velikosti y k od půlnoci x, modulo počet 100 nanosekundových ticků v 24hodinovém období. Pokud x nezadá hodnotu pro ticks od půlnoci, předpokládá se hodnota 0.
- Zkopírujte hodnoty x pro dny od epochy a minut posunu od času UTC beze změny.

Následující příklady ukazují výpočet absolutního dočasného součtu, když datetime určuje dny od epochy:

#date(2010,05,20) + #duration(0,8,0,0) 
    //#datetime( 2010, 5, 20, 8, 0, 0 ) 
    //2010-05-20T08:00:00 
 
#date(2010,01,31) + #duration(30,08,0,0) 
    //#datetime(2010, 3, 2, 8, 0, 0) 
    //2010-03-02T08:00:00 
 
#datetime(2010,05,20,12,00,00,-08) + #duration(0,04,30,00) 
    //#datetime(2010, 5, 20, 16, 30, 0, -8, 0) 
    //2010-05-20T16:30:00-08:00 
 
#datetime(2010,10,10,0,0,0,0) + #duration(1,0,0,0) 
   //#datetime(2010, 10, 11, 0, 0, 0, 0, 0) 
   //2010-10-11T00:00:00+00:00

Následující příklad ukazuje výpočet posunu data a času podle doby trvání pro daný čas:

#time(8,0,0) + #duration(30,5,0,0) 
   //#time(13, 0, 0) 
   //13:00:00

operátor odčítání

Interpretace operátoru odčítání (x - y) je závislá na druhu hodnoty vyhodnocených výrazů x a ynásledujícím způsobem:

linka	Y	Výsledek	Interpretace
`type number`	`type number`	`type number`	Číselný rozdíl
`type number`	`null`	`null`
`null`	`type number`	`null`
`type duration`	`type duration`	`type duration`	Číselný rozdíl velikostí
`type duration`	`null`	`null`
`null`	`type duration`	`null`
`type` datetime	`type` datetime	`type duration`	Doba trvání mezi datetimes
`type` datetime	`type duration`	`type` datetime	Posun data a času o negovanou dobu trvání
`type` datetime	`null`	`null`
`null`	`type` datetime	`null`

V tabulce typepředstavuje datum a čas libovolnou z type datehodnot , type datetime, type datetimezonenebo type time. Při odečtení doby trvání od hodnoty určitého typu datetime je výsledná hodnota stejného typu.

U jiných kombinací hodnot, než jsou hodnoty uvedené v tabulce, je vyvolána chyba s kódem "Expression.Error" důvodu. Každá kombinace je popsána v následujících částech.

Chyby vyvolané při vyhodnocování jednoho operandu se rozšíří.

Číselný rozdíl

Rozdíl mezi dvěma čísly se vypočítá pomocí operátoru odčítání a vytvoří číslo. Příklad:

1 - 1                // 0 
#nan - #infinity     // #nan

Operátor - odčítání nad čísly používá dvojitou přesnost. Funkci standardní knihovny Value.Subtract lze použít k určení desetinné přesnosti. Při výpočtu rozdílu čísel platí následující:

Rozdíl v dvojité přesnosti se vypočítá podle pravidel 64bitové binární dvojité přesnosti IEEE 754 aritmetické IEEE 754-2008. Následující tabulka uvádí výsledky všech možných kombinací nenulových konečných hodnot, nul, infinit a naN. V tabulce x a y jsou nenulové konečné hodnoty a z je výsledkem x - y. Pokud x a y jsou rovny, z je kladná nula. Pokud x - y je příliš velký, aby byl reprezentován v cílovém typu, z je nekonečno se stejným znaménkem jako x - y.

-	y	+0	0 až	+∞	-∞	Není číslo
x	z	linka	linka	-∞	+∞	Není číslo
+0	-y	+0	+0	-∞	+∞	Není číslo
-0	-y	0 až	+0	-∞	+∞	Není číslo
+∞	+∞	+∞	+∞	Není číslo	+∞	Není číslo
-∞	-∞	-∞	-∞	-∞	Není číslo	Není číslo
Nan	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo

Rozdíl v desítkové přesnosti se vypočítá bez ztráty přesnosti. Měřítko výsledku je větší z měřítka dvou operandů.

Rozdíl doby trvání

Rozdíl dvou dob trvání představuje rozdíl mezi počtem 100 nanosekundových ticků reprezentovaných každou dobou trvání. Příklad:

#duration(1,2,30,0) - #duration(0,0,0,30.45) 
// #duration(1, 2, 29, 29.55)

Posun data a času o negovanou dobu trvání

K x a dobu trvání.y Zde představuje datum a čas libovolnou z date, datetime, datetimezonenebo time. Výsledný datetime má vzdálenost od x lineární časové osy, která je přesně velikost y, ve směru proti znaménku y. Odečtení kladných dob trvání vrátí výsledky, které jsou zpětně relativní vzhledem k x, zatímco odečtení záporných hodnot vrátí výsledky, které jsou v čase dopředu.

#date(2010,05,20) - #duration(00,08,00,00) 
   //#datetime(2010, 5, 19, 16, 0, 0) 
   //2010-05-19T16:00:00 
#date(2010,01,31) - #duration( 30,08,00,00) 
   //#datetime(2009, 12, 31, 16, 0, 0) 
   //2009-12-31T16:00:00

Doba trvání mezi dvěma hodnotami datetime

Dva data a časyt a u je možné je odečíst pomocí k t - u výpočtu doby trvání mezi nimi. Zde představuje datum a čas libovolnou z date, datetime, datetimezonenebo time. Doba trvání získaná odečtením u od t musí být přičtována t k u.

#date(2010,01,31) - #date(2010,01,15) 
// #duration(16,00,00,00) 
// 16.00:00:00 
 
#date(2010,01,15)- #date(2010,01,31) 
// #duration(-16,00,00,00) 
// -16.00:00:00 
 
#datetime(2010,05,20,16,06,00,-08,00) - 
#datetime(2008,12,15,04,19,19,03,00) 
// #duration(521,22,46,41)
// 521.22:46:41

Odečtení t - u , když u > t výsledkem je záporná doba trvání:

#time(01,30,00) - #time(08,00,00) 
// #duration(0, -6, -30, 0)

Při odečítání dvou hodnot datetime pomocí t - u:

u + (t - u) = t

operátor násobení

Interpretace operátoru násobení (x * y) závisí na druhu hodnoty vyhodnocených výrazů x a y následujícím způsobem:

X	Y	Výsledek	Interpretace
`type number`	`type number`	`type number`	Číselný produkt
`type number`	`null`	`null`
`null`	`type number`	`null`
`type duration`	`type number`	`type duration`	Násobek doby trvání
`type number`	`type duration`	`type duration`	Násobek doby trvání
`type duration`	`null`	`null`
`null`	`type duration`	`null`

U jiných kombinací hodnot, než jsou hodnoty uvedené v tabulce, je vyvolána chyba s kódem "Expression.Error" důvodu. Každá kombinace je popsána v následujících částech.

Chyby vyvolané při vyhodnocování jednoho operandu se rozšíří.

Číselný produkt

Součin dvou čísel se vypočítá pomocí operátoru násobení a vytvoří číslo. Příklad:

2 * 4                // 8 
6 * null             // null 
#nan * #infinity     // #nan

Operátor * násobení čísel používá dvojitou přesnost. Standardní funkce Value.Multiply knihovny lze použít k určení desetinné přesnosti. Při výpočtu součinu čísel platí následující:

Produkt s dvojitou přesností se vypočítá podle pravidel 64bitové binární dvojité přesnosti IEEE 754 aritmetické IEEE 754-2008. Následující tabulka uvádí výsledky všech možných kombinací nenulových konečných hodnot, nul, infinit a naN. V tabulce x jsou y kladné konečné hodnoty. zje výsledkem .x * y Pokud je výsledek pro cílový typ příliš velký, z je nekonečno. Pokud je výsledek pro cílový typ příliš malý, z je nula.

*	+y	-y	+0	0 až	+∞	-∞	Není číslo
+x	+z	-z	+0	0 až	+∞	-∞	Není číslo
-x	-z	+z	0 až	+0	-∞	+∞	Není číslo
+0	+0	0 až	+0	0 až	Není číslo	Není číslo	Není číslo
-0	0 až	+0	0 až	+0	Není číslo	Není číslo	Není číslo
+∞	+∞	-∞	Není číslo	Není číslo	+∞	-∞	Není číslo
-∞	-∞	+∞	Není číslo	Není číslo	-∞	+∞	Není číslo
Nan	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo

Součin v desetinné přesnosti se vypočítá bez ztráty přesnosti. Měřítko výsledku je větší z měřítka dvou operandů.

Násobky doby trvání

Součin doby trvání a číslo je doba trvání představující počet 100nanosekondů, které představují operand doby trvání krát číselný operand. Příklad:

#duration(2,1,0,15.1) * 2 
// #duration(4, 2, 0, 30.2)

operátor dělení

Interpretace operátoru dělení (x / y) závisí na druhu hodnoty vyhodnocených výrazů x a ynásledujícím způsobem:

X	Y	Výsledek	Interpretace
`type number`	`type number`	`type number`	Číselný podíl
`type number`	`null`	`null`
`null`	`type number`	`null`
`type duration`	`type number`	`type duration`	Zlomek doby trvání
`type duration`	`type duration`	`type number`	Číselný podíl dob trvání
`type duration`	`null`	`null`
`null`	`type duration`	`null`

U jiných kombinací hodnot, než jsou hodnoty uvedené v tabulce, je vyvolána chyba s kódem "Expression.Error" důvodu. Každá kombinace je popsána v následujících částech.

Chyby vyvolané při vyhodnocování jednoho operandu se rozšíří.

Číselný podíl

Podíl dvou čísel se vypočítá pomocí operátoru dělení a vytvoří číslo. Příklad:

8 / 2               // 4 
8 / 0               // #infinity 
0 / 0               // #nan 
0 / null            // null 
#nan / #infinity    // #nan

Operátor / dělení nad čísly používá dvojitou přesnost. Standardní funkce Value.Divide knihovny lze použít k určení desetinné přesnosti. Při výpočtu podílu čísel platí následující:

Podíl v dvojité přesnosti se vypočítá podle pravidel 64bitové binární dvojité přesnosti IEEE 754 aritmetické IEEE 754-2008. Následující tabulka uvádí výsledky všech možných kombinací nenulových konečných hodnot, nul, infinit a naN. V tabulce x jsou y kladné konečné hodnoty. zje výsledkem .x / y Pokud je výsledek pro cílový typ příliš velký, z je nekonečno. Pokud je výsledek pro cílový typ příliš malý, z je nula.

/	+y	-y	+0	0 až	+∞	-∞	Není číslo
+x	+z	-z	+∞	-∞	+0	0 až	Není číslo
-x	-z	+z	-∞	+∞	0 až	+0	Není číslo
+0	+0	0 až	Není číslo	Není číslo	+0	0 až	Není číslo
-0	0 až	+0	Není číslo	Není číslo	0 až	+0	Není číslo
+∞	+∞	-∞	+∞	-∞	Není číslo	Není číslo	Není číslo
-∞	-∞	+∞	-∞	+∞	Není číslo	Není číslo	Není číslo
Nan	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo	Není číslo

Součet v desetinné přesnosti se vypočítá bez ztráty přesnosti. Měřítko výsledku je větší z měřítka dvou operandů.

Podíl dob trvání

Podíl dvou dob trvání je číslo představující podíl počtu 100nanosekondů představovaných dobami trvání. Příklad:

#duration(2,0,0,0) / #duration(0,1,30,0) 
// 32

Škálované doby trvání

Podíl doby trvání x a čísla y je doba trvání představující podíl počtu 100 nanosekundových ticků reprezentovaných dobou trvání x a číslem y. Příklad:

#duration(2,0,0,0) / 32 
// #duration(0,1,30,0)

Kombinace struktury

Operátor kombinace (x & y) je definován v následujících typech hodnot:

X	Y	Výsledek	Interpretace
`type text`	`type text`	`type text`	Zřetězení
`type text`	`null`	`null`
`null`	`type text`	`null`
`type date`	`type time`	`type datetime`	Sloučení
`type date`	`null`	`null`
`null`	`type time`	`null`
`type list`	`type list`	`type list`	Zřetězení
`type record`	`type record`	`type record`	Sloučení
`type table`	`type table`	`type table`	Zřetězení

Zřetězení

Dva texty, dva seznamy nebo dvě hodnoty tabulky mohou být zřetězeny pomocí x & y.

Následující příklad znázorňuje zřetězení textových hodnot:

"AB" & "CDE"     // "ABCDE"

Následující příklad znázorňuje zřetězení seznamů:

{1, 2} & {3}     // {1, 2, 3}

Při zřetězení dvou hodnot pomocí x & y:

Chyby vyvolané při vyhodnocování x výrazů nebo y výrazů se šíří.
Pokud položka nebo xy obsahuje chybu, není šířena žádná chyba.
Výsledkem zřetězení dvou textových hodnot je textová hodnota, která obsahuje hodnotu x, za kterou bezprostředně následuje y. Pokud je některý z operandů null a druhý je textová hodnota, výsledek je null.
Výsledkem zřetězení dvou seznamů je seznam, který obsahuje všechny položky x následované všemi položkami y.
Výsledkem zřetězení dvou tabulek je tabulka, která má sjednocení sloupců obou operandů. Pořadí sloupců x je zachováno, následované sloupci, které se zobrazují pouze v y, zachovávají jejich relativní pořadí. Pro sloupce, které se zobrazují pouze v jednom z operandů, null slouží k vyplnění hodnot buněk druhého operandu.

Sloučení

Sloučení záznamů

Dva záznamy lze sloučit pomocí x & y, vytvořit záznam, který obsahuje pole z obou x a y.

Sloučení záznamů znázorňuje následující příklady:

[ x = 1 ] & [ y = 2 ]                // [ x = 1, y = 2 ] 
[ x = 1, y = 2 ] & [ x = 3, z = 4 ]  // [ x = 3, y = 2, z = 4 ]

Při slučování dvou záznamů pomocí x + y:

Chyby vyvolané při vyhodnocování x výrazů nebo y výrazů se šíří.
Pokud se pole zobrazí v obou x polích, ypoužije se hodnota z y .
Pořadí polí ve výsledném záznamu je v xpořadí , po kterém následují pole, která y nejsou součástí x, ve stejném pořadí, v yjakém se zobrazují .
Sloučení záznamů nezpůsobí vyhodnocení hodnot.
Není vyvolána žádná chyba, protože pole obsahuje chybu.
Výsledkem je záznam.

Sloučení s datem a časem

Datum x lze sloučit s časem y pomocí , x & yvytvoří datum a čas, který kombinuje části z obou x a y.

Následující příklad znázorňuje sloučení data a času:

#date(2013,02,26) & #time(09,17,00) 
// #datetime(2013,02,26,09,17,00)

Při slučování dvou záznamů pomocí x + y:

Chyby vyvolané při vyhodnocování x výrazů nebo y výrazů se šíří.
Výsledkem je datum a čas.

Unární operátory

Operátory , +a - operátory notjsou unární operátory.

unární výraz:
      type-expression
       + unární výraz
       - unární výraz
       not unární výraz

Jednočlenný operátor plus

Unární operátor plus (+x) je definován pro následující typy hodnot:

X	Výsledek	Interpretace
`type number`	`type number`	Unární plus
`type duration`	`type duration`	Unární plus
`null`	Null

U jiných hodnot je vyvolána chyba s kódem "Expression.Error" důvodu.

Unární operátor plus umožňuje použít znaménko + na číslo, datum a čas nebo hodnotu null. Výsledek je stejná hodnota. Příklad:

+ - 1                 // -1 
+ + 1                 // 1 
+ #nan                // #nan 
+ #duration(0,1,30,0) // #duration(0,1,30,0)

Při vyhodnocování unárního operátoru +xplus platí následující:

Chyby vyvolané při vyhodnocování x se rozšíří.
Pokud výsledek vyhodnocení x není číselná hodnota, vyvolá se chyba s kódem "Expression.Error" důvodu.

Unární operátor minus

Operátor unární minus (-x) je definován pro následující typy hodnot:

X	Výsledek	Interpretace
`type number`	`type number`	Negace
`type duration`	`type duration`	Negace
`null`	`null`

U jiných hodnot je vyvolána chyba s kódem "Expression.Error" důvodu.

Operátor unární minus slouží ke změně znaménka čísla nebo doby trvání. Příklad:

- (1 + 1)       // -2 
- - 1           // 1 
- - - 1         // -1 
- #nan          // #nan 
- #infinity     // -#infinity 
- #duration(1,0,0,0)  // #duration(-1,0,0,0) 
- #duration(0,1,30,0) // #duration(0,-1,-30,0)

Při vyhodnocování operátoru -xunární minus platí následující:

Chyby vyvolané při vyhodnocování x se rozšíří.
Pokud je výraz číslo, výsledek je číselná hodnota z výrazu x se změněným symbolem. Pokud je hodnota NaN, výsledek je také NaN.

Logický operátor negace

Logický operátor negace (not) je definován pro následující typy hodnot:

X	Výsledek	Interpretace
`type logical`	`type logical`	Negace
`null`	`null`

Tento operátor vypočítá logickou not operaci s danou logickou hodnotou. Příklad:

not true             // false 
not false            // true 
not (true and true)  // false

Při vyhodnocování logického operátoru not xnegace platí následující:

Chyby vyvolané při vyhodnocování x se rozšíří.
Hodnota vytvořená z vyhodnocení výrazu x musí být logická hodnota nebo musí být vyvolána chyba s kódem "Expression.Error" důvodu. Pokud je truehodnota , výsledek je false. Pokud je falseoperand , výsledek je true.

Výsledkem je logická hodnota.

Operátory typů

Operátory is a as jsou známé jako operátory typu.

Operátor kompatibility typů

Operátor x is y kompatibility typů je definován pro následující typy hodnot:

X	Y	Výsledek
`type any`	nullable-primitive-type	`type logical`

Výraz x is y vrátí true , pokud přiřazený typ x je kompatibilní s y, a vrátí false , pokud přiřazený typ x není kompatibilní s y. ymusí být primitivní typ s možnou hodnotou null.

is-expression:
      as-expression
      is-expressionisnullable-primitive-type
nullable-primitive-type:
       nullable _opt primitive-type

Kompatibilita typů podporovaná operátorem is je podmnožinou obecné kompatibility typů a je definována pomocí následujících pravidel:

Pokud x je hodnota null, je kompatibilní, pokud y je typ any, typ nullnebo typ s možnou hodnotou null.
Pokud x není null, pak pokud je kompatibilní, pokud primitivní typ x je stejný jako y.

Při vyhodnocování výrazu x is yplatí následující:

Při vyhodnocování výrazu x se rozšíří chyba.

Operátor kontrolního výrazu typu

Operátor x as y kontrolního výrazu typu je definován pro následující typy hodnot:

X	Y	Výsledek
`type any`	nullable-primitive-type	`type any`

x as y Výraz tvrdí, že hodnota x je kompatibilní s operátorem yis. Pokud není kompatibilní, vyvolá se chyba. y musí být typu nullable-primitive-type.

as-expression:
výraz rovnosti
as-expressionasnullable-primitive-type

Výraz x as y se vyhodnotí takto:

Provede se kontrola x is y kompatibility typů a kontrolní výraz vrátí x beze změny, pokud je test úspěšný.
Pokud kontrola kompatibility selže, vyvolá se chyba s kódem "Expression.Error" důvodu.

Příklady:

1 as number               // 1 
"A" as number             // error 
null as nullable number   // null

Při vyhodnocování výrazu x as yplatí následující:

Při vyhodnocování výrazu x se rozšíří chyba.

Operátor Coalesce

Operátor ?? coalesce vrátí výsledek levého operandu, pokud není null, jinak vrátí výsledek jeho pravého operandu. Pravý operand se vyhodnotí, pokud je levý operand null.

Sdílet prostřednictvím

Chování operátoru

Priorita operátorů

Operátory a metadata

Rekurzivní operátory strukturálně

Operátory výběru a projekce

Přístup k položce

Přístup k poli

Operátor metadat

Operátory rovnosti

Relační operátory

Podmíněné logické operátory

Aritmetické operátory

Počet deset. míst

operátor sčítání

Číselný součet

Součet dob trvání

Posun data a času podle doby trvání

operátor odčítání

Číselný rozdíl

Rozdíl doby trvání

Posun data a času o negovanou dobu trvání

Doba trvání mezi dvěma hodnotami datetime

operátor násobení

Číselný produkt

Násobky doby trvání

operátor dělení

Číselný podíl

Podíl dob trvání

Škálované doby trvání

Kombinace struktury

Zřetězení

Sloučení

Sloučení záznamů

Sloučení s datem a časem

Unární operátory

Jednočlenný operátor plus

Unární operátor minus

Logický operátor negace

Operátory typů

Operátor kompatibility typů

Operátor kontrolního výrazu typu

Operátor Coalesce

Váš názor

Další materiály