ประเภท

บทความ
01/31/2024

ค่าชนิด คือค่าที่ใช้ในการจัดประเภทค่าอื่น ๆ ค่าที่จัดประเภทตามชนิดจะกล่าวได้ว่า สอดคล้องกับ ชนิดนั้น ระบบชนิด 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, anytableanynonnull และnone ค่าฟังก์ชันทั้งหมดสอดคล้องกับชนิด functionนามธรรม ค่าตารางทั้งหมดกับชนิด tableนามธรรม ค่าทั้งหมดกับชนิด anyนามธรรม ค่าที่ไม่ใช่ null ทั้งหมดกับชนิด anynonnullนามธรรม และไม่มีค่ากับชนิด noneนามธรรม นิพจน์ของชนิด none ต้องเกิดข้อผิดพลาดหรือล้มเหลวในการยกเลิกเนื่องจากไม่สามารถสร้างค่าที่สอดคล้องกับชนิด noneได้เลย โปรดทราบว่าชนิด function แรกเริ่ม และ table เป็นนามธรรมเนื่องจากไม่มีฟังก์ชันหรือตารางโดยตรงจากชนิดเหล่านั้นตามลําดับ ชนิด record แรกเริ่ม และ list ไม่ใช่นามธรรมเนื่องจากเป็นตัวแทนของเรกคอร์ดแบบเปิดโดยไม่มีเขตข้อมูลที่กําหนดและรายการของชนิดใดก็ตาม ตามลําดับ

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

type-expression:
      primary-expression
      typeprimary-type
ประเภท:
      primary-expression
      primary-type
primary-type:
      primitive-type
      record-type
      list-type
      function-type
      table-type
      nullable-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 ไม่มีวิธีการตรวจสอบค่าสําหรับความสอดคล้องกับชนิดที่กําหนดเอง

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

ความเข้ากันได้ของชนิด

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

ตัวดำเนินการ	ผลลัพธ์
`x = y`	Equal
`x <> y`	Not equal
`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 )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:
      optionalparameter-specification
parameter-specification:
      parameter-name parameter-type
function-return-type:
      การยืนยัน
คําแถลง:
      as nullable-primitive-type

ผลลัพธ์ของการประเมิน 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:
tablerow-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 nullable T จะลดไปเป็นการ type null type บอกหรือ 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)) อาจส่งกลับ ในขณะที่เปรียบเทียบค่าอื่น ๆ (เช่น (type [a = text]) = (type [a = text])) อาจไม่เป็นtrueเช่นนั้น

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

แชร์ผ่าน