Bizga "Zang tilini tanqid qilish va nima uchun C / C ++ hech qachon o'lmaydi" maqolasi juda yoqdi. Biz muallifga maqolani ingliz tiliga tarjima qilib, blogimizda chop etishimizni taklif qildik. U rozi bo'ldi va biz ushbu maqolani rus va ingliz tillarida taqdim etishdan mamnunmiz. Asl maqola joylashgan.

Asl maqola e'lon qilingan (matn rus tilida). Maqola muallifning roziligi bilan bizning blogimizda nashr etilgan.

Eslatma: Quyida Rust tez va xavfsiz til yaratishga urinish deb taxmin qilaman. Axir, Mozilla'dagi yigitlar uni brauzer mexanizmini ishlab chiqish vositasi sifatida yaratdilar. Agar bu boshqa xavfsiz til bo'lsa, biz g'alati bo'lamiz. O'nlab turli xil xavfsiz tillar allaqachon mavjud, har kim o'z xohishiga ko'ra topadi. Va agar maqsad C ++ ni almashtirish bo'lmasa, unda (1) nima uchun xavfli bo'lmagan kichik to'plam tilda yaratilgan? (2) nima uchun tildan engil oqimlarni olib tashlash qulay edi? Boshqacha qilib aytganda, bu holatda sodir bo'layotgan narsa hech qanday ma'noga ega emas.

Agar siz to'satdan linux.org.ru forumini o'qib chiqsangiz, shuni ta'kidlaymanki, bu ushbu mavzuda muhokama qilingan Rustni yoqtirmaslik uchun 10 ta texnik sabablar ro'yxati emas. Skype bilan suhbat sifatida aziz o'rtoq @ sum3rman Ushbu sabablar qanchalik "texnik" ekanligi haqida bir nechta fikrlar mavjud. Umuman olganda, men anjir ro'yxatini tuzdim, lekin undan ba'zi fikrlarni, eng qiziqarlisini, ehtimol, men hali ham keltirishga jur'at etaman. Darhaqiqat, ko'zlar uchun oddiy, texnik bo'lmagan sabablar etarli.

C / C ++ yaqin kelajakda hech qaerga ketmasligi har qanday hushyor odamga ayon. Hech kim deyarli barcha ish stoli ilovalarini, operatsion tizim yadrolarini, kompilyatorlarni, o'yin va brauzer dvigatellarini, virtual mashinalarni, ma'lumotlar bazalarini, arxivatorlarni, audio va video kodeklarni, tonna boshqa sic kutubxonalarini va hokazolarni qayta yozmaydi. Bu juda tez, tuzatilgan, vaqt sinovidan o'tgan koddir. Uni qayta yozish juda, juda qimmat, xavfli va rostini aytsam, faqat eng o'jar Rust "Ummonning buzilgan ongida mantiqiy. C / C ++ dasturchilariga bo'lgan talab juda katta bo'lgan va bo'ladi. uzoq vaqt.

OK, yangi kod yozishda Rust-dan foydalanish haqida nima deyish mumkin?

Esda tutingki, bu "to'g'riroq" C / C ++ qilish uchun birinchi urinish emas. Keling, D tilini olaylik, u 2001 yilda paydo bo'lgan, juda yaxshi til. Bo'sh ish o'rinlari, oddiy rivojlanish vositalari yoki biron bir ajoyib muvaffaqiyat hikoyalari yo'q. OpenMW loyihasi dastlab D tilida yozilgan, keyin esa birdan ular uni butunlay C++ da qayta yozishga qaror qilishdi. Ishlab chiquvchilar tan olganidek, ular "ajoyib loyiha, biz bunga hissa qo'shishdan xursand bo'lardik, lekin biz bu ahmoq D"ni bilmaymiz va bilishni xohlamaymiz" tarzida ko'plab xatlar oldi. Vikipediya xabar berishicha, D dan tashqari, C ++ ni u yoki bu darajada o'ldirishga urinishlar bo'lgan, masalan, Vala, Cyclone, Limbo, BitC. Qancha odamlar hatto bunday tillar haqida eshitgan?

Menimcha, tarixdan saboq olish vaqti keldi. Hech bo'lmaganda unga oddiy rivojlanish vositalarini ko'rsatmaguningizcha, bir nechta muvaffaqiyat hikoyalarini aytib bermaguningizcha va yaqin atrofda yashovchi o'nlab dasturchilarni ko'rsatmaguningizcha, biron bir aqli raso odam yangi tilni loyihaga tortmaydi. Dasturchilar, ehtimol, eng kichigidan tashqari, siz ularga oddiy rivojlanish vositalarini (Racer kabi hunarmandchilikni emas), bir necha o'n minglab tayyor kutubxonalarni (emas) ko'rsatmaguningizcha, keyingi eng to'g'ri tilni o'rganish uchun hech qachon vaqt va sog'lig'ini behuda sarflamaydi. "eksperimental", "beqaror" va boshqalar), bir nechta muvaffaqiyat hikoyalarini aytmang va o'z shahridagi o'nlab ochiq vakansiyalarni ko'rsatmang. Tovuq va tuxum muammosi. Juda kamdan-kam hollarda, bu muammoni muvaffaqiyatli hal qilish mumkin (masalan, Scala-ni bu erda misol qilib keltirish mumkin), asosan ba'zi bir yirik kompaniya (Google, Typesafe) tomonidan vaqt va pul investitsiyalari tufayli, bu qandaydir sabablarga ko'ra. , tilni ommalashtirishdan manfaatdor.

Men ta'kidlaganimdek, texnik bo'lmagan sabablarning o'zi etarli. Biroq, faqat qiziquvchanlik uchun, keling, ular u erda yo'qligini bir soniya tasavvur qilishga harakat qilaylik. Unda Rustda yozmaslik uchun hech qanday sabab yo'qmi? Ma'lum bo'lishicha, bu ham hech bo'lmaganda juda katta savol.

C / C ++ turli xil narsalar uchun tanqid qilinadi. Aytgancha, uni uzoqdan ishlab chiqarishda C ++ kodini ham ko'rmaganlar juda tez-tez tanqid qilishadi. Qisqa va tushunarli qilib, muammoni quyidagicha ta'riflash mumkin: C ++ juda tez (shuningdek, xotira, batareya quvvati va boshqalarni talab qilmaydi), lekin massivlar chegarasidan tashqariga chiqishga imkon beradigan ma'noda xavfsiz emas. , bo'shatilgan xotira qismlariga xatolik bilan kirish va hokazo. Bir vaqtlar bu muammo Java, C#, Python va boshqalar kabi xavfsiz tillar massasining paydo bo'lishiga olib keldi. Ammo ma'lum bo'lishicha, bu tillar C ++ ga nisbatan juda ko'p resurs talab qiladi va boshqa kamchiliklarga ega, hech bo'lmaganda axlat yig'ish paytida muqarrar ravishda dunyoni to'xtatishni unutmang. Shu sababli, odamlar tilni C ++ kabi tez, lekin ayni paytda xavfsiz qilish vazifasi bilan kurashmoqda. Ushbu tillardan biri Rust.

Rust haqiqatan ham xavfsiz, lekin afsuski, tezdan uzoqdir. Ushbu yozish paytidagi tezlik bo'yicha Rust Java, Go va Haskell bilan taqqoslanadi:

Men chin dildan umid qilamanki, vaqt o'tishi bilan u qandaydir tarzda overclock qilinadi, ammo shu vaqtgacha tezlik va xavfsizlikning murosaga kelishi nuqtai nazaridan bu Scala yoki Go'dan ko'ra qiziqroq emas. Hozirgacha savol tug'iladi: tilni umuman tez va xavfsiz qilish mumkinmi yoki massiv chegaralaridan tashqarida doimiy tekshiruvlar, C kutubxonalari bilan bog'lanishlar atrofida xavfsiz bog'lanish va hokazolar har qanday tilni avtomatik ravishda 2 baravar sekinroq qiladi. C / C ++.

Rust aslida qanday xavfsiz? Oddiy qilib aytganda, bu o'rnatilgan statik kod analizatoriga ega til. Haqiqatan ham juda ajoyib statik analizator, C ++ uchun xos bo'lgan barcha xatolarni ushlaydi, bundan tashqari, nafaqat xotirani boshqarish bilan bog'liq, balki ko'p ish zarralarini ham. Men o'zgaruvchan ob'ektga havolani kanal orqali boshqa mavzuga o'tkazdim, keyin esa o'zim ushbu havoladan foydalanishga harakat qildim - tamom, u kompilyatsiya qilmaydi. Bu juda zo'r.

Ko'pincha kodning atigi 10% 90% bajarilganligi haqida bahslashadi (bu men tushunganimdek, bu oddiy qoida - bu mavzu bo'yicha hech qanday jiddiy tadqiqot tezda topilmadi). Shuning uchun, dasturning ko'p qismi xavfsiz Rustda yozilishi mumkin va issiq kodning 10% xavfsiz bo'lmagan kichik to'plamda yozilishi mumkin va hozirgi Rustni amalga oshirishning sekinligi aslida muammo emas. OK, lekin keyin Rust umuman kerak emasligi ma'lum bo'ldi, chunki men Go'da kodning 90% va C da 10% yoza olaman. Faqat kumush o'q izlovchilar va haqiqatdan ajralgan bid'atchilar Rustdan faqat dasturning 100% bir tilda yozilishi mumkinligi sababli foydalanadilar. Garchi aslida bu bir xil tilning ikkita lahjasi bo'lsa-da, bu Java plus C yoki Go plus C to'plamidan unchalik farq qilmaydi.

Aslida 10:90 qoidasi hali ham yolg'on. Ushbu mantiqdan kelib chiqib, Java-da WebKit-ning 90%, VirtualBox-ning 90% yoki GCC-ning 90% ni qayta yozishingiz va xuddi shunday natijaga erishishingiz mumkin. Bu shunday emasligi aniq. Gap bir qator dasturlarda bu munosabat juda boshqacha ekanligida bo'lmasa ham, qo'llaringizga e'tibor bering. Aytaylik, butun dastur xavfsiz bo'lmagan C / C ++ da yozilgan va uning bajarilish vaqti, nisbatan aytganda, 0,9 * 1 (issiq kodning kichik qismi) + 0,1 * 1 (ko'p sovuq kod) = 1. Endi keling, xavfsiz tildagi dastur bilan Si-dagi qo'shimchalar bilan taqqoslaylik: 0,9 * 1 + 0,1 * 2 = 1,1, shartli ravishda farqning 10%. Ko'pmi yoki ozmi? O'lchovingizga bog'liq. Google misolida, hatto bir necha foiz ham millionlab dollarlarni tejashga qodir ("Utilizatsiya" gazetasining 5-bandiga qarang). Yoki tasavvur qiling-a, keyingi yangilanish bilan JVM to'satdan 10% ko'proq resurslarni talab qila boshlaydi! Men foizlarni Amerika puliga o'tkazgandan keyin olingan raqamda qancha nol bo'lishini taxmin qilishdan ham qo'rqaman! 10% C va C ++ ishlatiladigan vazifalarda dofig hisoblanadi.

Biz mantra sifatida "erta optimallashtirish - barcha yomonliklarning ildizi" ni takrorlaymiz. Lekin tom ma'noda, keling, tez saralash o'rniga hamma joyda qabariq sortidan foydalanaylik. Dastur aynan shu joyda sekinlashishini aniq bilmaymiz! Agar siz darhol samaraliroq atomdan foydalanishingiz mumkin bo'lsa, ba'zi harakatlarning oddiy hisoblagichlarini aktyorlar yoki tranzaksiya xotirasiga o'rashning nima keragi bor? Va umuman olganda, arzimas holatlarda, barcha o'zgaruvchilarni majburan ishga tushirish, bir qator qo'shimcha tekshiruvlar qilish va hokazolar mantiqiy emas. Oxir-oqibat biz 10% tezlashuvni emas, balki 2-5% ni olamiz. Bu ham yomon emas, agar bir necha qo'shimcha o'ylash kerak bo'lsa. Va biz allaqachon bilib olganimizdek, C / C ++ da hal qilingan muammolarda bu katta farq bo'lishi mumkin! Keyin kim aytdi: "Issiq nuqta" topish, kodni qayta yozish (ko'p kod bo'lishi mumkin) va bu haqiqatan ham tezroq ekanligini isbotlash ishlash haqida oldindan o'ylashdan osonroqdir?

Tezlik va xavfsizlik o'rtasidagi kelishuvdan tashqari, menda tilning o'zi dizayni haqida ham savollarim bor. Xususan, besh turdagi ko'rsatkichlar haqida. Bir tomondan, dasturchi o'zgaruvchilar qayerda, stek yoki to'plamda va ular bilan bir vaqtning o'zida bir nechta iplar ishlashi yoki ishlamasligi haqida o'ylash yomon emas. Ammo boshqa tomondan, siz dastur yozayotganingizni tasavvur qiling va o'zgaruvchi stekda emas, balki to'pda yashashi kerakligi ma'lum bo'ldi. Box-dan foydalanish uchun hamma narsani qayta yozasiz. Shunday qilib, siz haqiqatan ham Rc yoki Arc kerakligini tushunasiz. Qayta yozing. Va keyin siz uni stekdagi oddiy o'zgaruvchi bilan qayta yozasiz. Bularning barchasi - oddiy IDE-siz. Oddiy mavsum esa yordam bermaydi. Xo'sh, yoki shunchaki "Vec" uslubida >>> "salom Java! Lekin eng achinarlisi shundaki, kompilyator barcha o'zgaruvchilarning ishlash muddati haqida allaqachon biladi, u barcha bu Boxes, Arc va hokazolarni avtomatik ravishda ko'rsatishi mumkin. Lekin negadir ishning bu qismi qolgan. val yozish ancha qulayroq bo'lardi (uchinchi ming yillikda!) va kerak bo'lganda Box yoki R ni aniq ko'rsating.

Shu sababli, xususan, Rustning doirasi juda toraygan. Aqli joyida hech kim veb va server tomonini bunday tilda yozmaydi. Ayniqsa, JVM ostidagi bir xil tillarga nisbatan sezilarli afzalliklarni bermasligini hisobga olsak. Va oddiy engil iplar bilan Go (fyuchers emas) bu vazifalar uchun ancha jozibali ko'rinadi. Fyucherslar bilan, oyog'ingizga o'q uzmaslik uchun siz hali ham ishlashni o'rganishingiz kerak va siz "xavfsiz til" deysiz. Ha, bu tillarning o'ziga xos xususiyatlari bor, dunyoni bir xil to'xtatadi, ammo bu muammoni mikroservislarga arralash orqali ham, boshqa usullar bilan ham hal qilish mumkin. Va ha, hech kim Rust-ni JavaScript-ga tarjima qilmaydi, AWS-da tartib uchun skriptlarni yozmaydi yoki uni MongoDB uchun so'rovlar tili sifatida ishlatmaydi. Ular Android uchun ham deyarli yozishmaydi, lekin boshqa sababga ko'ra - bir nechta arxitektura mavjud, JVM bilan bu juda oson. Agar siz to'satdan Rustni "barcha vazifalar uchun mos" deb o'ylasangiz, men sizni xafa qilishim kerak.

Xo'sh, to'pga:

• Makroslar, oddiy istisnolar yo'qligi tufayli yuzaga kelgan haddan tashqari aniqlik uchun zaxira sifatida. Men allaqachon metadasturlash muammolari haqida yozgan edim, xususan, Rust uchun oddiy IDE-ni ko'rishimiz dargumon. Ishonchim komil emas, lekin Rust-dagi makroslarda hatto nom bo'shliqlari ham yo'qdek ko'rinadi.
• Odamlar ahmoqdir va yuk Crates.io-ni chetlab o'tib, to'g'ridan-to'g'ri git repozitoriylaridan paketlarni tortib olishga undaydi. Natijada, Rabar bilan Erlang dunyosida bo'lgani kabi, paketlar bilan ham xuddi shunday tartibsizlikka tushish ehtimoli yuqori.Aytgancha, Go dunyosida ham xuddi shunday holat.
• Ko'pgina yangi tillar singari, Rust ham soddalashtirish yo'lidan boradi. Umuman olganda, men nima uchun oddiy meros va istisnolar yo'qligini tushunaman, lekin kimdir men uchun bunday narsalarni hal qilishi yoqimsiz ta'mni qoldiradi. C ++ dasturchini nimadan foydalanishi va nima bo'lmasligi haqida cheklamaydi.
• Agar biz soddalashtirish yo'lidan borsak, tilning barcha kengaytmalarini chiqarib tashlagan bo'lardik. Aks holda, Xaskell dunyosida bo'lgani kabi, har bir dasturchi o'z shevasida yozadi.
• Aqlli ko'rsatkichlar, agar biror narsa bo'lsa, bepul emas va axlatni yig'ish vaqtini oldindan aytib bo'lmaydi. Ba'zi bir ish zarrachalari to'satdan juda chuqur ma'lumotlar strukturasini chiqarish imtiyoziga ega bo'ladi. U o'lik rishtalar labirintida yurarkan, unga bog'liq bo'lgan iplar sabr bilan to'mtoq bo'lib ketadi. Xuddi shu muammo Erlangda ham bor, uning kichik uyumlari bilan men o'zim buni bir necha bor kuzatganman. Aqlli ko'rsatkichlarning o'ziga xos muammolari, xotiraning bir xil bo'linishi va oqishi bor. Men siklik tuzilmadagi wikpointerni unutibman, hammasi shu. Va bu xavfsiz deb da'vo qiladigan tilda. Agar siz oldindan taxmin qilinadigan GC vaqtini xohlasangiz, yuk ostidagi ilovangizning harakatini oʻrganing va agar GC vaqti sizga mos kelmasa, chora koʻring (hech boʻlmaganda bir xil obʼyektlar hovuzlarini eslang) yoki xotirani qoʻlda boshqaring.
• Kimdir Rust semantikasining qat'iy tavsifini ko'rganmi? Uning hech bo'lmaganda xotira modeli bormi? Bundan tashqari, men uchun dasturlarning "to'g'riligini isbotlovchi" "xavfsiz" til, u aslida manba kodini o'n xil yo'l bilan izohlay oladi, ha!
• Shuni eslatib o‘tmasdan ilojim yo‘q muammo deyarli har doim odamlar, texnologiya emas... Agar siz yomon C++ yoki Java kodini olsangiz, u birdan sekinlashadi, bu texnologiya yomonligi uchun emas, balki undan toʻgʻri foydalanishni oʻrganmaganligingizdir. Siz ham Rustdan norozi bo'lasiz, lekin turli sabablarga ko'ra. Eng mashhur vositalardan foydalanishni o'rganish va ularni sevishni boshlash osonroq emasmi?

Umuman olganda, keyingi 5 yil davomida men Rustdan ko'ra C / C ++ tilini o'rganishga vaqtimni sarflaganim yaxshi bo'ladi. C ++ - bu sanoat standarti... 30 yildan ortiq vaqt davomida ushbu tilda turli muammolar muvaffaqiyatli hal qilindi. Rust va shunga o'xshash boshqalar esa noaniq kelajakka ega bo'lgan tushunarsiz o'yinchoqlardir. Hech bo'lmaganda 2000-yillardan beri C ++ ning yaqin orada o'limi haqida gap bor edi, ammo bu vaqt ichida C / C ++ da yozish kam bo'lmadi. Aksincha. Va biz til rivojlanayotganini ko'rmoqdamiz (C ++ 11, C ++ 14), u uchun yangi vositalar paydo bo'ladi (hech bo'lmaganda CLion va Clang-ni eslang) va bir nechta tegishli bo'sh ish o'rinlari mavjud.

C++ dasturchisi har doim bemalol munosib maoshga ega ish topa oladi va kerak bo'lganda Rustni tezda qayta o'qitishi mumkin. Suhbat juda va juda shubhali. Aytgancha, til, agar biror narsa bo'lsa, yangi ish joyini tanlashda yagona va hal qiluvchi omil emas. Bundan tashqari, tajribali C / C ++ dasturchisi PostgreSQL manbasini yoki Linux yadrolarini osongina qazib olishi, kuchli zamonaviy ishlab chiqish vositalaridan foydalanishi, shuningdek, o'z ixtiyorida ko'plab kitoblar va maqolalarga ega bo'lishi mumkin (aytaylik, OpenGL da).

Vaqtingizni va sog'lig'ingizni tejang, sizda ular ko'rinadigan darajada ko'p emas!

2013-yilda Mozilla Samsung bilan hamkorlikda yangi Servo veb-brauzer mexanizmini ishlab chiqdi. U mobil qurilmalarning ko'p yadroli protsessorlari uchun maxsus yaratilgan bo'lib, u vazifalarni parallel iplarga bo'lish va veb-sahifalarni yuklash vaqtini sezilarli darajada kamaytirishga qodir. Servo butunlay Rust dasturlash tilida yozilgan bo'lib, Mozilla mobil ilovalarni yozish uchun o'zi ishlab chiqqan.

Til haqida

Rust - bu turli xil kodlash uslublarini qo'llab-quvvatlaydigan protsessual dasturlash tili. Dasturchi Graydon Horus tilni 2006 yilda yaratishni boshlagan va Mozilla uch yildan so'ng loyihaga qo'shilgan. 2010 yilda Rust Mozilla sammitida taqdim etildi. Xuddi shu yili ishlanma Rustda yozilgan kompilyatorga o'tkazildi. Kompilyator ma'lumotlar bazasi sifatida LLVM universal dasturlarni tahlil qilish va o'zgartirish tizimidan foydalangan.

Tilning birinchi barqaror versiyasi 2015 yilda chiqarilgan. Alfa versiyasi chiqqandan so'ng, Rust o'zgarishlarga duch keldi - kompilyator ichida faqat o'zgarmas tayyor xususiyatlar qoldi. Qolganlarning hammasi eksperimental qismga o'tkazildi.

Graydon Xor tilning markazida quyidagi tushunchalarni qo'ydi:

• Xavfsizlik. Rust sukut bo'yicha yoqilgan bir qator dasturchi cheklovlarini o'z ichiga oladi. Ularni bloklar va funktsiyalarda o'chirish uchun "xavfsiz" yorlig'i talab qilinadi.
• Tezlik. Til tezligi bo'yicha boshqa C ++ dasturlash tili bilan taqqoslanadi, bu dasturchi uchun aniq afzalliklarni beradi.
• Parallellik. Tizim bir vaqtning o'zida bir nechta hisob-kitoblarni amalga oshirishi mumkin, shu bilan birga ular bir-biri bilan o'zaro aloqada bo'lishi mumkin.
• Qisqartirish. Rust-dagi birinchi kalit so'zlar besh belgidan iborat edi. Ammo keyinroq bu cheklov olib tashlandi.

Birinchi Rust kodlaridan biriga misol

Biroq, Rust o'zining kamchiliklaridan xoli emas, ularning eng yorqinlari:

• Kodning ortiqchaligi.
• Til o'rganish uchun adabiyotlarning etishmasligi.
• Kompilyatsiya variantlarini kiritishda aniqlik. Bu har doim ham tajribali dasturchilarga mos kelmaydi, chunki boshqa tillarda o'xshash qoidalar yo'q.

Biroq, til muntazam ravishda yangilanadi va to'ldiriladi: uning yangilanishlari har 6 haftada chiqariladi.

Rustni C ++ bilan solishtirish

Rust yaratuvchilari uni 1980-yillarning boshlarida, ishlab chiquvchi C tiliga bir nechta yaxshilanishlarni taklif qilganda paydo bo'lgan C ++ ning vorisi deb hisoblashadi.Shuning uchun yosh va hali ham o'zgaruvchan tilni vaqt bilan solishtirishga arziydi. sinovdan o'tgan.

• Masofaviy xotiraga kirish. C++ da o‘zgaruvchini o‘chirish bir qancha muammolarni keltirib chiqarishi mumkin. Rustda bu kabi asoratlar mumkin emas, chunki xotirani o'chirish uchun buyruqlar yo'q. Vorisning kompilyatori yozilgan kodda xato borligi haqida xabar beradi va C ++ kompilyatori natijani o'chirilgan qiymatlarsiz, hatto muammo haqida xabar bermasdan chiqaradi.
• Nuqtali vergul. Kodingizga qo'shimcha nuqta-vergul qo'shsangiz, C ++ da xatolik yuzaga keladi, Rustda esa halqa tanasi jingalak qavslar ichiga olingan.
• Xavfli kod. Rust asosiy kodni xavfli koddan izolyatsiya qiluvchi "xavfsiz" yorlig'iga ega. Kelajakda, kodni ko'rib chiqishda, bu zaifliklarni qidirishni qisqartirish imkonini beradi.

Firefox aynan C++ da amalga oshirildi: bu injiq til tafsilotlarga katta e'tiborni talab qildi. Aks holda, xatolar jiddiy zaifliklarga aylandi. Rust ushbu muammoni hal qilish uchun yaratilgan.

Perspektivlar

Mozilla dasturlash tili 2018 yilning uchinchi choragida RedMonk reytingida doimiy ravishda 23-o‘rinni egallaydi. Mutaxassislarning fikricha, uning mavqeini yaxshilash xavfi yo'q. Nima bo'lishidan qat'iy nazar, 2018 yil avgust oyida ijodkorlar yangilangan Rust 1.28-ni chiqardilar.

Stack Overflow ma'lumotlariga ko'ra, Rust 2015 yilda chiqarilgandan so'ng, dasturchilarning 74 foizi uni ko'rishni xohlashdi. Biroq, 2016 yilda u birinchi o'ringa ko'tarildi: 79% foydalanuvchi Rustni o'zining sevimli dasturlash tili deb nomladi va u bilan ishlashni davom ettirish istagini bildirdi. Rust 2018 yilda ham ushbu parametr bo'yicha birinchi o'rinni egalladi.

Stack Overflow - 2008 yilda ishlab chiqilgan mashhur kodlash savol-javob tizimi.

Rustning mashhurligi uni ishlab chiqishda ishlatadigan kompaniyalar soni bilan tasdiqlanadi. Ro‘yxatga hozirda 105 ta tashkilot kiritilgan.

Bugungi kunda Rust sintaksisi kompilyator bilan ta'minlangan sintaksis fayllari yordamida vim va emacs-da qo'llab-quvvatlanadi.
Shuningdek, mashhur sublime Text 2 muharriri va bepul Kate muharriri uchun sintaksis paketlari mavjud. IDE-da hali Rust-ni qo'llab-quvvatlamaydi. Debugger yordami ham etishmayotgan ko'rinadi.

Quyidagi yordamchi dasturlar rustc kompilyatori bilan ta'minlangan:
> rustdoc- Doxygen kabi manba kodidan hujjatlarni avtomatik yaratish uchun yordamchi dastur;
> rustpkg- qo'shimcha paketlar va kutubxonalarni osongina o'rnatish imkonini beruvchi paketlar menejeri;
> rusti- REPL yordam dasturi (o'qish-baholash-chop etish-loop). Aslini olganda, bu buyruq satridan Rust ifodasini oladigan, uni ichki LLVM ko'rinishiga kompilyatsiya qiladigan, natijani bajaradigan va chiqaradigan test tarjimonidir;
> zang- parametrlarga qarab boshqa yordamchi dasturlarni yoki kompilyatorni ishga tushiradigan universal yordamchi dastur. Bu men uchun hech qachon ishlamagan.

Barcha mavjud til hujjatlari www.rust-lang.org rasmiy veb-saytida to'plangan. Batafsil qo'llanma (http://static.rust-lang.org/doc/tutorial.html) mavjud - sintaksisning barcha nuanslari, xotira modeli, ish vaqti tizimi va boshqalar bo'yicha keng qamrovli rasmiy hujjatlar, shuningdek hujjatlar o'rnatilgan yadro kutubxonasi va standart kutubxona std. Barcha hujjatlar ingliz tilida. Rus tilida tegishli materiallar yo'q va bir nechta mavjud sharh maqolalari allaqachon eskirgan.

Mafkura va sintaksis

Rust - kod bloklarini belgilash uchun jingalak qavslardan foydalanadigan C-ga o'xshash til. Til "ko'p paradigma", ya'ni. kodni imperativ protsessual, ob'ektga yo'naltirilgan, parallel yoki funktsional tarzda yozish imkonini beradi. Rust har qanday qo'llab-quvvatlanadigan platformada mahalliy ikkilik fayllarni kompilyatsiya qiladi (backend sifatida LLVM-dan foydalanadi). Nazariy jihatdan, Rust kodi C / C ++ kodi kabi tez bo'lishi kerak. Rust tizim tili sifatida sotiladi, lekin u C, C ++ yoki D "haqiqiy" tizim tillarida bo'lgani kabi montaj kodlari bloklari uchun o'rnatilgan yordamga ega emas.

Rustning xotira modeli tabiiy ravishda null yoki osilgan ko'rsatkichlarga va bufer to'lib ketishiga ruxsat bermaydi. Faqat bitta kod satrida ishlaydigan ixtiyoriy axlat yig'uvchi mavjud. Bu tilda engil ko'p vazifali va mavzuli xabar almashish uchun o'rnatilgan yordam mavjud. Rustda umumiy xotira mavjud emas. Barcha oʻzgaruvchilar stek oʻzgaruvchilari, berilgan ip uchun yigʻma oʻzgaruvchilar va “almashtirish” yigʻma oʻzgaruvchilarga boʻlinadi, ularni barcha oqimlar oʻqiy oladi, lekin ular tomonidan oʻzgartirib boʻlmaydi. Bu ko'p tarmoqli dasturlash balosi hisoblangan o'liklarni avtomatik ravishda yo'q qiladi. Tilning ABI ko'rsatkichi C bilan mos keladi, shuning uchun Rust dasturlari C tilida yozilgan kutubxonalarga qo'shimcha o'ramlarsiz ulanishi mumkin. Past darajadagi tizim dasturlash ehtiyojlari uchun va C bilan mosligini ta'minlash uchun til ko'rsatkichlarning to'g'riligini tekshirmasdan maxsus "xavfli" rejimga ega. Mafkurasi jihatidan Rust Go tiliga eng yaqin. Xuddi Go'da bo'lgani kabi, asosiy e'tibor ko'p bosqichli dasturlashning soddaligi va keng ko'lamli ilovalarni ishlab chiqish tezligiga qaratiladi va sintaksis ham xuddi shunday noodatiy va ba'zi joylarda biroz hayratlanarli. Shu bilan birga, Rust Go kabi minimalistik emas va tizim tili ekanligini da'vo qiladi.

Rustning sintaksisi asosan C va C ++ dan o'zlashtirilgan, Go, C #, Haskell, Python va Ruby g'oyalari bilan. Men tilning sintaksisini to'liq ta'riflamayman, faqat eng qiziqarli tushunchalarga e'tibor qarataman.

Zang Mozilla tomonidan ishlab chiqilgan yangi eksperimental dasturlash tilidir. Til tuzilgan va ko'p paradigma bo'lib, u C / C ++ ga muqobil sifatida joylashtirilgan, bu o'zi qiziq, chunki raqobat uchun unchalik ko'p da'vogarlar yo'q. Uolter Brightning D yoki Google Go-ni o'ylab ko'ring.
Rust funktsional, parallel, protsessual va ob'ektga yo'naltirilgan dasturlashni qo'llab-quvvatlaydi, ya'ni. amaliy dasturlashda haqiqatda qo'llaniladigan paradigmalarning deyarli barcha diapazoni.

Men hujjatlarni tarjima qilmoqchi emasman (bundan tashqari, u juda kam va doimiy ravishda o'zgarib turadi, chunki hali tilning rasmiy nashri bo'lmagan), buning o'rniga men tilning eng qiziqarli xususiyatlarini ta'kidlamoqchiman. Ma'lumotlar rasmiy hujjatlardan ham, Internetdagi til haqida juda kam eslatmalardan ham to'plangan.

Birinchi taassurot

Tilning sintaksisi an'anaviy C-ga o'xshash uslubda qurilgan (bu yaxshi yangilik, chunki bu allaqachon amalda standart). Tabiiyki, taniqli C / C ++ dizayn xatolari hisobga olingan.
An'anaviy Salom dunyosi quyidagicha ko'rinadi:
std dan foydalaning; fn main (args :) (std :: io :: println ("salom dunyodan" + args + "!");)

Misol biroz murakkabroq - faktorialni hisoblash funktsiyasi:

Fn fac (n: int) -> int (natija = 1, i = 1; esa i<= n { result *= i; i += 1; } ret result; }

Misoldan ko'rinib turibdiki, funksiyalar "funktsional" uslubda e'lon qilingan (bu uslub an'anaviy "int fac (int n)"ga nisbatan ba'zi afzalliklarga ega). Ko'ramiz avtomatik turdagi xulosa(let kalit so'zi), while argumenti uchun qavssiz (Go ga o'xshash). Kalit so'zlarning ixchamligi ham darhol namoyon bo'ladi. Rust yaratuvchilari haqiqatan ham barcha kalit so'zlarni iloji boricha qisqaroq qilib qo'yishdi va rostini aytsam, men buni yaxshi ko'raman.

Kichik, ammo qiziqarli sintaktik xususiyatlar

• Raqamli konstantalarda pastki chiziqdan foydalanishingiz mumkin. Qulay narsa, endi bu xususiyat ko'plab yangi tillarga qo'shilmoqda.
  0xffff_ffff_ffff_ffff_ffff_ffff
• Ikkilik konstantalar. Albatta, haqiqiy dasturchi o'z boshida binni olti burchakka aylantirishi kerak, ammo bu qulayroq! 0b1111_1111_1001_0000
• Har qanday operatorlarning tanasi (hatto bitta ifodadan iborat bo'lganlar ham) jingalak qavslar ichiga olinishi kerak. Masalan, C tilida if (x> 0) foo (); , Rust da foo () atrofida jingalak qavslar qo'yish kerak
• Lekin if, while va shunga o'xshash operatorlarning argumentlarini qavs ichiga olish shart emas.
• ko'p hollarda kod bloklarini ifoda sifatida ko'rish mumkin. Xususan, bu mumkin, masalan:
  x = agar yulduzlar_align bo'lsa () (4) boshqa bir narsa bo'lsa () (3) boshqa (0);
• funksiyalarni e'lon qilish sintaksisi - avval fn kalit so'zi, so'ngra argumentlar ro'yxati, nomdan keyin argument turi ko'rsatiladi, so'ngra funktsiya qiymat qaytarsa, "->" strelkasi va qaytariladigan qiymatning turi.
• o'zgaruvchilar shunga o'xshash tarzda e'lon qilinadi: let kalit so'zi, o'zgaruvchining nomi, o'zgaruvchidan keyin siz ikki nuqta orqali turni belgilashingiz va keyin boshlang'ich qiymatni belgilashingiz mumkin.
  hisoblaymiz: int = 5;
• sukut bo'yicha barcha o'zgaruvchilar o'zgarmasdir; mutable kalit so'zi o'zgaruvchan o'zgaruvchilarni e'lon qilish uchun ishlatiladi.
• asosiy turdagi nomlar men uchratgan eng ixchamlari: i8, i16, i32, i64, u8, u16, u32, u64, f32, f64
• yuqorida aytib o'tilganidek, avtomatik turdagi xulosa qo'llab-quvvatlanadi

Tilda dasturlarni tuzatish uchun o'rnatilgan vositalar mavjud:
Kalit so'z muvaffaqiyatsiz joriy jarayonni tugatadi
Kalit so'z jurnal har qanday til ifodasini jurnalga chiqaradi (masalan, stderr ga)
Kalit so'z ta'kidlamoq ifodani tekshiradi va agar noto'g'ri bo'lsa, joriy jarayondan chiqadi
Kalit so'z Eslatma jarayonning g'ayritabiiy tugatilishi holatlarida qo'shimcha ma'lumotlarni ko'rsatishga imkon beradi.

Ma'lumotlar turlari

Rust, xuddi Go kabi, qo'llab-quvvatlaydi strukturaviy tiplash(garchi mualliflarning fikriga ko'ra, tillar mustaqil ravishda rivojlangan, shuning uchun bu ularning umumiy o'tmishdoshlari - Alef, Limbo va boshqalarning ta'siridir). Strukturaviy tiplash nima? Masalan, sizda biron bir faylda e'lon qilingan tuzilma mavjud (yoki Rust terminologiyasida "rekord")
turi nuqtasi = (x: float, y: float);
Siz "nuqta" argument turlari bilan bir qator o'zgaruvchilar va funktsiyalarni e'lon qilishingiz mumkin. Keyin, boshqa joyda, masalan, boshqa tuzilmani e'lon qilishingiz mumkin
MySuperPoint yozing = (x: float, y: float);
va bu turdagi o'zgaruvchilar nuqta tipidagi o'zgaruvchilar bilan to'liq mos keladi.

Bundan farqli o'laroq, C, C ++, C # va Java-da qo'llaniladigan nominativ tiplash bunday konstruktsiyalarga ruxsat bermaydi. Nominativ yozish bilan har bir tuzilma o'ziga xos tur bo'lib, sukut bo'yicha boshqa turlarga mos kelmaydi.

Rustdagi tuzilmalar "yozuvlar" deb ataladi. Kortejlar ham bor - bular bir xil yozuvlar, ammo nomsiz maydonlar bilan. Kortej elementlari, yozuv elementlaridan farqli o'laroq, o'zgaruvchan bo'lishi mumkin emas.

Vektorlar mavjud - qaysidir ma'noda oddiy massivlarga o'xshash va qaysidir ma'noda - stl dan std :: vektor turi. Ro'yxat bilan ishga tushirishda C / C ++ kabi jingalak qavslar emas, balki kvadrat qavslar ishlatiladi

myvec = bo'lsin;

Biroq vektor dinamik ma'lumotlar strukturasidir, xususan, vektorlar birlashtirishni qo'llab-quvvatlaydi.

v: o'zgaruvchan =; v + =;

Shablonlar mavjud. Ularning sintaksisi juda mantiqiy, C ++ dan "shablon" ning tartibsizligisiz. Funktsiya shablonlari va ma'lumotlar turlari qo'llab-quvvatlanadi.

Fn for_rev (v: [T], akt: blok (T)) (let i = std :: vec :: len (v); while i> 0u (i - = 1u; akt (v [i]);)) turi circular_buf = (start: uint, end: uint, buf:);

Til deb atalmishni qo'llab-quvvatlaydi teglar... Bu qo'shimcha maydonga ega bo'lgan C dan birlashmadan boshqa narsa emas - foydalanilgan variantning kodi (ya'ni birlashma va ro'yxatga olish o'rtasidagi umumiy narsa). Yoki nazariya nuqtai nazaridan, algebraik ma'lumotlar turi.

Teg shakli (doira (nuqta, float); to'rtburchaklar (nuqta, nuqta);)

Eng oddiy holatda teg ro'yxatga olish bilan bir xil bo'ladi:

Tag hayvon (it; mushuk;) a: hayvon = it; a = mushuk;
Murakkab holatlarda "sanoq" ning har bir elementi o'zining "konstruktori" bilan mustaqil tuzilma hisoblanadi.
Yana bir qiziqarli misol - bu "ro'yxat" tipidagi ob'ektni belgilaydigan rekursiv tuzilma:
teglar ro'yxati (no; minuslar (T, @list ); ) bo'lsin: ro'yxat = minuslar (10, @ minuslar (12, @nil));
Teglar naqshga mos keladigan ifodalarda ishtirok etishi mumkin, bu juda murakkab bo'lishi mumkin.
alt x (minuslar (a, @cons (b, _)) (jarayon_juftligi (a, b);) minuslar (10, _) (jarayon_o'n ();) _ (muvaffaqiyatsiz;))

Shakl mosligi

Boshlash uchun siz mos naqshni takomillashtirilgan kalit sifatida ko'rib chiqishingiz mumkin. Alt kalit so'zi ishlatiladi, undan keyin tahlil qilingan ifoda, so'ngra operator tanasida - naqshlar va naqshlar bilan mos kelgan taqdirda harakatlar.
alt my_number (0 (std :: io :: println ("nol");) 1 | 2 (std :: io :: println ("bir yoki ikkita");) 3 dan 10 gacha (std :: io :: println ("uchdan o'ngacha");) _ (std :: io :: println ("boshqa narsa");))
Nafaqat konstantalar (C da bo'lgani kabi), balki murakkabroq ifodalar - o'zgaruvchilar, kortejlar, diapazonlar, tiplar, to'ldiruvchilar ("_") "naqsh" sifatida ishlatilishi mumkin. Naqshdan so'ng darhol when bandidan foydalanib, qo'shimcha shartlarni yozishingiz mumkin. Turlarni moslashtirish uchun operatorning maxsus varianti mavjud. Bu mumkin, chunki til universal variant turiga ega. har qanday ob'ektlari har qanday turdagi qiymatlarni o'z ichiga olishi mumkin.

Ko'rsatkichlar. Umumiy ko'rsatkichlarga qo'shimcha ravishda, Rust o'rnatilgan mos yozuvlar hisobiga ega maxsus aqlli ko'rsatkichlarni qo'llab-quvvatlaydi - Umumiy qutilar va Noyob qutilar. Ular C++ dan shared_ptr va unique_ptr ga biroz o'xshaydi. Ularning o'z sintaksisi mavjud: umumiy uchun @ va yagona uchun ~. Noyob ko'rsatkichlar uchun nusxa ko'chirish o'rniga maxsus operatsiya mavjud - ko'chirish:
x = ~ 10 bo'lsin; ruxsat bering<- x;
bunday harakatdan so'ng, x ko'rsatkichi deinitializatsiya qilinadi.

Yopish, qisman qo'llash, iteratorlar

Bu erda funktsional dasturlash boshlanadi. Rust yuqori tartibli funktsiyalar tushunchasini to'liq qo'llab-quvvatlaydi - ya'ni o'z argumentlari sifatida qabul qilinishi va boshqa funktsiyalarni qaytarishi mumkin bo'lgan funktsiyalar.

1. Kalit so‘z lambda ichki funksiya yoki funktsional ma'lumotlar turini e'lon qilish uchun ishlatiladi.

Fn make_plus_funksiyasi (x: int) -> lambda (int) -> int (lambda (y: int) -> int (x + y)) qo'shimcha_ikki = make_plus_funksiyasi (2); assert plus_ikki (3) == 5;

Bu misolda bizda bitta int argumenti “x”ni oladigan va “int-> int” tipidagi funksiyani qaytaruvchi make_plus_funksiyasi mavjud (bu yerda lambda kalit so‘zdir). Funktsiya tanasi aynan shu funktsiyani tavsiflaydi. "Qaytish" operatorining yo'qligi biroz chalkash, ammo FP uchun bu odatiy holdir.

2. Kalit so‘z blok funktsional turni e'lon qilish uchun ishlatiladi - oddiy kod blokiga o'xshash narsa bilan almashtirilishi mumkin bo'lgan funktsiya argumenti.
fn map_int (f: blok (int) -> int, vec:) -> (natija =; i uchun vecda (natija + =;) ret natija bo'lsin;) map_int ((| x | x + 1),);

Bu erda bizda kirish sifatida blokli funksiya mavjud - aslida "int-> int" tipidagi lambda funksiyasi va int tipidagi vektor (keyinroq vektorlar sintaksisi haqida batafsilroq). Qo'ng'iroq kodidagi "blok" ning o'zi biroz noodatiy sintaksis (| x | x + 1) yordamida yozilgan. Shaxsan menga C # lambdas ko'proq yoqadi, | o'jarlik bilan bitli OR sifatida qabul qilinadi (bu, aytmoqchi, Rustda ham, barcha yaxshi eski C operatsiyalari kabi).

3. Qisman qo'llash - bu boshqa funktsiyaning ba'zi argumentlarining qiymatlarini ko'rsatish orqali ko'p sonli argumentlarga ega bo'lgan boshqa funktsiya asosida funktsiya yaratish. Buning uchun kalit so'z ishlatiladi. bog'lamoq va "_" to'ldiruvchisi:

daynum = bind std :: vec :: pozitsiyasi (_, ["mo", "tu", "we", "do", "fr", "sa", "su"]) bo'lsin.

Buni aniqroq qilish uchun men darhol aytamanki, buni oddiy C da oddiy o'ramni yaratish orqali amalga oshirish mumkin, masalan:
const char * daynum (int i) (const char * s = ("mo", "tu", "we", "do", "fr", "sa", "su"); return s [i]; )

Lekin qisman qo'llash protsessual emas, funksional uslubdir (Aytgancha, yuqoridagi misolda argumentsiz funktsiyani olish uchun qisman dasturni qanday qilish aniq emas)

Yana bir misol: add funksiyasi ikkita int argumenti bilan e'lon qilinadi va int ni qaytaradi. Keyinchalik, bitta int argumentiga ega bo'lgan va intni qaytaradigan single_param_fn funktsional turi e'lon qilinadi. Bind-dan foydalanib, qisman argumentlarga ega bo'lgan add funksiyasi ustiga qurilgan ikkita funktsiya ob'ekti, add4 va add5 e'lon qilinadi.

Fn add (x: int, y: int) -> int (ret x + y;) type single_param_fn = fn (int) -> int; add4 bo'lsin: single_param_fn = bog'lash qo'shish (4, _); add5 bo'lsin: single_param_fn = bog'lash qo'shish (_, 5);

Funktsional ob'ektlarni oddiy funktsiyalar kabi chaqirish mumkin.
tasdiqlang (qo'shing (4,5) == qo'shing4 (5)); tasdiqlash (qo'shish (4,5) == qo'shish5 (4));

4. Sof funksiyalar va predikatlar
Sof funksiyalar nojo‘ya ta’sirga ega bo‘lmagan funksiyalardir (shu jumladan, sof funksiyalardan boshqa funksiyalarni chaqirmaydiganlar ham). Bunday funktsiyalar sof kalit so'z bilan ajralib turadi.
sof fn lt_42 (x: int) -> bool (ret (x< 42); }
Predikatlar bool turini qaytaradigan sof funksiyalardir. Bunday funktsiyalardan tipstate tizimida foydalanish mumkin (pastga qarang), ya'ni ularni turli xil statik tekshiruvlar uchun kompilyatsiya vaqtida chaqirish mumkin.

Sintaksis makrolari
Rejalashtirilgan xususiyat, lekin juda foydali. Rustda u hali rivojlanishning dastlabki bosqichida.
std :: io :: println (#fmt ("% s is% d", "javob", 42));
Printf ga o'xshash, lekin kompilyatsiya vaqtida bajarilgan ifoda (mos ravishda, barcha argument xatolari kompilyatsiya vaqtida aniqlanadi). Afsuski, sintaktik makrolar bo'yicha materiallar juda kam va ularning o'zlari ishlab chiqilmoqda, ammo Nemerle makroslari kabi narsa paydo bo'lishiga umid bor.
Aytgancha, xuddi shu Nemerledan farqli o'laroq, menimcha, # belgisi yordamida makroslarni sintaktik tarzda ajratib ko'rsatish qarori juda vakolatli: so'l - bu funktsiyadan juda farq qiladigan ob'ekt va menimcha, bir qarashda qaerda ekanligini ko'rish juda muhim. funktsiyalar kodda chaqiriladi va bu erda - makroslar.

Atributlar

C # atributlariga o'xshash tushuncha (va hatto shunga o'xshash sintaksis bilan). Buning uchun ishlab chiquvchilarga alohida rahmat. Siz kutganingizdek, atributlar izoh qo'shadigan ob'ektga meta-ma'lumotni qo'shadi.
# fn register_win_service () (/ * ... * /)
Atribut sintaksisining yana bir varianti ixtiro qilindi - xuddi shu qator, lekin oxirida nuqtali vergul mavjud kontekstga izoh beradi. Ya'ni, bunday atributni o'z ichiga olgan eng yaqin jingalak qavslarga mos keladigan narsa.
fn register_win_service () (#; / * ... * /)

Parallel hisoblash

Ehtimol, tilning eng qiziqarli qismlaridan biri. Shu bilan birga, u hozirda o'quv qo'llanmasida umuman tasvirlanmagan :)
Rust dasturi "vazifalar daraxti" dan iborat. Har bir vazifa kirish funktsiyasiga, o'z stekiga, boshqa vazifalar bilan o'zaro ta'sir qilish vositalariga ega - chiquvchi ma'lumotlar uchun kanallar va kiruvchi portlar va dinamik yig'ishdagi ob'ektlarning bir qismiga egalik qiladi.
Ko'pgina Rust vazifalari bitta operatsion tizim jarayonida mavjud bo'lishi mumkin. Rust vazifalari "engil": har bir vazifa OS jarayoniga qaraganda kamroq xotirani sarflaydi va ular o'rtasida almashish OS jarayonlari o'rtasida almashishdan tezroq (bu, ehtimol, "iplar" degan ma'noni anglatadi).

Vazifa hech qanday argumentsiz kamida bitta funktsiyadan iborat. Vazifa spawn funktsiyasi yordamida boshlanadi. Har bir vazifa boshqa vazifalarga ma'lumot yetkazadigan kanallarga ega bo'lishi mumkin. Kanal - bu kanal ma'lumotlari turi bilan parametrlangan maxsus shablon turi chan. Masalan, chan imzosiz baytlarni uzatish uchun kanaldir.
Kanalga yuborish uchun yuborish funksiyasidan foydalaniladi, uning birinchi argumenti kanal, ikkinchisi esa yuboriladigan qiymatdir. Aslida, bu funksiya qiymatni kanalning ichki buferiga joylashtiradi.
Portlar ma'lumotlarni qabul qilish uchun ishlatiladi. Port - bu port ma'lumotlari turi bo'yicha parametrlangan shablonli port turi: port imzosiz baytlarni qabul qilish portidir.
Portlardan o'qish uchun recv funktsiyasidan foydalaniladi, uning argumenti port, qaytish qiymati esa portdan olingan ma'lumotlardir. O'qish vazifani bloklaydi, ya'ni. agar port bo'sh bo'lsa, boshqa vazifa port bilan bog'langan kanalga ma'lumotlarni yubormaguncha vazifa kutilayotgan holatga o'tadi.
Kanallarni portlarga ulash juda oddiy - chan kalit so'zidan foydalangan holda portli kanalni ishga tushirish orqali:
let reqport = port ();
let reqchan = chan (reqport);
Bir portga bir nechta kanal ulanishi mumkin, lekin aksincha emas - bir kanalni bir vaqtning o'zida bir nechta portga ulash mumkin emas.

Tip holati

Men rus tiliga "typestate" tushunchasining umume'tirof etilgan tarjimasini topa olmadim, shuning uchun uni "turi davlatlar" deb atayman. Bu xususiyatning mohiyati shundan iboratki, statik yozishda qabul qilinadigan odatiy turdagi tekshirishga qo'shimcha ravishda kompilyatsiya bosqichida qo'shimcha kontekstni tekshirish mumkin.
U yoki bu shaklda turlarning holatlari barcha dasturchilarga tanish - kompilyatorning xabarlariga ko'ra, "o'zgaruvchi ishga tushirilmasdan ishlatiladi". Kompilyator hech qachon yozilmagan o'zgaruvchi o'qish uchun ishlatiladigan joylarni aniqlaydi va ogohlantirish beradi. Umuman olganda, bu fikr quyidagicha ko'rinadi: har bir ob'ekt qabul qilishi mumkin bo'lgan holatlar to'plamiga ega. Har bir holatda ushbu ob'ekt uchun haqiqiy va noto'g'ri operatsiyalar aniqlanadi. Va kompilyator dasturning ma'lum bir joyida ob'ekt ustida muayyan operatsiyani bajarishga ruxsat etilganligini tekshirishi mumkin. Bu tekshiruvlar kompilyatsiya vaqtida amalga oshirilishi muhim.

Masalan, agar bizda "fayl" tipidagi ob'ekt bo'lsa, u holda u "yopiq" va "ochiq" holatiga ega bo'lishi mumkin. Va agar fayl yopiq bo'lsa, fayldan o'qish operatsiyasi yaroqsiz. Zamonaviy tillarda o'qish funksiyasi istisno qilish yoki xato kodini qaytarish odatiy holdir. Tur holati tizimi kompilyatsiya vaqtida bunday xatoni aniqlashi mumkin edi - xuddi kompilyator o'zgaruvchining o'qish operatsiyasi har qanday mumkin bo'lgan yozish operatsiyasidan oldin sodir bo'lishini aniqlaganidek, "O'qish" usuli "fayl ochiq" holatida amal qilishini aniqlashi mumkin. , ob'ektni shu holatga o'tkazuvchi "Ochiq" usulidan oldin chaqiriladi.

Rustda "predikatlar" tushunchasi mavjud - hech qanday nojo'ya ta'sirga ega bo'lmagan va bool turini qaytaradigan maxsus funktsiyalar. Bunday funksiyalar kompilyator tomonidan ma'lum shartlarni statik tekshirish maqsadida kompilyatsiya vaqtida chaqirilishi uchun ishlatilishi mumkin.

Cheklovlar kompilyatsiya vaqtida bajarilishi mumkin bo'lgan maxsus tekshiruvlardir. Buning uchun tekshirish kalit so'zi ishlatiladi.
sof fn kichikroq (int a, int b) -< bool { ret a < b; } fn test() { let x: int = 10; let y: int = 20; check is_less_than(x,y); }
Predikatlar funksiyalarning kirish parametrlariga quyidagi tarzda “osilishi” mumkin:
fn testi (int x, int y): (x, y)dan_kamroq (...)

Typestate haqida juda kam ma'lumot mavjud, shuning uchun ko'p fikrlar hali aniq emas, lekin kontseptsiya baribir qiziqarli.

Hammasi shu. Men ba'zi qiziqarli fikrlarni o'tkazib yuborgan bo'lishim mumkin, ammo maqola allaqachon shishib ketgan edi. Agar xohlasangiz, Rust kompilyatorini hozir qurishingiz va turli misollar bilan o'ynashga harakat qilishingiz mumkin. Yig'ish haqida ma'lumot olish uchun qarang

Men Rustni yangi bilaman, lekin u tezda mening sevimli dasturlash tilimga aylanib bormoqda. Rust-da kichik loyihalarni yozish odatda kamroq ergonomik bo'lsa va ko'proq vaqt talab etadi (hech bo'lmaganda rulda men bilan), bu mening dastur dizayni haqidagi fikrimni shubha ostiga qo'yadi. Mening kompilyator bilan janglarim yangi narsalarni o'rganishim bilan kamroq bo'ladi.

Rust hamjamiyati yaqinda Tokio kutubxonasi sifatida amalga oshirilgan asinxron kiritish-chiqarishga ko'p harakatlarini qaratdi. Va bu ajoyib.

Jamiyat a'zolarining ko'pchiligi, veb-serverlar va shunga o'xshash narsalar bilan ishlamaganlar, biz nimaga erishmoqchi ekanligimiz aniq emas. 1.0 davrida bu narsalar muhokama qilinganida, men ham bu haqda noaniq tasavvurga ega edim, ilgari u bilan hech qachon ishlamaganman.

• Bu nima - Async I/U?
• Korutinlar nima ( koroutinlar )?
• Engil oqimlar nima ( engil iplar )?

Fyuchers nima? ( fyucherslar )?

• Qanday qilib ular bir-biriga mos keladi?

Men sizga tasmani yuklab oladigan kichik dasturni qanday yozishni ko'rsataman ( ozuqa) JSON formatida, formatlangan shaklda konsolga eslatmalar ro'yxatini tahlil qiladi va chiqaradi.

Hamma narsa juda lakonik kodga olib keldi. Qanaqasiga? Kesish ostiga qarang.

Xavfli kalit so'z Rust tili dizaynining ajralmas qismidir. U bilan tanish bo'lmaganlar uchun: xavfli bu kalit so'z, oddiy so'z bilan aytganda, turdagi tekshirishni chetlab o'tishning bir usuli ( turini tekshirish) Zang.

Xavfli kalit so'zning mavjudligi dastlab ko'pchilikni ajablantiradi. Haqiqatan ham, Rust-ning o'ziga xos xususiyati dasturlarning xotiradagi xatolar tufayli ishdan chiqishi emasmi? Agar shunday bo'lsa, nega turdagi tizimni chetlab o'tishning oson yo'li bor? Bu tilda dizayn nuqsoni kabi ko'rinishi mumkin.

Biroq, mening fikrimcha, xavfli bo'lish kamchilik emas. Aslida, bu tilning muhim qismidir. xavfli chiqish klapanlari vazifasini bajaradi - bu shuni anglatadiki, biz oddiy holatlarda turdagi tizimdan foydalanishimiz mumkin, ammo bu bizga kodingizda ishlatmoqchi bo'lgan har qanday hiyla-nayranglardan foydalanishga imkon beradi. Biz faqat xavfsiz tashqi abstraktsiyalar orqasida xavfli kodingizni yashirishingizni talab qilamiz.

Ushbu eslatma xavfli kalit so'z va cheklangan "xavfsizlik" g'oyasini taqdim etadi. Darhaqiqat, bu biroz keyinroq yozmoqchi bo'lgan eslatmaning xabarchisi. U xavfli kodda nima qilish va nima qilish mumkin emasligini ko'rsatadigan Rust xotira modelini muhokama qiladi.

Rustga yangi boshlovchi sifatida men satrlarni ifodalashning turli usullari haqida bosh qotirdim. Rust kitobida "Ma'lumotnomalar va qarz olish" bo'limi mavjud bo'lib, unda misollarda uch xil turdagi qator o'zgaruvchilari qo'llaniladi: String, & String va & str.

str va String o'rtasidagi farqdan boshlaylik: String kengaytiriladigan, yig'iladigan ma'lumotlar strukturasidir, str esa o'zgarmas, qat'iy uzunlikdagi qatordir. qayerdadir hayolda.

Ko'pgina dasturchilar allaqachon ob'ektga yo'naltirilgan tillarda dasturlashni bilishadi. Rust klassik ob'ektga yo'naltirilgan til emas, lekin unda asosiy OOP vositalaridan foydalanish mumkin.

Ushbu maqolada biz Rust-da OOP uslubida qanday dasturlashni ko'rib chiqamiz. Biz buni misol yordamida qilamiz: biz o'quv muammosida sinf ierarxiyasini quramiz.

Bizning vazifamiz geometrik shakllar bilan ishlashdir. Biz ularni matn shaklida ko'rsatamiz va ularning maydonini hisoblaymiz. Bizning shakllar to'plami - to'rtburchaklar, kvadrat, ellips, doira.

Rust - bu boshqa mashhur tillardan biroz farq qiladigan oqlangan til. Masalan, sinflar va merosdan foydalanish o'rniga, Rust o'ziga xos xususiyatga asoslangan turdagi tizimini taklif qiladi. Biroq, ko'plab yangi Rust dasturchilari (men kabi) qabul qilingan dizayn naqshlari bilan tanish emasligiga ishonaman.

Ushbu maqolada men dizayn naqshini muhokama qilmoqchiman yangi turi(yangi turdagi), shuningdek, turni o'zgartirishga yordam beruvchi From va Into belgilari.

Men so'nggi paytlarda dasturlashda foydalanadigan dizayn naqshlari va usullari haqida ko'p o'ylayapman. Loyihani tadqiq qilishni boshlash va bir necha marta duch kelgan tanish naqsh va uslublarni ko'rish juda ajoyib. Bu loyihani tushunishni osonlashtiradi va ishni tezlashtirishga imkon beradi.

Ba'zan siz yangi loyiha ustida ishlayapsiz va siz avvalgi loyihada bo'lgani kabi biror narsa qilishingiz kerakligini tushunasiz. Bu funksiya yoki kutubxonaning bir qismi bo'lmasligi mumkin, bu ajoyib so'l yoki kichik konteynerga o'ralib bo'lmaydigan narsa bo'lishi mumkin. Bu muammoni yaxshi hal qiladigan dizayn namunasi yoki strukturaviy kontseptsiya bo'lishi mumkin.

Bunday muammolarga tez-tez qo'llaniladigan qiziqarli naqshlardan biri "Davlat mashinasi" dir. Men ushbu iborada aniq nimani anglatishini va nima uchun bu juda qiziq ekanligini tushunish uchun biroz vaqt sarflashni taklif qilaman.

Quyida Rust dasturlash tilida ko'chirish, nusxalash va qarz olishning grafik tavsifi keltirilgan. Asosan, bu tushunchalar faqat Rustga xos bo'lib, ko'pincha yangi boshlanuvchilar uchun to'siq bo'ladi.

Chalkashmaslik uchun matnni minimal darajada saqlashga harakat qildim. Ushbu eslatma turli xil darsliklar o'rnini bosmaydi va faqat ma'lumot vizual tarzda osonroq qabul qilinishiga ishonadiganlar uchun yaratilgan. Agar siz Rustni endigina o'rganishni boshlayotgan bo'lsangiz va ushbu grafiklarni foydali deb topsangiz, tushunchalarni yaxshiroq mustahkamlash uchun kodingizni shunga o'xshash sxemalar bilan belgilashingizni tavsiya qilaman.

Peano raqamlari yordamida natural sonlar arifmetikasini amalga oshirish dasturlashni o'rganishda keng tarqalgan muammo hisoblanadi. Men ularni Rustda amalga oshirish mumkinmi, deb o'yladim.

Shunday qilib, mening vazifam turini tekshirish bilan natural sonlarni yozish va qo'shishdir.

Vikipediyaga ko'ra, "Peano aksiomalari 19-asrda italyan matematigi Juzeppe Peano tomonidan kiritilgan natural sonlar uchun aksiomalar tizimlaridan biri".

Bizni ulardan ikkitasi qiziqtiradi - ular yordamida siz natural sonlarni kiritishingiz va foydalanishingiz mumkin:

• 1 - natural son
• Tabiiydan keyingi son ham tabiiydir.

Keling, uni zanglash uchun so'zma-so'z yozamiz:

1 2 3 4

enum Nat (nol, Succ (Nat))

Nat nol yoki keyingi natural sondir.

Izoh: fyuchers-rs loyihasi qayta tashkil etildi va ko'p narsalar nomi o'zgartirildi. Mumkin bo'lgan joylarda havolalar yangilandi.

Fyuchers bilan ishlashni boshlash

Ushbu hujjat fyuchers va oqimlarning nol xarajatini ta'minlovchi Rust dasturlash tili konteynerini, fyuchersni o'rganishga yordam beradi. Fyucherslar C++, Java va Scala kabi ko'plab boshqa dasturlash tillarida mavjud va fyuchers konteyneri ushbu tillarning kutubxonalaridan ilhom oladi. Biroq, u ergonomikdir va Rustga xos bo'lgan nol xarajatli abstraksiya falsafasiga amal qiladi, ya'ni fyucherslarni yaratish va tuzish xotirani ajratishni talab qilmaydi va ularni boshqaradigan Vazifa uchun faqat bitta ajratish talab qilinadi. Fyuchers Rustning asinxron kompozitsion yuqori unumdorligi I/U ning asosi bo'lishi kerak va dastlabki ko'rsatkichlar fyuchers asosida qurilgan oddiy HTTP serveri haqiqatan ham tez ekanligini ko'rsatadi.

Ushbu hujjat bir nechta bo'limlarga bo'lingan:

• "Salom Dunyo!";
• kelajak turi;
• oqim xususiyati;
• aniq fyuchers va oqim;
• fyucherslarni qaytarish;
• Vazifa va kelajak;
• mahalliy vazifa ma'lumotlari.

Izoh: fyuchers-rs loyihasi qayta tashkil etildi va ko'p narsalar nomi o'zgartirildi. Mumkin bo'lgan joylarda havolalar yangilandi.

Rust ekotizimidagi asosiy kamchiliklardan biri tez va samarali edi asinxron I/U... Bizda mio kutubxonasining mustahkam poydevori bor, lekin bu juda past darajada: biz davlat mashinalarini qo'lda yaratishimiz va qayta qo'ng'iroqlarni o'tkazishimiz kerak.

Biz ergonomikasi yaxshiroq, ammo yaxshisi yuqoriroq narsani xohlaymiz birlashma qobiliyati birgalikda ishlaydigan asinxron abstraktsiyalar ekotizimini qo'llab-quvvatlash orqali. Juda tanish tuyuladi: amalga oshirish bilan ham xuddi shunday maqsad ko'zlangan fyucherslar(yoki va'dalar) shaklida sintaktik shakarni qo'llab-quvvatlaydigan ko'plab tillarga async / kutish tepada.

Protsessorlar tomonidan qo'llab-quvvatlanadigan ibtidoiy butun son turlari biz haqiqiy hayotda ishlashga odatlangan cheksiz butun sonlar to'plamiga cheklangan yaqinlikdir. Bu cheklangan tasvir har doim ham "haqiqiy" raqamlarga mos kelmaydi, masalan 255_u8 + 1 == 0. Ko'pincha dasturchi bu farqni unutib qo'yadi, bu esa osongina xatolarga olib kelishi mumkin.

Rust - bu xatolardan himoya qilish uchun mo'ljallangan dasturlash tili bo'lib, u ularning eng makkori - xotira xatolarining oldini olishga qaratilgan, shuningdek, dasturchiga boshqa muammolardan qochishga yordam berishga harakat qiladi: xatolarga e'tibor bermaslik va ko'rib turganimizdek, butun sonlar to'lib ketishi.

Temir haqida bir oz

Iron - bu Rust dasturlash tilida yozilgan va boshqa mashhur giper kutubxona ustiga qurilgan yuqori darajadagi veb-ramka. Dazmol Rust taqdim etadigan imtiyozlardan to'liq foydalanish uchun mo'ljallangan. Temir o'z yadrosida operatsiyalarni blokirovka qilishdan qochishga harakat qiladi.

Falsafa

Temir imkon qadar kengayish printsipi asosida qurilgan. U o'z funksiyalarini kengaytirish uchun tushunchalarni taqdim etadi:

• "Oraliq" belgilar so'rovni qayta ishlashda oxirigacha funksionallikni amalga oshirish uchun ishlatiladi;
• modifikatorlar - so'rovlar va javoblarni eng ergonomik tarzda o'zgartirish uchun ishlatiladi.

Maqolada modifikatorlarning asosiy qismi va oraliq belgilar bilan tanishasiz.

Loyiha yaratish

Birinchidan, buyruq yordamida yuk bilan loyiha yaratamiz:

Kompilyatsiya qilgandan so'ng, biz tegishli bajariladigan faylni olamiz:

1 2 3

$ rustc hello.rs $ du -h salom 632K salom

Oddiy chop etish uchun 632 kilobayt ?! Rust C / C ++ o'rnini bosadigan tizim tili sifatida sotiladi, shunday emasmi? Xo'sh, nega eng yaqin raqobatchi bilan shunga o'xshash dasturni tekshirib ko'rmaysiz?

Bizning muhitimizda axlat yig'uvchining afzalliklaridan biri bu yuqori samarali blokirovkasiz ma'lumotlar tuzilmalarini ishlab chiqish qulayligi ekanligiga keng ishoniladi. Ularda xotirani qo'lda boshqarish oson emas va GC bu muammoni osongina hal qiladi.

Ushbu post Rust-dan foydalanib, bir vaqtning o'zida ma'lumotlar tuzilmalari uchun xotirani boshqarish API yaratish mumkinligini ko'rsatadi:

• GC kabi blokirovkasiz ma'lumotlar strukturasini amalga oshirish imkoniyatini yarating;
• Xotirani boshqarish sxemasidan noto'g'ri foydalanishdan statik himoya yaratish;
• GC bilan solishtirish mumkin bo'lgan qo'shimcha xarajatlarga ega bo'ladi (va oldindan taxmin qilinadigan).

Men quyida ko'rsatadigan testlarda Rust Java-ning qulflanmagan navbat dasturlarini osongina ortda qoldiradi va Rust ilovasining o'zini yozish oson.

Men yangi Crossbeam kutubxonasida "davrga asoslangan xotirani qayta tiklash" sxemasini joriy qildim, u endi sizning ma'lumotlar tuzilmalaringiz bilan foydalanishga tayyor. Ushbu postda men blokirovkasiz ma'lumotlar tuzilmalari, davr algoritmi va ichki Rust API haqida gapiraman.

Xotiraga kirish xatolari va xotiraning oqishi eng ko'p e'tiborni tortadigan xatolarning ikkita toifasidir, shuning uchun ularning oldini olish yoki hech bo'lmaganda minimallashtirish uchun ko'p kuch sarflanadi. Garchi ularning nomi o'xshashlikni ko'rsatsa-da, ular qaysidir ma'noda diametral qarama-qarshidir va muammolardan birini hal qilish bizni ikkinchisidan xalos qilmaydi. Boshqariladigan tillarning keng qo'llanilishi ushbu g'oyani tasdiqlaydi: ular xotirani bo'shatish vazifasini o'z zimmasiga olib, xotiraga kirishda ba'zi xatolarni oldini oladi.

Oddiy qilib aytganda: xotiraga kirish buzilishi - bu noto'g'ri ma'lumotlarga ega bo'lgan harakatning bir turi va xotiraning oqishi yo'qligi to'g'ri ma'lumotlar bilan muayyan harakatlar... Jadval shaklida:

Menda dasturlash tillarini o'rganish haqida bir nechta fikrlarim bor.

Birinchidan, biz noto'g'ri tushunamiz. Ishonchim komilki, siz ham xuddi shunday tuyg'uni boshdan kechirdingiz. Siz yangi tilni o'rganishga harakat qilyapsiz va unda hamma narsa qanday ishlashini tushunmayapsiz. Nima uchun bitta sintaksis bir joyda, ikkinchisi boshqa joyda qo'llaniladi? Bu g'alati narsalarning barchasi bezovta qiladi va oxirida biz tanish tilga qaytamiz.

Ishonamanki, bizning tillarni idrok etishimiz bizga shafqatsiz hazil o'ynaydi. Yangi tilni oxirgi marta muhokama qilganingizni eslang. Kimdir buni eslatib o'tdi, kimdir uning tezligi, sintaksisi yoki mavjud veb-ramka haqida so'radi.

Bu mashinalar haqida gapirishga o'xshaydi. Yangi UAZ Rybak haqida eshitganmisiz? U qanchalik tez? Uni minib ko‘l bo‘ylab o‘ta olamanmi?

Biz tillar haqida shunga o'xshash tarzda gapirganda, biz ularning bir-birini almashtirilishini nazarda tutamiz. Mashinalar kabi. Agar men Lada Saranskni qanday haydashni bilsam, men UAZ Rybakni hech qanday muammosiz haydashim mumkin. Farqi faqat tezlik va asboblar panelida, shunday emasmi?

Ammo PHP mashinasi qanday ko'rinishini tasavvur qiling. Endi Lisp avtomobili qanchalik boshqacha bo'lishini tasavvur qiling. Biridan ikkinchisiga o'tish isitishni qaysi tugma boshqarishini o'rganishdan ko'ra ko'proq narsani talab qiladi.

Eslatma: Ushbu maqola o'quvchi Rust FFI (tarjima), endianess va ioctl bilan tanish deb taxmin qiladi.

C kodiga ulanishlarni yaratishda biz muqarrar ravishda birlashmani o'z ichiga olgan tuzilmaga duch kelamiz. Rust qo'shilish uchun o'rnatilgan yordamga ega emas, shuning uchun biz o'zimizni strategiyalashimiz kerak. C tilida birlashma bir xil xotira sohasida turli xil ma'lumotlarni saqlaydigan tur. Butun sonlarning ikkilik tasvirlari va suzuvchi nuqta raqamlari o'rtasida konvertatsiya qilish, psevdopolimorfizmni amalga oshirish va bitlarga to'g'ridan-to'g'ri kirish kabi birlashtirishni tanlashning ko'plab sabablari mavjud. Men psevdopolimorfizmga e'tibor qarataman.