ในการคำนวณ การเรียกใช้ฟังก์ชันแบบคงที่ ( static dispatch)เป็นรูปแบบหนึ่งของโพลีมอร์ฟิซึมที่ได้รับการแก้ไขอย่างสมบูรณ์ในระหว่างการคอมไพล์เป็นรูปแบบหนึ่งของการเรียกใช้เมธอดซึ่งอธิบายว่าภาษาหรือสภาพแวดล้อมจะเลือกการใช้งานเมธอดหรือฟังก์ชันใดที่จะใช้^{[ 1 ]}

ตัวอย่างเช่นเทมเพลตในภาษา C++และการเขียนโปรแกรมแบบเจเนริกใน ภาษา Fortranและภาษาอื่นๆ ร่วมกับการโอเวอร์โหลดฟังก์ชัน (รวมถึงการโอเวอร์โหลดตัวดำเนินการ ) โค้ดจะถูกเรียกว่าเป็นแบบโมโนมอ ร์ฟิเซชัน โดยมี การอนุมานและติดตามชนิดข้อมูลเฉพาะ ผ่าน กราฟการเรียกเพื่อสร้างอินสแตนซ์ของฟังก์ชันเจเนริก เวอร์ชันเฉพาะ และเลือกการเรียกฟังก์ชันเฉพาะตามคำจำกัดความที่ให้มา

สิ่งนี้แตกต่างจากการส่งคำสั่งแบบไดนามิกซึ่งอิงตามข้อมูลขณะทำงาน (เช่น ตัวชี้ vtableและข้อมูลประเภทขณะทำงานรูปแบบอื่นๆ)

การเรียกใช้ฟังก์ชันแบบคงที่ (Static dispatch) เป็นไปได้เพราะมีการรับประกันว่าจะมีเพียงการใช้งานเดียวของเมธอดที่เกี่ยวข้องเท่านั้น โดยทั่วไปแล้ว การเรียกใช้ฟังก์ชันแบบคงที่นั้นเร็วกว่าการเรียกใช้ฟังก์ชันแบบไดนามิก (Dynamic dispatch) ซึ่งโดยธรรมชาติแล้วจะมีค่าใช้จ่ายสูงกว่า

พิจารณา โปรแกรม Rust ต่อไปนี้ : ^{[ 2 ]}

ลักษณะสัตว์เลี้ยง{fn พูด( & ตัวเอง);}โครงสร้างแมว{ชื่อ: สตริง}อิมพลีแคท{fn ใหม่( name : String ) -> Self {แมว{ ชื่อ}}}impl สัตว์เลี้ยงสำหรับแมว{fn พูด( & ตัวเอง) {println! ( "{} พูดว่าเหมียว!" , self . name );}}fn talk < T : Pet > ( pet : T ) {สัตว์เลี้ยง. พูด();}ฟังก์ชันหลัก() {let pet = Cat :: new ( String :: from ( "Simba" ));พูดคุย( สัตว์เลี้ยง);}

คอมไพเลอร์ Rust จะ แปลง โค้ดของโปรแกรม ให้เป็นรูปแบบโมโนมอร์ฟิก ในระหว่างการคอมไพล์เป็น:

// [...]// โครงสร้าง struct Cat, การใช้งานของ Cat, การใช้งาน Pet สำหรับ struct Cat และ trait ของ Pet ยังคงเหมือนเดิมfn talk_cat ( pet : Cat ) {แมว:: พูด( และลูบ)}ฟังก์ชันหลัก() {let pet = Cat :: new ( String :: from ( "Simba" ));talk_cat ( pet ); // talk(pet) ถูกแทนที่ด้วย talk_cat ที่มีความเฉพาะเจาะจงมากกว่า}

^{[หมายเหตุ 1 ]}

• การจัดส่งแบบไดนามิก