Tyypit
Tyypin arvo on arvo, joka luokittelee muut arvot. Arvo, joka luokitellaan tyypin mukaan, noudattaa tätä tyyppiä. M-tyyppijärjestelmä koostuu seuraavanlaisista tyypeistä:
Primitiivityypit, jotka luokittelevat primitiiviset arvot (
binary
,date
,datetime
,datetimezone
,duration
, ,list
,logical
, ,null
,number
record
,text
,time
type
) ja sisältävät myös joukon abstrakteja tyyppejä (function
, ,table
any
anynonnull
ja )none
Tietuetyypit, jotka luokittelevat tietuearvot kenttien nimien ja arvotyyppien perusteella
Luettelotyypit, jotka luokittelevat luetteloita käyttäen yksittäistä kohteen perustyyppiä
Funktiotyypit, jotka luokittelevat funktioiden arvot parametrien tyyppien ja palautusarvojen perusteella
Taulukkotyypit, jotka luokittelevat taulukon arvot sarakkeiden nimien, saraketyyppien ja avainten perusteella
Tyhjäarvoiset tyypit, jotka luokittelevat arvon tyhjäarvoksi kaikkien perustyypin luokittelemien arvojen lisäksi
Tyyppityypit, jotka luokittelevat arvot, jotka ovat tyyppejä
Sarja primitiivityyppejä sisältää primitiiviarvojen tyypit ja joukon abstrakteja tyyppejä, jotka ovat tyyppejä, jotka eivät luokittele arvoja yksilöllisesti: function
, table
, any
anynonnull
ja none
. Kaikki funktioiden arvot ovat abstraktin tyypin function
mukaisia, kaikki taulukon arvot vastaavat abstraktia tyyppiä table
, kaikki arvot vastaavat abstraktia tyyppiä any
, kaikki muut kuin tyhjäarvot vastaavat abstraktia tyyppiä anynonnull
eikä mikään arvo vastaa abstraktia tyyppiä none
. Tyyppiä olevan lausekkeen none
täytyy aiheuttaa virhe, tai se ei voi päättyä, koska tyypin none
mukaista arvoa ei voitu tuottaa. Ota huomioon, että primitiivityypit function
ja table
ovat abstrakteja, koska mikään funktio tai taulukko ei ole suoraan kyseisistä tyypeistä. Primitiivityypit record
ja list
ovat ei-abstrakteja, koska ne edustavat avointa tietuetta, jolla ei ole määritettyjä kenttiä eikä mitään tyyppiluetteloa.
Kaikkia tyyppejä, jotka eivät ole primitiivityyppien suljettujen joukon jäseniä ja niiden tyhjäarvoja tukevia vastapuolia, kutsutaan yhteisesti mukautetuiksi tyypeiksi. Mukautettuja tyyppejä voi kirjoittaa käyttämällä type-expression
:
type-expression:
primary-expression
type
primary-type
tyyppi:
primary-expression
primary-type
primary-type:
primitive-type
record-type
list-type
function-type
table-type
nullable-type
primitive-type: joku seuraavista
any anynonnull binary date datetime datetimezone duration function list logical
none null number record table text time type
primitive-type-nimet ovat kontekstuaalisia avainsanoja, jotka tunnistetaan vain tyypin kontekstissa. Sulkeiden käyttö tyypin kontekstissa siirtää kieliopin takaisin säännönmukaiseen lausekekontekstiin, joka edellyttää tyyppiavainsanan käyttämistä takaisin tyyppikontekstiin siirtymiseksi. Jos esimerkiksi haluat käynnistää funktion tyypin kontekstissa, sulkeita voidaan käyttää:
type nullable ( Type.ForList({type number}) )
// type nullable {number}
Sulkeiden avulla voidaan myös käyttää muuttujaa, jonka nimi on ristiriidassa primitive-type-nimen kanssa:
let record = type [ A = any ] in type {(record)}
// type {[ A = any ]}
Seuraavassa esimerkissä määritetään tyyppi, joka luokittelee lukuluettelon:
type { number }
Myös seuraava esimerkki määrittää mukautetun tyypin, joka luokittelee tietueet, joissa on pakollisia kenttiä nimeltään X
ja Y
joiden arvot ovat lukuja:
type [ X = number, Y = number ]
Arvon määritetty tyyppi saadaan käyttämällä vakiokirjastofunktiota Value.Type, kuten seuraavissa esimerkeissä esitetään:
Value.Type( 2 ) // type number
Value.Type( {2} ) // type list
Value.Type( [ X = 1, Y = 2 ] ) // type record
operaattoria is
käytetään määrittämään, onko arvon tyyppi yhteensopiva määritetyn tyypin kanssa, kuten seuraavissa esimerkeissä esitetään:
1 is number // true
1 is text // false
{2} is list // true
Operaattori as
tarkistaa, onko arvo yhteensopiva määritetyn tyypin kanssa, ja aiheuttaa virheen, jos se ei ole. Muussa tapauksessa se palauttaa alkuperäisen arvon.
Value.Type( 1 as number ) // type number
{2} as text // error, type mismatch
Huomioi, että is
ja as
operaattorit hyväksyvät vain tyhjäarvoja tukevia primitiivityyppejä oikeaksi operandiksi. M ei tarjoa keinoja tarkistaa arvoja mukautettujen tyyppien vastaavuuden osalta.
Tyyppi on yhteensopiva tyypin kanssa, jos ja vain, jos kaikki arvot, jotka ovat X
mukaisia, ovat myös mukaisia.Y
X
Y
Kaikki tyypit ovat yhteensopivia tyypin any
kanssa, joten mitkään tyypit (paitsi none
itse) eivät ole yhteensopivia tyypin none
kanssa. Seuraavassa kaaviossa näytetään yhteensopivuussuhde. (Tyypin yhteensopivuus on refleksiivinen ja transitiivinen. Se muodostaa säleikön tyypin any
kanssa ylimmäksi ja tyyppi none
alimmaksi arvoksi.) Abstraktien tyyppien nimet on määritetty kursivoituina.
Seuraavat operaattorit on määritetty tyyppiarvoille:
Operaattori | Result |
---|---|
x = y |
Equal |
x <> y |
Not equal |
x ?? y |
Coalesce |
Tyyppiarvojen alkuperäinen tyyppi on perustyyppi type
.
M-kielen tyypit muodostavat epäyhtäisen hierarkian, jonka juurena on tyyppi any
, joka on tyyppi, joka luokittelee kaikki arvot. Mikä tahansa M-arvo noudattaa täsmälleen yhtä primitiivistä alityyppiä any
. Tyypistä any
johdettujen primitiivityyppien suljetut sarjat ovat seuraavat:
-
type null
, joka luokittelee tyhjäarvon. -
type logical
, joka luokittelee arvot tosi ja epätosi. -
type number
, joka luokittelee lukuarvot. -
type time
, joka luokittelee aika-arvot. -
type date
, joka luokittelee päivämääräarvot. -
type datetime
, joka luokittelee päivämäärä- ja aika-arvot. -
type datetimezone
, joka luokittelee päivämäärä- ja aikavyöhykearvot. -
type duration
, joka luokittelee kestoarvot. -
type text
, joka luokittelee tekstiarvot. -
type binary
, joka luokittelee binaariarvot. -
type type
, joka luokittelee tyyppiarvot. -
type list
, joka luokittelee luetteloarvot. -
type record
, joka luokittelee tietuearvot. -
type table
, joka luokittelee taulukkoarvot. -
type function
, joka luokittelee funktioarvot. -
type anynonnull
, joka luokittelee kaikki arvot paitsi tyhjäarvoa. -
type none
, joka ei luokittele arvoja.
Tyyppi any
on abstrakti, luokittelee kaikki M-arvot, ja kaikki M-tyypit ovat yhteensopivia :n kanssa any
. Tyyppiä any
olevan muuttujan voi sitoa kaikkiin mahdollisiin arvoihin. Koska any
on abstrakti, sen arvot eivät voi olla eli mikään arvo ei ole suoraan tyyppiä any
.
Mikä tahansa arvo, joka on luettelo, on sisäisen tyypin list
mukainen, mikä ei aseta mitään rajoituksia luetteloarvon kohteille.
list-type:
{
item-type}
item-type:
tyyppi
list-type-tyypin arvioinnin list
Seuraavissa esimerkeissä havainnollistetaan yhdenmukaisten luettelotyyppien määrittämissyntaksi:
type { number } // list of numbers type
{ record } // list of records type
{{ text }} // list of lists of text values
Arvo on yhdenmukainen luettelotyypin kanssa, jos arvo on luettelo ja jokainen kyseisen luetteloarvon kohde vastaa luettelotyypin kohdetyyppiä.
Luettelotyypin kohdetyyppi ilmaisee sidoksen: kaikki vaatimustenmukaisuusluettelon kohteet ovat kohteen tyypin mukaisia.
Mikä tahansa arvo, joka on tietue, on sisäisen tyypin mukainen tietue, mikä ei aseta mitään rajoituksia kenttien nimille tai arvoille tietueen arvossa. record-type-arvoa käytetään rajoittamaan kelvollisten nimien joukkoa sekä niiden arvojen tyyppejä, joiden sallitaan liittyvän näihin nimiin.
record-type:
[
open-record-marker]
[
field-specification-listopt]
[
field-specification-list , open-record-marker]
field-specification-list:
field-specification
field-specification,
field-specification-list
field-specification:
optional
opt field-name field-type-specificationopt
field-type-specification:
=
field-type
field-type:
tyyppi
open-record-marker:
...
record-type-tyypin arvioinnin tulos on tyypin arvo, jonka perustyyppi on record
.
Seuraavissa esimerkeissä havainnollistetaan tietuetyyppien määrittämissyntaksi:
type [ X = number, Y = number]
type [ Name = text, Age = number ]
type [ Title = text, optional Description = text ]
type [ Name = text, ... ]
Tietuetyypit on suljettu oletusarvoisesti, mikä tarkoittaa, että lisäkenttiä, joita ei ole fieldspecification-list-luettelossa, ei sallita vaatimustenmukaisuusarvoissa. Mukaan lukien openrecord-marker tietuetyypissä ilmaisee tyypin, jonka tulee olla avoin, mikä sallii kenttien olevan kenttämääritysluettelossa. Seuraavat kaksi lauseketta vastaavat toisiaan:
type record // primitive type classifying all records
type [ ... ] // custom type classifying all records
Arvo on tietuetyypin mukainen, jos arvo on tietue ja jokainen kentän määritys tietuetyypissä täyttyy. Kentän määritys täyttyy, jos jokin seuraavista on tosi:
Tietueessa on määrityksen tunnusta vastaava kentän nimi, ja siihen liittyvä arvo on määrityksen tyypin mukainen
Määritys on merkitty valinnaiseksi, eikä vastaavaa kentän nimeä löydy tietueesta
Vaatimustenmukainen arvo voi sisältää kenttien nimiä, joita ei ole lueteltu kentän määritysluettelossa, jos ja vain, jos tietuetyyppi on avoin.
Mikä tahansa funktioiden arvo vastaa primitiivityyppiä function
, joka ei aseta mitään rajoituksia funktioiden muodollisten parametrien tyypeille tai funktioiden paluuarvolle. Mukautettua function-type-arvoa käytetään asettamaan tyyppirajoituksia yhteensopiviksi funktioiden arvojen allekirjoituille.
function-type:
function (
parameter-specification-listopt)
function-return-type
parameter-specification-list:
required-parameter-specification-list
required-parameter-specification-list,
optional-parameter-specification-list
optional-parameter-specification-list
required-parameter-specification-list:
required-parameter-specification
required-parameter-specification,
required-parameter-specification-list
required-parameter-specification:
parameter-specification
optional-parameter-specification-list:
optional-parameter-specification
optional-parameter-specification,
optional-parameter-specification-list
optional-parameter-specification:
optional
parameter-specification
parameter-specification:
parameter-name parameter-type
function-return-type:
assertion
väite:
as
nullable-primitive-type
function-type-tyypin arvioinnin tulos on tyypin arvo, jonka perustyyppi on function
.
Seuraavissa esimerkeissä havainnollistetaan funktiotyyppien määrittämissyntaksi:
type function (x as text) as number
type function (y as number, optional z as text) as any
Funktion arvo noudattaa funktion tyyppiä, jos funktion arvon palautustyyppi on yhteensopiva funktion tyypin palautustyypin kanssa ja jokainen parametrimääritys on yhteensopiva positionally-funktion vastaavan muodollisen parametrin kanssa. Parametrimääritys on yhteensopiva muodollisen parametrin kanssa, jos määritetty parameter-type-tyyppi on yhteensopiva muodollisen parametrin tyypin kanssa ja parametrimääritys on valinnainen, jos muodollinen parametri on valinnainen.
Muodolliset parametrien nimet ohitetaan määritettäessä funktiotyypin vastaavuus.
Parametrin määrittäminen valinnaisena tekee tyypistä implisiittisesti tyhjäarvon sallivan. Seuraavat luovat identtiset funktiotyypit:
type function (optional x as text) as any
type function (optional x as nullable text) as any
Taulukkoarvon rakennetta määritetään table-type-arvon avulla.
table-type:
table
row-type
row-type:
[
field-specification-listopt]
table-type-tyypin arvioinnin tulos on tyypin arvo, jonka perustyyppi on table
.
Taulukon rivityyppi määrittää taulukon sarakkeiden nimet ja saraketyypit suljetuksi tietuetyypeiksi. Jotta kaikki taulukon arvot olisivat tyypin table
mukaisia, sen rivityyppi on record
(tyhjä avoin tietuetyyppi). Tyyppitaulukko on siis abstrakti, koska minkään taulukon arvon tyyppi table
ei voi olla :n rivityyppi (mutta kaikilla taulukon arvoilla on rivityyppi, joka on yhteensopiva tyypin table
rivityypin kanssa). Seuraavassa esimerkissä näytetään taulukkotyypin rakenne:
type table [A = text, B = number, C = binary]
// a table type with three columns named A, B, and C
// of column types text, number, and binary, respectively
Table-type-arvo sisältää myös taulukon arvon avainten määrittelyn. Avain on sarakenimien joukko. Enintään yksi avain voidaan nimetä taulukon perusavaimeksi. (M-taulukkoavaimilla ei ole semanttista merkitystä. Ulkoisten tietolähteiden, kuten tietokantojen tai OData-syötteiden avainten määrittäminen kuitenkin tavallista taulukoiden yli. Power Query käyttää avaintietoja parantaakseen kehittyneiden toimintojen suorituskykyä, kuten ristilähdetoiminnot.)
Vakiokirjastofunktioiden Type.TableKeys
, Type.AddTableKey
ja Type.ReplaceTableKeys
avulla voidaan hankkia taulukkotyypin avaimia, lisätä avain taulukkotyyppiin ja korvata kaikki taulukkotyypin avaimet.
Type.AddTableKey(tableType, {"A", "B"}, false)
// add a non-primary key that combines values from columns A and B
Type.ReplaceTableKeys(tableType, {})
// returns type value with all keys removed
type T
Kaikille nolla-arvoinen variantti voidaan johtaa käyttämällä nullable-type-tyyppiä:
nullable-type:
nullable
tyyppi
Tulos on abstrakti tyyppi, joka sallii tyypin T arvot tai arvon null
.
42 is nullable number // true null is
nullable number // true
Merkintä type nullable
T vähentää merkintään tai type
. (Muista, että tyhjäarvoja sisältävät tyypit ovat abstrakteja, eikä mikään arvo voi olla suoraan abstraktia tyyppiä.)
Value.Type(42 as nullable number) // type number
Value.Type(null as nullable number) // type null
Vakiokirjastofunktioita Type.IsNullable
ja Type.NonNullable
voidaan käyttää testaamaan tyhjäarvon tyyppiä ja poistamaan tyhjäarvon tyypistä.
Seuraava pätee (mikä tahansa type T
):
-
type T
on yhteensopiva :n kanssatype nullable T
-
Type.NonNullable(type T)
on yhteensopiva :n kanssatype T
Seuraavat ovat pareittain toisiaan vastaavia (mikä tahansa type T
):
type nullable any
any
Type.NonNullable(type any)
type anynonnull
type nullable none
type null
Type.NonNullable(type null)
type none
type nullable nullable T
type nullable T
Type.NonNullable(Type.NonNullable(type T))
Type.NonNullable(type T)
Type.NonNullable(type nullable T)
Type.NonNullable(type T)
type nullable (Type.NonNullable(type T))
type nullable T
Arvon määritetty tyyppi on tyyppi, jonka mukaan arvo on määritetty vaatimusten mukaiseksi.
Arvolle voidaan määrittää tyyppi käyttämällä kirjastofunktiota Value.ReplaceType
. Tämä funktio joko palauttaa joko uuden arvon, jolle on määritetty tyyppi, tai aiheuttaa virheilmoituksen, jos uusi tyyppi on yhteensopimaton arvon kanssa.
Kun arvo on määritetty tyypiksi, vain rajoitettu vastaavuuden tarkistus suoritetaan:
- Määritettävän tyypin on oltava ei-abstrakti, ei-tyhjäarvoja salliva ja yhteensopiva arvon perustyypin (alkuperäisen) primitiivityypin kanssa.
- Kun rakenteen määrittävän mukautetun tyypin on vastattava arvon rakennetta.
- Tietueille: Tyyppi on suljettava, sen on määritettävä sama määrä kenttiä kuin arvo, eikä se saa sisältää valinnaisia kenttiä. (Tyypin kenttien nimet ja kenttätyypit korvaavat tietueeseen tällä hetkellä liittyvät nimet. Aiemmin luotuja kenttien arvoja ei kuitenkaan valita uusissa kenttätyypeissä.)
- Taulukoille: -tyypin on määritettävä sama määrä sarakkeita kuin arvon. (Tyypin sarakkeiden nimet ja saraketyypit korvaavat taulukkoon tällä hetkellä liittyvät nimet. Olemassa olevia sarakearvoja ei kuitenkaan tarkistetaan uusien saraketyyppien mukaan.)
- Funktioille: -tyypin on määritettävä sama määrä pakollisia parametreja sekä sama määrä valinnaisia parametreja kuin arvo. (Tyypin parametri ja palautusvahvistukset sekä niiden parametrien nimet korvaavat funktion arvon nykyiseen tyyppiin liittyvät parametrit. Uudet vahvistukset eivät kuitenkaan vaikuta funktion todelliseen toimintaan.)
- Luetteloille: Arvon on oltava luettelo. (Olemassa olevia luettelokohteita ei kuitenkaan tarkistetaan uuden kohdetyypin mukaan.)
Kirjastofunktiot voivat laskea ja määrittää tulokset monitasoisia tyyppejä tulosten perusteella syötearvoille määritetyille tyypeille.
Arvon määritetty tyyppi voidaan saada käyttämällä kirjastofunktiota Value.Type
. Esimerkkejä:
Value.Type( Value.ReplaceType( {1}, type {number} )
// type {number}
Tyyppivastaavuutta ei ole määritetty kohteessa M. M-toteutus voi valinnaisesti päättää käyttää omia sääntöjään tyyppiarvojen välisen yhtäläisyysvertailun suorittamiseen. Kahden yhtäläisyystyyppiarvon vertailun pitäisi antaa tulokseksi se true
, pidetäänkö niitä samanlaisina toteutuksessa, ja false
muussa tapauksessa. Kummassakin tapauksessa palautetun vastauksen on oltava johdonmukainen, jos samoja kahta arvoa verrataan toistuvasti. Huomaa, että tietyssä toteutuksessa joidenkin identtisten tyyppiarvojen (kuten (type text) = (type text)
) vertailu voi palauttaa true
, vaikka toiset arvot (kuten (type [a = text]) = (type [a = text])
) ei ehkä vertailta.
Tietyn tyypin ja tyhjäarvoisen primitiivityypin yhteensopivuus voidaan määrittää käyttämällä kirjastofunktiota Type.Is
, joka hyväksyy satunnaisen tyyppiarvon ensimmäisenä ja tyhjäarvoisen primitiivityypin arvon sen toisena argumenttina:
Type.Is(type text, type nullable text) // true
Type.Is(type nullable text, type text) // false
Type.Is(type number, type text) // false
Type.Is(type [a=any], type record) // true
Type.Is(type [a=any], type list) // false
M-tukea ei ole määritetty tietyn tyypin yhteensopivuuden määrittämiseksi mukautetulla tyypillä.
Vakiokirjasto sisältää kokoelman funktioita, jotka poimivat määritteleviä ominaisuuksia mukautetusta tyypistä, joten tietyt yhteensopivuustestit voidaan ottaa käyttöön M-lausekkeina. Alla on joitakin esimerkkejä. Katso täydelliset tiedot M-kirjastomäärityksestä.
Type.ListItem( type {number} )
// type number
Type.NonNullable( type nullable text )
// type text
Type.RecordFields( type [A=text, B=time] )
// [ A = [Type = type text, Optional = false],
// B = [Type = type time, Optional = false] ]
Type.TableRow( type table [X=number, Y=date] )
// type [X = number, Y = date]
Type.FunctionParameters(
type function (x as number, optional y as text) as number)
// [ x = type number, y = type nullable text ]
Type.FunctionRequiredParameters(
type function (x as number, optional y as text) as number)
// 1
Type.FunctionReturn(
type function (x as number, optional y as text) as number)
// type number