Artikel ini ditulis oleh Lin Clarke bekerja sama dengan tim pengembangan Rust ("kami" dalam teks). Anda juga dapat membaca posting di blog Rust resmi.

Versi pertama Rust 2018 dirilis pada 6 Desember 2018. Dalam rilis ini, kami fokus pada produktivitas sehingga pengembang Rust mulai bekerja seefisien mungkin.


Timeline menunjukkan transisi dari beta ke Rust 2018 dan Rust 2015. Ini dikelilingi oleh ikon untuk alat dan empat bidang: WebAssembly, tertanam, jaringan dan CLI. Lingkaran merah - produktivitas pengembang - mengelilingi segalanya kecuali Rust 2015

Tetapi secara umum tidak mudah untuk menjelaskan apa itu Rust 2018.

Beberapa menyajikannya sebagai versi baru dari bahasa ... sesuatu seperti itu, tetapi tidak juga. Saya katakan “tidak juga,” karena di sini “versi baru” tidak berarti versi baru dari bahasa lain.

Di sebagian besar bahasa lain, semua fitur baru menambahkan versi baru. Versi sebelumnya tidak diperbarui.

Sistem Rust beroperasi secara berbeda. Ini karena bagaimana bahasa berkembang. Hampir semua fitur baru 100% kompatibel dengan Rust. Mereka tidak membutuhkan perubahan apa pun. Ini berarti bahwa tidak ada alasan untuk membatasi kode Rust 2018. Versi yang lebih baru dari kompiler akan terus mendukung "mode Rust 2015" secara default.

Namun terkadang pengembangan bahasa membutuhkan inovasi, misalnya sintaksis baru. Dan sintaks baru ini dapat memecah basis kode yang ada.

Misalnya, fungsi async/await . Awalnya, tidak ada konsep seperti itu di Rust. Tetapi ternyata primitif ini sangat berguna, mereka menyederhanakan penulisan kode asinkron.

Untuk fungsi ini, kata kunci async dan await harus ditambahkan. Tetapi Anda harus berhati-hati untuk tidak merusak kode lama di mana async atau await dapat digunakan sebagai nama variabel.

Dengan demikian, kami menambahkan kata kunci di Rust 2018. Meskipun fungsi belum dirilis, kata kunci sekarang dicadangkan. Semua perubahan yang tidak kompatibel untuk tiga tahun ke depan pengembangan (misalnya, menambahkan kata kunci baru) dilakukan sekaligus pada Rust 1.31.



Meskipun ada perubahan yang tidak kompatibel di Rust 2018, ini tidak berarti bahwa kode Anda akan rusak. Bahkan dengan variabel async dan await , kode akan dikompilasi. Secara default, kompiler berfungsi seperti sebelumnya.

Tetapi jika Anda ingin menggunakan salah satu fungsi baru, Anda dapat memilih mode kompilasi baru Rust 2018. Perintah cargo fix akan memberi tahu Anda jika Anda perlu memperbarui kode untuk menggunakan fungsi baru dan mengotomatiskan proses membuat perubahan. Kemudian Anda dapat menambahkan edition=2018 ke Cargo.toml Anda jika Anda setuju dengan penggunaan fungsi baru.

Penentu versi ini di Cargo.toml tidak berlaku untuk seluruh proyek dan tidak berlaku untuk dependensi Anda. Ini terbatas pada satu rak tertentu. Artinya, Anda bisa menggunakan peti Rust 2015 dan Rust 2018 secara bersamaan.



Oleh karena itu, bahkan ketika menggunakan Rust 2018, semuanya terlihat hampir sama dengan Rust 2015. Sebagian besar perubahan diimplementasikan secara bersamaan di Rust 2018 dan Rust 2015. Hanya beberapa fungsi yang membutuhkan perubahan yang tidak kompatibel.



Karat 2018 tidak hanya perubahan dalam bahasa utama. Jauh bukan hanya mereka.

Rust 2018, pertama-tama, merupakan dorongan untuk meningkatkan produktivitas pengembang Rust, sebagian besar berkat alat yang berada di luar bahasa, serta melalui pengembangan aplikasi spesifik dan pemahaman tentang bagaimana menjadikan Rust bahasa pemrograman yang paling efektif untuk kasus-kasus ini.

Dengan demikian, Anda dapat mewakili Rust 2018 sebagai specifier di Cargo.toml, yang digunakan untuk menyertakan beberapa fungsi yang memerlukan perubahan yang tidak kompatibel ...



Atau Anda dapat membayangkannya pada suatu saat ketika Rust menjadi salah satu bahasa yang paling efisien untuk banyak aplikasi - ketika Anda membutuhkan kinerja, penggunaan sumber daya yang efisien, atau keandalan yang tinggi.



Kami lebih suka versi definisi kedua. Jadi, mari kita lihat semua perbaikan yang dilakukan di luar bahasa, dan kemudian terjun ke bahasa itu sendiri.

Karat untuk aplikasi spesifik

Bahasa pemrograman tidak dapat efektif dengan sendirinya, secara abstrak. Ini efektif dalam aplikasi tertentu. Oleh karena itu, kami memahami bahwa tidak hanya perlu meningkatkan Karat sebagai bahasa atau alat. Penting juga untuk menyederhanakan penggunaan Karat di area tertentu.



Dalam beberapa kasus, ini berarti menciptakan seperangkat alat yang sama sekali baru untuk ekosistem yang sama sekali baru. Dalam kasus lain, memoles fungsi yang ada dan dokumentasi yang baik untuk membuatnya lebih mudah untuk menaikkan dan menjalankan sistem kerja.

Tim pengembangan Rust telah membentuk kelompok kerja di empat bidang:

• Perakitan web
• Aplikasi Tertanam
• Tugas jaringan
• Alat baris perintah

Perakitan web

WebAssembly harus membuat seperangkat alat yang sama sekali baru.

Hanya tahun lalu apakah WebAssembly memungkinkan untuk mengkompilasi bahasa seperti Rust untuk dijalankan di Internet. Sejak itu, Rust dengan cepat menjadi bahasa terbaik untuk berintegrasi dengan aplikasi web yang ada.



Rust sangat cocok untuk pengembangan web karena dua alasan:

1. Cargo Crash Ecosystem bekerja seperti kebanyakan pengembang aplikasi web. Gabungkan banyak modul kecil untuk membentuk aplikasi yang lebih besar. Ini berarti bahwa Rust mudah digunakan tepat di mana Anda membutuhkannya.
2. Karat memiliki sumber daya yang rendah dan tidak memerlukan runtime. Anda tidak perlu banyak kode. Jika Anda memiliki modul kecil yang melakukan banyak pekerjaan komputasi keras, terapkan beberapa jalur Rust untuk mempercepatnya.

Menggunakan web-sys dan js-sys dari kode Rust, mudah untuk memanggil API web seperti fetch atau appendChild . Dan wasm-bindgen membuatnya mudah untuk mendukung tipe data tingkat tinggi yang tidak didukung WebAssembly secara asli.

Setelah menulis modul Rust WebAssembly, ada alat untuk menghubungkannya dengan mudah ke aplikasi web lainnya. Anda dapat menggunakan paket-wm untuk meluncurkan alat-alat ini secara otomatis, dan menjalankan modul di npm jika Anda mau.

Lihat buku Karat dan WebAssembly untuk informasi lebih lanjut .

Apa selanjutnya

Setelah rilis Rust 2018, pengembang berencana untuk berdiskusi dengan komunitas di mana arah untuk bekerja lebih jauh.

Aplikasi Tertanam

Untuk pengembangan yang disematkan, perlu untuk meningkatkan stabilitas fungsi yang ada.

Secara teoritis, Rust selalu menjadi bahasa yang baik untuk aplikasi yang disematkan. Ini adalah toolkit modern, yang sangat kurang untuk pengembang, dan fungsi bahasa tingkat tinggi yang sangat nyaman. Semua ini tanpa memuat yang tidak perlu pada CPU dan memori. Karenanya, Rust sangat bagus untuk disematkan.

Namun dalam praktiknya ternyata berbeda. Saluran stabil tidak memiliki fungsi yang diperlukan. Selain itu, untuk digunakan pada perangkat yang disematkan, perlu untuk mengubah perpustakaan standar. Ini berarti bahwa orang harus mengkompilasi versi mereka sendiri dari kotak inti Rust (kotak yang digunakan dalam setiap aplikasi Karat untuk menyediakan blok bangunan dasar Rust - fungsi bawaan dan primitif).



Akibatnya, pengembang bergantung pada versi eksperimental Rust. Dan dengan tidak adanya tes otomatis, majelis eksperimental sering tidak bekerja pada mikrokontroler.

Untuk memperbaikinya, pengembang mencoba untuk mentransfer semua fungsi yang diperlukan ke saluran yang stabil, menambahkan tes ke sistem CI untuk mikrokontroler. Ini berarti bahwa mengubah komponen desktop tidak akan merusak versi bawaan.

Dengan perubahan seperti itu, pengembangan sistem embedded pada Rust bergerak dari bidang eksperimen lanjutan ke bidang efisiensi normal.

Untuk informasi lebih lanjut, lihat buku Rust for Embedded Systems .

Apa selanjutnya

Tahun ini, Rust mendapat dukungan yang sangat baik untuk keluarga ARM Cortex-M yang populer. Namun, banyak arsitektur yang belum didukung dengan baik. Karat perlu diperluas untuk memberikan dukungan serupa untuk arsitektur lain.

Tugas jaringan

Untuk bekerja di jaringan, perlu memasukkan abstraksi kunci ke dalam bahasa: async/await . Dengan demikian, pengembang dapat menggunakan idiom standar Rust bahkan dalam kode asinkron.

Dalam tugas-tugas jaringan, Anda sering harus menunggu. Misalnya, respons terhadap permintaan. Jika kode disinkronkan, maka pekerjaan akan dihentikan: inti prosesor tempat kode dieksekusi tidak dapat melakukan apa-apa sampai permintaan tiba. Tetapi dalam kode asinkron, fungsi seperti itu dapat dimasukkan ke mode siaga, sedangkan inti CPU akan melakukan sisanya.

Pemrograman asinkron juga dimungkinkan di Rust 2015, dan ada banyak keuntungan untuk ini. Dalam aplikasi berkinerja tinggi, aplikasi server akan menangani lebih banyak koneksi ke setiap server. Aplikasi tertanam pada CPU single-threaded kecil mengoptimalkan penggunaan utas tunggal.

Tetapi kelebihan ini disertai dengan kelemahan utama: untuk kode seperti itu, verifikasi pinjaman tidak berfungsi dan Anda harus menggunakan idiom Rust yang tidak standar (dan sedikit bingung). Ini adalah manfaat dari async/await . Ini memberikan kompiler informasi yang diperlukan untuk menguji pinjaman dari panggilan fungsi tidak sinkron.

Kata kunci untuk async/await diimplementasikan dalam versi 1.31, meskipun saat ini tidak didukung oleh implementasi. Sebagian besar pekerjaan selesai, dan fitur tersebut harus tersedia dalam rilis berikutnya.

Apa selanjutnya

Selain pengembangan tingkat rendah yang efektif, Rust dapat memberikan pengembangan aplikasi jaringan yang lebih efisien di tingkat yang lebih tinggi.

Banyak server melakukan tugas rutin: parse URL atau bekerja dengan HTTP. Jika Anda mengubahnya menjadi komponen - abstraksi umum yang dibagikan sebagai krat - maka akan mudah untuk menghubungkannya satu sama lain, membentuk semua jenis konfigurasi server dan kerangka kerja.

Kerangka Tide eksperimental telah dibuat untuk mengembangkan dan menguji komponen.

Alat baris perintah

Untuk alat-alat baris perintah, perlu untuk menggabungkan perpustakaan tingkat rendah kecil ke abstraksi tingkat tinggi dan memoles beberapa alat yang ada.

Untuk beberapa skrip, bash sangat ideal. Misalnya, untuk memanggil alat-alat shell lainnya dan meneruskan data di antara mereka.

Tetapi Rust adalah pilihan bagus untuk banyak alat lainnya. Misalnya, jika Anda membuat alat yang kompleks seperti ripgrep atau alat CLI di atas fungsi perpustakaan yang ada.

Rust tidak memerlukan runtime dan mengkompilasi ke dalam biner statis tunggal, yang menyederhanakan distribusi program. Dan Anda mendapatkan abstraksi tingkat tinggi yang tidak ada dalam bahasa lain, seperti C dan C ++.

Apa lagi yang bisa meningkatkan Karat? Tentu saja, abstraksi dari level yang lebih tinggi lagi.

Dengan abstraksi tingkat yang lebih tinggi, CLI yang sudah jadi dibuat dengan cepat dan mudah.

Contoh abstraksi semacam itu adalah perpustakaan kepanikan manusia . Dengan tidak adanya perpustakaan seperti itu, dalam hal terjadi kegagalan, kode CLI mungkin akan mengembalikan semua backtracking. Tetapi itu tidak terlalu menarik bagi pengguna. Anda dapat menambahkan penanganan kesalahan khusus, tetapi sulit.

Dengan perpustakaan kepanikan manusia, output akan secara otomatis pergi ke file dump kesalahan. Pengguna akan melihat penawaran pesan informatif untuk melaporkan masalah dan mengunduh file dump.



Mulai mengembangkan alat-alat CLI juga menjadi lebih mudah. Sebagai contoh, perpustakaan confy mengotomatiskan konfigurasinya. Dia hanya bertanya dua hal:

• Apa nama aplikasi itu?
• Parameter konfigurasi apa yang ingin Anda berikan (yang Anda tetapkan sebagai struktur yang dapat diserialisasi dan diurai-kan)?

Confy akan menentukan segalanya dengan sendirinya.

Apa selanjutnya

Kami mengabstraksikan banyak tugas untuk CLI. Tetapi ada sesuatu yang lain untuk abstrak. Kami akan merilis lebih banyak perpustakaan tingkat tinggi tersebut.

Alat Karat

Ketika Anda menulis dalam bahasa apa pun, Anda bekerja dengan alat-alatnya: mulai dengan editor dan melanjutkan dengan alat-alat lain di semua tahap pengembangan dan dukungan.

Ini berarti bahwa bahasa yang efektif tergantung pada alat yang efektif.

Berikut adalah beberapa alat baru (dan perbaikan yang ada) di Rust 2018.

Dukungan IDE

Tentu saja, kinerja tergantung pada transfer kode yang cepat dan lancar dari pikiran pengembang ke layar komputer. Di sinilah dukungan IDE sangat penting. Untuk melakukan ini, kita memerlukan alat yang dapat "menjelaskan" IDE dengan arti kode Rust: misalnya, menyarankan opsi yang bermakna untuk pelengkapan string secara otomatis.

Di Rust 2018, komunitas fokus pada fitur yang dibutuhkan oleh IDE. Dengan munculnya Server Bahasa Rust dan IntelliJ Rust, banyak IDE sekarang sepenuhnya mendukung Rust.

Kompilasi lebih cepat

Meningkatkan kinerja kompiler berarti mempercepatnya. Inilah yang kami lakukan.

Sebelumnya, ketika Anda mengkompilasi peti Rust, kompiler mengkompilasi ulang setiap file dalam peti tersebut. Kompilasi tambahan sekarang diterapkan: kompilasi hanya bagian-bagian yang telah berubah. Bersama dengan optimasi lainnya, ini membuat kompiler Rust jauh lebih cepat.

rustfmt

Efisiensi juga mengharuskan kami tidak pernah berdebat tentang aturan pemformatan kode atau memperbaiki gaya orang lain secara manual.

Alat rustfmt membantu dengan ini: ia akan memformat ulang kode secara otomatis sesuai dengan gaya default (yang olehnya komunitas telah mencapai konsensus ). Rustfmt memastikan bahwa semua kode Rust cocok dengan gaya yang sama, seperti format dentang untuk C ++ atau Lebih cantik untuk JavaScript.

Clippy

Terkadang senang memiliki konsultan berpengalaman di dekat Anda memberikan saran tentang praktik terbaik untuk menulis kode. Inilah yang dilakukan Clippy: memeriksa kode sambil melihatnya dan menyarankan idiom standar.

perbaikan karat

Tetapi jika Anda memiliki basis kode lama dengan idiom yang sudah usang, maka verifikasi dan perbaiki kode secara mandiri dapat melelahkan. Anda hanya ingin seseorang membuat koreksi ke seluruh basis kode.

Dalam kasus ini, perbaikan karat mengotomatiskan proses. Secara bersamaan berlaku aturan dari alat-alat seperti Clippy, dan memperbarui kode lama sesuai dengan idiom Rust 2018.

Perubahan ke Rust sendiri

Perubahan ekosistem telah secara signifikan meningkatkan efisiensi pemrograman. Tetapi beberapa masalah hanya bisa diselesaikan dengan perubahan dalam bahasa itu sendiri.



Seperti yang kami katakan dalam pendahuluan, sebagian besar perubahan bahasa sepenuhnya kompatibel dengan kode Rust yang ada. Semua perubahan ini adalah bagian dari Rust 2018. Tetapi karena mereka tidak merusak apa pun, mereka bekerja dalam kode Rust apa pun ... bahkan dalam yang lama.

Mari kita lihat fitur-fitur penting yang ditambahkan ke semua versi. Kemudian lihat daftar singkat fitur Rust 2018.

Fitur baru untuk semua versi

Berikut adalah contoh kecil dari fitur-fitur baru yang (atau akan) ada di semua versi bahasa.

Verifikasi pinjaman yang lebih akurat

Satu keuntungan besar dari Rust adalah verifikasi pinjamannya. Ini memastikan bahwa kode tersebut aman memori. Tapi ini juga fitur yang cukup rumit bagi pemula untuk Rust.

Bagian dari kesulitannya terletak pada mempelajari konsep-konsep baru. Tetapi ada bagian lain ... Pengujian pinjaman terkadang menolak kode yang tampaknya bekerja dari sudut pandang seorang programmer yang sepenuhnya memahami konsep keamanan memori.


Anda tidak dapat meminjam variabel karena sudah dipinjam

Ini terjadi karena masa pinjaman seharusnya meluas ke akhir bidangnya - misalnya, ke akhir fungsi di mana variabel berada.

Ini berarti bahwa bahkan jika variabel selesai bekerja dengan nilai dan tidak lagi mencoba mengakses, variabel lain masih ditolak akses ke nilai ini hingga akhir fungsi.

Untuk memperbaiki situasi, kami membuat pemeriksaan menjadi lebih cerdas. Sekarang dia melihat ketika variabel benar - benar selesai menggunakan nilai. Setelah itu, itu tidak menghalangi penggunaan data.



Meskipun ini hanya tersedia di Rust 2018, tetapi dalam waktu dekat fungsi akan ditambahkan ke semua versi lainnya. Kami akan segera menulis lebih banyak tentang topik ini.

Makro Prosedural dalam Karat Stabil

Rust memiliki makro sebelum Rust 1.0. Tetapi dalam Rust 2018, perbaikan serius dilakukan, misalnya, macro prosedural muncul. Mereka memungkinkan Anda untuk menambahkan sintaks Anda sendiri ke Rust.

Rust 2018 menawarkan dua jenis makro prosedural:

Makro fungsi

Makro mirip fungsi memungkinkan Anda untuk membuat objek yang terlihat seperti panggilan fungsi normal, tetapi sebenarnya dieksekusi pada waktu kompilasi. Mereka mengambil satu kode dan memberikan yang lain, yang kemudian dimasukkan oleh kompiler ke dalam biner.

Mereka ada sebelumnya, tetapi dengan terbatas. Makro hanya bisa menjalankan pernyataan pertandingan. Dia tidak memiliki akses untuk melihat semua token dalam kode yang masuk.

Tetapi dengan macro prosedural, Anda mendapatkan input yang sama dengan parser: aliran token yang sama. Ini berarti Anda dapat membuat fungsi makro yang jauh lebih kuat.

Makro seperti atribut

Jika Anda terbiasa dengan dekorator dalam bahasa seperti JavaScript, atribut makro sangat mirip. Mereka memungkinkan Anda untuk membubuhi keterangan fragmen kode Rust yang harus diproses sebelumnya dan berubah menjadi sesuatu yang lain.

derive makro tidak hanya itu. Ketika Anda meletakkannya di atas suatu struktur, kompiler mengambil struktur itu (setelah diuraikan sebagai daftar token) dan memprosesnya. Secara khusus, ini menambahkan implementasi fungsi dasar dari sifat.

Perbandingan pinjaman yang lebih ergonomis

Ada perubahan sederhana.

Sebelumnya, jika Anda ingin meminjam sesuatu dan mencoba mencocokkan, Anda harus menambahkan beberapa sintaks aneh:



Sekarang, alih-alih &Some(ref s) kita cukup menulis Some(s) .

Fitur Baru Rust 2018

Bagian terkecil dari Rust 2018 adalah fitur khusus untuk versi ini. Berikut adalah sejumlah kecil perubahan di Rust 2018.

Kata kunci

Rust 2018 menambahkan beberapa kata kunci:

• try
• async/await

Fitur-fitur ini belum sepenuhnya diimplementasikan, tetapi kata kunci ditambahkan di Rust 1.31. Karenanya, di masa mendatang kami tidak perlu memperkenalkan kata kunci baru (yang akan menjadi perubahan yang tidak kompatibel) ketika kami menerapkan fungsi-fungsi ini.

Sistem modular

Satu rasa sakit besar bagi pemula untuk Rust adalah sistem modular. Dan jelas mengapa. Sulit dimengerti mengapa Rust memilih modul tertentu. Untuk memperbaiki ini, kami membuat beberapa perubahan pada mekanisme jalur.

Misalnya, jika Anda mengimpor rak, Anda dapat menggunakannya di jalur di tingkat atas. Tetapi jika Anda memindahkan kode apa pun ke submodule, itu tidak akan berfungsi lagi.

 // top level module extern crate serde; // this works fine at the top level impl serde::Serialize for MyType { ... } mod foo { // but it does *not* work in a sub-module impl serde::Serialize for OtherType { ... } } 

Contoh lain adalah awalan ::, yang digunakan untuk root peti dan peti eksternal. Sulit untuk memahami apa yang ada di hadapan kita.

Kami membuatnya lebih eksplisit. Sekarang jika Anda ingin merujuk ke kotak root, kemudian gunakan awalan crate::. Ini hanyalah salah satu perbaikan untuk kejelasan.

Jika Anda ingin kode saat ini menggunakan kemampuan Rust 2018, kemungkinan besar, Anda perlu memperbarui kode untuk mempertimbangkan jalur baru akun. Tetapi tidak perlu melakukan ini secara manual. Sebelum menambahkan specifier versi ke Cargo.toml, jalankan saja cargo fixdan rustfixbuat perubahan yang diperlukan.

Informasi tambahan

Semua informasi tentang versi baru bahasa terdapat dalam Panduan Rust 2018 .