สนิม
กระบวนทัศน์	หลายกระบวนทัศน์ : พร้อมกัน ใช้งานได้ ทั่วไป คำสั่ง โครงสร้าง
นักพัฒนา	ทีม Rust
ปรากฏครั้งแรก	19 มกราคม 2555 ( 19 มกราคม 2012 )
เวอร์ชันเสถียร	1.96 [ 1 ]  / 28 พฤษภาคม 2026 ( 28 พฤษภาคม 2569 )
วินัยในการพิมพ์	อัฟฟิน อนุมาน นาม คงที่ แข็งแกร่ง
ภาษาการใช้งาน	OCaml (2006–2011) Rust (2012–ปัจจุบัน)
แพลตฟอร์ม	ข้ามแพลตฟอร์ม[หมายเหตุ 1 ]
โอเอส	ข้ามแพลตฟอร์ม[หมายเหตุ 2 ]
ใบอนุญาต	MIT , Apache 2.0 [หมายเหตุ 3 ]
นามสกุลไฟล์	.rs,.rlib
เว็บไซต์	rust-lang.org
ได้รับอิทธิพลจาก
อาเลฟ เบต้า ซีแอลยู ซี# ซี++ พายุไซโคลน ต้นเอล์ม เออร์ลัง ฮัสเคลล์ เฮอร์เมส ลิมโบ้ เมซา เนเปียร์ ข่าวใหม่ ไม่มี[หมายเหตุ 4 ] โอแคมล์ ทับทิม ซาเธอร์ โครงการ มาตรฐาน ML สวิฟต์[ 7 ] [ 8 ]
ได้รับอิทธิพล
อิดริส[ 9 ] PHP [ 10 ] [ 11 ] [ 12 ] [ 13 ] โครงการเวโรนา[ 14 ] ประกายไฟ[ 15 ] สวิฟต์[ 16 ] V [ 17 ] ซิก[ 18 ] แสงแวววาว[ 19 ]

Rustเป็นภาษาโปรแกรมอเนกประสงค์ ที่เน้นประสิทธิภาพความปลอดภัยของชนิดข้อมูลการทำงานพร้อมกันและความปลอดภัยของหน่วยความจำ

Rust รองรับ กระบวน ทัศน์การเขียนโปรแกรม หลายแบบ ได้รับอิทธิพลจากแนวคิดของการเขียนโปรแกรมเชิงฟังก์ชันรวมถึง ความ ไม่เปลี่ยนแปลง ของข้อมูล ฟังก์ชันลำดับสูงชนิดข้อมูลเชิงพีชคณิตและการจับคู่รูปแบบนอกจากนี้ยังรองรับการเขียนโปรแกรมเชิงวัตถุผ่านโครงสร้าง (structs) enums traits และ methods Rust บังคับใช้ความปลอดภัยของหน่วยความจำ (กล่าวคือการอ้างอิง ทั้งหมด ชี้ไปยังหน่วยความจำที่ถูกต้อง) โดยไม่ต้องใช้ตัวเก็บขยะ แบบทั่วไป แต่จะป้องกัน ข้อผิดพลาดด้านความปลอดภัยของหน่วยความจำและการแข่งขันของข้อมูลด้วย "ตัวตรวจสอบการยืม" (borrow checker) ซึ่งติดตามอายุ การใช้ งานของการอ้างอิง วัตถุ ในระหว่างการคอมไพล์

Graydon Hoare นักพัฒนาซอฟต์แวร์ได้สร้าง Rust ขึ้นในปี 2006 ขณะทำงานอยู่ที่Mozillaซึ่งให้การสนับสนุนโครงการอย่างเป็นทางการในปี 2009 Rust 1.0 เวอร์ชันเสถียรแรกได้รับการเผยแพร่ในเดือนพฤษภาคม 2015 หลังจากที่ Mozilla ปลดพนักงานในเดือนสิงหาคม 2020 บริษัทอีกสี่แห่งได้เข้าร่วมกับ Mozilla ในการสนับสนุน Rust ผ่านการก่อตั้งRust Foundationในเดือนกุมภาพันธ์ 2021

Rust ถูกนำไปใช้ในโครงการซอฟต์แวร์หลายโครงการ โดยเฉพาะอย่างยิ่งเว็บเซอร์วิสและซอฟต์แวร์ระบบมีการศึกษาในเชิงวิชาการและมีชุมชนนักพัฒนาที่เติบโตขึ้นเรื่อย ๆ

Rust เริ่มต้นจากโครงการส่วนตัวของ Graydon Hoare พนักงาน ของ Mozillaในปี 2006 ตาม รายงานของ MIT Technology Reviewเขาเริ่มโครงการนี้เนื่องจากรู้สึกหงุดหงิดกับลิฟต์เสียในอาคารอพาร์ตเมนต์ของเขาซึ่งซอฟต์แวร์ล่ม^{[ 20 ]}และตั้งชื่อภาษาตามกลุ่มเชื้อราที่มีชื่อเดียวกันซึ่ง "ได้รับการออกแบบเกินความจำเป็นเพื่อความอยู่รอด" ^{[ 20 ]}ในช่วงเวลาระหว่างปี 2006 ถึง 2009 Rust ไม่ได้ถูกเผยแพร่ให้ผู้อื่นใน Mozilla ทราบ และถูกเขียนขึ้นในเวลาว่างของ Hoare ^{[ 21 ] : 7:50} Hoare เริ่มพูดถึงภาษานี้ประมาณปี 2009 หลังจากที่กลุ่มเล็กๆ ใน Mozilla เริ่มสนใจโครงการนี้^{[ 22 ]} Hoare อ้างถึงภาษาต่างๆ จากช่วงทศวรรษ 1970, 1980 และ 1990 เป็นอิทธิพล ซึ่งรวมถึงCLU , BETA , Mesa , NIL, ^{[หมายเหตุ 4 ]} Erlang , Newsqueak , Napier , Hermes , Sather , AlefและLimbo ^{[ 22 ]}เขาอธิบายภาษานี้ว่าเป็น "เทคโนโลยีจากอดีตที่มาเพื่อช่วยอนาคตจากตัวมันเอง" [ ^{21 ] : 8:17 [ 22 ] Manish Goregaokar นักพัฒนา Rust ยุคแรกๆ อธิบาย Rust ในทำนองเดียวกันว่ามีพื้นฐานมาจาก "งานวิจัยที่เก่าแก่หลายทศวรรษเป็นส่วน ใหญ่} " ^{[ 20 ]}

ในช่วงปีแรก ๆคอมไพเลอร์ Rust ถูกเขียนขึ้นด้วย ภาษาOCamlประมาณ 38,000 บรรทัด^{[ 21 ] : 15:34 [ 23 ]} Rust ในยุคแรกมีคุณสมบัติหลายอย่างที่ไม่มีอยู่ในปัจจุบันแล้ว รวมถึงการเขียนโปรแกรมเชิงวัตถุ อย่างชัดเจน ผ่านobjคีย์เวิร์ด^{[ 21 ] : 10:08} และ ระบบ typestatesสำหรับการเปลี่ยนแปลงสถานะของตัวแปร เช่น การเปลี่ยนจากสถานะที่ยังไม่ได้เริ่มต้นเป็นสถานะที่เริ่มต้นแล้ว^{[ 21 ] : 13:12}

Mozilla ให้การสนับสนุนโครงการ Rust อย่างเป็นทางการในปี 2009 ^{[ 20 ]} Brendan Eichและผู้บริหารคนอื่นๆ ต่างสนใจความเป็นไปได้ในการใช้ Rust สำหรับเอนจิ้นเว็บเบราว์เซอร์ที่ ปลอดภัย จึงได้ส่งวิศวกรเข้าร่วมโครงการ ได้แก่ Patrick Walton, Niko Matsakis, Felix Klock และ Manish Goregaokar ^{[ 20 ]}ห้องประชุมที่นักพัฒนาโครงการใช้ถูกขนานนามว่า "ถ้ำเนิร์ด" โดยมีป้ายติดอยู่ด้านนอกประตู^{[ 20 ]}

ในช่วงเวลาดังกล่าว งานได้เปลี่ยนจากคอมไพเลอร์ OCaml รุ่นแรกไปเป็นคอมไพเลอร์แบบโฮสต์ตัวเอง ( กล่าว คือเขียนด้วย Rust) ที่กำหนดเป้าหมายเป็นLLVM [ ^{24 ] [ หมายเหตุ 5 ]}ระบบการเป็นเจ้าของได้ถูกนำมาใช้ในปี 2010 ^{[ 20 ]}โลโก้ Rust ได้รับการพัฒนาในปี 2011 โดยอิงจากจานโซ่จักรยาน^{[ 26 ]}

Rust 0.1 กลายเป็นเวอร์ชันแรกที่เผยแพร่สู่สาธารณะเมื่อวันที่ 20 มกราคม 2012 ^{[ 27 ]}สำหรับ Windows, Linux และ MacOS ^{[ 28 ]}ในช่วงต้นทศวรรษ 2010 มีการมีส่วนร่วมเพิ่มมากขึ้นจากวิศวกรเต็มเวลาที่ Mozilla และอาสาสมัครโอเพนซอร์สนอก Mozilla ^{[ 20 ]}

ช่วงปี 2012 ถึง 2015 มีการเปลี่ยนแปลงครั้งสำคัญในระบบประเภท ของ Rust ^{[ 21 ] : 18:36 [ 20 ]}การจัดการหน่วยความจำผ่านระบบความเป็นเจ้าของได้รับการรวมและขยายอย่างค่อยเป็นค่อยไป ภายในปี 2013 ตัวเก็บขยะแทบจะไม่ถูกใช้งาน และถูกลบออกเพื่อสนับสนุนระบบความเป็นเจ้าของ^{[ 20 ]}คุณสมบัติอื่นๆ ถูกลบออกเพื่อทำให้ภาษาง่ายขึ้น รวมถึง typestates, pureคำหลัก^{[ 29 ]}ประเภทตัวชี้เฉพาะต่างๆ และการสนับสนุนไวยากรณ์สำหรับช่องสัญญาณ [ ^{21 ] : 22:32}

ตามที่ Steve Klabnik กล่าว Rust ได้รับอิทธิพลในช่วงเวลานี้จากนักพัฒนาที่มาจากC++ (เช่น ประสิทธิภาพระดับต่ำของฟีเจอร์ต่างๆ) ภาษาสคริปต์ (เช่น Cargo และการจัดการแพ็กเกจ) และการเขียนโปรแกรมเชิงฟังก์ชัน (เช่น การพัฒนาระบบประเภท) ^{[ 21 ] : 30:50}

Graydon Hoare ลาออกจาก Rust ในปี 2013 ^{[ 20 ]}หลังจาก Hoare ออกไป Rust ก็พัฒนาไปเองตามธรรมชาติภายใต้โครงสร้างการกำกับดูแลแบบสหพันธ์ โดยมี "ทีมหลัก" เริ่มต้น 6 คน^{[ 21 ] : 21:45} และมีนักพัฒนารวมประมาณ 30-40 คนในทีมอื่นๆ^{[ 21 ] : 22:22} กระบวนการขอความคิดเห็น (RFC) สำหรับคุณสมบัติภาษาใหม่ถูกเพิ่มเข้ามาในเดือนมีนาคม 2014 ^{[ 21 ] : 33:47} ทีมหลักจะเติบโตเป็น 9 คนภายในปี 2016 ^{[ 21 ] : 21:45} โดยมี RFC มากกว่า 1600 รายการ^{[ 21 ] : 34:08}

ตามที่ Andrew Binstock กล่าวไว้ในDr. Dobb's Journalเมื่อเดือนมกราคม 2014 แม้ว่า Rust จะ "ได้รับการมองว่าเป็นภาษาที่สง่างามอย่างน่าทึ่ง" แต่การนำไปใช้กลับชะลอตัวลงเนื่องจากมีการเปลี่ยนแปลงอย่างมากในแต่ละเวอร์ชัน^{[ 30 ]}การพัฒนา Rust ในช่วงเวลานี้มุ่งเน้นไปที่การทำให้คุณสมบัติสำหรับเวอร์ชัน 1.0 เสร็จสมบูรณ์ เพื่อที่จะสามารถเริ่มรับประกันความเข้ากันได้แบบย้อนหลังได้ [ ^{21 ] : 41:26}

หกปีหลังจากที่ Mozilla ให้การสนับสนุน Rust 1.0 ก็ได้รับการเผยแพร่และกลายเป็นเวอร์ชันเสถียร แรก เมื่อวันที่ 15 พฤษภาคม 2015 ^{[ 20 ]}หนึ่งปีต่อมา คอมไพเลอร์ Rust มีผู้ร่วมพัฒนามากกว่า 1,400 คน และมีไลบรารีของบุคคลที่สามมากกว่า 5,000 รายการที่เผยแพร่บนเว็บไซต์จัดการแพ็กเกจ Rust Crates.io ^{[ 21 ] : 43:15}

การพัฒนาเอนจินเบราว์เซอร์ Servoดำเนินต่อไปควบคู่ไปกับ Rust โดยได้รับการสนับสนุนทางการเงินร่วมกันจาก Mozilla และSamsung ^{[ 31} ] ทีมงานเบื้องหลังทั้งสองโครงการทำงานร่วมกันอย่างใกล้ชิด คุณสมบัติใหม่ใน Rust ได้รับการทดสอบโดยทีม Servo และคุณสมบัติใหม่ใน Servo ถูกนำมาใช้เพื่อให้ข้อเสนอแนะแก่ทีม Rust ^{[ 21 ] : 5:41} Servo เวอร์ชันแรกเปิดตัวในปี 2016 ^{[ 20 ]}เว็บ เบราว์เซอร์ Firefoxมาพร้อมกับโค้ด Rust ตั้งแต่ปี 2016 (เวอร์ชัน 45) ^{[ 21 ] : 53:30 [ 32 ]}แต่ส่วนประกอบของ Servo ไม่ปรากฏใน Firefox จนกระทั่งเดือนกันยายน 2017 (เวอร์ชัน 57) ซึ่งเป็นส่วนหนึ่งของโครงการGeckoและQuantum ^{[ 33 ]}

มีการปรับปรุงระบบนิเวศของชุดเครื่องมือ Rust ในช่วงหลายปีหลังจากเวอร์ชัน 1.0 รวมถึงRustfmtการบูรณาการสภาพแวดล้อมการพัฒนาแบบบูรณาการ [ ^{21 ] : 44:56} และวงจรการทดสอบและการเผยแพร่คอมไพเลอร์อย่างสม่ำเสมอ^{[ 21 ] : 46:48} ชุมชน Rust ได้รับหลักปฏิบัติและ ห้องแชท IRCสำหรับการสนทนา^{[ 21 ] : 50:36}

การนำไปใช้ครั้งแรกที่ทราบนอกเหนือจาก Mozilla คือโครงการส่วนบุคคลที่ Samsung, Facebook (ปัจจุบันคือMeta Platforms ), Dropboxและ Tilde, Inc. ซึ่งเป็นบริษัทที่อยู่เบื้องหลังember.js ^{[ 21 ] : 55:44 [ 20 ]} Amazon Web Servicesตามมาในปี 2020 ^{[ 20 ]}วิศวกรอ้างถึงประสิทธิภาพ การไม่มีตัวเก็บขยะ ความปลอดภัย และความสะดวกสบายในการทำงานในภาษาดังกล่าวเป็นเหตุผลในการนำไปใช้ นักพัฒนาของ Amazon อ้างถึงการค้นพบโดยนักวิจัยชาวโปรตุเกสว่าโค้ด Rust ใช้พลังงานน้อยกว่าเมื่อเทียบกับโค้ดที่คล้ายกันซึ่งเขียนด้วยJava ^{[ 20 ] [ 34 ]}

ในเดือนสิงหาคม พ.ศ. 2563 Mozilla ได้เลิกจ้างพนักงาน 250 คนจากทั้งหมด 1,000 คนทั่วโลก ซึ่งเป็นส่วนหนึ่งของการปรับโครงสร้างองค์กรอันเนื่องมาจาก การระบาด ของโรคโควิด-19 ^{[ 35 ] [ 36 ]}ทีมงานเบื้องหลัง Servo ก็ถูกยุบ เหตุการณ์นี้ทำให้เกิดความกังวลเกี่ยวกับอนาคตของ Rust ^{[ 37 ]}ในสัปดาห์ต่อมา ทีมหลักของ Rust ได้รับทราบถึงผลกระทบอย่างรุนแรงจากการเลิกจ้างและประกาศว่ากำลังวางแผนจัดตั้งมูลนิธิ Rust เป้าหมายแรกของมูลนิธิคือการเป็นเจ้าของเครื่องหมายการค้าและชื่อโดเมน ทั้งหมด และรับผิดชอบค่าใช้จ่ายทางการเงิน^{[ 38 ]}

เมื่อวันที่ 8 กุมภาพันธ์ 2021 บริษัทผู้ก่อตั้ง 5 บริษัท ได้แก่ Amazon Web Services , Google , Huawei , MicrosoftและMozillaได้ประกาศการก่อตั้งRust Foundation ^{[ 39 ] [ 40} ] มูลนิธิจะให้การสนับสนุนทางการเงินแก่นักพัฒนา Rust ในรูปแบบของเงินช่วยเหลือและเงินทุนสำหรับเซิร์ฟเวอร์^{[ 20 ]}ในบทความบล็อกที่เผยแพร่เมื่อวันที่ 6 เมษายน 2021 Google ได้ประกาศสนับสนุน Rust ภายในAndroid Open Source Project ในฐานะทางเลือกแทน C ^/ C++ ^{[ 41 ]}

เมื่อวันที่ 22 พฤศจิกายน 2021 ทีมผู้ดูแลซึ่งมีหน้าที่บังคับใช้ระเบียบปฏิบัติของชุมชนได้ประกาศลาออก "เพื่อประท้วงการที่ทีมหลักไม่รับผิดชอบต่อใครนอกจากตัวเอง" ^{[ 42 ]}ในเดือนพฤษภาคม 2022 สมาชิกของสภาผู้นำ Rust ได้โพสต์คำตอบต่อสาธารณะเกี่ยวกับเหตุการณ์ดังกล่าว^{[ 43 ]}

มูลนิธิ Rust ได้เผยแพร่ร่างนโยบายเครื่องหมายการค้าฉบับใหม่เมื่อวันที่ 6 เมษายน 2566 ซึ่งส่งผลให้เกิดปฏิกิริยาเชิงลบอย่างกว้างขวางจากผู้ใช้และผู้มีส่วนร่วมของ Rust ^{[ 44 ]}นโยบายเครื่องหมายการค้าดังกล่าวรวมถึงกฎเกณฑ์เกี่ยวกับการใช้โลโก้และชื่อของ Rust ^{[ 44 ]}

ไวยากรณ์ของ Rust คล้ายกับของCและC++ [ ^{45 ] [ 46 ]}แม้ว่าคุณสมบัติหลายอย่างจะได้รับอิทธิพลจาก ภาษาการ ^{เขียน}โปรแกรมเชิงฟังก์ชันเช่นOCaml [ ^{47 ] Hoare ได้อธิบายว่า Rust มุ่งเป้าไปที่นักพัฒนา C++ ที่}รู้สึกผิดหวัง^{[ 22 ]}

ด้านล่างนี้คือโปรแกรม "Hello, World!"ในภาษา Rust fnคำหลัก `function` หมายถึงฟังก์ชันและprintln!มาโคร ` print` (ดู§ Macros ) จะพิมพ์ข้อความไปยังเอาต์พุตมาตรฐาน^{[ 48 ]}คำสั่งในภาษา Rust จะคั่นด้วยเครื่องหมาย เซมิโคลอน

fn main () { println! ( "Hello, World!" ); }

ตัวแปรใน Rust ถูกกำหนดผ่านletคีย์เวิร์ด^{[ 49 ]}ตัวอย่างด้านล่างกำหนดค่าให้กับตัวแปรที่มีชื่อfooประเภทi32และแสดงค่าออกมาสามารถละเว้นคำอธิบายประเภทได้ :i32

fn main () { let foo : i32 = 10 ; println! ( "ค่าของ foo คือ {foo}" ); }

โดยค่าเริ่มต้น ตัวแปรจะไม่สามารถเปลี่ยนแปลงได้เว้นแต่mutจะมีการเพิ่มคำหลัก^{[ 50 ]}ตัวอย่างต่อไปนี้ใช้//ซึ่งหมายถึงจุดเริ่มต้นของความคิดเห็น^{[ 51 ]}

fn main () { // โค้ดนี้จะไม่สามารถคอมไพล์ได้หากไม่เพิ่ม "mut" let mut foo = 10 ; println! ( "ค่าของ foo คือ {foo}" ); foo = 20 ; println! ( "ค่าของ foo คือ {foo}" ); }

นิพจน์ หลายรายการletสามารถกำหนดตัวแปรหลายตัวที่มีชื่อเดียวกันได้ ซึ่งเรียกว่าการซ้อนตัวแปรการซ้อนตัวแปรช่วยให้สามารถแปลงตัวแปรได้โดยไม่ต้องตั้งชื่อตัวแปรให้แตกต่างกัน^{[ 52 ]}ตัวอย่างด้านล่างประกาศตัวแปรใหม่ที่มีชื่อเดียวกันซึ่งมีค่าเป็นสองเท่าของค่าเดิม:

fn main () { let foo = 10 ; // ผลลัพธ์ที่ได้คือ "The value of foo is 10" println! ( "The value of foo is {foo}" ); let foo = foo * 2 ; // ผลลัพธ์ที่ได้คือ "The value of foo is 20" println! ( "The value of foo is {foo}" ); }

การซ่อนค่าตัวแปรยังสามารถทำได้สำหรับค่าที่มีประเภทต่างกัน ตัวอย่างเช่น การแปลงจากสตริงเป็นความยาวของสตริง:

fn main () { let letters = "abc" ; let letters = letters . len (); }

นิพจน์บล็อกจะถูกคั่นด้วยวงเล็บปีกกาเมื่อนิพจน์สุดท้ายภายในบล็อกไม่ได้ลงท้ายด้วยเครื่องหมายเซมิโคลอน บล็อกจะประเมินค่าเป็นค่าของนิพจน์ที่ตามหลัง: ^{[ 53 ]}

fn main () { let x = { println! ( "this is inside the block" ); 1 + 2 }; println! ( "1 + 2 = {x}" ); }

นิพจน์ท้ายสุดของเนื้อหาฟังก์ชันจะถูกใช้เป็นค่าส่งคืน: ^{[ 54 ]}

fn add_two ( x : i32 ) -> i32 { x + 2 }

นิพจน์ifเงื่อนไขจะดำเนินการโค้ดโดยพิจารณาจากว่าค่าที่กำหนดเป็นจริงหรือไม่trueสามารถelseใช้ได้เมื่อค่าประเมินเป็นจริงfalseและสามารถใช้สำหรับการรวมนิพจน์หลายรายการ^{[ 55 ]}elseif

fn main () { let x = 10 ; if x > 5 { println! ( "ค่ามากกว่าห้า" ); }ถ้าx % 7 == 0 ให้พิมพ์" ค่านี้หารด้วย 7 ลงตัว" มิฉะนั้นถ้าx % 5 == 0 ให้พิมพ์" ค่านี้หารด้วย 5 ลงตัว" มิฉะนั้นให้พิมพ์ " ค่านี้หารด้วย 7 หรือ 5 ไม่ลงตัว" } }

ifและelseบล็อกสามารถประเมินค่าเป็นค่าได้ จากนั้นจึงกำหนดให้กับตัวแปร: ^{[ 55 ]}

fn main () { let x = 10 ; let new_x = if x % 2 == 0 { x / 2 } else { 3 * x + 1 }; println! ( "{new_x}" ); }

whileสามารถใช้เพื่อทำซ้ำบล็อกโค้ดในขณะที่ตรงตามเงื่อนไข^{[ 56 ]}

fn main () { // วนลูปผ่านจำนวนเต็มทั้งหมดตั้งแต่ 4 ถึง 10 let mut value = 4 ; while value <= 10 { println! ( "value = {value}" ); value += 1 ; } }

ลูป forใน Rust จะวนซ้ำเหนือองค์ประกอบของคอลเลกชัน^{[ 57 ]}forนิพจน์ใช้งานได้กับตัววนซ้ำประเภท ใดก็ได้

fn main () { // ใช้ `for` กับไวยากรณ์ช่วงเพื่อให้ได้ฟังก์ชันการทำงานเช่นเดียวกับข้างต้น// ไวยากรณ์ 4..=10 หมายถึงช่วงตั้งแต่ 4 ถึง 10 รวมทั้ง 10 ด้วยfor value in 4 ..= 10 { println! ( "value = {value}" ); } }

ในโค้ดด้านบนเป็นค่าประเภทที่ใช้คุณสมบัติ (trait) โค้ดภายในวงเล็บปีกกาจะถูกนำไปใช้กับแต่ละองค์ประกอบที่ส่งคืนโดยตัววนซ้ำ (iterator) 4..=10RangeIterator

ตัววนซ้ำสามารถใช้ร่วมกับฟังก์ชันที่ทำงานกับตัววนซ้ำได้ เช่นmap, filter, และsumตัวอย่างเช่น โค้ดต่อไปนี้จะบวกเลขทั้งหมดระหว่าง 1 ถึง 100 ที่เป็นพหุคูณของ 3:

( 1 ..= 100 ). filter ( | x | x % 3 == 0 ). sum ()

โดยทั่วไปแล้วloopคำหลักนี้อนุญาตให้ทำซ้ำส่วนของโค้ดจนกว่าจะbreakเกิดเหตุการณ์ขึ้นbreakอาจออกจากลูปด้วยค่าได้ ในกรณีของลูปซ้อนกัน ป้ายกำกับที่ระบุด้วยสามารถใช้เพื่อหยุดลูปภายนอกแทนที่จะเป็นลูปภายในสุด^{[ 58 ]}'label_name

fn main () { let value = 456 ; let mut x = 1 ; let y = loop { x *= 10 ; if x > value { break x / 10 ; } }; println! ( "เลขยกกำลังของสิบที่มากที่สุดที่น้อยกว่าหรือเท่ากับค่า: {y}" );let mut up = 1 ; ' outer : loop { let mut down = 120 ; loop { if up > 100 { break 'outer ; }ถ้าdown น้อยกว่า4 ให้หยุดการทำงานลง/= 2 ; ขึ้น+= 1 ; พิมพ์ ln! ( "ขึ้น: {ขึ้น}, ลง: {ลง}" ); ขึ้น* = 2 ; } }

นิพจน์matchand สามารถใช้สำหรับการจับคู่รูปแบบได้ ตัวอย่างเช่นสามารถใช้เพื่อคูณค่าจำนวนเต็มที่เป็นตัวเลือกด้วย 2 หากมีอยู่ และส่งคืนค่าศูนย์หากไม่มี: ^{[ 59 ]}ifletmatch

fn double ( x : Option < u64 > ) -> u64 { match x { Some ( y ) => y * 2 , None => 0 , } }

ในทำนองเดียวกัน สามารถเขียนได้โดยใช้และ: ifletelse

fn double ( x : Option < u64 > ) -> u64 { if let Some ( y ) = x { y * 2 } else { 0 } }

Rust เป็นภาษาที่มีการกำหนดประเภทอย่างเข้มงวดและมีการกำหนดประเภทแบบคงที่ซึ่งหมายความว่าประเภทของตัวแปรทั้งหมดจะต้องทราบได้ในระหว่างการคอมไพล์ การกำหนดค่าของประเภทเฉพาะให้กับตัวแปรที่มีประเภทแตกต่างกันจะทำให้เกิดข้อผิดพลาดในการคอมไพล์การอนุมานประเภทจะถูกใช้เพื่อกำหนดประเภทของตัวแปรหากไม่ได้ระบุไว้^{[ 60 ]}

ชนิดข้อมูล()`null` ซึ่งใน Rust เรียกว่า "ชนิดข้อมูลหน่วย" (unit type) เป็นชนิดข้อมูลที่เป็นรูปธรรมที่มีค่าเพียงค่าเดียวเท่านั้น มันไม่ใช้หน่วยความจำ (เนื่องจากแสดงถึงการไม่มีค่า) ฟังก์ชันทั้งหมดที่ไม่ได้ระบุชนิดข้อมูลส่งคืนจะส่งคืนค่า `null` โดยปริยาย()มันคล้ายกับ ` null` voidในภาษาโปรแกรมแบบ C อื่นๆ แต่ `null` voidหมายถึงการไม่มีชนิดข้อมูลและไม่สามารถมีค่าใดๆ ได้

ประเภทจำนวนเต็มเริ่มต้นคือi32และประเภทจุดลอยตัวf64 เริ่มต้นคือ หากไม่ได้ระบุประเภทของ ตัวเลข ตัวอักษรอย่างชัดเจน ระบบจะอนุมานจากบริบทหรือใช้ประเภทเริ่มต้น^{[ 61 ]}

ประเภทจำนวนเต็มใน Rust จะถูกตั้งชื่อตามเครื่องหมายและจำนวนบิตที่ประเภทนั้นใช้ ตัวอย่างเช่นi32เป็นจำนวนเต็มที่มีเครื่องหมายซึ่งใช้พื้นที่จัดเก็บ 32 บิต ในขณะที่u8เป็นจำนวนเต็มที่ไม่มีเครื่องหมายและใช้พื้นที่จัดเก็บเพียง 8 บิตisizeและusizeใช้พื้นที่จัดเก็บขึ้นอยู่กับความกว้างของบัสที่อยู่หน่วยความจำของเป้าหมายการคอมไพล์ ตัวอย่างเช่น เมื่อสร้างสำหรับเป้าหมาย 32 บิตทั้งสองประเภทจะใช้พื้นที่ 32 บิต^{[ 62 ] [ 63 ]}

โดยค่าเริ่มต้น ค่าจำนวนเต็มจะอยู่ในระบบฐาน 10 แต่รองรับฐาน ที่แตกต่างกันได้โดย ใช้ คำนำหน้า เช่น 0b11สำหรับเลขฐานสองสำหรับเลขฐานแปดและ0o567สำหรับเลขฐานสิบหกโดยค่าเริ่มต้น ค่าจำนวนเต็มจะใช้ ค่าเริ่มต้น เป็นประเภทสามารถใช้คำต่อท้าย เช่น เพื่อกำหนดประเภทของค่าได้อย่างชัดเจน^{[ 64 ]}สามารถใช้ค่าไบต์ เช่น เพื่อแสดงค่า ASCII (เป็น) ของอักขระเฉพาะได้^{[ 65 ]}0xDBi324u32b'X'u8

ประเภทบูลีนเรียกว่าboolซึ่งสามารถรับค่าได้เป็นtrueหรือโดยfalseใช้charพื้นที่ 32 บิตและแทนค่าสเกลาร์ Unicode: ^{[ 66 ]}รหัสUnicodeที่ไม่ใช่surrogate ^{[ 67 ]} รองรับตัวเลขจุดลอยตัวIEEE 754f32 โดยใช้ สำหรับตัวเลขจุดลอยตัวความแม่นยำเดี่ยวและf64สำหรับตัวเลขจุดลอยตัวความแม่นยำคู่^{[ 68 ]}

ประเภทผสมสามารถมีค่าได้หลายค่า ทูเพิลเป็นรายการที่มีขนาดคงที่ซึ่งสามารถมีค่าที่มีประเภทต่างกันได้ อาร์เรย์เป็นรายการที่มีขนาดคงที่ซึ่งค่าต่างๆ มีประเภทเดียวกัน นิพจน์ของประเภททูเพิลและอาร์เรย์สามารถเขียนได้โดยการแสดงรายการค่า และสามารถเข้าถึงได้ด้วย(สำหรับทูเพิล) หรือ(สำหรับอาร์เรย์): ^{[ 69 ]}.index[index]

let tuple : ( u32 , bool ) = ( 3 , true ); let array : [ i8 ; 5 ] = [ 1 , 2 , 3 , 4 , 5 ]; let value = tuple . 1 ; // true let value = array [ 2 ]; // 3

อาร์เรย์ยังสามารถสร้างขึ้นได้โดยการคัดลอกค่าเดียวจำนวนครั้ง: ^{[ 70 ]}

let array2 : [ char ; 10 ] = [ ' ' ; 10 ];

ระบบการเป็นเจ้าของของ Rust ประกอบด้วยกฎที่รับประกันความปลอดภัยของหน่วยความจำโดยไม่ต้องใช้ตัวเก็บขยะ ในระหว่างการคอมไพล์ ค่าแต่ละค่าจะต้องถูกผูกไว้กับตัวแปรที่เรียกว่าเจ้าของค่านั้น และทุกค่าจะต้องมีเจ้าของเพียงคนเดียว^{[ 71 ]}ค่าจะถูกย้ายระหว่างเจ้าของที่แตกต่างกันผ่านการกำหนดค่าหรือการส่งค่าเป็นพารามิเตอร์ของฟังก์ชัน ค่าสามารถถูกยืมได้ เช่นกัน ซึ่งหมายความว่าค่าเหล่านั้นจะถูกส่งผ่านไปยังฟังก์ชันอื่นชั่วคราวก่อนที่จะส่งคืนให้กับเจ้าของ^{[ 72 ]}ด้วยกฎเหล่านี้ Rust สามารถป้องกันการสร้างและการใช้พอยเตอร์ที่ค้างอยู่^ได้ [ ^{72 ] [ 73 ]}

fn print_string ( s : String ) { println! ( "{}" , s ); }fn main () { let s = String :: from ( "Hello, World" ); print_string ( s ); // s ถูกใช้ไปแล้วโดย print_string // s ถูกย้ายไปแล้ว จึงไม่สามารถใช้งานได้อีกต่อไป// การเรียกใช้ print_string(s) อีกครั้งจะทำให้เกิดข้อผิดพลาดในการคอมไพล์}

ฟังก์ชันprint_stringจะรับสิทธิ์ความเป็นเจ้าของเหนือStringค่าที่ส่งเข้ามา หรืออีกทางหนึ่ง&สามารถใช้เพื่อระบุ ประเภท อ้างอิง (ใน) และเพื่อสร้างการอ้างอิง (ใน): ^{[ 74 ]}&String&s

fn print_string ( s : & String ) { println! ( "{}" , s ); }fn main () { let s = String :: from ( "Hello, World" ); print_string ( & s ); // s ถูกยืมโดย print_string print_string ( & s ); // s ยังไม่ได้ถูกใช้ไป เราสามารถเรียกฟังก์ชันนี้ได้หลายครั้ง}

เนื่องจากกฎการเป็นเจ้าของเหล่านี้ ประเภทของ Rust จึงเรียกว่าประเภทแอฟฟินซึ่งหมายความว่าแต่ละค่าสามารถใช้ได้เพียงครั้งเดียวเท่านั้น สิ่งนี้บังคับใช้การแยกความผิดพลาดของซอฟต์แวร์ รูปแบบหนึ่ง เนื่องจากเจ้าของค่ามีหน้าที่รับผิดชอบแต่เพียงผู้เดียวต่อความถูกต้องและการยกเลิกการจัดสรร^{[ 75 ]}

เมื่อค่าอยู่นอกขอบเขต จะถูกทิ้งโดยการเรียกใช้ตัวทำลายตัวทำลายอาจถูกกำหนดโดยโปรแกรมผ่านการใช้งานDroptraitซึ่งช่วยจัดการทรัพยากร เช่น ตัวจัดการไฟล์ ซ็อกเก็ตเครือข่าย และตัวล็อกเนื่องจากเมื่อวัตถุถูกทิ้ง ทรัพยากรที่เกี่ยวข้องกับวัตถุเหล่านั้นจะถูกปิดหรือปล่อยโดยอัตโนมัติ^{[ 76 ]}

อายุการใช้งานของวัตถุหมายถึงช่วงเวลาที่การอ้างอิงยังคงมีผลใช้ได้ กล่าวคือ เวลาระหว่างการสร้างและการทำลายวัตถุ^{[ 77 ]}อายุการใช้งานเหล่านี้เชื่อมโยงกับประเภทการอ้างอิง Rust ทั้งหมดโดยปริยาย แม้ว่าจะมีการอนุมานบ่อยครั้ง แต่ก็สามารถระบุได้อย่างชัดเจนด้วยพารามิเตอร์อายุการใช้งานที่มีชื่อ (มักใช้สัญลักษณ์, , และอื่นๆ) ^{[ 78 ]}'a'b

อายุการใช้งานของค่าใน Rust จะถูกอนุมานจากชุดตำแหน่งในซอร์สโค้ด (เช่น หมายเลขฟังก์ชัน บรรทัด และคอลัมน์) ที่ตัวแปรนั้นใช้ได้^{[ 79 ]}ตัวอย่างเช่น การอ้างอิงถึงตัวแปรโลคอลจะมีอายุการใช้งานตั้งแต่การประกาศนิพจน์จนถึงการใช้งานครั้งสุดท้าย^{[ 79 ]}

fn main () { let mut x = 5 ; // ------------------+- อายุการใช้งาน 'a // | let r = & x ; // -+-- อายุการใช้งาน 'b | // | | println! ( "r: {}" , r ); // -+ | // เนื่องจาก r ไม่ได้ถูกใช้งานอีกต่อไป | // อายุการใช้งานของมันจึงสิ้นสุดลง | let r2 = & mut x ; // -+-- อายุการใช้งาน 'c | } // ------------------+

ตัวตรวจสอบการยืมในคอมไพเลอร์ Rust จะบังคับให้ใช้การอ้างอิงเฉพาะในตำแหน่งของซอร์สโค้ดที่อายุการใช้งานที่เกี่ยวข้องถูกต้อง^{[ 80 ] [ 81 ]}ในตัวอย่างข้างต้น การจัดเก็บการอ้างอิงไปยังตัวแปรxในนั้นrถูกต้อง เนื่องจากตัวแปรxมีอายุการใช้งานที่ยาวนานกว่า ( ) กว่าตัวแปร( ) อย่างไรก็ตาม เมื่อมีอายุการใช้งานที่สั้นกว่า ตัวตรวจสอบการยืมจะปฏิเสธโปรแกรม: 'ar'bx

fn main () { let r ; // ------------------+- อายุการใช้งาน 'a // | { // | let x = 5 ; // -+-- อายุการใช้งาน 'b | r = & x ; // ข้อผิดพลาด: x ไม่ | | } // มีอายุไม่นานพอ -| | // println! ( "r: {}" , r ); // | } // ------------------+

เนื่องจากอายุการใช้งานของตัวแปรที่อ้างอิง ( ) สั้นกว่าอายุการใช้งานของตัวแปรที่ถือการอ้างอิง ( ) ตัวตรวจสอบการยืมจึงเกิดข้อผิดพลาด ป้องกันไม่ให้ถูกใช้งานจากภายนอกขอบเขต^{[ 82 ]}'b'ax

สามารถระบุอายุการใช้งานได้โดยใช้พารามิเตอร์อายุการใช้งาน ที่ชัดเจน ในอาร์กิวเมนต์ของฟังก์ชัน ตัวอย่างเช่น โค้ดต่อไปนี้ระบุว่าการอ้างอิงที่ส่งคืนโดยฟังก์ชันมีอายุการใช้งานเท่ากับoriginal(และไม่จำเป็นต้องมีอายุการใช้งานเท่ากับprefix): ^{[ 83 ]}

fn remove_prefix <' a > ( mut original : & ' a str , prefix : & str ) -> & ' a str { if original . starts_with ( prefix ) { original = original [ prefix . len () .. ]; } original }

ในคอมไพเลอร์ การเป็นเจ้าของและอายุการใช้งานจะทำงานร่วมกันเพื่อป้องกันปัญหาความปลอดภัยของหน่วยความจำ เช่น พอยเตอร์ที่ค้างอยู่^{[ 84 ] [ 85 ]}

ประเภทที่ผู้ใช้กำหนดเองจะถูกสร้างขึ้นด้วยคำหลักstructหรือคำหลัก ใช้เพื่อระบุประเภทเรคอร์ดที่จัดกลุ่มค่าที่เกี่ยวข้องหลายค่า^{[ 86 ]}สามารถรับรูปแบบต่างๆ ได้ในขณะรันไทม์ โดยมีความสามารถคล้ายกับประเภทข้อมูลพีชคณิตที่พบในภาษาการเขียนโปรแกรมเชิงฟังก์ชัน^{[ 87 ]}ทั้งเรคอร์ดและรูปแบบ enum สามารถมีฟิลด์ที่มีประเภทต่างกันได้^{[ 88 ]}สามารถกำหนดชื่อทางเลือกหรือนามแฝงสำหรับประเภทเดียวกันได้ด้วยคำหลัก^{[ 89 ]}enumstructenumtype

คำimplหลักสามารถกำหนดวิธีการสำหรับประเภทที่ผู้ใช้กำหนดได้ ข้อมูลและฟังก์ชันจะถูกกำหนดแยกกัน การใช้งานทำหน้าที่คล้ายกับคลาสในภาษาอื่นๆ^{[ 90 ]}

ไลบรารีมาตรฐานของ Rust กำหนดและใช้งานประเภทข้อมูลแบบกำหนดเองที่ใช้กันอย่างแพร่หลายมากมาย รวมถึงโครงสร้างข้อมูลหลัก เช่นVec, Option, และHashMapรวมถึง ประเภท ตัวชี้อัจฉริยะ Rust มีวิธีการยกเว้นไลบรารีมาตรฐานส่วนใหญ่โดยใช้แอตทริบิวต์#![no_std]สำหรับแอปพลิเคชัน เช่น อุปกรณ์ฝังตัว ภายใน ไลบรารีมาตรฐานจะถูกแบ่งออกเป็นสามส่วน คือ^,core , allocและstdโดยที่stdและallocจะถูกยกเว้นโดย#![no_std][ ^{91 ]}

Rust ใช้ประเภทตัวเลือกOption<T>เพื่อกำหนดค่าตัวเลือก ซึ่งสามารถจับคู่โดยใช้if letหรือmatchเพื่อเข้าถึงค่าภายใน: ^{[ 92 ]}

fn main () { let name1 : Option <& str > = None ; // ในกรณีนี้ จะไม่มีอะไรพิมพ์ออกมาif let Some ( name ) = name1 { println! ( "{name}" ); }let name2 : Option <& str > = Some ( "Matthew" ); // ในกรณีนี้ คำว่า "Matthew" จะถูกพิมพ์ออกมาif let Some ( name ) = name2 { println! ( "{name}" ); } }

ในทำนองเดียวกัน ประเภทผลลัพธ์ ของ Rust Result<T, E>จะเก็บค่าที่คำนวณสำเร็จ ( Okตัวแปร) หรือข้อผิดพลาด ( Errตัวแปร) ^{[ 93 ]}เช่นเดียวกับOptionการใช้Resultหมายความว่าไม่สามารถใช้ค่าภายในได้โดยตรง โปรแกรมเมอร์ต้องใช้matchการแสดงออก ไวยากรณ์แบบย่อ เช่น?(ตัวดำเนินการ "try") หรือunwrapการยืนยันที่ชัดเจนเพื่อเข้าถึง ทั้งOptionและResultถูกใช้ทั่วทั้งไลบรารีมาตรฐานและเป็นส่วนสำคัญของแนวทางที่ชัดเจนของ Rust ในการจัดการข้อผิดพลาดและข้อมูลที่หายไป

ประเภท อ้างอิง &และรับประกันว่าจะไม่เป็นค่าว่างและชี้ไปยังหน่วยความจำที่ถูกต้อง^{[ 94 ]}ประเภทตัวชี้แบบดิบและเลือกที่จะไม่รับประกันความปลอดภัย ดังนั้นอาจเป็นค่าว่างหรือไม่ถูกต้อง อย่างไรก็ตาม เป็นไปไม่ได้ที่จะเข้าถึงค่าที่ชี้โดยตัวชี้แบบดิบ เว้นแต่โค้ดจะถูกประกาศว่าไม่ปลอดภัยอย่างชัดเจนโดยใช้บล็อก^{[ 95 ]}ต่างจากการเข้าถึงค่าที่ชี้โดยตัวชี้แบบดิบ การสร้างตัวชี้แบบดิบได้รับอนุญาตภายในโค้ด Rust ที่ปลอดภัย^{[ 96 ]}&mut*const*mutunsafe

let x : i32 = 1000 ; println! ( "1000 as a u16 is: {}" , x as u16 );

Rust รองรับโพลีมอร์ฟิซึมผ่านคุณสมบัติฟังก์ชันทั่วไปและวัตถุคุณสมบัติ^{[ 98 ]}

พฤติกรรมทั่วไประหว่างประเภทต่างๆ จะถูกประกาศโดยใช้ลักษณะและimplบล็อก: ^{[ 99 ]}

trait Zero : Sized { fn zero () -> Self ; fn is_zero ( & self ) -> bool where Self : PartialEq , { self == & Zero :: zero () } }impl Zero for u32 { fn zero () -> u32 { 0 } }impl Zero for f32 { fn zero () -> Self { 0.0 } }

ตัวอย่างข้างต้นประกอบด้วยวิธีการis_zeroที่ให้การใช้งานเริ่มต้นซึ่งสามารถแทนที่ได้เมื่อใช้งานคุณลักษณะ^{[ 99 ]}

ฟังก์ชันสามารถทำให้เป็นแบบเจเนริกได้โดยการเพิ่มพารามิเตอร์ประเภทไว้ภายในวงเล็บเหลี่ยม ( ) ซึ่งอนุญาตเฉพาะประเภทที่ใช้งาน trait นั้นเท่านั้น: <Num>

// zero เป็นฟังก์ชันทั่วไปที่มีพารามิเตอร์ประเภทเดียวคือ Num fn zero < Num : Zero > () -> Num { Num :: zero () }fn main () { let a : u32 = zero (); let b : f32 = zero (); assert! ( a . is_zero () && b . is_zero ()); }

ในตัวอย่างข้างต้นรวมถึงขอบเขตลักษณะเฉพาะที่จำกัดประเภทให้ยอมรับเฉพาะประเภทที่นำไปใช้หรือเท่านั้น^{[ 99 ]}ภายในลักษณะเฉพาะหรือการใช้งานหมายถึงประเภทที่โค้ดกำลังนำไปใช้^{[ 100 ]}Num:ZerowhereSelf:PartialEqZeroPartialEqSelf

Generics สามารถใช้ในฟังก์ชันเพื่ออนุญาตให้ใช้งานพฤติกรรมสำหรับประเภทต่างๆ โดยไม่ต้องเขียนโค้ดซ้ำ (ดูbounded parametric polymorphism ) ฟังก์ชัน Generic สามารถเขียนขึ้นโดยสัมพันธ์กับ generics อื่นๆ โดยไม่ต้องรู้ประเภทที่แท้จริง^{[ 101 ]}

โดยค่าเริ่มต้น คุณสมบัติจะใช้การเรียกใช้แบบคงที่ : คอมไพเลอร์ จะแปลงฟังก์ชัน ให้เป็นโมโนมอร์ฟิกสำหรับแต่ละอินสแตนซ์ของประเภทที่เป็นรูปธรรม ซึ่งให้ประสิทธิภาพเทียบเท่ากับโค้ดเฉพาะประเภท แต่แลกมาด้วยเวลาคอมไพล์ที่นานขึ้นและไบนารีที่มีขนาดใหญ่ขึ้น^{[ 102 ]}

เมื่อไม่ทราบประเภทที่แน่นอนในระหว่างการคอมไพล์ Rust จะจัดเตรียมออบเจ็กต์ trait&dyn TraitและBox<dyn Trait>. ^{[ 103 ]}การเรียกออบเจ็กต์ trait ใช้การส่งแบบไดนามิกผ่านตารางค้นหา ออบเจ็กต์ trait เป็น "ตัวชี้อ้วน" ที่มีทั้งตัวชี้ข้อมูลและตัวชี้ตารางเมธอด^{[ 102 ]}การอ้างอิงทางอ้อมนี้เพิ่มต้นทุนรันไทม์เล็กน้อย แต่จะเก็บสำเนาโค้ดเพียงชุดเดียวและลดขนาดไบนารี เฉพาะ trait ที่ "ปลอดภัยต่อออบเจ็กต์" เท่านั้นที่มีสิทธิ์ใช้เป็นออบเจ็กต์ trait ^{[ 104 ]}

แนวทางนี้คล้ายกับduck typingซึ่งประเภทข้อมูลทั้งหมดที่ใช้คุณสมบัติที่กำหนดสามารถถือได้ว่าสามารถทดแทนกันได้ในเชิงฟังก์ชัน^{[ 105 ]}ตัวอย่างต่อไปนี้สร้างรายการของวัตถุ โดยแต่ละวัตถุใช้Displayคุณสมบัติดังกล่าว:

ใช้std :: fmt :: Display ;let v : Vec < Box < dyn Display >> = vec! [ Box :: new ( 3 ), Box :: new ( 5.0 ), Box :: new ( "hi" ), ];สำหรับx ในv { println! ( "{x}" ); }

หากองค์ประกอบในรายการไม่ปฏิบัติตามDisplayคุณลักษณะ จะทำให้เกิดข้อผิดพลาดในการคอมไพล์^{[ 106 ]}

Rust ไม่ใช้การเก็บขยะ (garbage collection ) หน่วยความจำและทรัพยากรอื่นๆ จะถูกจัดการผ่านหลักการ "การได้มาซึ่งทรัพยากรคือการเริ่มต้น" (resource acquisition is initialization) ^{[ 107 ]}โดยมีตัวเลือกในการนับการอ้างอิง Rust ให้การจัดการทรัพยากรแบบกำหนดได้ (deterministic management) โดยมีค่าใช้จ่ายต่ำ มาก ^{[ 108 ]}ค่าต่างๆ จะถูกจัดสรรบนสแต็กโดยค่าเริ่มต้น และการจัดสรรแบบไดนามิก ทั้งหมด จะต้องระบุอย่างชัดเจน^{[ 109 ]}

ประเภทอ้างอิงในตัวที่ใช้&สัญลักษณ์ไม่เกี่ยวข้องกับการนับการอ้างอิงขณะรันไทม์ ความปลอดภัยและความถูกต้องของพอยเตอร์พื้นฐานจะได้รับการตรวจสอบในระหว่างการคอมไพล์ ป้องกันพอยเตอร์ที่ค้างอยู่และพฤติกรรมที่ไม่กำหนดรูปแบบอื่น ๆ[ 110 ^{]ระบบประเภท}ของ Rust แยกการอ้างอิงที่ใช้ร่วมกันและเปลี่ยนแปลงไม่ได้ในรูปแบบ ออก&Tจากการอ้างอิงที่ไม่ซ้ำกันและเปลี่ยนแปลงได้ในรูปแบบ&mut Tการอ้างอิงที่เปลี่ยนแปลงได้สามารถแปลงเป็นการอ้างอิงที่เปลี่ยนแปลงไม่ได้ได้ แต่ในทางกลับกันทำไม่ได้^{[ 111 ]}

การตรวจสอบความปลอดภัยของหน่วยความจำของ Rust (ดู#Safety ) อาจถูกหลีกเลี่ยงได้โดยการใช้unsafeบล็อก ซึ่งช่วยให้โปรแกรมเมอร์สามารถเข้าถึงพอยเตอร์ดิบใดๆ เรียกใช้โค้ดภายนอก หรือดำเนินการฟังก์ชันระดับต่ำอื่นๆ ที่ไม่ได้รับอนุญาตใน Rust ที่ปลอดภัย^{[ 112 ]}ฟังก์ชันระดับต่ำบางอย่างที่เปิดใช้งานด้วยวิธีนี้ ได้แก่การเข้าถึงหน่วยความจำแบบ volatile , intrinsic เฉพาะสถาปัตยกรรม, type punningและการประกอบแบบอินไลน์^{[ 113 ]}

จำเป็นต้องใช้โค้ดที่ไม่ปลอดภัย เช่น ในการใช้งานโครงสร้างข้อมูล^{[ 114 ]}ตัวอย่างที่มักถูกยกมาคือ เป็นเรื่องยากหรือเป็นไปไม่ได้ที่จะใช้งานลิสต์แบบเชื่อมโยงสองทางใน Rust ที่ปลอดภัย^{[ 115 ] [ 116 ] [ 117 ] [ 118 ]}

โปรแกรมเมอร์ที่ใช้ Rust ที่ไม่ปลอดภัยถือว่ามีความรับผิดชอบในการรักษาระเบียบข้อบังคับด้านความปลอดภัยของหน่วยความจำและประเภทของ Rust เช่น ห้ามมีการอ้างอิงที่เปลี่ยนแปลงได้สองรายการที่ชี้ไปยังตำแหน่งเดียวกัน^{[ 119 ]}หากโปรแกรมเมอร์เขียนโค้ดที่ละเมิดข้อกำหนดเหล่านี้ จะส่งผลให้เกิดพฤติกรรมที่ไม่กำหนด^{[ 119 ]} เอกสารประกอบของ Rust มีรายการพฤติกรรมที่ถือว่าไม่กำหนด รวมถึงการเข้าถึงพอยเตอร์ที่ค้างอยู่หรือพ อยเตอร์ที่ไม่ตรงแนว หรือการละเมิดกฎการกำหนดชื่อแทนสำหรับการอ้างอิง^{[ 120 ]}

มาโครช่วยให้สามารถสร้างและแปลงโค้ด Rust เพื่อลดการทำซ้ำ มาโครมีสองรูปแบบ ได้แก่มาโครแบบประกาศที่กำหนดผ่านmacro_rules!และมาโครแบบขั้นตอนซึ่งกำหนดไว้ใน crate แยกต่างหาก^{[ 121 ] [ 122 ]}

มาโครแบบประกาศ (เรียกอีกอย่างว่า "มาโครโดยตัวอย่าง") คือมาโครที่กำหนดโดยใช้macro_rules!คำหลัก ซึ่งใช้การจับคู่รูปแบบเพื่อกำหนดการขยายตัว^{[ 123 ] [ 124 ]}ด้านล่างนี้คือตัวอย่างที่รวมผลรวมของอาร์กิวเมนต์ทั้งหมด:

กฎมาโคร! ผลรวม{ ( $initial : expr $(, $expr : expr ) * $(, ) ? ) => { $initial $( + $expr ) * } }fn main () { let x = sum ! ( 1 , 2 , 3 ); println! ( "{x}" ); // พิมพ์ 6 }

ในตัวอย่างนี้ มาโครชื่อsumถูกกำหนดโดยใช้รูปแบบmacro_rules! sum {(...) => { ... } }ส่วนแรกภายในวงเล็บของการกำหนด คือ รูปแบบของมาโคร( $initial:expr $(, $expr:expr )* $(,)? )ซึ่งระบุโครงสร้างของอินพุตที่สามารถรับได้ ในที่นี้$initial:exprแทนนิพจน์แรก ในขณะที่$(, $expr:expr )*หมายความว่าสามารถมีนิพจน์เพิ่มเติมที่คั่นด้วยเครื่องหมายจุลภาคได้ศูนย์หรือมากกว่านั้น ส่วนท้าย$(,)?อนุญาตให้ผู้เรียกสามารถใส่เครื่องหมายจุลภาคสุดท้ายได้โดยไม่ทำให้เกิดข้อผิดพลาด ส่วนที่สอง หลังลูกศร=>อธิบายว่าโค้ดใดจะถูกสร้างขึ้นเมื่อเรียกใช้มาโคร ในกรณีนี้$initial $(+ $expr)*หมายความว่าโค้ดที่สร้างขึ้นจะเริ่มต้นด้วยนิพจน์แรก ตามด้วย+และนิพจน์เพิ่มเติมแต่ละรายการตามลำดับ*อีกครั้ง หมายความว่า "ทำซ้ำรูปแบบนี้ศูนย์ครั้งหรือมากกว่า" ซึ่งหมายความว่า เมื่อเรียกใช้มาโครในบรรทัดที่ 8 ในภายหลัง ในsum!(1, 2, 3)รูปแบบ มาโครจะแปลงเป็น ซึ่ง1 + 2 + 3แสดงถึงผลรวมของนิพจน์ทั้งหมดที่ส่งผ่านเข้ามา

มาโครเชิงขั้นตอนคือฟังก์ชัน Rust ที่รันและแก้ไขสตรีม โทเค็นอินพุตของคอมไพเลอร์ก่อนที่ส่วนประกอบอื่นๆ จะถูกคอมไพล์ โดยทั่วไปแล้วจะมีความยืดหยุ่นมากกว่ามาโครเชิงประกาศ แต่ดูแลรักษายากกว่าเนื่องจากมีความซับซ้อน^{[ 125 ] [ 126 ]}

มาโครแบบขั้นตอนการทำงานมีอยู่ 3 ประเภท:

• มาโครที่มีลักษณะคล้ายฟังก์ชันcustom!(...)
• สร้างมาโคร#[derive(CustomDerive)]
• มาโครแอตทริบิวต์#[custom_attribute]

Rust รองรับการสร้างอินเทอร์เฟซฟังก์ชันภายนอก (FFI) ผ่านexternคีย์เวิร์ด ฟังก์ชันที่ใช้รูปแบบการเรียกแบบ C สามารถเขียนได้โดยใช้สัญลักษณ์สามารถส่งออกจาก Rust ไปยังภาษาอื่นได้ผ่านแอตทริบิวต์ และสัญลักษณ์สามารถนำเข้าสู่ Rust ได้ผ่านบล็อก: ^{[หมายเหตุ 6 ] [ 128 ]}extern"C"fn#[unsafe(no_mangle)]extern

#[unsafe(no_mangle)] pub extern "C" fn exported_from_rust ( x : i32 ) -> i32 { x + 1 } unsafe extern "C" { fn imported_into_rust ( x : i32 ) -> i32 ; }

คุณลักษณะ นี้#[repr(C)]ช่วยให้สามารถกำหนดรูปแบบหน่วยความจำสำหรับstructs และenums สำหรับการใช้งานข้ามขอบเขต FFI ได้^{[ 128 ]}ไลบรารีภายนอก เช่นbindgenและcxxสามารถสร้างการเชื่อมโยง Rust สำหรับ C/C++ ได้^{[ 128 ] [ 129 ]}

คุณสมบัติด้านความปลอดภัยที่รับประกันโดย Rust ได้แก่ความปลอดภัยของหน่วยความจำความปลอดภัยของชนิดข้อมูลและ การปราศจาก ปัญหาการแข่งขันของข้อมูลดังที่ได้อธิบายไว้ข้างต้น การรับประกันเหล่านี้สามารถถูกหลีกเลี่ยงได้โดยการใช้unsafeคีย์เวิร์ด

ความปลอดภัยของหน่วยความจำรวมถึงการไม่มีการอ้างอิงไปยังค่า ว่าง ตัวชี้ ที่ค้างอยู่และตัวชี้ ที่ไม่ตรงแนว รวมถึงการไม่มีบัฟเฟอร์โอเวอร์โฟลว์และข้อผิดพลาดการปล่อยหน่วยความจำซ้ำซ้อน^{[ 130 ] [ 131 ] [ 132 ] [ 133 ]}

การรั่วไหลของหน่วยความจำอาจเกิดขึ้นได้ใน Rust ที่ปลอดภัย^{[ 134 ]}การรั่วไหลของหน่วยความจำอาจเกิดขึ้นจากการสร้างพอยเตอร์ที่มีการนับจำนวนการอ้างอิงที่ชี้ไปยังกันและกัน (วงจรการอ้างอิง) ^{[ 134 ]}หรืออาจสร้างขึ้นโดยเจตนาผ่านการเรียกBox::leakใช้^{[ 135 ]}

ระบบนิเวศของ Rust ประกอบด้วยคอมไพเลอร์ไลบรารีมาตรฐานและส่วนประกอบเพิ่มเติมสำหรับการพัฒนาซอฟต์แวร์ การติดตั้งส่วนประกอบมักจะจัดการโดยrustupRust toolchain installer ซึ่งพัฒนาโดยโครงการ Rust ^{[ 136 ]}

คอมไพเลอร์ Rust rustcคอมไพล์โค้ด Rust ให้เป็นไบนารีขั้นแรก คอมไพเลอร์จะแยกวิเคราะห์ซอร์สโค้ดเป็นASTจากนั้น AST นี้จะถูกลดระดับเป็นIR จาก นั้นส่วนหลังของคอมไพเลอร์จะถูกเรียกใช้เป็นส่วนประกอบย่อยเพื่อใช้การเพิ่มประสิทธิภาพและแปล IR ที่ได้เป็นโค้ดออบเจ็กต์สุดท้ายตัวเชื่อมโยงจะถูกใช้เพื่อรวมออบเจ็กต์ (หรือหลายออบเจ็กต์) เข้าด้วยกันเป็นอิมเมจที่สามารถเรียกใช้งานได้เพียงอิมเมจเดียว^{[ 137 ]}

rustc ใช้LLVMเป็นแบ็กเอนด์คอมไพเลอร์โดยค่าเริ่มต้น แต่ยังรองรับการใช้แบ็กเอนด์ทางเลือกอื่นๆ เช่นGCCและCraneliftด้วย^{[ 138 ]}จุดประสงค์ของแบ็กเอนด์ทางเลือกเหล่านี้คือเพื่อเพิ่มความครอบคลุมของแพลตฟอร์ม Rust หรือเพื่อปรับปรุงเวลาในการคอมไพล์^{[ 139 ] [ 140 ]}

Cargo คือระบบสร้างและจัดการแพ็กเกจ ของ Rust โดยจะดาวน์โหลด คอมไพล์ แจกจ่าย และอัปโหลดแพ็กเกจ—ที่เรียกว่าcrates—ซึ่งได้รับการดูแลรักษาในรีจิสทรีอย่างเป็นทางการ นอกจากนี้ยังทำหน้าที่เป็นส่วนหน้าสำหรับ Clippy และส่วนประกอบ Rust อื่นๆ อีกด้วย^{[ 141 ]}

โดยค่าเริ่มต้น Cargo จะดึงการพึ่งพาจากรีจิสทรีที่ผู้ใช้สร้างขึ้นcrates.ioแต่ สามารถระบุที่เก็บ Git , crates ในระบบไฟล์ในเครื่อง และแหล่งข้อมูลภายนอกอื่นๆ เป็นการพึ่งพาได้เช่นกัน^{[ 142 ]}

Cargo รองรับการสร้างซ้ำได้ผ่านไฟล์เมตาเดตา 2 ไฟล์ ได้แก่ Cargo.toml และ Cargo.lock ^{[ 143 ]} Cargo.toml ประกาศแพ็กเกจที่ใช้แต่ละรายการและข้อกำหนดเวอร์ชัน Cargo.lock จะถูกสร้างขึ้นโดยอัตโนมัติในระหว่างการแก้ไขการพึ่งพา และบันทึกเวอร์ชันที่แน่นอนของการพึ่งพาทั้งหมด รวมถึงการพึ่งพาแบบส่งต่อ^{[ 144 ]}

Rustfmt เป็นโปรแกรมจัดรูปแบบโค้ดสำหรับ Rust โดยจะจัดรูปแบบช่องว่างและการเยื้องเพื่อสร้างโค้ดตามรูปแบบ ทั่วไป เว้นแต่จะระบุไว้เป็นอย่างอื่น สามารถเรียกใช้งานได้ทั้งในรูปแบบโปรแกรมเดี่ยวหรือจากโปรเจกต์ Rust ผ่าน Cargo ^{[ 145 ]}

Clippy เป็นเครื่องมือ ตรวจสอบโค้ดในตัวของ Rust เพื่อปรับปรุงความถูกต้อง ประสิทธิภาพ และความอ่านง่ายของโค้ด Rust ณ ปี 2026 มีกฎมากกว่า 800 ข้อ^{[ 146 ] [ 147 ]}

หลังจาก Rust 1.0 คุณสมบัติใหม่จะได้รับการพัฒนาใน เวอร์ชัน รายวันซึ่งจะเผยแพร่ทุกวัน ในแต่ละรอบการเผยแพร่หกสัปดาห์ การเปลี่ยนแปลงในเวอร์ชันรายวันจะถูกเผยแพร่ไปยังเวอร์ชันเบต้า ในขณะที่การเปลี่ยนแปลงจากเวอร์ชันเบต้าก่อนหน้าจะถูกเผยแพร่ไปยังเวอร์ชันเสถียรใหม่^{[ 148 ]}

ทุกๆ สองหรือสามปี จะมีการผลิต "รุ่น" ใหม่ รุ่นต่างๆ จะถูกปล่อยออกมาเพื่อให้สามารถทำการเปลี่ยนแปลง ที่จำกัดได้ เช่น การโปรโมตawaitเป็นคีย์เวิร์ดเพื่อรองรับ คุณสมบัติ async/await Crate ที่กำหนดเป้าหมายไปยังรุ่นต่างๆ สามารถทำงานร่วมกันได้ ดังนั้น crate จึงสามารถอัปเกรดเป็นรุ่นใหม่ได้ แม้ว่าผู้เรียกใช้หรือการพึ่งพาของมันจะยังคงกำหนดเป้าหมายไปยังรุ่นเก่ากว่าก็ตาม การย้ายไปยังรุ่นใหม่สามารถทำได้โดยใช้เครื่องมืออัตโนมัติ^{[ 149 ]}

rust-analyzerเป็นชุดยูทิลิตี้ที่ให้ข้อมูลเกี่ยวกับโปรเจกต์ Rust แก่สภาพแวดล้อมการพัฒนาแบบบูรณาการ (IDE) และโปรแกรมแก้ไขข้อความ ผ่านทาง Language Server Protocolซึ่งช่วยให้สามารถใช้งานฟีเจอร์ต่างๆ เช่น การเติม ข้อความอัตโนมัติและ การแสดง ข้อผิดพลาดในการคอมไพล์ขณะแก้ไขโค้ดได้^{[ 150 ]}

เนื่องจาก Rust ไม่ทำการเก็บขยะ จึงมักจะเร็วกว่าภาษาที่ปลอดภัยต่อหน่วยความจำอื่นๆ^{[ 151 ] [ 75 ] [ 152 ]}การรับประกันความปลอดภัยของหน่วยความจำส่วนใหญ่ของ Rust ไม่ก่อให้เกิดภาระการทำงานในขณะรันไทม์^{[ 153 ]}ยกเว้นการตรวจสอบดัชนีอาร์เรย์ซึ่งจะถูกตรวจสอบในขณะรันไทม์โดยค่าเริ่มต้น^{[ 154 ]} ผลกระทบต่อประสิทธิภาพของการตรวจสอบขอบเขตดัชนีอาร์เรย์นั้นแตกต่างกันไป แต่อาจมีนัยสำคัญในบางกรณี^{[ 154 ]}

คุณสมบัติหลายอย่างของ Rust เรียกว่านามธรรมต้นทุนศูนย์ซึ่งหมายความว่าคุณสมบัติเหล่านั้นจะถูกปรับให้เหมาะสมในระหว่างการคอมไพล์และไม่ก่อให้เกิดโทษใดๆ ในระหว่างการรันไทม์^{[ 155 ]}ระบบการเป็นเจ้าของและการยืมช่วยให้สามารถ ใช้งานแบบ ไม่มีสำเนาสำหรับงานที่ต้องการประสิทธิภาพสูงบางอย่าง เช่นการแยกวิเคราะห์^{[ 156 ]} การเรียก ใช้แบบคงที่ถูกใช้เป็นค่าเริ่มต้นเพื่อกำจัดเมธอดที่เรียก ใช้ ยกเว้นเมธอดที่เรียกใช้บนออบเจ็กต์ลักษณะเฉพาะแบบไดนามิก[ ^{157 ]}คอมไพเลอร์ใช้การขยายแบบอินไลน์เพื่อกำจัดการเรียกใช้ฟังก์ชันและการเรียกใช้เมธอดที่เรียกใช้แบบคง^{ที่[ 158 ]}

เนื่องจาก Rust ใช้LLVMการปรับปรุงประสิทธิภาพทั้งหมดใน LLVM จึงมีผลกับ Rust ด้วยเช่นกัน^{[ 159 ]}ต่างจาก C และ C++ Rust อนุญาตให้คอมไพเลอร์จัดเรียงลำดับองค์ประกอบของโครงสร้างและ enum ใหม่ได้ เว้นแต่#[repr(C)]จะมีการใช้แอตทริบิวต์การแสดงผล^{[ 160 ]}ซึ่งช่วยให้คอมไพเลอร์สามารถปรับให้เหมาะสมกับรอยเท้าหน่วยความจำ การจัดแนว และการเติมช่องว่าง ซึ่งสามารถใช้เพื่อสร้างโค้ดที่มีประสิทธิภาพมากขึ้นในบางกรณี^{[ 161 ]}

ในบริการเว็บOpenDNSซึ่งเป็น บริการแก้ไข DNSที่เป็นของCiscoใช้ Rust ภายใน^{[ 162 ] [ 163 ]} Amazon Web Servicesใช้ Rust ใน "ส่วนประกอบที่ไวต่อประสิทธิภาพ" ของบริการ ในปี 2019 AWS ได้เปิดซอร์สโค้ดFirecrackerซึ่งเป็นโซลูชันการจำลองเสมือนที่เขียนด้วย Rust เป็นหลัก^{[ 164 ]} Microsoft Azure IoT Edge ซึ่งเป็นแพลตฟอร์มที่ใช้ในการเรียกใช้บริการ Azure บน อุปกรณ์ IoTมีส่วนประกอบที่เขียนด้วย Rust ^{[ 165 ]} Microsoft ยังใช้ Rust เพื่อเรียกใช้โมดูลคอนเทนเนอร์ด้วยWebAssemblyและKubernetes ^[ 166 ^] Cloudflareบริษัทที่ให้ บริการ เครือข่ายการส่งเนื้อหาใช้ Rust ในการสร้างพร็อกซีเว็บ ใหม่ ชื่อ Pingora เพื่อเพิ่มประสิทธิภาพและประสิทธิผล^{[ 167 ]}ตัวจัดการแพ็กเกจ npm ใช้ Rust สำหรับบริการ ^ตรวจสอบสิทธิ์การผลิตในปี 2019 ^{[ 168 ] [ 169 ] [ 170 ]}

ในระบบปฏิบัติการ เคอร์เนล Linux เริ่มนำเสนอการสนับสนุนแบบทดลองสำหรับโค้ด Rust ในเวอร์ชัน 6.1 ในช่วงปลายปี 2022 ซึ่งเป็นส่วนหนึ่งของโครงการRust for Linux ^{[ 171 ] [ 172 ] [ 173 ]}ไดรเวอร์ตัวแรกที่เขียนด้วย Rust ถูกรวมอยู่ในเวอร์ชัน 6.8 ^{[ 171 ]}ในปี 2025 นักพัฒนาเคอร์เนลในการประชุมสุดยอดนักพัฒนาเคอร์เนล Linuxได้ตัดสินว่าโครงการนี้ประสบความสำเร็จ และการใช้ Rust สำหรับโค้ดเคอร์เนลจะไม่ถือว่าเป็นการทดลองอีกต่อไป^{[ 174 ]}นัก พัฒนา Androidใช้ Rust ในปี 2021 เพื่อเขียนส่วนประกอบที่มีอยู่ใหม่^{[ 175 ] [ 176 ]} Microsoftได้เขียนส่วนต่างๆ ของWindowsใหม่ด้วย Rust ^{[ 177 ]}โครงการ r9 มีเป้าหมายที่จะนำPlan 9 จาก Bell Labs มาใช้งานใหม่ ใน Rust ^{[ 178 ]} Rust ยังถูกนำไปใช้ในการพัฒนาระบบปฏิบัติการใหม่ๆ เช่นRedoxซึ่งเป็นระบบปฏิบัติการแบบ "Unix-like" และไมโครเคอร์เนล^{[ 179 ]} Theseus ซึ่งเป็นระบบปฏิบัติการทดลองที่มีการจัดการสถานะแบบโมดูลาร์^{[ 180 ] [ 181 ]}และส่วนใหญ่ของFuchsia ^{[ 182 ]} Rust ถูกใช้สำหรับเครื่องมือบรรทัดคำสั่งและส่วนประกอบของระบบปฏิบัติการ เช่นstratisdซึ่งเป็นตัวจัดการระบบไฟล์^{[ 183 ] [ 184 ]}และ COSMIC ซึ่งเป็นสภาพแวดล้อมเดสก์ท็อปโดยSystem76 ^{[ 185 ]}

ในการพัฒนาเว็บDenoซึ่งเป็นรันไทม์ที่ปลอดภัยสำหรับJavaScriptและTypeScriptถูกสร้างขึ้นบนV8โดยใช้ Rust และ Tokio ^{[ 186 ]}การนำไปใช้ที่โดดเด่นอื่นๆ ในด้านนี้ ได้แก่Ruffle ซึ่งเป็น โปรแกรมจำลองSWFแบบโอเพนซอร์ส^{[ 187 ]}และPolkadotซึ่งเป็นแพลตฟอร์มบล็อกเชนและสกุลเงินดิจิทัล แบบโอเพนซอร์ส ^{[ 188 ]}ส่วนประกอบจากเอ็นจิ้นเบราว์เซอร์ Servo (ได้รับทุนจากMozillaและSamsung ) ถูกรวมเข้าไว้ใน เอ็นจิ้น เบราว์เซอร์Gecko ซึ่งเป็นพื้นฐานของ Firefox ^{[ 189 ]}ในเดือนมกราคม 2023 Google ( Alphabet ) ประกาศสนับสนุนการใช้ไลบรารี Rust ของบุคคล ที่สามในChromium ^{[ 190 ] [ 191 ]}

ในการใช้งานอื่นๆDiscordซึ่งเป็น บริษัทซอฟต์แวร์ ส่งข้อความโต้ตอบแบบทันทีได้เขียนระบบบางส่วนขึ้นใหม่ด้วย Rust เพื่อเพิ่มประสิทธิภาพในปี 2020 ในปีเดียวกัน Dropbox ได้ประกาศว่าการซิงโครไนซ์ไฟล์ ของตน ได้รับการเขียนขึ้นใหม่ด้วย Rust Facebook ( Meta ) ใช้ Rust เพื่อออกแบบระบบที่จัดการซอร์สโค้ดสำหรับโครงการภายในใหม่^{[ 20 ]}

จาก การสำรวจนักพัฒนา Stack Overflow ปี 2025 พบว่า 14.8% ของผู้ตอบแบบสอบถามได้ทำการพัฒนาอย่างกว้างขวางด้วย Rust เมื่อเร็วๆ นี้^{[ 192 ]}การสำรวจนี้ระบุว่า Rust เป็น "ภาษาโปรแกรมที่ได้รับความชื่นชมมากที่สุด" ในแต่ละปีตั้งแต่ปี 2016 ถึง 2025 (รวมทั้งสองปี) โดยวัดจากจำนวนนักพัฒนาที่มีอยู่ที่สนใจที่จะทำงานในภาษาดังกล่าวต่อไป^{[ 193 ] [หมายเหตุ 7 ]}ในปี 2025 นักพัฒนา 29.2% ที่ไม่ได้ทำงานใน Rust ในปัจจุบันแสดงความสนใจที่จะทำเช่นนั้น^{[ 192 ]}

ความปลอดภัยและประสิทธิภาพของ Rust ได้รับการตรวจสอบในการวิจัยภาษาโปรแกรม^{[ 194 ] [ 114 ] [ 195 ]}

ในสาขาอื่น ๆ บทความวารสารที่ตีพิมพ์ในProceedings of the International Astronomical Unionใช้ Rust เพื่อจำลองระบบดาวเคราะห์หลายดวง^{[ 196 ]}บทความที่ตีพิมพ์ในNatureได้แบ่งปันเรื่องราวของนักชีวสารสนเทศที่ใช้ Rust ^{[ 141 ]}ทั้งสองบทความอ้างถึงประสิทธิภาพและความปลอดภัยของ Rust เป็นข้อดี และเส้นโค้งการเรียนรู้เป็นข้อเสียหลักในการนำ Rust มาใช้

โครงการ TRACTOR ของ DARPAในปี 2025 มีเป้าหมายที่จะแปล C เป็น Rust โดยอัตโนมัติโดยใช้เทคนิคต่างๆ เช่น การวิเคราะห์แบบคงที่ การวิเคราะห์แบบไดนามิก และแบบจำลองภาษาขนาดใหญ่^{[ 197 ]}

ตามรายงานของMIT Technology Reviewชุมชน Rust ได้รับการมองว่าเป็น "มิตรอย่างยิ่ง" ต่อผู้มาใหม่ และดึงดูดผู้คนจากชุมชน LGBTQ+ เป็นพิเศษ ส่วนหนึ่งเนื่องมาจากหลักปฏิบัติ [ ^{20 ] การ}รวมกลุ่มได้รับการอ้างถึงว่าเป็นปัจจัยสำคัญสำหรับนักพัฒนา Rust บางคน^{[ 141 ]}บล็อกอย่างเป็นทางการของ Rust รวบรวมและเผยแพร่ข้อมูลทางประชากรศาสตร์ทุกปี^{[ 200 ]}

มูลนิธิสนิม

การก่อตัว	8 กุมภาพันธ์ 2564 ( 8 กุมภาพันธ์ 2021 )
ผู้ก่อตั้ง	บริการเว็บอเมซอน Google หัวเว่ย ไมโครซอฟต์ มูลนิธิโมสโมซซา
พิมพ์	องค์กร501(c)(6) [ 201 ]
ที่ตั้ง	สหรัฐอเมริกา
ประธาน	เชน มิลเลอร์
ผู้อำนวยการบริหาร	รีเบคก้า รัมบูล
เว็บไซต์	foundation .rust-lang .org

มูลนิธิRustเป็นองค์กรสมาชิกที่ไม่แสวงหาผลกำไร ซึ่งจดทะเบียนในสหรัฐอเมริกาโดยทำหน้าที่บริหารจัดการเครื่องหมายการค้า โครงสร้างพื้นฐาน และทรัพย์สินของ Rust ^{[ 202 ] [ 46 ]}

มูลนิธินี้ก่อตั้งขึ้นเมื่อวันที่ 8 กุมภาพันธ์ พ.ศ. 2564 โดยมีสมาชิกผู้ก่อตั้ง 5 บริษัท (Amazon Web Services, Huawei, Google, Microsoft และ Mozilla) ^{[ 203 ]}คณะกรรมการมูลนิธิมี Shane Miller เป็นประธาน^{[ 204 ]}โดยมี Ashley Williams เป็นผู้อำนวยการบริหารชั่วคราว^{[ 46 ]}ในช่วงปลายปี พ.ศ. 2564 Rebecca Rumbul ได้ดำรงตำแหน่งผู้อำนวยการบริหารและซีอีโอ^{[ 205 ]}

ณ เดือนพฤศจิกายน 2025 โครงการ Rust ได้รับการดูแลโดย ทีมระดับสูงสุด 8 ทีม ได้แก่ สภาผู้นำ ทีมคอมไพเลอร์ ทีมเครื่องมือพัฒนา ทีมโครงสร้างพื้นฐาน ทีมภาษา แพลตฟอร์มการเปิดตัว ทีมไลบรารี และทีมการดูแล ^{[ 206 ]}สภาผู้นำทำหน้าที่กำกับดูแลโครงการและประกอบด้วยตัวแทนจากทีมอื่นๆ^{[ 207 ]}

• การเปรียบเทียบภาษาโปรแกรม
• ประวัติความเป็นมาของภาษาโปรแกรม
• รายชื่อภาษาโปรแกรม
• รายชื่อซอฟต์แวร์และเครื่องมือ Rust
• โครงร่างของภาษาโปรแกรม Rust

เว็บไซต์ Wikibooks มีหนังสือเกี่ยวกับหัวข้อ " Rust สำหรับโปรแกรมเมอร์มือใหม่"

• เว็บไซต์อย่างเป็นทางการ
• ซอร์สโค้ดบนGitHub
• เอกสารประกอบ