Rust 2018 ada di sini … tapi apa itu? – Mozilla Hacks

Publikasi ini ditulis bekerja sama dengan Tim Karat ("kami" dalam artikel ini). Anda juga bisa membaca iklannya di blog Rust.

Mulai hari ini, edisi Rust 2018 dalam rilis pertamanya. Dengan edisi ini, kami berfokus pada produktivitas … untuk membuat pengembang Rust menjadi seproduktif mungkin.

Garis waktu yang menunjukkan saluran yang berbeda: beta, Rust 2018, dan Rust 2015, dengan fitur yang berasal dari versi beta ke dua lainnya. Garis waktu dikelilingi oleh ikon untuk alat dan untuk 4 domain: perakitan web, tertanam, jaringan, dan CLI. Lingkaran merah mengelilingi semuanya kecuali Rust 2015 dan diberi label dengan Produktivitas Pengembang.

Tetapi di luar itu, sulit menjelaskan apa tepatnya Rust 2018.

Sebagian orang menganggapnya sebagai bahasa baru, yaitu … sesuatu seperti itu, tapi tidak juga. Saya mengatakan "tidak benar-benar" karena jika ini adalah versi baru, itu tidak berfungsi seperti versi dalam bahasa lain.

Di sebagian besar bahasa lain, ketika versi bahasa baru muncul, fitur-fitur baru ditambahkan ke versi baru tersebut. Versi sebelumnya tidak memiliki fitur baru.

Edisi oksida berbeda. Ini karena cara bahasa berkembang. Hampir semua fitur baru 100% kompatibel dengan Rust sebagaimana adanya. Mereka tidak membutuhkan perubahan menit terakhir. Ini berarti bahwa tidak ada alasan untuk membatasi mereka pada kode Rust 2018. Versi baru dari kompiler akan terus kompatibel dengan "Rust mode 2015", yang merupakan apa yang Anda dapatkan secara default.

Namun terkadang untuk memajukan bahasa, perlu menambahkan hal-hal seperti sintaks baru. Dan sintaks baru ini dapat memecahkan berbagai hal dalam basis kode yang ada.

Contoh dari ini adalah asynchronous / wait karakteristik Awalnya, Rust tidak memiliki konsep asynchronous dan tunggu sebentar. Tapi ternyata primitif ini sangat berguna. Mereka memfasilitasi penulisan kode yang tidak sinkron tanpa kode yang sulit dikelola.

Untuk dapat menambahkan fitur ini, kita perlu menambahkan keduanya asynchronous dan tunggu sebentar sebagai kata kunci. Tetapi kita juga harus berhati-hati untuk tidak membatalkan kode lama … kode yang bisa menggunakan kata-kata asynchronous o tunggu sebentar sebagai nama variabel.

Oleh karena itu, kami menambahkan kata kunci sebagai bagian dari Rust 2018. Meskipun fitur tersebut belum tersedia, kata kunci sekarang dilindungi. Semua perubahan terobosan yang diperlukan untuk tiga tahun ke depan pembangunan (seperti menambahkan kata kunci baru) sedang dilakukan sekaligus, di Rust 1.31.

Garis waktu dengan garis yang menghubungkan Rust 2015 dengan permulaan Rust 2018 di versi 1.31.

Meskipun ada perubahan yang pecah di Rust 2018, itu tidak berarti bahwa kode Anda akan rusak. Kode Anda akan terus dikompilasi bahkan jika memiliki asynchronous o tunggu sebentar sebagai nama variabel. Kecuali saya memberitahu Anda sebaliknya, compiler mengasumsikan bahwa Anda ingin mengkompilasi kode Anda dengan cara yang sama seperti yang Anda lakukan hingga saat ini.

Tetapi segera setelah Anda ingin menggunakan salah satu fitur baru di menit-menit terakhir ini, Anda dapat memilih mode Rust 2018. Jalankan saja pengaturan kargo, yang akan memberi tahu Anda jika Anda perlu memperbarui kode Anda untuk menggunakan fitur-fitur baru. Ini juga akan mengotomatisasi proses pembuatan perubahan. Maka Anda bisa menambahkan edisi = 2018 ke Cargo.toml Anda untuk memilih dan menggunakan fungsi-fungsi baru.

Penentu edisi ini di Cargo.toml tidak berlaku untuk seluruh proyek Anda … itu tidak berlaku untuk dependensi Anda. Ini terbatas pada satu kotak. Ini berarti Anda dapat memiliki bagan kotak dengan Rust 2015 dan Rust 2018 diselingi.

Karena ini, bahkan sekali Rust 2018 tersedia, itu akan terlihat hampir sama dengan Rust 2015. Sebagian besar perubahan akan jatuh pada Rust 2018 dan Rust 2015. Hanya beberapa fitur yang memerlukan perubahan menit terakhir tidak akan terpengaruh. .

Namun, Rust 2018 bukan hanya tentang perubahan dalam bahasa utama. Bahkan, jauh dari itu.

Rust 2018 adalah dorongan bagi para pengembang Rust agar lebih produktif. Banyak keuntungan produktivitas berasal dari hal-hal di luar bahasa pusat … hal-hal seperti alat. Mereka juga berasal dari fokus pada kasus penggunaan tertentu dan menemukan bagaimana Rust dapat menjadi bahasa yang paling produktif untuk kasus-kasus penggunaan tersebut.

Jadi Anda bisa memikirkan Rust 2018 sebagai penentu dalam Cargo.toml yang Anda gunakan untuk mengaktifkan beberapa fungsi yang memerlukan perubahan menit terakhir …

Garis waktu dengan panah menunjuk ke sepasang fitur Rust 2018 yang tidak terjadi pada Rust 2015.

Atau Anda dapat menganggapnya sebagai momen tepat waktu, di mana Rust menjadi salah satu bahasa paling produktif yang dapat Anda gunakan dalam banyak kasus, kapan pun Anda membutuhkan kinerja, ruang yang berkurang atau keandalan yang tinggi.

Dalam pikiran kami, itu yang kedua. Jadi mari kita lihat semua yang terjadi di luar bahasa pusat. Kemudian kita bisa membenamkan diri dalam bahasa pusat itu sendiri.

Suatu bahasa pemrograman tidak bisa produktif dengan sendirinya, secara abstrak. Itu produktif ketika diberikan beberapa penggunaan. Karena itu, tim tahu bahwa kita tidak hanya perlu meningkatkan bahasa karat atau alat Rust. Kami juga perlu memfasilitasi penggunaan Rust dalam domain tertentu.

Dalam beberapa kasus, ini berarti menciptakan seperangkat alat yang benar-benar baru untuk ekosistem yang benar-benar baru.

Dalam kasus lain, itu berarti memoles apa yang sudah ada dalam ekosistem dan mendokumentasikannya dengan baik sehingga mudah untuk mewujudkannya.

Tim Karat membentuk kelompok kerja yang berfokus pada empat domain:

  • Perakitan web
  • Aplikasi tertanam
  • Jaringan
  • Alat baris perintah

Perakitan web

Untuk WebAssembly, kelompok kerja perlu membuat seperangkat alat yang benar-benar baru.

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

Logo karat dan logo JS dengan hati di tengah.

Karat adalah opsi yang bagus untuk pengembangan web karena dua alasan:

  1. Ekosistem kotak kargo bekerja dengan cara yang sama seperti kebanyakan pengembang aplikasi web. Anda mengumpulkan banyak modul kecil untuk membentuk aplikasi yang lebih besar. Ini berarti mudah menggunakan Rust tepat di tempat yang Anda butuhkan.
  2. Karat memiliki jejak cahaya dan tidak membutuhkan runtime. Ini berarti Anda tidak perlu mengirim banyak kode. Jika Anda memiliki modul kecil yang melakukan banyak pekerjaan komputasi, Anda dapat memasukkan beberapa baris Rust hanya untuk membuat ini bekerja lebih cepat.

Dengan sistem web dan js-sys kotak, mudah untuk memanggil API web seperti telah mampu pulih o tambahkan Anak dari kode karat. Y wasm-bindgen memfasilitasi dukungan untuk tipe data tingkat tinggi yang WebAssembly tidak mendukung secara native.

Setelah Anda menyandikan modul perakitan web Rust Anda, ada alat untuk memfasilitasi koneksi ke seluruh aplikasi web Anda. Anda dapat menggunakan paket-ism untuk menjalankan alat-alat ini secara otomatis, dan dorong modul baru Anda ke npm jika Anda mau.

Lihatlah buku Rust dan WebAssembly untuk mengujinya sendiri.

Apa selanjutnya?

Sekarang Rust 2018 telah pergi, kelompok kerja menemukan tempat untuk mengambil hal-hal berikutnya. Mereka akan bekerja dengan komunitas untuk menentukan bidang fokus berikut.

Tertanam

Untuk pengembangan terintegrasi, kelompok kerja perlu membuat stabil fungsi yang ada.

Secara teori, Rust selalu menjadi bahasa yang baik untuk pengembangan terintegrasi. Ini menyediakan pengembang terintegrasi dengan alat-alat hari ini yang mereka miliki, dan fitur bahasa tingkat tinggi yang sangat nyaman. Semua ini tanpa mengorbankan penggunaan sumber daya. Jadi Rust tampak sangat cocok untuk pengembangan terintegrasi.

Namun, dalam praktiknya itu agak liar. Karakteristik yang diperlukan tidak berada di saluran stabil. Selain itu, perpustakaan standar harus disesuaikan untuk digunakan dalam perangkat yang terintegrasi. Itu berarti bahwa orang-orang harus menyusun versi mereka sendiri dari kotak dasar Rust (kotak yang digunakan dalam setiap aplikasi Rust untuk menyediakan blok bangunan dasar Karat: intrinsik dan primitif).

Di sebelah kiri: Seseorang yang memasang chip mikroprosesor yang mengatakan sesuatu

Bersama-sama, kedua hal ini berarti bahwa para pengembang harus bergantung pada versi malam Rust. Dan karena tidak ada tes otomatis untuk tujuan mikrokontroler, setiap malam mereka sering memutuskan untuk tujuan ini.

Untuk mengatasi ini, kelompok kerja perlu memastikan bahwa fungsi yang diperlukan berada di saluran stabil. Kami juga harus menambahkan tes ke sistem CI untuk tujuan mikrokontroler. Ini berarti bahwa seseorang yang menambahkan sesuatu ke komponen desktop tidak akan merusak sesuatu untuk komponen bawaan.

Dengan perubahan ini, pengembangan terintegrasi dengan Rust bergerak menjauh dari avant-garde dan menuju ke dataran produktivitas.

Lihatlah buku tentang tertanam karat untuk membuktikannya sendiri.

Apa selanjutnya?

Dengan momentum tahun ini, Rust memiliki dukungan yang sangat baik untuk keluarga inti mikroprosesor ARM Cortex-M, yang digunakan di banyak perangkat. Namun, ada banyak arsitektur yang digunakan dalam perangkat terintegrasi, dan ini tidak kompatibel. Karat perlu diperluas untuk memiliki tingkat dukungan yang sama untuk arsitektur lain ini.

Jaringan

Untuk pembuatan jaringan, kelompok kerja perlu membangun abstraksi sentral dalam bahasa:asynchronous / wait. Dengan cara ini, pengembang dapat menggunakan idiom Rust bahkan ketika kode tersebut tidak sinkron.

Untuk tugas jaringan, Anda sering harus menunggu. Misalnya, Anda mungkin menunggu tanggapan atas permintaan. Jika kode Anda sinkron, itu berarti bahwa pekerjaan akan berhenti: inti dari CPU yang mengeksekusi kode tidak dapat melakukan apa pun hingga permintaan itu datang. Tetapi jika meng-enkode secara asynchronous, maka fungsi yang menunggu respons dapat berlanjut. Pertahankan sementara inti dari CPU bertanggung jawab untuk menjalankan fungsi lain.

Pengodean Karat asynchronous dimungkinkan bahkan dengan Rust 2015. Dan ada banyak keuntungan dalam hal ini. Dalam skala besar, untuk hal-hal seperti aplikasi server, itu berarti bahwa kode Anda dapat menangani lebih banyak koneksi per server. Dalam skala kecil, untuk hal-hal seperti aplikasi tertanam yang berjalan pada CPU kecil dan CPU single-threaded, itu berarti Anda dapat menggunakan subproses tunggal Anda dengan lebih baik.

Namun kelebihan ini memiliki satu kelemahan besar: Saya tidak dapat menggunakan verifikator pinjaman untuk kode itu, dan saya harus menulis Rust yang tidak peka (dan sesuatu yang membingungkan). Di sinilah asynchronous / wait masukkan Ini memberi kompilator informasi yang perlu dipinjam melalui panggilan fungsi asynchronous.

Kata kunci untuk asynchronous / wait mereka diperkenalkan di 1,31, meskipun saat ini mereka tidak didukung oleh implementasi. Banyak pekerjaan yang dilakukan dan Anda dapat mengharapkan fitur tersebut tersedia dalam rilis mendatang.

Apa selanjutnya?

Di luar yang memungkinkan pengembangan produktivitas tingkat rendah untuk aplikasi jaringan, Rust dapat memungkinkan pengembangan yang lebih produktif pada tingkat yang lebih tinggi.

Banyak server perlu melakukan tugas yang sama. Mereka perlu menganalisis URL atau bekerja dengan HTTP. Jika ini menjadi komponen (abstraksi umum yang dapat dibagikan sebagai kotak), akan mudah untuk menghubungkannya untuk membentuk semua jenis server dan berbagai bingkai.

Untuk menggerakkan proses pengembangan komponen, kerangka Tide menyediakan test bed untuk komponen-komponen ini dan, akhirnya, penggunaan komponen-komponen ini.

Alat baris perintah

Untuk alat baris perintah, kelompok kerja diperlukan untuk mengumpulkan pustaka yang lebih kecil dan lebih rendah ke abstraksi tingkat tinggi dan memoles beberapa alat yang ada.

Untuk beberapa skrip CLI, Anda benar-benar ingin menggunakan bash. Misalnya, jika Anda hanya perlu memanggil alat shell lain dan data pipa di antara mereka, maka bash lebih baik.

Namun Rust sangat ideal untuk banyak jenis alat CLI lainnya. Misalnya, sangat bagus jika Anda membuat alat yang kompleks seperti ripgrep atau membuat alat CLI pada fungsi pustaka yang ada.

Karat tidak memerlukan waktu eksekusi dan memungkinkan Anda untuk mengkompilasi dalam satu biner statis, yang memfasilitasi distribusinya. Dan itu memperoleh abstraksi tingkat tinggi yang tidak didapat dengan bahasa lain seperti C dan C ++, sehingga membuat pengembang CLI Karat produktif.

Apa yang kelompok kerja perlu perbaiki ini? Abstraksi tingkat yang lebih tinggi.

Dengan abstraksi tingkat tinggi ini, cepat dan mudah untuk membangun CLI yang siap diproduksi.

Contoh salah satu abstraksi ini adalah perpustakaan panik manusia. Tanpa perpustakaan ini, jika kode CLI Anda menjadi panik, kemungkinan akan menghasilkan semua jejak berikutnya. Tapi itu tidak terlalu berguna untuk pengguna akhirnya. Saya dapat menambahkan penanganan kesalahan khusus, tetapi itu membutuhkan usaha.

Jika Anda menggunakan kepanikan manusia, output akan secara otomatis diarahkan ke file dump kesalahan. Apa yang akan dilihat pengguna adalah pesan bermanfaat yang menunjukkan bahwa mereka melaporkan masalah dan mengunggah file dump kesalahan.

Alat cli dengan keluar ramah dari kepanikan manusia.

Kelompok kerja juga mempermudah memulai dengan pengembangan CLI. Sebagai contoh, pustaka confy akan mengotomatisasi sejumlah besar konfigurasi untuk alat CLI baru. Dia hanya menanyakan dua hal:

  • Apa nama aplikasi Anda?
  • Apa opsi konfigurasi yang ingin Anda ekspos (yang Anda definisikan sebagai struktur yang dapat diserialisasi dan deserialized)?

Dari situ, Confy akan menyelesaikan sisanya untuk Anda.

Apa selanjutnya?

Kelompok kerja mengambil banyak tugas berbeda yang umum di antara CLI. Tapi masih ada lagi yang bisa diabstraksikan. Gugus tugas akan membuat lebih banyak pustaka tingkat tinggi ini dan memperbaiki lebih banyak pemotongan kertas saat mereka pergi.

Ikon alat

Ketika Anda mengalami bahasa, Anda mengalaminya melalui alat. Ini dimulai dengan editor yang Anda gunakan. Ini berlanjut melalui setiap tahap proses pengembangan, dan melalui pemeliharaan.

Ini berarti bahwa bahasa produktif bergantung pada alat produktif.

Berikut adalah beberapa alat (dan perbaikan alat Rust yang ada) yang diperkenalkan sebagai bagian dari Rust 2018.

Dukungan IDE

Tentu saja, produktivitas tergantung pada cara mendapatkan kode dari pikiran Anda ke layar dengan cepat. Dukungan IDE sangat penting untuk ini. Untuk mendukung IDE, kita memerlukan alat yang dapat memberi tahu IDE apa arti kode Karat, misalnya, untuk memberi tahu IDE yang string-nya masuk akal untuk kompetensi kode.

Dalam momentum Rust 2018, komunitas berfokus pada karakteristik yang dibutuhkan SDI. Dengan Rust Language Server dan IntelliJ Rust, banyak IDE sekarang memiliki dukungan cairan Rust.

Kompilasi lebih cepat

Dengan kompilasi, lebih cepat berarti lebih produktif. Jadi kami telah membuat kompilator lebih cepat.

Sebelumnya, ketika mengkompilasi kotak Karat, kompilator mengkompilasi ulang setiap file di dalam kotak. Tetapi sekarang, dengan kompilasi inkremental, kompilator cerdas dan hanya mengkompilasi ulang bagian-bagian yang telah berubah. Ini, bersama dengan pengoptimalan lainnya, telah membuat kompilator Rust jauh lebih cepat.

rustfmt

Produktivitas juga berarti tidak harus memperbaiki nits gaya (dan tidak perlu berdebat tentang aturan pemformatan).

Alat rustfmt membantu ini dengan secara otomatis memformat ulang kode Anda menggunakan gaya kode default (di mana komunitas mencapai konsensus). Penggunaan rustfmt memastikan bahwa semua kode Rust Anda sesuai dengan gaya yang sama, seperti halnya format Clang untuk C ++ dan Prettier untuk JavaScript.

Clippy

Terkadang ada baiknya memiliki penasihat yang berpengalaman di sisi Anda … memberi Anda nasihat tentang praktik terbaik saat Anda membuat kode. Itulah yang Clippy lakukan: periksa kode Anda dengan cepat dan beri tahu Anda cara membuat kode itu lebih idiomatis.

rustfix

Tetapi jika Anda memiliki basis kode yang lebih tua yang menggunakan idiom yang ketinggalan jaman, maka hanya mendapatkan saran dan memperbaiki kode sendiri bisa membosankan. Anda hanya ingin seseorang memasukkan kode dasar Anda dan melakukan koreksi.

Untuk kasus ini, rustfix akan mengotomatiskan proses. Lints alat akan diterapkan sebagai Clippy dan kode sebelumnya akan diperbarui agar sesuai dengan idiom Rust 2018.

Perubahan-perubahan dalam ekosistem ini telah membawa banyak keuntungan produktivitas. Tetapi beberapa masalah produktivitas hanya bisa diselesaikan dengan perubahan dalam bahasa itu sendiri.

Seperti yang saya sebutkan dalam pendahuluan, sebagian besar perubahan bahasa sepenuhnya kompatibel dengan kode Karat yang ada. Perubahan ini adalah bagian dari Rust 2018. Tapi karena mereka tidak melanggar kode apa pun, mereka juga bekerja dengan kode Rust … bahkan jika kode itu tidak menggunakan Rust 2018.

Mari kita lihat beberapa fitur bahasa hebat yang ditambahkan ke semua edisi. Kemudian kita dapat melihat daftar kecil fitur spesifik Rust 2018.

Fitur bahasa baru untuk semua edisi.

Berikut ini adalah contoh kecil fitur bahasa baru dan hebat yang (atau akan) ada di semua edisi bahasa.

Verifikasi pinjaman yang lebih akurat (misalnya, waktu hidup non-leksikal)

Titik penjualan yang bagus untuk Rust adalah validator pinjaman. Validator pinjaman membantu memastikan bahwa kode Anda aman untuk memori. Tetapi itu juga merupakan titik yang sulit bagi para pengembang Rust baru.

Bagian dari itu adalah mempelajari konsep-konsep baru. Tetapi ada bagian penting lain … pemverifikasi pinjaman kadang-kadang menolak kode yang tampaknya berhasil, bahkan bagi mereka yang memahami konsepnya.

pemverifikasi pinjaman memberi tahu programmer bahwa mereka tidak dapat meminjam variabel karena sudah dipinjam

Ini karena diasumsikan bahwa masa manfaat pinjaman mencapai akhir ruang lingkupnya, misalnya, pada akhir fungsi di mana variabel tersebut ditemukan.

Ini berarti bahwa meskipun variabel dibuat dengan nilai dan tidak akan mencoba untuk mengaksesnya lagi, variabel lain ditolak akses hingga akhir fungsi.

Untuk mengatasi ini, kami telah membuat verifikator pinjaman lebih cerdas. Sekarang Anda dapat melihat kapan sebuah variabel saat ini selesai menggunakan nilai. Jika itu dilakukan, maka itu tidak mencegah peminjam lain menggunakan data.

pemverifikasi pinjaman berkata: Oh, sekarang saya lihat

Meskipun ini hanya tersedia di Rust 2018 mulai hari ini, ini akan tersedia di semua edisi dalam waktu dekat. Saya akan menulis lebih banyak tentang semua ini segera.

Prosedur macro dalam Rust yang stabil

Makro di Rust telah ada sejak sebelum Rust 1.0. Tetapi dengan Rust 2018, kami telah membuat peningkatan besar, seperti pengenalan makro prosedural.

Dengan makro prosedural, seolah-olah Anda dapat menambahkan sintaks Anda sendiri ke Rust.

Rust 2018 menghadirkan dua jenis makro prosedural:

Makro seperti fungsi

Makro fungsi-seperti memungkinkan Anda untuk memiliki elemen yang terlihat seperti panggilan fungsi biasa, tetapi sebenarnya berjalan selama kompilasi. Mereka mengambil kode dan memuntahkan kode yang berbeda, yang kemudian disisipkan ke dalam biner.

Mereka telah ada untuk sementara waktu, tetapi apa yang dapat Anda lakukan dengan mereka terbatas. Makro Anda hanya bisa mengambil kode input dan menjalankan deklarasi pertandingan di atasnya. Dia tidak memiliki akses untuk melihat semua chip dalam kode entri itu.

Tetapi dengan macro prosedur, Anda mendapatkan input yang sama seperti yang diperoleh seorang analis: urutan token. Ini berarti Anda dapat membuat makro yang serupa dengan fungsi yang jauh lebih kuat.

Macro mirip dengan atribut

Jika Anda akrab dengan dekorator dalam bahasa seperti JavaScript, makro atribut cukup mirip. Mereka memungkinkan Anda untuk menulis kode bit di Rust yang harus dipreprocess dan diubah menjadi sesuatu yang lain.

itu berasal makro melakukan hal semacam ini. Ketika Anda meletakkannya di atas struktur, kompilator akan mengambil struktur itu (setelah itu dianalisis sebagai daftar token) dan memanipulasinya. Secara khusus, ini akan menambahkan implementasi fitur dasar dari suatu fitur.

Lebih banyak pinjaman ergonomis dalam kombinasi

Perubahan ini cukup sederhana.

Sebelumnya, jika Anda ingin meminjam sesuatu dan mencoba mencocokkannya, Anda harus menambahkan sintaks yang aneh:

Versi sebelumnya dari kode dengan & Beberapa (refs) di samping versi baru dengan Some (s)

Tetapi sekarang, Anda tidak membutuhkan & Beberapa (ref) tidak pernah lagi Anda hanya bisa menulis Beberapa (s), dan Rust akan menyelesaikannya dari sana.

Fitur khusus baru untuk Rust 2018

Bagian terkecil dari Rust 2018 adalah karakteristik spesifiknya. Berikut adalah beberapa perubahan yang dibuka kuncinya saat menggunakan edisi Rust 2018.

Kata kunci

Ada beberapa kata kunci yang telah ditambahkan ke Rust 2018.

  • mengobati kata kunci
  • asynchronous / wait kata kunci

Fitur-fitur ini belum sepenuhnya diimplementasikan, tetapi kata kunci ditambahkan dalam Rust 1.31. Ini berarti bahwa kami tidak perlu memperkenalkan kata kunci baru (yang akan menjadi perubahan besar) di masa depan, setelah fitur di balik kata kunci ini diimplementasikan.

Sistem modul

Masalah besar bagi pengembang yang mempelajari Rust adalah sistem modul. Dan kita bisa melihat mengapa. Sulit untuk berpikir tentang bagaimana Rust akan memilih modul mana yang akan digunakan.

Untuk mengatasi ini, kami membuat beberapa perubahan dalam cara rute di Rust bekerja.

Misalnya, jika Anda mengimpor kotak, Anda dapat menggunakannya dalam rute di tingkat atas. Tetapi jika Anda memindahkan kode apa pun ke submodul, maka itu tidak akan berfungsi lagi.

// modul tingkat yang lebih tinggi
kotak eksternal dari kotak;

// ini berfungsi dengan baik di tingkat atas
impl serde :: Serialize untuk MyType {...}

mod foo {
// tetapi * tidak * berfungsi dalam submodul
impl serde :: Serialize for OtherType {...}
}

Contoh lain adalah awalan. ::, yang digunakan untuk merujuk ke akar kotak atau kotak eksternal. Mungkin sulit untuk mengatakan yang mana.

Kami telah membuat ini lebih eksplisit. Sekarang, jika Anda ingin merujuk ke root kotak, Anda menggunakan awalan kotak :: sebagai gantinya. Dan ini hanyalah salah satu perbaikan dalam kejelasan jalan yang telah kita tempuh.

Jika Anda memiliki kode Rust yang ada dan Anda ingin menggunakan Rust 2018, kemungkinan besar Anda perlu memperbaruinya untuk rute modul baru ini. Tetapi itu tidak berarti Anda harus memperbarui kode Anda secara manual. lari pengaturan kargo Sebelum menambahkan specifier edisi ke Cargo.toml dan rustfix Ini akan membuat semua perubahan untuk Anda.

Pelajari semua tentang edisi ini di panduan edisi Rust 2018.

Lin adalah seorang insinyur di tim hubungan pengembang Mozilla. Dia bermain dengan JavaScript, WebAssembly, Rust dan Servo, dan juga menggambar kartun kode.

Artikel lain oleh Lin Clark …

Item lain dari The Rust Team …

Be the first to comment

Leave a Reply

Your email address will not be published.


*