ประเภท

ค่าชนิด คือค่าที่ใช้ในการจัดประเภทค่าอื่น ๆ ค่าที่จัดประเภทตามชนิดจะกล่าวได้ว่า สอดคล้องกับ ชนิดนั้น ระบบชนิด M ประกอบด้วยชนิดของชนิดต่อไปนี้:

• ชนิด Primitive ซึ่งจัดประเภทค่าดั้งเดิม (binary, , date, datetime, datetimezone, duration, list, logicalnull, number, record, , text, time, ) typeและยังรวมถึงจํานวนของชนิดนามธรรม (function, table, anyanynonnull และ none)

• ชนิด Record ซึ่งจัดประเภทค่าเรกคอร์ดโดยยึดตามชื่อเขตข้อมูลและชนิดค่า

• ชนิด List ซึ่งจัดประเภทรายการโดยใช้ชนิดฐานของหน่วยข้อมูลเดียว

• ชนิดฟังก์ชัน ซึ่งจัดประเภทค่าฟังก์ชันที่ยึดตามชนิดของพารามิเตอร์และค่าผลลัพธ์

• ชนิด Table ซึ่งจัดประเภทค่าตารางโดยยึดตามชื่อคอลัมน์ ชนิดคอลัมน์ และคีย์

• ชนิด Nullable ซึ่งจัดประเภท null ของค่านอกเหนือจากค่าทั้งหมดที่จัดประเภทโดยชนิดฐาน

• ชนิด Type ซึ่งจัดประเภทค่าที่เป็นชนิด

ชุดของ ค่าฟังก์ชันทั้งหมดสอดคล้องกับชนิด functionนามธรรม ค่าตารางทั้งหมดกับชนิด tableนามธรรม ค่าทั้งหมดกับชนิด anyนามธรรม ค่าที่ไม่ใช่ null ทั้งหมดกับชนิด anynonnullนามธรรม และไม่มีค่ากับชนิด noneนามธรรม นิพจน์ของชนิด none ต้องเกิดข้อผิดพลาดหรือล้มเหลวในการยกเลิกเนื่องจากไม่สามารถสร้างค่าที่สอดคล้องกับชนิด noneได้เลย โปรดทราบว่าชนิด function แรกเริ่ม และ table เป็นนามธรรมเนื่องจากไม่มีฟังก์ชันหรือตารางโดยตรงจากชนิดเหล่านั้นตามลําดับ ชนิด record แรกเริ่ม และ list ไม่ใช่นามธรรมเนื่องจากเป็นตัวแทนของเรกคอร์ดแบบเปิดโดยไม่มีเขตข้อมูลที่กําหนดและรายการของชนิดใดก็ตาม ตามลําดับ

ชนิดทั้งหมดที่ไม่ใช่สมาชิกของชุดชนิดแรกเริ่มแบบปิดรวมถึงคู่แบบ nullable จะถูกเรียกว่า ชนิดแบบกําหนดเอง คุณสามารถเขียนชนิดแบบกําหนดเองโดยใช้ type-expression:

type-expression:
      primary-expression
       type primary-type
primary-type:
      primitive-or-nullable-primitive-type
      record-type
      list-type
      function-type
      table-type
      nullable-type
primitive-or-nullable-primitive-type:
       nullable _opt primitive-type
primitive-type: หนึ่งใน
      any anynonnull binary date datetime datetimezone duration function list logical
      none null number record table text time type

ชื่อ primitive-type เป็น คําหลัก เชิงบริบทที่รู้จักเฉพาะใน บริบทชนิด เท่านั้น การใช้วงเล็บใน บริบทชนิด จะย้ายไวยากรณ์กลับไปยังบริบทนิพจน์ปกติ ซึ่งจําเป็นต้องใช้คําสําคัญชนิดเพื่อย้ายกลับไปยังบริบทชนิด ตัวอย่างเช่น เมื่อต้องการเรียกใช้ฟังก์ชันใน บริบทชนิด คุณสามารถใช้วงเล็บได้:

type nullable ( Type.ForList({type number}) )   
// type nullable {number}

คุณยังสามารถใช้วงเล็บเพื่อเข้าถึงตัวแปรที่มีชื่อชนกับ ชื่อ primitive-type :

let  record = type [ A = any ]  in  type {(record)} 
// type {[ A = any ]}

ตัวอย่างต่อไปนี้กําหนดชนิดที่ใช้ในการจัดประเภทรายการของตัวเลข:

type { number }

ในทํานองเดียวกัน ตัวอย่างต่อไปนี้จะกําหนดชนิดแบบกําหนดเองที่จัดประเภทเรกคอร์ดที่มีเขตข้อมูลแบบบังคับที่ชื่อว่า X และ Y ที่มีค่าเป็นตัวเลข:

type [ X = number, Y = number ]

คุณจะได้รับชนิดของค่าโดยเบื้องต้นโดยใช้ฟังก์ชันไลบรารีมาตรฐาน Value.Typeดังที่แสดงในตัวอย่างต่อไปนี้:

Value.Type( 2 )                 // type number 
Value.Type( {2} )               // type list 
Value.Type( [ X = 1, Y = 2 ] )  // type record

ตัว is ดําเนินการ ถูกใช้เพื่อกําหนดว่าชนิดของค่าสามารถเข้ากันได้กับชนิดที่กําหนดหรือไม่ ดังที่แสดงในตัวอย่างต่อไปนี้:

1 is number          // true 
1 is text            // false 
{2} is list          // true

ตัวดําเนินการ จะ as ตรวจสอบว่าค่าสามารถเข้ากันได้กับชนิดที่กําหนดหรือไม่ และทําให้เกิดข้อผิดพลาดหากไม่เป็นเช่นนั้น มิฉะนั้นจะส่งกลับค่าเดิม

Value.Type( 1 as number )   // type number 
{2} as text                 // error, type mismatch

โปรดทราบว่า is ตัวดําเนินการ และ as ยอมรับเฉพาะ ชนิดแรกเริ่มหรือชนิดแรกเริ่มแบบ nullable (เช่น ชนิดที่ไม่ใช่แบบกําหนดเอง) เป็นตัวถูกดําเนินการด้านขวา M ไม่มีวิธีการตรวจสอบค่าสําหรับความสอดคล้องกับชนิดที่กําหนดเอง

ชนิด สามารถเข้ากันได้กับชนิด X ถ้าหากค่าทั้งหมดที่สอดคล้องกับ สอดคล้องกับYXY ชนิดทั้งหมดสามารถเข้ากันได้กับชนิด any และไม่มีชนิด (แต่noneตัวเอง) สามารถเข้ากันได้กับชนิดnone กราฟต่อไปนี้แสดงความสัมพันธ์ของความเข้ากันได้ (ความเข้ากันได้ของชนิดเป็นแบบสะท้อนและแบบถ่ายทอด ซึ่งเป็นรูปแบบแลตทิซที่มีชนิด any เป็นค่าด้านบนและชนิด none เป็นค่าด้านล่าง) ชื่อของชนิดนามธรรมจะถูกตั้งค่าเป็นตัวเอียง

ตัวดําเนินการต่อไปนี้ถูกกําหนดไว้สําหรับค่าชนิด:

ตัวดำเนินการ	ผลลัพธ์
x = y	Equal
x <> y	ไม่เท่ากับ
x ?? y	Coalesce

ชนิดเนทีฟของค่าชนิดคือชนิด typeอินทรินซิก

Primitive Types

Types ในภาษา M สร้างลําดับชั้นที่แยกจากกันที่รูทที่ชนิด anyซึ่งเป็นชนิดที่จัดประเภทค่าทั้งหมด ค่า M ใดก็ตามสอดคล้องกับชนิดย่อยแบบดั้งเดิมหนึ่งรายการที่เป็น anyอย่างแม่นยํา ชุดปิดของชนิดดั้งเดิมที่สืบทอดมาจากชนิด any มีดังนี้:

• type nullซึ่งจัดประเภทค่า null
• type logicalซึ่งจัดประเภทค่าจริงและเท็จ
• type numberซึ่งจัดประเภทค่าตัวเลข
• type timeซึ่งจัดประเภทค่าเวลา
• type dateซึ่งจัดประเภทค่าวันที่
• type datetimeซึ่งจัดประเภทค่าวันที่เวลา
• type datetimezoneซึ่งจัดประเภทค่าโซนวันที่เวลา
• type durationซึ่งจัดประเภทค่าระยะเวลา
• type textซึ่งจัดประเภทค่าข้อความ
• type binaryซึ่งจัดประเภทค่าไบนารี
• type typeซึ่งจัดประเภทค่าชนิด
• type listซึ่งจัดประเภทค่ารายการ
• type recordซึ่งจัดประเภทค่าเรกคอร์ด
• type tableซึ่งจัดประเภทค่าตาราง
• type functionซึ่งจัดประเภทค่าฟังก์ชัน
• type anynonnullซึ่งจัดประเภทค่าทั้งหมด ยกเว้นค่า null
• type noneซึ่งจัดประเภทไม่มีค่า

Any Type

ชนิด any เป็นนามธรรม จัดประเภทค่าทั้งหมดใน M และชนิดทั้งหมดใน M สามารถเข้ากันได้กับany ตัวแปรของชนิด any สามารถผูกกับค่าที่เป็นไปได้ทั้งหมด เนื่องจาก any เป็นนามธรรม ดังนั้นจึงไม่สามารถกําหนดให้เป็นค่าได้ - นั่นคือไม่มีค่าใดที่เป็นชนิด anyโดยตรง

List Types

ค่าใดก็ตามที่เป็นรายการสอดคล้องกับชนิด listอินทรินซิก ซึ่งไม่มีข้อจํากัดใดเลยในหน่วยข้อมูลภายในค่ารายการ

list-type:
       { item-type}
item-type:
      ประเภท

ผลลัพธ์ของการประเมิน list-type เป็นค่าชนิดรายการที่มีชนิดฐานคือlist

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงไวยากรณ์สําหรับการประกาศชนิดรายการที่เหมือนกัน:

type { number }        // list of numbers type 
     { record }        // list of records type
     {{ text }}        // list of lists of text values

ค่าสอดคล้องกับชนิดรายการ หากค่าเป็นรายการ และแต่ละรายการในค่ารายการนั้นสอดคล้องกับชนิดหน่วยข้อมูลของชนิดรายการ

ชนิดหน่วยข้อมูลของชนิดรายการบ่งชี้ว่าผูกไว้: หน่วยข้อมูลทั้งหมดของรายการที่สอดคล้องสอดคล้องกับชนิดหน่วยข้อมูล

ชนิดของเรกคอร์ด

ค่าใดก็ตามที่เป็นเรกคอร์ดสอดคล้องกับเรกคอร์ดชนิดอินทรินซิก ซึ่งไม่มีข้อจํากัดใดเลยในชื่อเขตข้อมูลหรือค่าภายในค่าเรกคอร์ด record-type value ถูกใช้เพื่อจํากัดชุดของชื่อที่ถูกต้อง รวมถึงชนิดของค่าที่ได้รับอนุญาตให้เชื่อมโยงกับชื่อเหล่านั้น

record-type:
       [ open-record-marker]
       [ field-specification-list_opt]
       [ field-specification-list, open-record-marker]
field-specification-list:
      field-specification
      field-specification,field-specification-list
field-specification:
       optional _opt field-name field-type-specification_opt
field-type-specification:
       = field-type
field-type:
      ชนิด
open-record-marker:
      ...

ผลลัพธ์ของการประเมิน record-type เป็นค่าชนิดที่มีชนิดฐานคือrecord

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงไวยากรณ์สําหรับการประกาศชนิดเรกคอร์ด:

type [ X = number, Y = number] 
type [ Name = text, Age = number ]
type [ Title = text, optional Description = text ] 
type [ Name = text, ... ]

ชนิดเรกคอร์ดเป็นแบบ ปิด ตามค่าเริ่มต้น ซึ่งหมายความว่าเขตข้อมูลเพิ่มเติมที่ไม่ปรากฏใน fieldspecification-list ไม่ได้รับอนุญาตให้แสดงในค่าที่สอดคล้อง การรวม openrecord-marker ในชนิดเรกคอร์ดประกาศชนิดเป็นแบบ เปิด ซึ่งอนุญาตให้เขตข้อมูลไม่ปรากฏในรายการข้อมูลจําเพาะของเขตข้อมูล นิพจน์สองรายการต่อไปนี้เทียบเท่ากัน:

type record   // primitive type classifying all records 
type [ ... ]  // custom type classifying all records

ค่าสอดคล้องกับชนิดเรกคอร์ดถ้าค่าเป็นเรกคอร์ด และข้อมูลจําเพาะของเขตข้อมูลแต่ละรายการในชนิดเรกคอร์ดเหมาะสม ข้อมูลจําเพาะของเขตข้อมูลจะเหมาะสมถ้ารายการใดรายการหนึ่งต่อไปนี้เป็นจริง:

• ชื่อเขตข้อมูลที่ตรงกับตัวระบุของข้อมูลจําเพาะมีอยู่ในเรกคอร์ดและค่าที่เกี่ยวข้องสอดคล้องกับชนิดของข้อมูลจําเพาะ

• มีการทําเครื่องหมายข้อมูลจําเพาะเป็นตัวเลือก และไม่พบชื่อเขตข้อมูลที่สอดคล้องกันในเรกคอร์ด

ค่าที่สอดคล้องอาจประกอบด้วยชื่อเขตข้อมูลที่ไม่ได้แสดงอยู่ในรายการข้อมูลจําเพาะของเขตข้อมูล ถ้าและเฉพาะเมื่อชนิดของเรกคอร์ดเป็นแบบเปิดเท่านั้น

Function Types

ค่าฟังก์ชันใดก็ตามสอดคล้องกับชนิด functionแรกเริ่ม ซึ่งไม่ได้กําหนดข้อจํากัดใดเลยบนชนิดของพารามิเตอร์ทางการของฟังก์ชันหรือค่าที่ส่งกลับของฟังก์ชัน function-type value แบบกําหนดเองถูกใช้เพื่อกําหนดข้อจํากัดของชนิดในลายเซ็นของค่าฟังก์ชันที่สอดคล้อง

function-type:_
       function ( parameter-specification-list_opt)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
parameter-type:
      type-assertion
type-assertion:
       as ประเภท

ผลลัพธ์ของการประเมิน function-type เป็นค่าชนิดที่มีชนิดฐานคือfunction

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงไวยากรณ์สําหรับการประกาศชนิดฟังก์ชัน:

type function (x as text) as number 
type function (y as number, optional z as text) as any

ค่าฟังก์ชันสอดคล้องกับชนิดฟังก์ชัน หากชนิดส่งคืนของค่าฟังก์ชันสามารถเข้ากันได้กับชนิดการแสดงผลลัพธ์ของชนิดฟังก์ชัน และข้อมูลจําเพาะของพารามิเตอร์แต่ละรายการของชนิดฟังก์ชันสามารถเข้ากันได้กับพารามิเตอร์ทางการที่ตําแหน่งสอดคล้องกันของฟังก์ชัน ข้อมูลจําเพาะของพารามิเตอร์สามารถเข้ากันได้กับพารามิเตอร์ทางการถ้าชนิด parameter-type ที่ระบุสามารถเข้ากันได้กับชนิดของพารามิเตอร์ทางการและข้อมูลจําเพาะของพารามิเตอร์เป็นตัวเลือกถ้าพารามิเตอร์ทางการเป็นตัวเลือก

ชื่อพารามิเตอร์ทางการจะถูกละเว้นเพื่อวัตถุประสงค์ในการพิจารณาความสอดคล้องของชนิดฟังก์ชัน

การระบุพารามิเตอร์เป็นตัวเลือกโดยปริยายทําให้ชนิดเป็น null ได้ ต่อไปนี้สร้างชนิดฟังก์ชันที่เหมือนกัน:

type function (optional x as text) as any
type function (optional x as nullable text) as any

Table types (ชนิดตาราง)

table-type value ถูกใช้เพื่อกําหนดโครงสร้างของค่าตาราง

table-type:
       table row-type
row-type:
       [ field-specification-list_opt]

ผลลัพธ์ของการประเมิน table-type เป็นค่าชนิดที่มีชนิดฐานคือtable

ชนิดแถวของตารางจะระบุชื่อคอลัมน์และชนิดคอลัมน์ของตารางเป็นชนิดเรกคอร์ดแบบปิด เพื่อให้ค่าตารางทั้งหมดสอดคล้องกับชนิด tableชนิดแถวของตารางคือชนิด record (ชนิดเรกคอร์ดแบบเปิดที่ว่างเปล่า) ดังนั้น ตารางชนิดคือนามธรรมเนื่องจากไม่มีค่าตารางสามารถมีชนิด tableแถวของ (แต่ค่าตารางทั้งหมดมีชนิดแถวที่สามารถเข้ากันได้กับชนิดแถวของชนิด table) ตัวอย่างต่อไปนี้แสดงการสร้างชนิดตาราง:

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 ยังมีข้อกําหนดของคีย์ของค่าตาราง คีย์คือชุดของชื่อคอลัมน์ คุณสามารถกําหนดเป็นคีย์หลักของตารางได้สูงสุดหนึ่งคีย์ (ภายใน M คีย์ตารางไม่มีความหมายเชิงความหมาย อย่างไรก็ตาม เป็นเรื่องปกติสําหรับแหล่งข้อมูลภายนอก เช่น ฐานข้อมูลหรือตัวดึงข้อมูล OData เพื่อกําหนดคีย์ในตาราง Power Query ใช้ข้อมูลคีย์เพื่อปรับปรุงประสิทธิภาพการทํางานขั้นสูง เช่น การดําเนินการรวมข้ามแหล่งข้อมูล)

ฟังก์ชัน Type.TableKeysไลบรารีมาตรฐาน , Type.AddTableKeyและ Type.ReplaceTableKeys สามารถใช้เพื่อรับคีย์ของชนิดตาราง เพิ่มคีย์ลงในชนิดตาราง และแทนที่คีย์ทั้งหมดของชนิดตารางตามลําดับ

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

ชนิด Nullable

สําหรับ ใดก็ตาม type Tตัวแปร nullable สามารถมาจากการใช้ nullable-type:

nullable-type:
       nullable ประเภท

ผลลัพธ์เป็นชนิดนามธรรมที่อนุญาตให้ใช้ค่าชนิด T หรือค่าnull

42 is nullable number             // true null is
nullable number                   // true

การบอกลักษณะ type nullableT จะลดไปเป็นการ type nulltypeบอกหรือ T (โปรดทราบว่าชนิด nullable เป็นนามธรรมและไม่มีค่าที่สามารถเป็นชนิดนามธรรมโดยตรง)

Value.Type(42 as nullable number)       // type number
Value.Type(null as nullable number)     // type null

ฟังก์ชัน Type.IsNullable ไลบรารีมาตรฐาน และ Type.NonNullable สามารถใช้ในการทดสอบชนิดสําหรับ nullability และเพื่อลบ nullability ออกจากชนิดได้

การระงับต่อไปนี้ (สําหรับ ใดก็ตาม type T):

• type T สามารถเข้ากันได้กับ type nullable T
• Type.NonNullable(type T) สามารถเข้ากันได้กับ type T

รายการต่อไปนี้เทียบเท่ากันเป็นคู่ (สําหรับ ใดก็ตาม 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

ชนิดโดยเริ่มต้นของค่า

ชนิดโดยกําเนิดของค่าคือชนิดที่ค่าถูกประกาศเพื่อให้สอดคล้อง

อาจมีการกําหนดชนิดให้กับค่าโดยใช้ฟังก์ชัน Value.ReplaceTypeไลบรารี ฟังก์ชันนี้ส่งกลับค่าใหม่พร้อมกับชนิดที่กําหนดหรือทําให้เกิดข้อผิดพลาดหากชนิดใหม่ไม่สามารถใช้ร่วมกับค่าได้

เมื่อมีการกําหนดชนิดให้กับค่า จะมีการตรวจสอบความสอดคล้องที่จํากัดเกิดขึ้นเท่านั้น:

• ชนิดที่กําหนดต้องเป็นชนิดแรกเริ่มที่ไม่ใช่นามธรรม ไม่ใช่ null และเข้ากันได้กับชนิดดั้งเดิม (เนทีฟ) ของค่า
• เมื่อมีการกําหนดชนิดแบบกําหนดเองที่กําหนดโครงสร้าง โครงสร้างนั้นจะต้องตรงกับโครงสร้างของค่า
  • สําหรับเรกคอร์ด: ต้องปิดชนิด ต้องกําหนดจํานวนเขตข้อมูลเดียวกันกับค่า และต้องไม่มีเขตข้อมูลที่เลือกได้ (ชื่อเขตข้อมูลและชนิดเขตข้อมูลของชนิดจะแทนที่เขตข้อมูลที่เชื่อมโยงกับระเบียนในปัจจุบัน อย่างไรก็ตาม ค่าของเขตข้อมูลที่มีอยู่จะไม่ถูกทําเครื่องหมายเทียบกับชนิดเขตข้อมูลใหม่)
  • สําหรับตาราง: ชนิด ต้องกําหนดจํานวนคอลัมน์เท่ากับค่า (ชื่อคอลัมน์และชนิดคอลัมน์ของชนิด จะแทนที่ชื่อและชนิดคอลัมน์ที่เชื่อมโยงกับตารางในปัจจุบัน อย่างไรก็ตาม ค่าคอลัมน์ที่มีอยู่จะไม่ถูกตรวจสอบกับชนิดคอลัมน์ใหม่)
  • สําหรับฟังก์ชัน: ชนิด ต้องกําหนดจํานวนพารามิเตอร์ที่จําเป็นเดียวกัน ตลอดจนจํานวนพารามิเตอร์ทางเลือกเดียวกันกับค่า (พารามิเตอร์ของชนิดและการยืนยันผลลัพธ์ ตลอดจนชื่อพารามิเตอร์ จะแทนที่ค่าที่เชื่อมโยงกับชนิดปัจจุบันของค่าฟังก์ชัน อย่างไรก็ตาม การยืนยันใหม่จะไม่มีผลต่อลักษณะการทํางานจริงของฟังก์ชัน)
  • สําหรับรายการ: ค่าต้องเป็นรายการ (อย่างไรก็ตาม จะไม่มีการตรวจสอบรายการที่มีอยู่กับชนิดหน่วยข้อมูลใหม่)

ฟังก์ชันไลบรารีอาจเลือกที่จะคํานวณและกําหนดชนิดที่ซับซ้อนให้กับผลลัพธ์ตามชนิดโดยอ้างอิงของค่าที่ป้อน

คุณอาจได้รับชนิดโดยการกําหนดของค่าโดยใช้ฟังก์ชัน Value.Typeไลบรารี ตัวอย่างเช่น:

Value.Type( Value.ReplaceType( {1}, type {number} ) 
// type {number}

ความเทียบเท่าและความเข้ากันได้ของชนิด

ไม่ได้กําหนดความเทียบเท่าของชนิดใน M การใช้งาน M อาจเลือกที่จะใช้กฎของตนเองเพื่อดําเนินการเปรียบเทียบความเท่ากันระหว่างค่าชนิดได้ การเปรียบเทียบค่าชนิดสองค่าเพื่อความเท่ากันควรประเมินว่า true มีความเหมือนกันตามการใช้งานหรือไม่ หรือไม่ false ก็ควรประเมินว่าเหมือนกันหรือไม่ ในกรณีใดกรณีหนึ่ง การตอบสนองที่ส่งกลับจะต้องสอดคล้องกันหากค่าสองค่าเดียวกันถูกเปรียบเทียบซ้ํา ๆ โปรดทราบว่าภายในการนําไปใช้ที่กําหนด เปรียบเทียบค่าชนิดที่เหมือนกันบางค่า (เช่น (type text) = (type text)) อาจส่งกลับ ในขณะที่เปรียบเทียบค่าอื่น ๆ (เช่น true) อาจไม่เป็น(type [a = text]) = (type [a = text])เช่นนั้น

ความเข้ากันได้ระหว่างชนิดที่กําหนดและชนิดแรกเริ่มหรือชนิดแรกเริ่มแบบ nullable สามารถกําหนดได้โดยใช้ฟังก์ชัน Type.Isไลบรารี ซึ่งยอมรับค่าชนิดแบบอาบิทราจเป็นอาร์กิวเมนต์แรกและค่านิดแรกเริ่มหรือค่าดั้งเดิมแบบ nullable เป็นอาร์กิวเมนต์ที่สอง:

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 สําหรับการกําหนดความเข้ากันได้ของชนิดที่กําหนดด้วยชนิดที่กําหนดเอง

ไลบรารีมาตรฐานประกอบด้วยคอลเลกชันของฟังก์ชันเพื่อแยกลักษณะการกําหนดจากชนิดแบบกําหนดเอง เพื่อให้สามารถใช้การทดสอบความเข้ากันได้เฉพาะเป็นนิพจน์ M ด้านล่างนี้เป็นตัวอย่างบางรายการ ดูข้อมูลจําเพาะของไลบรารี M สําหรับรายละเอียดทั้งหมด

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 

เนื้อหาที่เกี่ยวข้อง

• ชนิดและการแปลงชนิด
• Types ใน ภาษาสูตร Power Query M