Rust Programlama Dili

Steve Klabnik, Carol Nichols ve Chris Krycho tarafından, Rust Topluluğunun katkılarıyla yazılmıştır.

Kitabın bu sürümü, Rust 1.99.1 (yayın tarihi: 2026-10-15) veya üzerini kullandığınızı ve tüm projeleri Rust 2024 Sürümü (Edition) kurallarını kullanacak şekilde yapılandırmak üzere Cargo.toml dosyalarında edition = "2024" ayarının bulunduğunu varsayar. Rust’ı kurma veya güncelleme yönergeleri için Bölüm 1’deki “Kurulum” başlığına, sürümler hakkında bilgi için ise Ek E’ye bakabilirsiniz.

Kitabın orijinal HTML sürümü çevrim içi olarak https://doc.rust-lang.org/stable/book/ adresinde, rustup ile yapılan Rust kurulumlarında ise çevrim dışı olarak yer alır; yerel kopyayı açmak için terminalde rustup doc --book komutunu çalıştırabilirsiniz.

Topluluk tarafından hazırlanan çeşitli çeviriler de mevcuttur.

Bu metin, İngilizce olarak No Starch Press’ten karton kapaklı baskı ve e-kitap formatında edinilebilir.

🚨 Daha etkileşimli bir öğrenme deneyimi mi arıyorsunuz? Kısa sınavlar, kod vurgulamaları, görselleştirmeler ve daha fazlasını içeren alternatif Rust Kitabı sürümünü (İngilizce) deneyin: https://rust-book.cs.brown.edu

Önsöz

Rust programlama dili, meraklılardan oluşan küçük ve yeni filizlenen bir topluluğun elinde doğup olgunlaşmasından dünyanın en sevilen ve en çok talep gören programlama dillerinden biri hâline gelmesine dek birkaç kısa yıl içinde uzun bir yol katetti. Geriye dönüp bakıldığında Rust’ın gücünün ve vadettiklerinin dikkatleri üzerine çekmesi ve sistem programlamada kendine sağlam bir yer edinmesi kaçınılmazdı. Kaçınılmaz olmayan ise açık kaynak topluluklarına nüfuz eden ve pek çok sektörde geniş ölçekli benimsenmeyi tetikleyen küresel çaptaki ilgi ve yenilik artışıydı.

Bugün gelinen noktada ilgi ve benimsenmedeki bu patlamayı açıklamak için Rust’ın sunduğu harika özelliklere işaret etmek kolaydır. Diğer pek çok güçlü özelliğin yanı sıra hem bellek güvenliğini hem yüksek performansı hem dost canlısı bir derleyiciyi hem de mükemmel geliştirme araçlarını kim istemez ki? Bugün gördüğünüz Rust dili, sistem programlama alanında yıllar süren araştırmaları canlı ve tutkulu bir topluluğun pratik bilgeliğiyle bir araya getiriyor. Bilinçli bir amaçla tasarlanıp büyük bir özenle işlenen bu dil, geliştiricilere güvenli, hızlı ve güvenilir kod yazmayı kolaylaştıran bir araç sunuyor.

Ancak Rust’ı gerçekten özel kılan, temelinde bir kullanıcı olarak hedeflerinize ulaşabilmeniz için sizi güçlendirme anlayışının yatmasıdır. Rust sizin başarılı olmanızı isteyen bir dildir ve kullanıcıyı güçlendirme ilkesi, bu dili inşa eden, sürdüren ve savunan topluluğun özüne işlemiştir. Bu başvuru niteliğindeki eserin önceki baskısından bu yana Rust, daha da gelişerek gerçek anlamda küresel ve güvenilir bir dil hâline geldi. Rust Projesi artık Rust Vakfı tarafından güçlü bir biçimde destekleniyor; vakıf aynı zamanda Rust’ın güvenli, kararlı ve sürdürülebilir kalmasını güvence altına alacak kritik girişimlere yatırım yapıyor.

Rust Programlama Dili kitabının bu baskısı, dilin yıllar içindeki evrimini yansıtan ve değerli yeni bilgiler sunan kapsamlı bir güncellemedir. Ancak elinizdeki kitap yalnızca sözdizimi ve kütüphaneler için bir rehber değil; kaliteye, performansa ve iyi düşünülmüş tasarıma değer veren bir topluluğa katılmanız için bir davettir. İster Rust’ı ilk kez keşfetmeye hazırlanan tecrübeli bir geliştirici ister becerilerini keskinleştirmek isteyen deneyimli bir Rustacean olun, bu baskı herkes için bir şeyler sunuyor.

Rust’ın yolculuğu; iş birliği, öğrenme ve adım adım iyileştirmeyle şekillendi. Dilin ve ekosisteminin büyümesi, arkasındaki canlı ve zengin çeşitliliğe sahip topluluğun doğrudan bir yansımasıdır. Çekirdek dil tasarımcılarından fırsat buldukça katkı sunanlara kadar binlerce geliştiricinin emeği, Rust’ı böylesine benzersiz ve güçlü bir araç hâline getiriyor. Bu kitabı elinize alarak yalnızca yeni bir programlama dili öğrenmekle kalmıyor; yazılımı daha iyi, daha güvenli ve üzerinde çalışması daha keyifli hâle getiren bir harekete katılıyorsunuz.

Rust topluluğuna hoş geldiniz!

• Bec Rumbul, Rust Vakfı İcra Direktörü

Giriş

Rust’a giriş niteliğindeki Rust Programlama Dili (The Rust Programming Language) kitabına hoş geldiniz. Rust programlama dili, daha hızlı ve daha güvenilir yazılımlar geliştirmenize yardımcı olur. Programlama dili tasarımında üst düzey ergonomi ile alt düzey kontrol genellikle birbiriyle çelişir; Rust ise bu ikileme meydan okur. Güçlü teknik kapasite ile mükemmel bir geliştirici deneyimini dengeleyen Rust, geleneksel olarak bu düzeydeki kontrolün beraberinde getirdiği zahmetlere katlanmak zorunda kalmadan alt düzey ayrıntıları (bellek kullanımı gibi) yönetme olanağı sunar.

Rust Kimler İçin?

Rust, çeşitli nedenlerle pek çok kişi için ideal bir dildir. Gelin en önemli gruplardan birkaçına birlikte bakalım.

Geliştirici Ekipleri

Rust, farklı düzeylerde sistem programlama bilgisine sahip geliştiricilerden oluşan büyük ekiplerin iş birliği içinde çalışması için üretken bir araç olduğunu kanıtlamıştır. Alt düzey kodlar, diğer pek çok dilde ancak kapsamlı testler ve deneyimli geliştiricilerin titiz kod incelemeleriyle yakalanabilen çeşitli sinsi hatalara açıktır. Rust’ta ise derleyici, bellek güvenliği ihlalleri ve veri yarışları gibi yakalanması güç pek çok hatayı derleme aşamasında engeller. Bu güvence, bütün eşzamanlılık (concurrency) hatalarının önlendiği anlamına gelmez; kilitlenmeler ve işlemlerin yanlış sıralanmasından kaynaklanan mantık hataları yine mümkündür. Ekip, derleyiciyle omuz omuza çalışarak vaktini hataların peşinden koşmak yerine programın mantığına odaklanmaya ayırabilir.

Rust ayrıca sistem programlama dünyasına çağdaş geliştirici araçları da kazandırır:

• Rust ile birlikte gelen bağımlılık yöneticisi ve derleme aracı olan Cargo; bağımlılıkları eklemeyi, derlemeyi ve yönetmeyi tüm Rust ekosistemi genelinde zahmetsiz ve tutarlı hâle getirir.
• rustfmt biçimlendirme aracı, geliştiriciler arasında tutarlı bir kodlama stili sağlar.
• Rust’ın dil sunucusu rust-analyzer, kod tamamlama ve satır içi hata mesajları gibi özellikler için tümleşik geliştirme ortamı (IDE) entegrasyonunu sağlar.

Geliştiriciler, Rust ekosistemindeki bu ve benzeri araçları kullanarak sistem düzeyinde kod yazarken yüksek üretkenliklerini koruyabilirler.

Öğrenciler

Rust, sistem kavramlarını öğrenmek isteyen öğrenciler ve meraklılar içindir. Pek çok kişi işletim sistemi geliştirme gibi konuları Rust kullanarak öğrenmiştir. Topluluk son derece sıcakkanlıdır ve öğrencilerin sorularını yanıtlamaktan mutluluk duyar. Rust ekipleri, bu kitap gibi çalışmalar aracılığıyla sistem kavramlarını başta programlamaya yeni başlayanlar olmak üzere daha fazla insan için erişilebilir kılmayı amaçlar.

Şirketler

İrili ufaklı yüzlerce şirket; komut satırı araçları, web servisleri, DevOps araçları, gömülü cihazlar, ses ve video analizi ile format dönüştürme, kripto paralar, biyoinformatik, arama motorları, Nesnelerin İnterneti uygulamaları, makine öğrenimi ve hatta Firefox web tarayıcısının önemli bölümleri dahil olmak üzere çok çeşitli görevler için üretim ortamında Rust kullanır.

Açık Kaynak Geliştiricileri

Rust; Rust programlama dilini, topluluğunu, geliştirici araçlarını ve kütüphanelerini inşa etmek isteyenler içindir. Rust diline katkıda bulunmanızdan büyük mutluluk duyarız.

Hıza ve Kararlılığa Önem Verenler

Rust, bir dilde hız ve kararlılık arayanlar içindir. Hız derken hem Rust kodunun çalışma hızını hem de Rust’ın size program geliştirme sürecinde kazandırdığı hızı kastediyoruz. Rust derleyicisinin yaptığı denetimler, yeni özellik eklemeleri ve kodda yapılan yeniden düzenlemeler boyunca kararlılığı güvence altına alır. Bu durum, bu tür denetimlerden yoksun dillerde geliştiricilerin dokunmaktan çekindiği kırılgan eski kod tabanlarıyla tam bir tezat oluşturur. Rust, sıfır maliyetli soyutlamalar (zero-cost abstractions) —elle yazılmış alt düzey kod kadar hızlı çalışan koda derlenen üst düzey özellikler— hedefleyerek güvenli kodun aynı zamanda hızlı kod olmasını sağlamaya çalışır.

Rust dili, daha pek çok farklı kullanıcı kitlesini de desteklemeyi hedefler; burada değinilenler yalnızca en büyük paydaşlardan bazılarıdır. Özetle Rust’ın en büyük tutkusu; güvenliği ve üretkenliği, hızı ve ergonomiyi bir arada sunarak programcıların on yıllardır kabullendiği ödünleşimleri ortadan kaldırmaktır. Rust’a bir şans verin ve tasarım tercihlerinin sizin için işe yarayıp yaramadığını kendiniz görün.

Bu Kitap Kimler İçin?

Bu kitap, daha önce başka bir programlama dilinde kod yazdığınızı varsayar; ancak bunun hangi dil olduğuna dair herhangi bir ön kabulde bulunmaz. İçeriği, çok çeşitli programlama geçmişlerinden gelen okuyucular için geniş ölçüde erişilebilir kılmaya özen gösterdik. Programlamanın ne olduğu veya programlama mantığıyla nasıl düşünüleceği üzerine uzun uzadıya vakit harcamayacağız. Programlamaya tamamen yeniyseniz öncelikle doğrudan programlamaya giriş niteliği taşıyan bir kitap okumanız sizin için çok daha faydalı olacaktır.

Bu Kitap Nasıl Kullanılır?

Genel olarak bu kitap, bölümleri baştan sona sırasıyla okuduğunuzu varsayar. İlerleyen bölümler önceki bölümlerde tanıtılan kavramların üzerine inşa edilir; önceki bölümler ise belirli bir konunun tüm ayrıntılarına hemen inmeyip konuyu daha sonraki bir bölümde yeniden ele alabilir.

Bu kitapta iki tür bölüm bulacaksınız: kavram bölümleri ve proje bölümleri. Kavram bölümlerinde Rust’ın belirli bir yönünü öğreneceksiniz. Proje bölümlerinde ise o ana dek öğrendiklerinizi uygulayarak birlikte küçük programlar geliştireceğiz. Bölüm 2, Bölüm 12 ve Bölüm 21 proje bölümleridir; geri kalanlar ise kavram bölümleridir.

Bölüm 1, Rust’ın nasıl kurulacağını, “Merhaba, dünya!” programının nasıl yazılacağını ve Rust’ın paket yöneticisi ve derleme aracı olan Cargo’nun nasıl kullanılacağını açıklar. Bölüm 2, bir sayı tahmin oyunu geliştirmenizi sağlayarak Rust’ta program yazmaya uygulamalı bir giriş sunar. Burada kavramları genel hatlarıyla ele alırız; ek ayrıntıları ise ilerleyen bölümler sağlar. Hemen kolları sıvayıp pratik yapmak istiyorsanız Bölüm 2 tam size göredir. Bir sonraki konuya geçmeden önce her ayrıntıyı öğrenmeyi tercih eden titiz bir okuyucuysanız Bölüm 2’yi atlayıp doğrudan Bölüm 3’e geçmek isteyebilirsiniz; bu bölüm, diğer programlama dillerindekilere benzeyen Rust özelliklerini ele alır. Öğrendiğiniz ayrıntıları bir proje üzerinde uygulamak istediğinizde Bölüm 2’ye geri dönebilirsiniz.

Bölüm 4’te Rust’ın sahiplik (ownership) sistemini öğreneceksiniz. Bölüm 5, struct’ları ve metotları ele alır. Bölüm 6 ise enum’ları, match ifadelerini ve if let ile let...else kontrol akışı yapılarını kapsar. Kendi özel türlerinizi oluşturmak için struct’ları ve enum’ları kullanacaksınız.

Bölüm 7’de Rust’ın modül sistemini ve kodunuz ile herkese açık uygulama programlama arayüzünüzü (API) düzenlemeye yönelik gizlilik kurallarını öğreneceksiniz. Bölüm 8, standart kütüphanenin sunduğu yaygın koleksiyon veri yapılarını ele alır: vektörler, string’ler ve hash map’ler. Bölüm 9, Rust’ın hata yönetimi felsefesini ve tekniklerini inceler.

Bölüm 10, birden fazla türe uygulanabilen kodlar tanımlama gücü veren jenerikleri, trait’leri ve ömürleri (lifetimes) derinlemesine inceler. Bölüm 11 tamamen test yazmaya ayrılmıştır; Rust’ın sunduğu güvenlik garantilerine rağmen programınızın mantığının doğru çalıştığından emin olmak için testler gereklidir. Bölüm 12’de, dosyalar içinde metin arayan grep komut satırı aracının işlevlerinin bir alt kümesini barındıran kendi uygulamamızı geliştireceğiz. Bunun için önceki bölümlerde ele aldığımız pek çok kavramı kullanacağız.

Bölüm 13, Rust’ın fonksiyonel programlama dillerinden gelen özellikleri olan kapanışları (closures) ve iteratörleri inceler. Bölüm 14’te Cargo’yu daha derinlemesine inceleyecek ve kütüphanelerinizi başkalarıyla paylaşmaya yönelik en iyi uygulamaları konuşacağız. Bölüm 15, standart kütüphanenin sunduğu akıllı işaretçileri (smart pointers) ve bunların işlevselliğini mümkün kılan trait’leri ele alır.

Bölüm 16’da farklı eşzamanlı programlama modellerini adım adım inceleyecek ve Rust’ın birden fazla thread (iş parçacığı) ile korkusuzca programlama yapmanıza nasıl yardımcı olduğunu konuşacağız. Bölüm 17’de ise bu temelin üzerine inşa ederek Rust’ın async ve await sözdizimini; görevler (tasks), future’lar ve akışlar (streams) ile bunların mümkün kıldığı hafif eşzamanlılık modelini keşfedeceğiz.

Bölüm 18, Rust’a özgü kullanım kalıplarının (idioms) aşina olabileceğiniz nesne yönelimli programlama ilkeleriyle nerelerde örtüşüp nerelerde ayrıştığını inceler. Bölüm 19, Rust programlarının genelinde fikirleri ifade etmenin güçlü yolları olan desenler (patterns) ve desen eşleştirme (pattern matching) üzerine bir başvuru kaynağıdır. Bölüm 20 ise güvenli olmayan (unsafe) Rust, makrolar ve ömürler, trait’ler, türler, fonksiyonlar ile kapanışlar hakkında daha fazla ayrıntının yer aldığı, ilgi çekici gelişmiş konulardan oluşan zengin bir seçki sunar.

Bölüm 21’de alt düzey, çok iş parçacıklı (multithreaded) bir web sunucusu geliştireceğimiz bir projeyi tamamlayacağız!

Son olarak ekler bölümü, dil hakkında başvuru kaynağı niteliğinde faydalı bilgiler barındırır. Ek A Rust’ın anahtar kelimelerini, Ek B Rust’ın operatörlerini ve sembollerini, Ek C standart kütüphane tarafından sağlanan türetilebilir trait’leri, Ek D faydalı geliştirme araçlarını ve Ek E Rust sürümlerini (editions) kapsar. Ek F’de kitabın çevirilerini bulabilir, Ek G’de ise Rust’ın nasıl geliştirildiğini ve “Nightly Rust” (gecelik derleme) sürümünün ne olduğunu öğrenebilirsiniz.

Bu kitabı okumanın yanlış bir yolu yoktur: İlerideki bölümlere atlamak isterseniz hiç çekinmeyin! Herhangi bir kafa karışıklığı yaşarsanız önceki bölümlere geri dönmeniz gerekebilir; ancak sizin için hangi yöntem en verimliyse onu izleyin.

Rust öğrenme sürecinin önemli bir parçası, derleyicinin gösterdiği hata mesajlarını nasıl okuyacağınızı öğrenmektir: Bu mesajlar sizi çalışan koda doğru yönlendirecektir. Bu doğrultuda kitap boyunca derlenmeyen pek çok örneği, derleyicinin her durumda size göstereceği hata mesajıyla birlikte paylaşacağız. Rastgele bir kod örneğini yazıp çalıştırmayı denediğinizde derlenmeyebileceğini unutmayın! Çalıştırmak istediğiniz örneğin bilerek hata üretmek üzere yazılıp yazılmadığını görmek için çevresindeki metni mutlaka okuyun. Ferris de çalışması amaçlanmayan kodları ayırt etmenize yardımcı olacaktır:

Ferris	Anlamı
	Bu kod derlenmez!
	Bu kod panik oluşturur!
	Bu kod istenen davranışı üretmez.

Çoğu durumda, derlenmeyen bir örneği sonraki adımlarda düzelteceğiz. Bu yüzden örnekleri yalnızca son hâlleriyle değil, anlatıldıkları aşamadaki amaçlarıyla birlikte değerlendirin.

Bir kod bloğu her zaman tek başına çalıştırılabilecek tam bir program değildir. // --snip-- işareti, konuyla doğrudan ilgili olmayan satırların gösterilmediğini belirtir; bir örnek de önceki adımda tanımladığınız tür veya fonksiyonları kullanabilir. Dosya adlarını ve çevredeki yönergeleri izleyerek kodu mevcut projenizin ilgili bölümüne yerleştirin.

Derleme hatası, panik ve istenmeyen sonuç farklı durumlardır: Derleme hatasında çalıştırılabilir program üretilmez; panikte kod derlenmiş olsa da yürütme sırasında normal akış kesilir; mantık hatasında ise program çalışabilir fakat beklenen sonucu üretmez. Bu ayrımı öğrenmek de örneklerin amacının bir parçasıdır.

Kaynak Kod

Bu kitabın oluşturulduğu orijinal İngilizce kaynak dosyalarına GitHub üzerindeki resmî rust-lang/book deposundan, elinizdeki Türkçe çevirinin kaynak dosyalarına ise hakantr/kitap-rs deposundan ulaşabilirsiniz.

Başlangıç

Rust yolculuğunuza başlayalım! Öğrenecek çok şey var, ancak her yolculuk bir yerden başlar. Bu bölümde şunları ele alacağız:

• Linux, macOS ve Windows üzerinde Rust’ı kurmak
• Ekrana Merhaba, dünya! yazdıran bir program yazmak
• Rust’ın paket yöneticisi ve derleme sistemi olan cargo’yu kullanmak

Kurulum

Kurulum

İlk adım Rust’ı kurmaktır. Rust sürümlerini ve ilişkili araçları yönetmek için kullanılan bir komut satırı aracı olan rustup aracılığıyla Rust’ı indireceğiz. İndirme işlemi için internet bağlantısına ihtiyacınız olacak.

Aşağıdaki adımlar, Rust derleyicisinin en son kararlı (stable) sürümünü kurar. Rust’ın kararlılık güvenceleri sayesinde, bu kitapta yer alan ve derlenen tüm örnekler daha yeni Rust sürümleriyle de sorunsuzca derlenmeye devam edecektir. Rust ekibi hata mesajlarını ve uyarıları düzenli olarak iyileştirdiği için çıktılar sürümler arasında küçük farklılıklar gösterebilir. Başka bir deyişle, bu adımları izleyerek kuracağınız daha yeni herhangi bir kararlı Rust sürümü, kitabın içeriğiyle beklendiği gibi çalışacaktır.

Linux veya macOS Üzerinde rustup Kurulumu

Linux veya macOS kullanıyorsanız bir terminal açın ve aşağıdaki komutu girin:

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

Bu komut bir betik indirir ve en son kararlı Rust sürümünü kuran rustup aracının kurulumunu başlatır. İşlem sırasında parolanız istenebilir. Kurulum başarılı olursa ekranda şu satır görünür:

Rust is installed now. Great!

Ayrıca Rust’ın derlenmiş çıktıları tek bir dosyada birleştirmek için kullandığı bir bağlayıcıya (linker) da ihtiyacınız olacaktır. Büyük olasılıkla sisteminizde zaten bir bağlayıcı kuruludur. Bağlayıcı hataları alırsanız genellikle bir bağlayıcı da içeren bir C derleyicisi kurmalısınız. Bazı yaygın Rust paketleri C koduna bağımlı olduğundan ve bir C derleyicisine ihtiyaç duyacağından, sisteminizde C derleyicisi bulunması ileride de faydalı olacaktır.

macOS üzerinde şu komutu çalıştırarak bir C derleyicisi edinebilirsiniz:

$ xcode-select --install

Linux kullanıcıları ise genel olarak kendi dağıtımlarının belgelerine göre GCC veya Clang kurmalıdır. Örneğin Ubuntu kullanıyorsanız build-essential paketini kurabilirsiniz.

Windows Üzerinde rustup Kurulumu

Windows üzerinde https://www.rust-lang.org/tools/install adresine gidin ve Rust kurulum yönergelerini izleyin. Kurulumun bir aşamasında sizden Visual Studio kurmanız istenecektir. Bu adım, programları derlemek için gereken bağlayıcıyı ve yerel kütüphaneleri sağlar. Bu adımda daha fazla yardıma ihtiyacınız olursa https://rust-lang.github.io/rustup/installation/windows-msvc.html adresine başvurabilirsiniz.

Bu kitabın geri kalanında hem cmd.exe hem de PowerShell üzerinde çalışan komutlar kullanılır. Belirli farklılıklar olduğunda hangisini kullanmanız gerektiğini açıklayacağız.

Sorun Giderme

Rust’ı doğru bir şekilde kurup kurmadığınızı kontrol etmek için bir terminal açın ve şu satırı girin:

$ rustc --version

Yayınlanmış en son kararlı sürüme ait sürüm numarasını, commit hash’ini ve commit tarihini şu biçimde görmelisiniz:

rustc x.y.z (abcabcabc yyyy-mm-dd)

Bu bilgiyi görüyorsanız Rust’ı başarıyla kurmuşsunuz demektir! Bu bilgiyi göremiyorsanız Rust’ın sisteminizin %PATH% ortam değişkeninde yer alıp almadığını aşağıdaki şekilde kontrol edin.

Windows CMD’de şunu kullanın:

> echo %PATH%

PowerShell’de şunu kullanın:

> echo $env:Path

Linux ve macOS’te şunu kullanın:

$ echo $PATH

Tüm bunlar doğru görünüyorsa ve Rust hâlâ çalışmıyorsa yardım alabileceğiniz pek çok yer vardır. Diğer Rustacean’larla (kendimize taktığımız esprili bir lakap) nasıl iletişime geçebileceğinizi topluluk sayfasında öğrenebilirsiniz.

Güncelleme ve Kaldırma

Rust’ı rustup aracılığıyla kurduktan sonra, yeni yayınlanan bir sürüme geçmek oldukça kolaydır. Terminalinizden şu güncelleme komutunu çalıştırın:

$ rustup update

Rust’ı ve rustup’ı sisteminizden kaldırmak içinse terminalinizden şu kaldırma komutunu çalıştırın:

$ rustup self uninstall

Yerel Belgeleri Okumak

Rust kurulumu, çevrim dışı okuyabilmeniz için belgelerin yerel bir kopyasını da içerir. Yerel belgeleri tarayıcınızda açmak için rustup doc komutunu çalıştırın.

Standart kütüphanenin sunduğu bir türün ya da fonksiyonun ne işe yaradığından veya nasıl kullanılacağından emin olmadığınız her an, bunu öğrenmek için uygulama programlama arayüzü (API) belgelerine başvurabilirsiniz!

Metin Düzenleyiciler ve IDE’leri Kullanmak

Bu kitap, Rust kodu yazmak için hangi araçları kullandığınız konusunda hiçbir varsayımda bulunmaz. Hemen hemen her metin düzenleyici işinizi görecektir! Bununla birlikte, pek çok metin düzenleyicinin ve tümleşik geliştirme ortamının (IDE) yerleşik Rust desteği vardır. Rust web sitesindeki araçlar sayfasında her zaman pek çok düzenleyici ve IDE’nin oldukça güncel bir listesini bulabilirsiniz.

Bu Kitapla Çevrim Dışı Çalışmak

Çeşitli örneklerde, standart kütüphanenin ötesindeki Rust paketlerini kullanacağız. Bu örnekler üzerinde çalışabilmek için ya internet bağlantınızın olması ya da söz konusu bağımlılıkları önceden indirmiş olmanız gerekir. Bağımlılıkları önceden indirmek için aşağıdaki komutları çalıştırabilirsiniz. (cargo’nun ne olduğunu ve bu komutların her birinin ne işe yaradığını ilerleyen bölümlerde ayrıntılı olarak açıklayacağız.)

$ cargo new get-dependencies
$ cd get-dependencies
$ cargo add rand@0.10.1 trpl@0.2.0

Bu işlem söz konusu paketleri indirip önbelleğe alır; böylece daha sonra tekrar indirmeniz gerekmez. İşlem tamamlandıktan sonra get-dependencies klasörünü saklamanıza gerek yoktur. Bağımlılıkları bu şekilde önceden indirdiyseniz ağa bağlanmaya çalışmak yerine önbelleğe alınmış sürümleri kullanmak için kitabın geri kalanındaki tüm cargo komutlarıyla birlikte --offline bayrağını kullanabilirsiniz.

Merhaba, Dünya!

Merhaba, Dünya!

Artık Rust’ı kurduğunuza göre ilk Rust programınızı yazmanın zamanı geldi. Yeni bir dil öğrenirken ekrana Merhaba, dünya! metnini yazdıran küçük bir program yazmak gelenektir; biz de burada aynısını yapacağız!

Proje Dizinini Ayarlamak

İşe Rust kodunuzu saklayacağınız bir dizin oluşturarak başlayacaksınız. Kodunuzun nerede durduğu Rust açısından fark etmez; ancak bu kitaptaki alıştırmalar ve projeler için ev dizininizde bir projects dizini oluşturmanızı ve tüm projelerinizi orada tutmanızı öneririz.

Bir terminal açın; projects dizinini ve onun içinde “Merhaba, dünya!” projesinin dizinini oluşturmak için aşağıdaki komutları girin.

Linux, macOS ve Windows’taki PowerShell için şunu girin:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir merhaba_dunya
$ cd merhaba_dunya

Windows CMD için şunu girin:

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir merhaba_dunya
> cd merhaba_dunya

Rust Programlamanın Temelleri

Ardından yeni bir kaynak dosya oluşturun ve adını main.rs koyun. Rust kaynak dosyaları her zaman .rs uzantısıyla biter. Dosya adınızda birden fazla kelime kullanıyorsanız kelimeleri ayırmak için alt çizgi (_) kullanmak yerleşik bir gelenektir. Örneğin merhabadunya.rs yerine merhaba_dunya.rs kullanın.

Şimdi yeni oluşturduğunuz main.rs dosyasını açın ve Liste 1-1’deki kodu girin.

fn main() {
    println!("Merhaba, dünya!");
}

Dosyayı kaydedin ve ~/projects/merhaba_dunya dizinindeki terminal pencerenize geri dönün. Linux veya macOS üzerinde dosyayı derlemek ve çalıştırmak için aşağıdaki komutları girin:

$ rustc main.rs
$ ./main
Merhaba, dünya!

Windows’ta ./main yerine .\main komutunu girin:

> rustc main.rs
> .\main
Merhaba, dünya!

İşletim sisteminiz ne olursa olsun terminale Merhaba, dünya! metni yazdırılmalıdır. Bu çıktıyı göremiyorsanız yardım alma yolları için Kurulum bölümündeki “Sorun Giderme” kısmına tekrar göz atın.

Eğer Merhaba, dünya! yazdırıldıysa tebrikler! Resmen bir Rust programı yazdınız. Bu sizi bir Rust programcısı yapar; aramıza hoş geldiniz!

Bir Rust Programının Anatomisi

Şimdi bu “Merhaba, dünya!” programını ayrıntılı olarak inceleyelim. İşte yapbozun ilk parçası:

fn main() {

}

Bu satırlar main adında bir fonksiyon tanımlar. main fonksiyonu özeldir: Çalıştırılabilir her Rust programında çalışan ilk kod her zaman budur. Buradaki ilk satır, hiçbir parametre almayan ve değer döndürmeyen main adında bir fonksiyon bildirir. Parametreleri olsaydı bunlar parantezlerin (()) içine yazılırdı.

Fonksiyon gövdesi {} içine alınmıştır. Rust, tüm fonksiyon gövdelerinin süslü parantez içine alınmasını zorunlu kılar. Açılış süslü parantezini fonksiyon bildirimiyle aynı satıra koymak ve araya bir boşluk bırakmak iyi bir kodlama stili kabul edilir.

main fonksiyonunun gövdesi şu kodu barındırır:

#![allow(unused)]
fn main() {
println!("Merhaba, dünya!");
}

Bu küçük programdaki tüm işi bu satır yapar: Ekrana metin yazdırır. Burada dikkat edilmesi gereken üç önemli ayrıntı vardır.

Birincisi, println! bir Rust makrosunu çağırır. Bunun yerine bir fonksiyon çağırsaydı println şeklinde (! olmadan) yazılırdı. Rust makroları, Rust sözdizimini genişletmek amacıyla kod üreten kodlar yazmanın bir yoludur; makroları Bölüm 20’de daha ayrıntılı ele alacağız. Şimdilik ! kullanımının normal bir fonksiyon yerine bir makro çağırdığınız anlamına geldiğini ve makroların her zaman fonksiyonlarla aynı kurallara uymadığını bilmeniz yeterlidir.

İkincisi, "Merhaba, dünya!" metnini (string) görüyorsunuz. Bu metni println! makrosuna argüman olarak iletiyoruz ve metin ekrana yazdırılıyor.

Üçüncüsü, bu ifadenin sona erdiğini ve bir sonrakinin başlamaya hazır olduğunu belirten noktalı virgül (;) ile satırı sonlandırıyoruz. Rust kod satırlarının çoğu noktalı virgülle biter.

Derleme ve Çalıştırma

Az önce yeni oluşturduğunuz bir programı çalıştırdınız; şimdi bu süreçteki her bir adımı inceleyelim.

Bir Rust programını çalıştırmadan önce, rustc komutuna kaynak dosyanızın adını vererek onu Rust derleyicisiyle derlemeniz gerekir:

$ rustc main.rs

C veya C++ geçmişiniz varsa bunun gcc ya da clang kullanımına benzediğini fark edeceksiniz. Derleme başarıyla tamamlandığında Rust, çalıştırılabilir bir ikili dosya (binary executable) üretir.

Linux, macOS ve Windows’taki PowerShell’de, komut kabuğunuza ls komutunu girerek çalıştırılabilir dosyayı görebilirsiniz:

$ ls
main  main.rs

Linux ve macOS’te iki dosya görürsünüz. Windows’ta PowerShell kullandığınızda ise CMD’dekiyle aynı üç dosyayı görürsünüz. Windows CMD’de şu komutu girebilirsiniz:

> dir /B %= /B seçeneği yalnızca dosya adlarını gösterir =%
main.exe
main.pdb
main.rs

Bu çıktı; .rs uzantılı kaynak kod dosyasını, çalıştırılabilir dosyayı (Windows’ta main.exe, diğer tüm platformlarda main) ve Windows kullanıyorsanız hata ayıklama bilgilerini içeren .pdb uzantılı dosyayı gösterir. Buradan main veya main.exe dosyasını şu şekilde çalıştırabilirsiniz:

$ ./main # veya Windows'ta .\main

Eğer main.rs dosyanız “Merhaba, dünya!” programınızsa bu satır terminalinize Merhaba, dünya! yazdırır.

Ruby, Python veya JavaScript gibi dinamik bir dile daha aşinaysanız bir programı derleme ve çalıştırma işlemlerini ayrı adımlar hâlinde yapmaya alışkın olmayabilirsiniz. Rust, önceden derlenen (ahead-of-time compiled / AOT) bir dildir; yani bir programı derleyip ürettiğiniz çalıştırılabilir dosyayı başka birine verebilirsiniz ve o kişi bilgisayarında Rust kurulu olmasa bile programı çalıştırabilir. Birine bir .rb, .py veya .js dosyası verirseniz karşı tarafın bilgisayarında sırasıyla bir Ruby, Python veya JavaScript dil uygulamasının (yorumlayıcısının veya çalışma ortamının) kurulu olması gerekir. Buna karşılık o dillerde programınızı derleyip çalıştırmak için tek bir komut yeterlidir. Dil tasarımında her karar bir ödünleşimdir.

Basit programlar için doğrudan rustc ile derleme yapmak yeterlidir; ancak projeniz büyüdükçe tüm derleme seçeneklerini yönetmek ve kodunuzu paylaşmayı kolaylaştırmak isteyeceksiniz. Bir sonraki bölümde, gerçek dünya Rust programları yazmanıza yardımcı olacak Cargo aracını tanıtacağız.

Merhaba, Cargo!

Merhaba, Cargo!

Cargo, Rust’ın derleme sistemi ve paket yöneticisidir. Rust geliştiricilerinin (Rustacean’ların) büyük çoğunluğu projelerini yönetmek için bu aracı kullanır; çünkü Cargo kodunuzu derlemek, kodunuzun ihtiyaç duyduğu kütüphaneleri indirmek ve bu kütüphaneleri derlemek gibi pek çok işi sizin yerinize üstlenir. (Kodunuzun ihtiyaç duyduğu bu kütüphanelere bağımlılıklar (dependencies) adını veriyoruz.)

Şimdiye kadar yazdığımız türden en basit Rust programlarının herhangi bir bağımlılığı yoktur. “Merhaba, dünya!” projesini Cargo ile oluşturmuş olsaydık, Cargo’nun yalnızca kod derleme özelliğinden yararlanırdık. Daha karmaşık Rust programları yazdıkça projelerinize bağımlılıklar ekleyeceksiniz; projeye baştan Cargo ile başlarsanız sonradan bağımlılık eklemek çok daha kolay olacaktır.

Rust projelerinin büyük çoğunluğu Cargo kullandığından, kitabın geri kalanında sizin de Cargo kullandığınız varsayılmaktadır. “Kurulum” bölümünde anlatılan resmî yükleyicileri kullandıysanız Cargo, Rust ile birlikte kurulu gelir. Rust’ı başka bir yöntemle kurduysanız terminalinize aşağıdaki komutu girerek Cargo’nun kurulu olup olmadığını kontrol edin:

$ cargo --version

Bir sürüm numarası görüyorsanız Cargo kuruludur! command not found (komut bulunamadı) gibi bir hata alırsanız Cargo’yu ayrıca nasıl kuracağınızı öğrenmek için kullandığınız kurulum yönteminin belgelerine bakın.

Cargo ile Proje Oluşturmak

Şimdi Cargo kullanarak yeni bir proje oluşturalım ve orijinal “Merhaba, dünya!” projemizden ne gibi farkları olduğuna bakalım. projects dizininize (veya kodlarınızı saklamaya karar verdiğiniz dizine) geri dönün. Ardından, hangi işletim sistemini kullanırsanız kullanın şu komutları çalıştırın:

$ cargo new merhaba_cargo
$ cd merhaba_cargo

İlk komut, merhaba_cargo adında yeni bir dizin ve proje oluşturur. Projemize merhaba_cargo adını verdiğimiz için Cargo, proje dosyalarını aynı adlı bir dizinin içinde oluşturur.

merhaba_cargo dizinine girip dosyaları listeleyin. Cargo’nun bizim için iki dosya ve bir dizin oluşturduğunu göreceksiniz: bir Cargo.toml dosyası ve içinde main.rs dosyası bulunan bir src dizini.

Cargo ayrıca bir .gitignore dosyasıyla birlikte yeni bir Git deposu da başlatmıştır. cargo new komutunu hâlihazırda var olan bir Git deposunun içinde çalıştırırsanız Git dosyaları oluşturulmaz; bu davranışı cargo new --vcs=git komutuyla geçersiz kılabilirsiniz.

Cargo.toml dosyasını tercih ettiğiniz metin düzenleyicide açın. İçeriği Liste 1-2’deki koda benzer görünmelidir.

[package]
name = "merhaba_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]

Bu dosya, Cargo’nun yapılandırma biçimi olan TOML (Tom’s Obvious, Minimal Language) biçimindedir.

İlk satırdaki [package], izleyen deyimlerin bir paketi yapılandırdığını belirten bir bölüm başlığıdır. Bu dosyaya daha fazla bilgi ekledikçe başka bölümler de ekleyeceğiz.

Sonraki üç satır, Cargo’nun programınızı derlemek için ihtiyaç duyduğu yapılandırma bilgilerini belirler: paket adı, paket sürümü ve kullanılacak Rust sürümü (edition). edition anahtarını Ek E bölümünde ayrıntılı olarak ele alacağız.

Son satırdaki [dependencies], projenizin bağımlılıklarını listeleyeceğiniz bölümün başlangıcıdır. Rust’ta kod paketlerine crate adı verilir. Bu projede başka bir crate’e ihtiyacımız olmayacak; ancak Bölüm 2’deki ilk projemizde harici bir crate kullanacağımız için bu bağımlılıklar bölümünden yararlanacağız.

Şimdi src/main.rs dosyasını açın ve bir göz atın:

Dosya adı: src/main.rs

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

Cargo, tıpkı Liste 1-1’de yazdığımız programa karşılık gelen bir “Hello, world!” başlangıç programı oluşturdu! Şu ana kadar önceki projemiz ile Cargo’nun oluşturduğu proje arasındaki farklar; Cargo’nun kaynak kodu src dizinine yerleştirmesi ve en üst dizinde bir Cargo.toml yapılandırma dosyasının bulunmasıdır.

Cargo, kaynak dosyalarınızın src dizini içinde bulunmasını bekler. En üst düzey proje dizini yalnızca README dosyaları, lisans bilgileri, yapılandırma dosyaları ve doğrudan kaynak kodunuzla ilgili olmayan diğer dosyalar içindir. Cargo kullanmak projelerinizi düzenli tutmanıza yardımcı olur: Her şeyin bir yeri vardır ve her şey yerli yerindedir.

“Merhaba, dünya!” projesinde yaptığımız gibi Cargo kullanmadan başladığınız bir projeyi sonradan Cargo projesine dönüştürebilirsiniz. Bunun için proje kodunu src dizinine taşıyıp uygun bir Cargo.toml dosyası oluşturmanız yeterlidir. Cargo.toml dosyasını oluşturmanın kolay bir yolu da mevcut dizinde cargo init komutunu çalıştırmaktır; bu komut dosyayı sizin için otomatik olarak üretir.

Bir Cargo Projesini Derlemek ve Çalıştırmak

Şimdi “Hello, world!” programını Cargo ile derleyip çalıştırdığımızda nelerin değiştiğine bakalım! merhaba_cargo dizininizdeyken aşağıdaki komutu girerek projenizi derleyin:

$ cargo build
   Compiling merhaba_cargo v0.1.0 (file:///projects/merhaba_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

Bu komut, çalıştırılabilir dosyayı bulunduğunuz dizin yerine target/debug/merhaba_cargo (veya Windows’ta target\debug\merhaba_cargo.exe) konumunda oluşturur. Varsayılan derleme bir hata ayıklama (debug) derlemesi olduğundan Cargo, ikili dosyayı debug adlı bir dizinin içine koyar. Çalıştırılabilir dosyayı şu komutla çalıştırabilirsiniz:

$ ./target/debug/merhaba_cargo # veya Windows'ta .\target\debug\merhaba_cargo.exe
Hello, world!

Her şey yolunda giderse terminale Hello, world! yazdırılmalıdır. cargo build komutunu ilk kez çalıştırmak, Cargo’nun en üst dizinde yeni bir dosya daha oluşturmasını sağlar: Cargo.lock. Bu dosya, projenizdeki bağımlılıkların tam sürümlerini kayıt altında tutar. Bu projenin henüz bağımlılığı olmadığından dosyanın içeriği oldukça kısadır. Bu dosyayı hiçbir zaman elle değiştirmenize gerek kalmaz; Cargo içeriğini sizin yerinize otomatik olarak yönetir.

Az önce projemizi cargo build ile derledik ve ./target/debug/merhaba_cargo ile çalıştırdık; ancak kodu derleyip üretilen çalıştırılabilir dosyayı tek bir komutla çalıştırmak için cargo run komutunu da kullanabiliriz:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/merhaba_cargo`
Hello, world!

cargo run kullanmak, önce cargo build komutunu çalıştırmayı ve ardından ikili dosyanın tam yolunu yazmayı hatırlamaktan çok daha pratiktir; bu nedenle geliştiricilerin çoğu cargo run komutunu tercih eder.

Dikkat ederseniz bu kez Cargo’nun merhaba_cargo paketini derlediğini belirten bir çıktı görmedik. Cargo kaynak dosyaların değişmediğini fark etti ve projeyi yeniden derlemek yerine doğrudan mevcut ikili dosyayı çalıştırdı. Kaynak kodunuzda değişiklik yapmış olsaydınız Cargo çalıştırmadan önce projeyi yeniden derlerdi ve şu çıktıyı görürdünüz:

$ cargo run
   Compiling merhaba_cargo v0.1.0 (file:///projects/merhaba_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
     Running `target/debug/merhaba_cargo`
Hello, world!

Cargo ayrıca cargo check adında bir komut da sunar. Bu komut, kodunuzun sorunsuz derlenip derlenmediğini hızla denetler ancak çalıştırılabilir bir dosya üretmez:

$ cargo check
   Checking merhaba_cargo v0.1.0 (file:///projects/merhaba_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

Neden çalıştırılabilir bir dosya üretilmemesini isteyesiniz? Çoğu zaman cargo check, çalıştırılabilir ikili dosya üretme adımını atladığı için cargo build komutundan çok daha hızlıdır. Kod yazarken çalışmanızı sık sık kontrol ediyorsanız cargo check kullanmak, projenizin hâlâ derlenip derlenmediğini çok daha kısa sürede öğrenmenizi sağlar! Bu nedenle pek çok Rust geliştiricisi program yazarken kodun derlendiğinden emin olmak için düzenli aralıklarla cargo check çalıştırır; çalıştırılabilir dosyayı gerçekten kullanmaya hazır olduklarında ise cargo build (veya cargo run) komutuna başvurur.

Cargo hakkında şimdiye kadar öğrendiklerimizi özetleyelim:

• cargo new komutuyla yeni bir proje oluşturabiliriz.
• cargo build komutuyla bir projeyi derleyebiliriz.
• cargo run komutuyla bir projeyi tek adımda derleyip çalıştırabiliriz.
• cargo check komutuyla ikili dosya üretmeden projedeki hataları denetleyebiliriz.
• Cargo, derleme çıktısını kaynak kodumuzla aynı dizine kaydetmek yerine target/debug dizininde saklar.

Cargo kullanmanın bir diğer avantajı da hangi işletim sisteminde çalışırsanız çalışın komutların tamamen aynı olmasıdır. Dolayısıyla bu noktadan itibaren Linux ve macOS ile Windows için ayrı komut talimatları vermeyeceğiz.

Yayın İçin Derlemek

Projeniz nihayet yayınlanmaya hazır olduğunda, optimizasyonlarla derlemek için cargo build --release komutunu kullanabilirsiniz. Bu komut, çalıştırılabilir dosyayı target/debug yerine target/release dizininde oluşturur. Optimizasyonlar Rust kodunuzun çok daha hızlı çalışmasını sağlar; ancak bu optimizasyonları uygulamak programınızın derlenme süresini uzatır. İki farklı derleme profilinin bulunmasının nedeni tam olarak budur: Biri hızlı ve sık yeniden derleme yapmak istediğiniz geliştirme süreci içindir; diğeri ise kullanıcıya teslim edeceğiniz, tekrar tekrar derlenmeyecek ve mümkün olduğunca hızlı çalışması gereken nihai programı üretmek içindir. Kodunuzun çalışma süresini ölçüyorsanız (benchmarking), derlemeyi mutlaka cargo build --release komutuyla yaptığınızdan ve ölçümleri target/release dizinindeki çalıştırılabilir dosyayla gerçekleştirdiğinizden emin olun.

Cargo Geleneklerinden Yararlanmak

Çok basit projelerde Cargo, doğrudan rustc kullanmaya kıyasla büyük bir fark yaratmıyor gibi görünebilir; ancak programlarınız karmaşıklaştıkça değerini kanıtlayacaktır. Programlar birden fazla dosyaya yayıldığında veya bir bağımlılığa ihtiyaç duyduğunda, derleme sürecini Cargo’nun koordine etmesine izin vermek işinizi çok kolaylaştırır.

merhaba_cargo projesi her ne kadar basit olsa da Rust kariyerinizin geri kalanında başvuracağınız gerçek araç takımının büyük bir kısmını şimdiden kullanıyor. Nitekim mevcut herhangi bir Rust projesi üzerinde çalışmak için Git ile kodu indirip proje dizinine geçmek ve derlemek üzere şu komutları kullanmanız yeterlidir:

$ git clone example.org/bir_proje
$ cd bir_proje
$ cargo build

Cargo hakkında daha fazla bilgi edinmek için Cargo belgelerine göz atabilirsiniz.

Özet

Rust yolculuğunuza şimdiden harika bir başlangıç yaptınız! Bu bölümde şunları öğrendiniz:

• rustup kullanarak Rust’ın en son kararlı sürümünü kurmayı,
• Daha yeni bir Rust sürümüne güncellemeyi,
• Yerel olarak kurulmuş belgeleri açmayı,
• Doğrudan rustc kullanarak bir “Merhaba, dünya!” programı yazıp çalıştırmayı,
• Cargo’nun standart düzenini kullanarak yeni bir proje oluşturup çalıştırmayı.

Artık Rust kodu okumaya ve yazmaya alışmak için daha kapsamlı bir program geliştirmenin tam zamanı! Bu doğrultuda Bölüm 2’de bir sayı tahmin oyunu geliştireceğiz. Öncelikle yaygın programlama kavramlarının Rust’ta nasıl çalıştığını öğrenerek başlamayı tercih ederseniz doğrudan Bölüm 3’e geçebilir ve ardından Bölüm 2’ye dönebilirsiniz.

Bir Tahmin Oyunu Programlama

Birlikte uygulamalı bir proje üzerinde çalışarak Rust’a hızlı bir giriş yapalım! Bu bölüm, yaygın kullanılan bazı Rust kavramlarını gerçek bir program içinde nasıl kullanacağınızı göstererek tanıtır. let, match, metotlar, ilişkili fonksiyonlar (associated functions), harici crate’ler ve daha pek çok kavramla tanışacaksınız! İlerleyen bölümlerde bu konuları tüm ayrıntılarıyla inceleyeceğiz; bu bölümde ise yalnızca temellerin pratiğini yapacağız.

Klasik bir başlangıç programlama problemini uygulayacağız: bir sayı tahmin oyunu. Oyun şöyle çalışacak: Program 1 ile 100 arasında rastgele bir tam sayı üretecek ve ardından oyuncudan bir tahmin girmesini isteyecek. Oyuncu tahminini girdikten sonra program, bu tahminin çok düşük mü yoksa çok yüksek mi olduğunu belirtecek. Tahmin doğruysa oyun bir tebrik mesajı yazdırıp sonlanacak.

Yeni Bir Proje Kurulumu

Yeni bir proje kurmak için Bölüm 1’de oluşturduğunuz projects dizinine gidin ve Cargo kullanarak aşağıdaki gibi yeni bir proje oluşturun:

$ cargo new tahmin_oyunu
$ cd tahmin_oyunu

İlk komut olan cargo new, projenin adını (tahmin_oyunu) ilk argüman olarak alır. İkinci komut ise çalışma dizinini yeni oluşturulan projenin dizinine geçirir.

Oluşturulan Cargo.toml dosyasına göz atalım:

Dosya adı: Cargo.toml

[package]
name = "tahmin_oyunu"
version = "0.1.0"
edition = "2024"

[dependencies]

Bölüm 1’de gördüğünüz gibi cargo new sizin için bir “Merhaba, dünya!” başlangıç programı üretir (varsayılan şablon "Hello, world!" yazdırır; burada Türkçe karşılığıyla gösterilmiştir). src/main.rs dosyasına göz atın:

Dosya adı: src/main.rs

fn main() {
    println!("Merhaba, dünya!");
}

Şimdi bu “Merhaba, dünya!” programını cargo run komutuyla tek adımda derleyip çalıştıralım:

$ cargo run
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.10s
     Running `target/debug/tahmin_oyunu`
Merhaba, dünya!

run komutu, bu oyunda da yapacağımız gibi bir proje üzerinde hızlı adımlarla geliştirme yapmanız ve bir sonraki aşamaya geçmeden önce her adımı çabucak test etmeniz gerektiğinde çok işinize yarar.

src/main.rs dosyasını yeniden açın. Tüm kodu bu dosyaya yazacaksınız.

Bir Tahmini İşlemek

Tahmin oyunu programının ilk kısmı kullanıcıdan girdi isteyecek, bu girdiyi işleyecek ve girdinin beklenen biçimde olup olmadığını kontrol edecektir. Başlangıç olarak oyuncunun bir tahmin girmesini sağlayalım. Liste 2-1’deki kodu src/main.rs dosyasına yazın.

use std::io;

fn main() {
    println!("Sayıyı tahmin et!");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

Bu kod pek çok bilgi içeriyor; gelin satır satır üzerinden geçelim. Kullanıcıdan girdi almak ve ardından sonucu çıktı olarak yazdırmak için girdi/çıktı kütüphanesi olan io modülünü kapsama dahil etmemiz gerekir. io kütüphanesi, std olarak bilinen standart kütüphaneden gelir:

use std::io;

fn main() {
    println!("Sayıyı tahmin et!");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

Rust, varsayılan olarak standart kütüphanede tanımlanmış belirli bir öğe kümesini her programın kapsamına otomatik olarak dahil eder. Bu kümeye prelude (ön tanımlı kapsam) adı verilir ve içindeki her şeyi standart kütüphane belgelerinde görebilirsiniz.

Kullanmak istediğiniz bir tür prelude içinde yer almıyorsa o türü bir use deyimiyle açıkça kapsama dahil etmeniz gerekir. std::io kütüphanesini kullanmak, kullanıcı girdisini kabul etme olanağı da dahil olmak üzere pek çok yararlı özellik sunar.

Bölüm 1’de gördüğünüz gibi main fonksiyonu programın giriş noktasıdır:

use std::io;

fn main() {
    println!("Sayıyı tahmin et!");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

fn sözdizimi yeni bir fonksiyon bildirir; () parantezleri parametre bulunmadığını gösterir; { süslü parantezi ise fonksiyonun gövdesini başlatır.

Yine Bölüm 1’de öğrendiğiniz gibi println!, ekrana bir metin yazdıran bir makrodur:

use std::io;

fn main() {
    println!("Sayıyı tahmin et!");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

Bu kod, oyunun ne olduğunu belirten bir karşılama metni yazdırır ve kullanıcıdan girdi ister.

Değerleri Değişkenlerle Saklamak

Sırada, kullanıcı girdisini saklamak üzere aşağıdaki gibi bir değişken oluşturmak var:

use std::io;

fn main() {
    println!("Sayıyı tahmin et!");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

Şimdi program ilginçleşmeye başlıyor! Bu kısacık satırda pek çok şey gerçekleşiyor. Bir değişken oluşturmak için let deyimini kullanırız. İşte başka bir örnek:

let elmalar = 5;

Bu satır elmalar adında yeni bir değişken oluşturur ve onu 5 değerine bağlar (bind). Rust’ta değişkenler varsayılan olarak değiştirilemezdir (immutable); yani değişkene bir kez değer verdiğimizde bu değer bir daha değişmez. Bu kavramı Bölüm 3’teki “Değişkenler ve Değiştirilebilirlik” kısmında ayrıntılı olarak inceleyeceğiz. Bir değişkeni değiştirilebilir (mutable) yapmak için değişken adından önce mut anahtar kelimesini ekleriz:

let elmalar = 5; // değiştirilemez
let mut muzlar = 5; // değiştirilebilir

Tahmin oyunu programına dönecek olursak artık let mut tahmin kısmının tahmin adında değiştirilebilir bir değişken tanımlayacağını biliyorsunuz. Eşittir işareti (=), Rust’a değişkene şimdi bir değer bağlamak istediğimizi söyler. Eşittir işaretinin sağında tahmin değişkeninin bağlandığı değer yer alır; bu değer, yeni bir String örneği döndüren String::new fonksiyonunun çağrılmasıyla elde edilir. String, standart kütüphane tarafından sağlanan, büyüyebilen ve UTF-8 kodlamalı bir metin türüdür.

::new yazımındaki :: sözdizimi, new fonksiyonunun String türüne ait bir ilişkili fonksiyon olduğunu gösterir. Bir ilişkili fonksiyon, belirli bir tür (bu örnekte String) üzerinde tanımlanmış fonksiyondur. Bu new fonksiyonu yeni ve boş bir string oluşturur. Pek çok tür üzerinde bir new fonksiyonuyla karşılaşırsınız; çünkü new, herhangi bir türden yeni bir değer üreten fonksiyonlar için yaygın bir isimdir.

Özetle let mut tahmin = String::new(); satırı, şu an yeni ve boş bir String örneğine bağlı olan değiştirilebilir bir değişken oluşturmuştur. Vay canına!

Kullanıcı Girdisini Almak

Programın ilk satırında standart kütüphanedeki girdi/çıktı işlevselliğini use std::io; ile dahil ettiğimizi hatırlayın. Şimdi kullanıcı girdisini işleyebilmek için io modülündeki stdin fonksiyonunu çağıracağız:

use std::io;

fn main() {
    println!("Sayıyı tahmin et!");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

Programın başında use std::io; ile io modülünü kapsama dahil etmemiş olsaydık bile, bu fonksiyon çağrısını std::io::stdin şeklinde açıkça yazarak yine kullanabilirdik. stdin fonksiyonu, terminalinizin standart girdisine ait bir tutamacı (handle) temsil eden std::io::Stdin türünden bir örnek döndürür.

Ardından gelen .read_line(&mut tahmin) satırı, kullanıcıdan girdi almak üzere standart girdi tutamacı üzerinde read_line metodunu çağırır. Kullanıcı girdisini hangi string içine kaydedeceğini belirtmek için read_line metoduna argüman olarak &mut tahmin değerini geçiriyoruz. read_line metodunun görevi, kullanıcının standart girdiye yazdığı metni alıp mevcut içeriğin üzerine yazmadan verilen string’in sonuna eklemektir; bu nedenle hedef string’i argüman olarak iletiriz. Metodun string içeriğini değiştirebilmesi için bu argümanın değiştirilebilir olması gerekir.

& işareti bu argümanın bir referans (reference) olduğunu belirtir. Referanslar, veriyi bellekte defalarca kopyalamaya gerek kalmadan kodunuzun farklı bölümlerinin aynı veriye erişmesine olanak tanır. Referanslar karmaşık bir özelliktir ve Rust’ın en büyük güçlü yönlerinden biri referansları hem son derece güvenli hem de kullanımı kolay biçimde sunmasıdır. Bu programı tamamlamak için tüm bu ayrıntıları şimdiden bilmenize gerek yok. Şimdilik bilmeniz gereken tek şey, tıpkı değişkenler gibi referansların da varsayılan olarak değiştirilemez olduğudur. Dolayısıyla referansı değiştirilebilir kılmak için &tahmin yerine &mut tahmin yazmanız gerekir. (Bölüm 4 referansları çok daha kapsamlı biçimde açıklayacaktır.)

Potansiyel Bir Hatayı Result ile Ele Almak

Hâlâ aynı kod satırı üzerinde çalışıyoruz. Metin olarak üçüncü satırı inceliyor olsak da bunun hâlâ tek bir mantıksal kod satırının parçası olduğuna dikkat edin. Sıradaki kısım şu metot çağrısıdır:

use std::io;

fn main() {
    println!("Sayıyı tahmin et!");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

Bu kodu tek satırda şu şekilde de yazabilirdik:

io::stdin().read_line(&mut tahmin).expect("Satır okunamadı");

Ancak tek bir uzun satırı okumak zordur; bu yüzden onu bölmek en doğrusudur. .metot_adi() sözdizimiyle zincirleme metot çağrıları yaparken uzun satırları yeni satır ve girintilerle ayırmak okunabilirliği büyük ölçüde artırır. Şimdi bu satırın ne işe yaradığına bakalım.

Daha önce belirttiğimiz gibi read_line, kullanıcının yazdığı metni kendisine geçirdiğimiz string içine ekler; ancak bunun yanı sıra bir Result değeri de döndürür. Result, genellikle kısaca enum olarak adlandırılan bir numaralandırma (enumeration) türüdür; yani birden fazla olası durumdan birinde bulunabilen bir türdür. Bu olası durumların her birine varyant (variant) adını veririz.

Bölüm 6 enum’ları çok daha ayrıntılı biçimde ele alacaktır. Result türlerinin amacı, hata yönetimine ilişkin bilgiyi taşımaktır.

Result türünün varyantları Ok ve Err’dir. Ok varyantı işlemin başarılı olduğunu belirtir ve başarıyla üretilen değeri içinde taşır. Err varyantı ise işlemin başarısız olduğu anlamına gelir ve işlemin nasıl ya da neden başarısız olduğuna dair bilgiyi barındırır.

Diğer türlerdeki değerler gibi Result türündeki değerlerin de üzerlerinde tanımlanmış metotları vardır. Bir Result örneği, çağırabileceğiniz bir expect metoduna sahiptir. Eğer bu Result örneği bir Err değeriyse expect programın çökmesine (panic) neden olur ve expect’e argüman olarak verdiğiniz mesajı ekrana yazdırır. read_line metodunun bir Err döndürmesi büyük olasılıkla altta yatan işletim sisteminden kaynaklanan bir girdi/çıktı hatasının sonucu olacaktır. Öte yandan bu Result örneği bir Ok değeriyse expect metodu Ok içinde tutulan dönüş değerini çıkarır ve doğrudan kullanabilmeniz için size döndürür. Bu örnekte söz konusu değer, kullanıcının girdisindeki bayt sayısıdır (UTF-8 kodlamasında her bir ASCII karakteri 1 bayt, 'ç', 'ğ', 'ı', 'ö', 'ş', 'ü' gibi Türkçe harfler ise ikişer bayt yer kaplar).

Eğer expect metodunu çağırmazsanız program yine derlenir, ancak derleyiciden bir uyarı alırsınız:

$ cargo build
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
warning: unused `Result` that must be used
  --> src/main.rs:10:5
   |
10 |     io::stdin().read_line(&mut tahmin);
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
   |
10 |     let _ = io::stdin().read_line(&mut tahmin);
   |     +++++++

warning: `tahmin_oyunu` (bin "tahmin_oyunu") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.18s

Rust derleyicisi, read_line çağrısından dönen Result değerini kullanmadığınız konusunda (unused Result that must be used) sizi uyarır; bu uyarı programın olası bir hatayı henüz ele almadığına işaret eder.

Bu uyarıyı gidermenin doğru yolu gerçek bir hata yönetimi kodu yazmaktır; ancak şu anki aşamada bir sorun oluştuğunda programın doğrudan durmasını istediğimizden expect kullanabiliriz. Hatalardan kurtularak çalışmaya devam etmeyi Bölüm 9’da öğreneceksiniz.

println! Yer Tutucuları ile Değerleri Yazdırmak

Kapanış süslü parantezini saymazsak şu ana kadarki kodda inceleyeceğimiz yalnızca bir satır kaldı:

use std::io;

fn main() {
    println!("Sayıyı tahmin et!");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

Bu satır, artık kullanıcının girdisini barındıran string’i ekrana yazdırır. {} süslü parantez çifti bir yer tutucudur (placeholder): {} işaretini, bir değeri yerinde tutan küçük yengeç kıskaçları gibi düşünebilirsiniz. Bir değişkenin değerini yazdırırken değişken adını doğrudan süslü parantezlerin içine yazabilirsiniz. Bir ifadenin (expression) hesaplanan sonucunu yazdırırken ise biçimlendirme metnine boş {} süslü parantezler yerleştirir, ardından biçimlendirme metninden sonra virgülle ayrılmış ifadeleri sırasıyla verirsiniz; Rust bu ifadelerin sonuçlarını boş yer tutuculara aynı sırayla yerleştirir. Tek bir println! çağrısında hem bir değişkeni hem de bir ifadenin sonucunu yazdırmak şöyle görünür:

#![allow(unused)]
fn main() {
let x = 5;
let y = 10;

println!("x = {x} ve y + 2 = {}", y + 2);
}

Bu kod ekrana x = 5 ve y + 2 = 12 yazdıracaktır.

İlk Kısmı Test Etmek

Tahmin oyununun ilk bölümünü test edelim. cargo run komutuyla programı çalıştırın:

$ cargo run
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 6.44s
     Running `target/debug/tahmin_oyunu`
Sayıyı tahmin et!
Lütfen tahmininizi girin.
6
Tahmininiz: 6

Bu noktada oyunun ilk kısmı tamamlandı: Klavyeden girdi alıyor ve bu girdiyi ekrana yazdırabiliyoruz.

Gizli Bir Sayı Üretmek

Sırada, kullanıcının tahmin etmeye çalışacağı gizli bir sayı üretmek var. Oyunun tekrar tekrar oynanmasının keyifli olması için gizli sayı her seferinde farklı olmalıdır. Oyunun çok zor olmaması adına 1 ile 100 arasında rastgele bir sayı kullanacağız. Rust, standart kütüphanesinde henüz rastgele sayı üretme işlevselliği barındırmaz. Bununla birlikte Rust ekibi, bu işlevselliği sunan rand crate’ini sağlamaktadır.

Bir Crate ile İşlevselliği Artırmak

Bir crate’in, Rust kaynak kodu dosyalarından oluşan bir bütün olduğunu hatırlayın. Şimdiye kadar geliştirdiğimiz proje, çalıştırılabilir bir dosya üreten bir ikili crate’tir (binary crate). rand crate’i ise başka programlarda kullanılmak üzere tasarlanmış kodlar içeren ve tek başına çalıştırılamayan bir kütüphane crate’idir (library crate).

Harici crate’lerin yönetimi, Cargo’nun gerçekten parladığı alandır. rand kullanan kodu yazmadan önce Cargo.toml dosyasını düzenleyip rand crate’ini bir bağımlılık (dependency) olarak eklememiz gerekir. Şimdi Cargo.toml dosyasını açın ve Cargo’nun sizin için oluşturduğu [dependencies] bölüm başlığının altına aşağıdaki satırı ekleyin. rand paketini burada verdiğimiz sürüm numarasıyla birebir aynı şekilde belirttiğinizden emin olun; aksi takdirde bu bölümdeki kod örnekleri çalışmayabilir:

Dosya adı: Cargo.toml

[dependencies]
rand = "0.10.1"

Cargo.toml dosyasında bir başlıktan sonra gelen her satır, yeni bir bölüm başlayana kadar o bölümün parçası kabul edilir. [dependencies] bölümünde Cargo’ya, projenizin hangi harici crate’lere bağımlı olduğunu ve bu crate’lerin hangi sürümlerine ihtiyaç duyduğunuzu bildirirsiniz. Bu örnekte rand crate’ini semantik sürüm belirteci 0.10.1 ile belirtiyoruz. Cargo, sürüm numaralarını yazmaya yönelik bir standart olan Semantik Sürümlemeyi (kısaca SemVer) anlar. 0.10.1 belirteci aslında ^0.10.1 ifadesinin kısaltmasıdır; bu da en az 0.10.1 olan ancak 0.11.0’ın altında kalan her sürümün kullanılabileceği anlamına gelir.

Cargo bu aralıktaki sürümlerin 0.10.1 sürümüyle uyumlu genel API’lere sahip olduğunu kabul eder; bu tanım sayesinde bu bölümdeki kodla sorunsuz derlenmeye devam edecek en güncel yama sürümünü (patch release) almanız sağlanır. 0.11.0 veya üzerindeki sürümlerin ise aşağıdaki örneklerin kullandığı API ile aynı kalacağı garanti edilmez.

Şimdi kodda hiçbir değişiklik yapmadan Liste 2-2’de gösterildiği gibi projeyi derleyelim.

$ cargo build
    Updating crates.io index
     Locking 8 packages to latest Rust 1.96.0 compatible versions
  Downloaded rand_core v0.10.1
  Downloaded chacha20 v0.10.1
  Downloaded rand v0.10.1
  Downloaded 3 crates (162.9KiB) in 0.59s
   Compiling libc v0.2.186
   Compiling rand_core v0.10.1
   Compiling getrandom v0.4.3
   Compiling cfg-if v1.0.4
   Compiling chacha20 v0.10.1
   Compiling rand v0.10.1
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.03s

Kendi ekranınızda farklı sürüm numaraları (ancak SemVer sayesinde hepsi bu kodla uyumlu olacaktır!) ve işletim sisteminize bağlı olarak farklı satırlar görebilirsiniz; ayrıca bu satırların sırası da değişebilir.

Harici bir bağımlılık eklediğimizde Cargo, o bağımlılığın ihtiyaç duyduğu tüm paketlerin uyumlu en son sürümlerini Crates.io verilerinin bir kopyası olan kayıt dizininden (registry) çeker. Crates.io, Rust ekosistemindeki geliştiricilerin açık kaynaklı Rust projelerini başkalarının da kullanabilmesi için yayınladıkları merkezdir.

Cargo, kayıt dizinini güncelledikten sonra [dependencies] bölümünü kontrol eder ve listelenen ancak henüz bilgisayarınızda önbelleğe alınmamış tüm crate’leri indirir. Bu örnekte bağımlılık olarak yalnızca rand’i yazmış olsak da Cargo, rand’in çalışmak için ihtiyaç duyduğu alt crate’leri de (rand_core, chacha20, getrandom vb.) otomatik olarak temin eder. Crate’leri indirdikten sonra Rust önce bu bağımlılıkları, ardından da bağımlılıkları hazır hâle gelen projemizi derler.

Hiçbir değişiklik yapmadan hemen ardından cargo build komutunu tekrar çalıştırırsanız Finished satırı dışında hiçbir çıktı almazsınız. Cargo tüm bağımlılıkları zaten indirip derlediğini ve Cargo.toml dosyanızda bunlarla ilgili bir değişiklik yapmadığınızı bilir. Kendi kodunuzda da bir değişiklik olmadığını bildiğinden onu da yeniden derlemez; yapılacak iş kalmadığı için doğrudan sonlanır.

src/main.rs dosyasını açıp küçük bir değişiklik yapar, kaydeder ve tekrar derlerseniz yalnızca iki satırlık bir çıktı görürsünüz:

$ cargo build
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s

Bu satırlar, Cargo’nun derlemeyi yalnızca src/main.rs dosyasındaki ufak değişikliğiniz için güncellediğini gösterir. Bağımlılıklarınız değişmediğinden Cargo daha önce indirip derlediği çıktıları olduğu gibi yeniden kullanır.

Tekrarlanabilir Derlemeleri Sağlamak

Cargo, siz veya bir başkası kodunuzu her derlediğinde birebir aynı derleme çıktısını (artifact) yeniden üretebilmenizi sağlayan bir mekanizmaya sahiptir: Siz aksi yönde talimat verene kadar Cargo yalnızca kilitlediği bağımlılık sürümlerini kullanır. Örneğin gelecek hafta rand crate’inin 0.10.2 sürümünün çıktığını, bu sürümün önemli bir hata düzeltmesi içerdiğini ancak aynı zamanda kodunuzu bozacak bir gerileme (regression) barındırdığını varsayalım. Bu sorunu önlemek için Rust, cargo build komutunu ilk çalıştırdığınızda Cargo.lock dosyasını oluşturur; şu an tahmin_oyunu dizinimizde bu dosya mevcuttur.

Bir projeyi ilk kez derlediğinizde Cargo, ölçütlerinize uyan tüm bağımlılık sürümlerini hesaplar ve kesin sürüm numaralarını Cargo.lock dosyasına yazar. Projenizi ileride yeniden derlediğinizde Cargo Cargo.lock dosyasının var olduğunu görür ve sürümleri baştan çözmek yerine doğrudan bu dosyada kayıtlı sürümleri kullanır. Böylece otomatik olarak tekrarlanabilir bir derleme elde edersiniz. Başka bir deyişle, Cargo.lock dosyası sayesinde siz açıkça yükseltme yapana kadar projeniz 0.10.1 sürümünde kalacaktır. Cargo.lock dosyası tekrarlanabilir derlemeler açısından kritik öneme sahip olduğundan genellikle projenin geri kalan kaynak kodlarıyla birlikte sürüm kontrol sistemine (örneğin Git’e) dahil edilir.

Yeni Bir Sürüm Almak İçin Bir Crate’i Güncellemek

Bir crate’i gerçekten güncellemek istediğinizde Cargo bunun için update komutunu sunar. Bu komut mevcut Cargo.lock dosyasını yok sayar, Cargo.toml dosyasındaki sürüm kurallarınıza uyan en güncel sürümleri bulur ve bu yeni sürümleri Cargo.lock dosyasına yazar. Varsayılan olarak Cargo yalnızca 0.10.1’den büyük ve 0.11.0’dan küçük sürümleri arayacaktır. Örneğin rand crate’i 0.10.2 ve 0.999.0 olmak üzere iki yeni sürüm yayınlamış olsaydı, cargo update komutunu çalıştırdığınızda şu çıktıyı görürdünüz:

$ cargo update
    Updating crates.io index
     Locking 1 package to latest Rust 1.96.0 compatible version
    Updating rand v0.10.1 -> v0.10.2 (available: v0.999.0)

Cargo 0.999.0 sürümünü dikkate almaz. Bu noktada Cargo.lock dosyanızda da artık kullandığınız rand sürümünün 0.10.2 olarak güncellendiğini görürsünüz. rand’in 0.999.0 sürümünü veya 0.999.x serisindeki herhangi bir sürümü kullanmak isteseydiniz Cargo.toml dosyasını şu şekilde güncellemeniz gerekirdi (ancak bu değişikliği gerçekte yapmayın; çünkü aşağıdaki örnekler rand 0.10 serisini kullandığınızı varsaymaktadır):

[dependencies]
rand = "0.999.0"

Bir sonraki cargo build çalıştırışınızda Cargo, mevcut crate kayıt dizinini güncelleyecek ve rand gereksinimlerinizi belirttiğiniz yeni sürüme göre yeniden değerlendirecektir.

Cargo ve ekosistemi hakkında söylenecek çok daha fazla şey var; bunları Bölüm 14’te ele alacağız, ancak şimdilik bilmeniz gerekenler bu kadar. Cargo kütüphaneleri yeniden kullanmayı son derece kolaylaştırdığı için Rust geliştiricileri (Rustaceans), birden çok paketin bir araya getirilmesiyle oluşan daha küçük ve odaklanmış projeler yazabilirler.

Rastgele Bir Sayı Üretmek

Şimdi tahmin edilecek sayıyı üretmek için rand crate’ini kullanmaya başlayalım. Bir sonraki adım, src/main.rs dosyasını Liste 2-3’te gösterildiği gibi güncellemektir.

use std::io;

use rand::prelude::*;

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    println!("Gizli sayı: {gizli_sayi}");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

İlk olarak use rand::prelude::*; satırını ekliyoruz. prelude modülü, rand crate’inin en sık kullanılan öğelerini içerir; sondaki * işaretiyle birlikte bu use deyimi, modüldeki tüm öğeleri programımızın kapsamında doğrudan kullanılabilir hâle getirir.

Ardından ortaya iki yeni satır ekliyoruz. İlk satırda, kullanacağımız rastgele sayı üretecini bize veren rand::rng fonksiyonunu çağırıyoruz: Bu üreteç, çalışmakta olan mevcut thread’e (iş parçacığına) özeldir ve işletim sistemi tarafından tohumlanır (seeded). Sonrasında bu rastgele sayı üreteci üzerinde random_range metodunu çağırıyoruz. Bu metot, use rand::prelude::*; deyimiyle kapsama dahil ettiğimiz RngExt trait’i tarafından tanımlanmıştır. RngExt trait’i rastgele sayı üreteçlerinin uyguladığı metotları tanımlar ve bu metotları çağırabilmemiz için söz konusu trait’in kapsamda bulunması gerekir. Trait kavramını Bölüm 10’da ayrıntılı olarak inceleyeceğiz. random_range metodu argüman olarak bir aralık ifadesi (range expression) alır ve bu aralıkta rastgele bir sayı üretir. Burada kullandığımız aralık ifadesi baslangic..=bitis biçimindedir ve hem alt hem de üst sınırı aralığa dahil eder; dolayısıyla 1 ile 100 arasında bir sayı istemek için 1..=100 yazmamız gerekir.

Eklediğimiz ikinci satır gizli sayıyı ekrana yazdırır. Programı geliştirirken test edebilmek açısından bu oldukça faydalıdır, ancak son sürümde bu satırı sileceğiz. Program başlar başlamaz doğru cevabı söylerse pek de bir tahmin oyunu sayılmaz!

Programı birkaç kez çalıştırmayı deneyin:

$ cargo run
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/tahmin_oyunu`
Sayıyı tahmin et!
Gizli sayı: 7
Lütfen tahmininizi girin.
4
Tahmininiz: 4

$ cargo run
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/tahmin_oyunu`
Sayıyı tahmin et!
Gizli sayı: 83
Lütfen tahmininizi girin.
5
Tahmininiz: 5

Her çalıştırmada farklı rastgele sayılar görmelisiniz ve bunların tamamı 1 ile 100 arasında olmalıdır. Derleme sırasında uyarılar alırsanız bunları güvenle göz ardı edebilirsiniz. Hata alırsanız lütfen Cargo.toml dosyanızda rand = "0.10.1" yazdığından emin olun; rand’in gelecekteki ana sürümleri farklı bir API sunabilir, ancak 0.10 serisindeki herhangi bir sürüm bu bölümdeki kodla çalışacaktır.

Tahmini Gizli Sayıyla Karşılaştırmak

Artık elimizde hem kullanıcı girdisi hem de rastgele bir sayı olduğuna göre bu ikisini karşılaştırabiliriz. Bu adım Liste 2-4’te gösterilmiştir. Açıklayacağımız nedenlerden ötürü bu kodun şu an için henüz derlenmeyeceğine dikkat edin.

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    // --snip--
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    println!("Gizli sayı: {gizli_sayi}");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");

    match tahmin.cmp(&gizli_sayi) {
        Ordering::Less => println!("Çok küçük!"),
        Ordering::Greater => println!("Çok büyük!"),
        Ordering::Equal => println!("Kazandınız!"),
    }
}

İlk olarak standart kütüphaneden std::cmp::Ordering adlı türü kapsama dahil eden bir use deyimi daha ekliyoruz. Ordering türü de bir enum’dır ve Less (daha küçük), Greater (daha büyük) ve Equal (eşit) varyantlarına sahiptir. İki değeri karşılaştırdığınızda ortaya çıkabilecek üç olası sonuç bunlardır.

Ardından dosyanın sonuna Ordering türünü kullanan beş yeni satır ekliyoruz. cmp metodu iki değeri karşılaştırır ve karşılaştırılabilen her değer üzerinde çağrılabilir. Karşılaştırmak istediğiniz değere bir referans alır: Burada tahmin değişkenini gizli_sayi ile karşılaştırıyoruz. Ardından use deyimiyle kapsama aldığımız Ordering enum’ının bir varyantını döndürür. tahmin ve gizli_sayi değerleriyle yapılan cmp çağrısından hangi Ordering varyantının döndüğüne göre ne yapacağımıza karar vermek için bir match ifadesi kullanıyoruz.

Bir match ifadesi kollardan (match arms) oluşur. Her kol, eşleştirilecek bir desenden (pattern) ve match’e verilen değer o kolun desenine uyduğunda çalıştırılacak koddan meydana gelir. Rust, match ifadesine verilen değeri alır ve sırayla her bir kolun deseniyle karşılaştırır. Desenler ve match yapısı Rust’ın çok güçlü özellikleridir: Kodunuzun karşılaşabileceği çeşitli durumları açıkça ifade etmenizi ve tüm olasılıkları eksiksiz ele aldığınızdan emin olmanızı sağlarlar. Bu özellikler sırasıyla Bölüm 6 ve Bölüm 19’da ayrıntılı olarak incelenecektir.

Burada kullandığımız match ifadesinin nasıl çalıştığını bir örnek üzerinden adım adım izleyelim. Diyelim ki kullanıcı 50 tahmininde bulundu ve bu turda rastgele üretilen gizli sayı 38 oldu.

Kod 50 ile 38’i karşılaştırdığında, 50 sayısı 38’den büyük olduğu için cmp metodu Ordering::Greater döndürür. match ifadesi Ordering::Greater değerini alır ve her kolun desenini sırayla kontrol etmeye başlar. İlk kolun deseni olan Ordering::Less’e bakar ve Ordering::Greater değerinin Ordering::Less ile eşleşmediğini görür; dolayısıyla bu koldaki kodu atlayıp bir sonraki kola geçer. İkinci kolun deseni Ordering::Greater’dır ve elimizdeki Ordering::Greater değeriyle eşleşir! Bu koldaki kod çalıştırılır ve ekrana Çok büyük! yazdırılır. İlk başarılı eşleşmenin ardından match ifadesi sona erdiğinden bu senaryoda son kola hiç bakılmaz.

Ancak Liste 2-4’teki kod henüz derlenmeyecektir. Gelin deneyelim:

$ cargo build
   Compiling libc v0.2.186
   Compiling getrandom v0.4.3
   Compiling rand_core v0.10.1
   Compiling cfg-if v1.0.0
   Compiling chacha20 v0.10.1
   Compiling rand v0.10.1
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
error[E0308]: mismatched types
  --> src/main.rs:23:22
   |
23 |     match tahmin.cmp(&gizli_sayi) {
   |                  --- ^^^^^^^^^^^ expected `&String`, found `&{integer}`
   |                  |
   |                  arguments to this method are incorrect
   |
   = note: expected reference `&String`
              found reference `&{integer}`
note: method defined here
  --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/cmp.rs:1012:7

For more information about this error, try `rustc --explain E0308`.
error: could not compile `tahmin_oyunu` (bin "tahmin_oyunu") due to 1 previous error

Hata mesajının özü uyumsuz türler (mismatched types) bulunduğunu bildiriyor. Rust güçlü ve statik bir tür sistemine sahiptir. Bununla birlikte tür çıkarımı (type inference) yeteneği de vardır. let mut tahmin = String::new() yazdığımızda Rust, tahmin değişkeninin bir String olması gerektiğini kendiliğinden çıkardı ve türü açıkça yazmamızı istemedi. Öte yandan gizli_sayi bir sayı türüdür. Rust’ta 1 ile 100 arasında değer tutabilen birden fazla sayı türü bulunur: 32 bitlik işaretli tam sayı i32, 32 bitlik işaretsiz tam sayı u32, 64 bitlik tam sayı i64 ve diğerleri. Aksi belirtilmedikçe Rust tam sayılar için varsayılan olarak i32 kullanır; başka bir yerde derleyicinin farklı bir sayısal tür çıkarmasına yol açacak bir tür bilgisi vermediğiniz sürece gizli_sayi değişkeninin türü i32 olur. Hatanın nedeni, Rust’ın bir metin (String) ile bir sayıyı doğrudan karşılaştıramamasıdır.

Sonuç olarak programın girdi olarak okuduğu String değerini bir sayı türüne dönüştürmek istiyoruz ki gizli sayıyla sayısal olarak karşılaştırabilelim. Bunu main fonksiyonunun gövdesine şu satırı ekleyerek yapıyoruz:

Dosya adı: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    println!("Gizli sayı: {gizli_sayi}");

    println!("Lütfen tahmininizi girin.");

    // --snip--

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    let tahmin: u32 = tahmin.trim().parse().expect("Lütfen bir sayı yazın!");

    println!("Tahmininiz: {tahmin}");

    match tahmin.cmp(&gizli_sayi) {
        Ordering::Less => println!("Çok küçük!"),
        Ordering::Greater => println!("Çok büyük!"),
        Ordering::Equal => println!("Kazandınız!"),
    }
}

Eklediğimiz satır şudur:

let tahmin: u32 = tahmin.trim().parse().expect("Lütfen bir sayı yazın!");

Burada yine tahmin adında bir değişken oluşturuyoruz. İyi ama programda zaten tahmin adında bir değişken yok muydu? Evet, var; ancak Rust önceki tahmin değerini yenisiyle gölgelememize (shadowing) olanak tanır. Gölgeleme, bizi tahmin_str ve tahmin gibi iki ayrı değişken oluşturmaya zorlamak yerine aynı tahmin adını yeniden kullanmamızı sağlar. Bu özelliği Bölüm 3’te daha ayrıntılı ele alacağız; şimdilik gölgelemenin en sık bir değeri bir türden başka bir türe dönüştürürken kullanıldığını bilmeniz yeterlidir.

Bu yeni değişkeni tahmin.trim().parse() ifadesine bağlıyoruz. Eşittirin sağındaki ifadede geçen tahmin, kullanıcı girdisini metin olarak tutan ilk tahmin değişkenini temsil eder. Bir String örneği üzerindeki trim metodu, metnin başındaki ve sonundaki tüm boşluk karakterlerini temizler. Yalnızca sayısal veri tutabilen u32 türüne dönüştürme yapmadan önce bu adımı mutlaka uygulamamız gerekir; çünkü kullanıcının read_line çağrısını tamamlayıp tahminini göndermek için enter tuşuna basması gerekir ve bu da string’in sonuna bir satır sonu karakteri ekler. Örneğin kullanıcı 5 yazıp enter’a bastığında tahmin gerçekte şöyle görünür: 5\n. Buradaki \n “yeni satır” (newline) karakterini temsil eder. (Windows’ta enter tuşuna basmak satır başı ve yeni satır anlamına gelen \r\n dizisini ekler.) trim metodu \n veya \r\n karakterlerini (ve varsa fazladan boşlukları) temizleyerek geriye yalnızca 5 kalmasını sağlar.

String’ler üzerindeki parse metodu, bir metni başka bir türe dönüştürür. Burada onu bir metni sayıya çevirmek için kullanıyoruz. parse pek çok farklı sayı türü üretebildiğinden, let tahmin: u32 yazarak Rust’a tam olarak hangi sayı türünü istediğimizi bildirmemiz gerekir. tahmin adından sonraki iki nokta üst üste (:), değişkenin türünü açıkça belirteceğimizi (type annotation) söyler. Rust’ta çeşitli yerleşik tam sayı türleri vardır; burada gördüğünüz u32, işaretsiz ve 32 bitlik bir tam sayıdır. Küçük pozitif sayılar için iyi bir varsayılan tercihtir. Diğer sayı türlerini Bölüm 3’te öğreneceksiniz.

Üstelik bu programda tahmin için yaptığımız u32 tür bildirimi ve aşağıda gizli_sayi ile yapılan karşılaştırma sayesinde Rust, gizli_sayi değişkeninin de bir u32 olması gerektiği çıkarımını otomatik olarak yapar. Böylece karşılaştırma artık aynı türden iki değer arasında gerçekleşir!

parse metodu yalnızca mantıksal olarak sayıya dönüştürülebilecek karakterler üzerinde çalışabilir ve bu yüzden kolayca hatayla karşılaşabilir. Örneğin string içinde A👍% yazıyor olsaydı bunu bir sayıya çevirmenin hiçbir yolu olmazdı. Başarısız olma ihtimali bulunduğundan parse metodu da tıpkı read_line metodu gibi (daha önce “Potansiyel Bir Hatayı Result ile Ele Almak” kısmında incelediğimiz üzere) bir Result türü döndürür. Bu Result değerini de yine expect metodunu kullanarak aynı şekilde ele alacağız. Eğer parse metodu verilen metinden bir sayı üretemediği için Err varyantı döndürürse expect çağrısı oyunu durdurup verdiğimiz hata mesajını ekrana yazdıracaktır. Eğer parse metni başarıyla sayıya dönüştürürse Result’ın Ok varyantını döndürür ve expect de Ok içindeki sayıyı çıkarıp bize verir.

Şimdi programı çalıştıralım:

$ cargo run
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.26s
     Running `target/debug/tahmin_oyunu`
Sayıyı tahmin et!
Gizli sayı: 58
Lütfen tahmininizi girin.
  76
Tahmininiz: 76
Çok büyük!

Güzel! Tahminden önce boşluk bırakılmış olmasına rağmen program kullanıcının 76 tahmininde bulunduğunu sorunsuzca anladı. Farklı girdilerle programın davranışını doğrulamak için birkaç kez çalıştırın: Sayıyı doğru tahmin edin, çok büyük bir sayı girin ve çok küçük bir sayı girin.

Oyunun büyük kısmı artık çalışıyor, ancak kullanıcı yalnızca tek bir tahmin yapabiliyor. Bir döngü ekleyerek bunu değiştirelim!

Döngüyle Birden Fazla Tahmine İzin Vermek

loop anahtar kelimesi sonsuz bir döngü oluşturur. Kullanıcılara sayıyı bulmaları için birden fazla şans tanımak üzere bir döngü ekleyelim:

Dosya adı: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    // --snip--

    println!("Gizli sayı: {gizli_sayi}");

    loop {
        println!("Lütfen tahmininizi girin.");

        // --snip--


        let mut tahmin = String::new();

        io::stdin()
            .read_line(&mut tahmin)
            .expect("Satır okunamadı");

        let tahmin: u32 = tahmin.trim().parse().expect("Lütfen bir sayı yazın!");

        println!("Tahmininiz: {tahmin}");

        match tahmin.cmp(&gizli_sayi) {
            Ordering::Less => println!("Çok küçük!"),
            Ordering::Greater => println!("Çok büyük!"),
            Ordering::Equal => println!("Kazandınız!"),
        }
    }
}

Gördüğünüz gibi, tahmin isteme satırından itibaren her şeyi bir loop bloğunun içine taşıdık. Döngü içindeki satırların her birini dörder boşluk daha girintilediğinizden emin olun ve programı yeniden çalıştırın. Program artık sonsuza dek yeni bir tahmin isteyecektir; tabii bu da beraberinde yeni bir sorun getirir: Kullanıcı oyundan çıkamıyor gibi görünüyor!

Kullanıcı ctrl-C klavye kısayolunu kullanarak programı her zaman yarıda kesebilir. Ancak “Tahmini Gizli Sayıyla Karşılaştırmak” kısmındaki parse açıklamasında değindiğimiz üzere, bu doymak bilmez canavardan kaçmanın bir yolu daha vardır: Kullanıcı sayı olmayan bir girdi yazarsa program çöker. Aşağıda gösterildiği gibi oyundan çıkmak için şimdilik bu davranıştan yararlanabiliriz:

$ cargo run
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.23s
     Running `target/debug/tahmin_oyunu`
Sayıyı tahmin et!
Gizli sayı: 59
Lütfen tahmininizi girin.
45
Tahmininiz: 45
Çok küçük!
Lütfen tahmininizi girin.
60
Tahmininiz: 60
Çok büyük!
Lütfen tahmininizi girin.
59
Tahmininiz: 59
Kazandınız!
Lütfen tahmininizi girin.
cikis

thread 'main' (6694925) panicked at src/main.rs:22:49:
Lütfen bir sayı yazın!: ParseIntError { kind: InvalidDigit }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

cikis yazmak gerçekten de oyundan çıkmanızı sağlar; ancak fark edeceğiniz üzere sayı olmayan herhangi bir başka girdi de aynı çökme sonucunu doğuracaktır. Bu en hafif tabirle pek ideal bir çözüm değildir; üstelik doğru sayı tahmin edildiğinde de oyunun kendiliğinden durmasını istiyoruz.

Doğru Tahminden Sonra Çıkmak

Kullanıcı kazandığında oyunun sonlanması için bir break deyimi ekleyelim:

Dosya adı: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    println!("Gizli sayı: {gizli_sayi}");

    loop {
        println!("Lütfen tahmininizi girin.");

        let mut tahmin = String::new();

        io::stdin()
            .read_line(&mut tahmin)
            .expect("Satır okunamadı");

        let tahmin: u32 = tahmin.trim().parse().expect("Lütfen bir sayı yazın!");

        println!("Tahmininiz: {tahmin}");

        // --snip--

        match tahmin.cmp(&gizli_sayi) {
            Ordering::Less => println!("Çok küçük!"),
            Ordering::Greater => println!("Çok büyük!"),
            Ordering::Equal => {
                println!("Kazandınız!");
                break;
            }
        }
    }
}

Kazandınız! satırından hemen sonra break eklemek, kullanıcı gizli sayıyı doğru tahmin ettiğinde programın döngüden çıkmasını sağlar. Döngü main fonksiyonunun son kısmı olduğundan döngüden çıkmak aynı zamanda programın sonlanması anlamına gelir.

Geçersiz Girdiyi Ele Almak

Oyunun davranışını biraz daha iyileştirmek için, kullanıcı sayı olmayan bir girdi yazdığında programı çökertmek yerine bu geçersiz girdiyi yok sayıp kullanıcının tahmin etmeye devam edebilmesini sağlayalım. Bunu Liste 2-5’te gösterildiği gibi tahmin değişkeninin String’den u32’ye dönüştürüldüğü satırı değiştirerek yapabiliriz.

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    println!("Gizli sayı: {gizli_sayi}");

    loop {
        println!("Lütfen tahmininizi girin.");

        let mut tahmin = String::new();

        // --snip--

        io::stdin()
            .read_line(&mut tahmin)
            .expect("Satır okunamadı");

        let tahmin: u32 = match tahmin.trim().parse() {
            Ok(sayi) => sayi,
            Err(_) => continue,
        };

        println!("Tahmininiz: {tahmin}");

        // --snip--

        match tahmin.cmp(&gizli_sayi) {
            Ordering::Less => println!("Çok küçük!"),
            Ordering::Greater => println!("Çok büyük!"),
            Ordering::Equal => {
                println!("Kazandınız!");
                break;
            }
        }
    }
}

Hata anında programı çökertmekten hatayı gerçekten ele almaya geçmek için expect çağrısını bir match ifadesiyle değiştiriyoruz. parse metodunun bir Result türü döndürdüğünü ve Result’ın Ok ile Err varyantlarına sahip bir enum olduğunu hatırlayın. Burada, tıpkı cmp metodunun döndürdüğü Ordering sonucunda yaptığımız gibi bir match ifadesi kullanıyoruz.

Eğer parse metni başarıyla bir sayıya dönüştürebilirse elde edilen sayıyı içeren bir Ok değeri döndürür. Bu Ok değeri ilk kolun Ok(sayi) deseniyle eşleşir ve match ifadesi parse’ın üretip Ok içine koyduğu sayi değerini dışarı döndürür. Bu sayı da oluşturduğumuz yeni tahmin değişkenine tam istediğimiz şekilde atanır.

Eğer parse metni bir sayıya dönüştüremezse hata hakkında ek bilgi taşıyan bir Err değeri döndürür. Err değeri ilk match kolundaki Ok(sayi) deseniyle eşleşmez, ancak ikinci koldaki Err(_) deseniyle eşleşir. Alt çizgi (_) her değeri yakalayan (catch-all) bir joker desendir; bu örnekte içinde hangi hata bilgisi bulunursa bulunsun tüm Err değerleriyle eşleşmek istediğimizi belirtiyoruz. Böylece program ikinci kolun kodu olan continue ifadesini çalıştırır; bu da programa loop döngüsünün bir sonraki adımına geçip kullanıcıdan yeniden tahmin istemesini söyler. Kısacası program, parse sırasında oluşabilecek tüm hataları zarifçe yok saymış olur!

Artık programdaki her şey beklendiği gibi çalışmalıdır. Hemen deneyelim:

$ cargo run
   Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
     Running `target/debug/tahmin_oyunu`
Sayıyı tahmin et!
Gizli sayı: 61
Lütfen tahmininizi girin.
10
Tahmininiz: 10
Çok küçük!
Lütfen tahmininizi girin.
99
Tahmininiz: 99
Çok büyük!
Lütfen tahmininizi girin.
foo
Lütfen tahmininizi girin.
61
Tahmininiz: 61
Kazandınız!

Harika! Son bir küçük dokunuşla tahmin oyununu tamamlayacağız. Programın hâlâ gizli sayıyı ekrana yazdırdığını hatırlayın. Test aşamasında bu çok işimize yaradı ama gerçek oyunu bozuyor. Gizli sayıyı yazdıran println! satırını silelim. Liste 2-6 oyunun tamamlanmış son kodunu göstermektedir.

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    loop {
        println!("Lütfen tahmininizi girin.");

        let mut tahmin = String::new();

        io::stdin()
            .read_line(&mut tahmin)
            .expect("Satır okunamadı");

        let tahmin: u32 = match tahmin.trim().parse() {
            Ok(sayi) => sayi,
            Err(_) => continue,
        };

        println!("Tahmininiz: {tahmin}");

        match tahmin.cmp(&gizli_sayi) {
            Ordering::Less => println!("Çok küçük!"),
            Ordering::Greater => println!("Çok büyük!"),
            Ordering::Equal => {
                println!("Kazandınız!");
                break;
            }
        }
    }
}

Bu noktada tahmin oyununu başarıyla geliştirdiniz. Tebrikler!

Özet

Bu proje sizi pek çok yeni Rust kavramıyla uygulamalı olarak tanıştırmanın keyifli bir yoluydu: let, match, fonksiyonlar, harici crate’lerin kullanımı ve daha fazlası. İzleyen bölümlerde bu kavramları çok daha ayrıntılı olarak öğreneceksiniz. Bölüm 3; değişkenler, veri türleri ve fonksiyonlar gibi çoğu programlama dilinde bulunan kavramları ele alır ve bunların Rust’ta nasıl kullanıldığını gösterir. Bölüm 4, Rust’ı diğer dillerden ayıran temel özellik olan sahipliği (ownership) inceler. Bölüm 5 struct’ları ve metot sözdizimini ele alırken Bölüm 6 enum’ların nasıl çalıştığını açıklar.

Yaygın Programlama Kavramları

Bu bölüm, neredeyse her programlama dilinde karşımıza çıkan kavramları ve bunların Rust’ta nasıl çalıştığını ele alır. Birçok programlama dili özünde pek çok ortak noktaya sahiptir. Bu bölümde sunulan kavramların hiçbiri yalnızca Rust’a özgü değildir; ancak bunları Rust bağlamında inceleyecek ve kullanımlarına ilişkin yerleşik kuralları açıklayacağız.

Bu bölümde özellikle değişkenler, temel veri türleri, fonksiyonlar, yorumlar ve kontrol akışı konularını öğreneceksiniz. Bu yapı taşları her Rust programında yer alacağından, bunları erkenden kavramak yola sağlam bir temelle çıkmanızı sağlayacaktır.

Değişkenler ve Değiştirilebilirlik

Değişkenler ve Değiştirilebilirlik

“Değerleri Değişkenlerle Saklamak” bölümünde değindiğimiz gibi, değişkenler varsayılan olarak değiştirilemezdir (immutable). Bu, Rust’ın kodunuzu dilin sunduğu güvenlik ve kolay eşzamanlılık (concurrency) avantajlarından yararlanacak biçimde yazmanız için size yaptığı pek çok küçük yönlendirmeden biridir. Bununla birlikte, değişkenlerinizi değiştirilebilir (mutable) yapma seçeneğiniz her zaman vardır. Gelin Rust’ın sizi değiştirilemezliği tercih etmeye nasıl ve neden teşvik ettiğini, ayrıca bazen bundan neden vazgeçmek isteyebileceğinizi inceleyelim.

Bir değişken değiştirilemez olduğunda, bir isme bir değer bağlandıktan sonra o değeri bir daha değiştiremezsiniz. Bunu görmek için projects dizininizde cargo new degiskenler komutunu kullanarak degiskenler adında yeni bir proje oluşturun.

Ardından yeni degiskenler dizininizde src/main.rs dosyasını açın ve içeriğini şimdilik derlenmeyecek olan aşağıdaki kodla değiştirin:

Dosya adı: src/main.rs

fn main() {
    let x = 5;
    println!("x'in değeri: {x}");
    x = 6;
    println!("x'in değeri: {x}");
}

Dosyayı kaydedin ve cargo run komutuyla programı çalıştırın. Aşağıdaki çıktıda gösterildiği gibi bir değiştirilemezlik hatası mesajı almalısınız:

$ cargo run
   Compiling degiskenler v0.1.0 (file:///projects/degiskenler)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
3 |     println!("x'in değeri: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 5;
  |         +++

For more information about this error, try `rustc --explain E0384`.
error: could not compile `degiskenler` (bin "degiskenler") due to 1 previous error

Bu örnek, derleyicinin programlarınızdaki hataları bulmanıza nasıl yardımcı olduğunu gösterir. Derleyici hataları zaman zaman can sıkıcı olabilir; ancak bu hatalar yalnızca programınızın yapmasını istediğiniz işi henüz güvenli bir biçimde gerçekleştirmediği anlamına gelir, sizin iyi bir programcı olmadığınız anlamına gelmez! Deneyimli Rust geliştiricileri (Rustaceans) bile hâlâ derleyici hataları alırlar.

Değiştirilemez x değişkenine ikinci bir değer atamaya çalıştığınız için cannot assign twice to immutable variable `x` (x değiştirilemez değişkenine ikinci kez atama yapılamaz) hata mesajını aldınız.

Değiştirilemez olarak tanımlanmış bir değeri değiştirmeye çalıştığımızda derleme zamanı (compile-time) hataları almamız son derece önemlidir; çünkü tam da bu durum kodda hatalara (bug) yol açabilir. Kodumuzun bir bölümü bir değerin asla değişmeyeceği varsayımıyla çalışırken başka bir bölümü o değeri değiştirirse, ilk bölümün tasarlandığı işi doğru yapmaması olasıdır. Bu tür bir hatanın nedenini sonradan bulmak çok zor olabilir; özellikle de ikinci kod parçası değeri yalnızca bazen değiştiriyorsa. Rust derleyicisi, bir değerin değişmeyeceğini belirttiğinizde gerçekten değişmeyeceğini garanti eder; dolayısıyla bunu kendiniz takip etmek zorunda kalmazsınız. Böylece kodunuz üzerinden akıl yürütmek çok daha kolaylaşır.

Ancak değiştirilebilirlik çok faydalı olabilir ve kod yazmayı daha pratik hâle getirebilir. Değişkenler varsayılan olarak değiştirilemez olsa da, Bölüm 2’de yaptığınız gibi değişken adının önüne mut ekleyerek onları değiştirilebilir yapabilirsiniz. mut eklemek aynı zamanda kodun başka bölümlerinin bu değişkenin değerini değiştireceğini açıkça göstererek kodu gelecekte okuyacak kişilere niyetinizi iletir.

Örneğin src/main.rs dosyasını aşağıdaki gibi değiştirelim:

Dosya adı: src/main.rs

fn main() {
    let mut x = 5;
    println!("x'in değeri: {x}");
    x = 6;
    println!("x'in değeri: {x}");
}

Programı şimdi çalıştırdığımızda şu çıktıyı elde ederiz:

$ cargo run
   Compiling degiskenler v0.1.0 (file:///projects/degiskenler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
     Running `target/debug/degiskenler`
x'in değeri: 5
x'in değeri: 6

mut kullanıldığında x değişkenine bağlı değeri 5’ten 6’ya değiştirmemize izin verilir. Sonuç olarak değiştirilebilirliği kullanıp kullanmamaya karar vermek size kalmıştır ve içinde bulunduğunuz durumda neyin en anlaşılır olduğunu düşündüğünüze bağlıdır.

Sabitleri Bildirmek

Değiştirilemez değişkenler gibi, sabitler (constants) de bir isme bağlı olan ve değiştirilmesine izin verilmeyen değerlerdir; ancak sabitler ile değişkenler arasında birkaç önemli fark vardır.

İlk olarak, sabitlerle birlikte mut kullanmanıza izin verilmez. Sabitler yalnızca varsayılan olarak değil, her zaman değiştirilemezdir. Sabitleri let anahtar kelimesi yerine const anahtar kelimesini kullanarak bildirirsiniz ve değerin türü mutlaka açıkça belirtilmelidir. Türleri ve tür bildirimlerini (type annotations) bir sonraki bölüm olan “Veri Türleri” kısmında ele alacağız; bu yüzden şimdilik ayrıntılar konusunda endişelenmeyin, yalnızca sabitlerde türü her zaman belirtmeniz gerektiğini bilin.

Sabitler, küresel kapsam (global scope) da dahil olmak üzere herhangi bir kapsamda bildirilebilir; bu da onları kodun pek çok bölümünün bilmesi gereken ortak değerler için kullanışlı kılar.

Son fark ise sabitlere yalnızca bir sabit ifadenin (constant expression), yani derleme zamanında değerlendirilebilen bir ifadenin atanabilmesidir; yalnızca çalışma zamanında (runtime) hesaplanabilecek bir değer sabite atanamaz.

İşte bir sabit bildirimi örneği:

#![allow(unused)]
fn main() {
const SANIYE_CINSINDEN_UC_SAAT: u32 = 60 * 60 * 3;
}

Sabitin adı SANIYE_CINSINDEN_UC_SAAT’tir; değeri ise 60 (bir dakikadaki saniye sayısı), 60 (bir saatteki dakika sayısı) ve 3 (bu programda saymak istediğimiz saat sayısı) sayılarının çarpımı olarak belirlenmiştir. Rust’ın sabitler için adlandırma geleneği, tüm harfleri büyük yazmak ve kelimeler arasında alt çizgi kullanmaktır (SCREAMING_SNAKE_CASE). Derleyici, derleme zamanında belirli bir dizi işlemi hesaplayabilir; bu sayede sabiti doğrudan 10_800 değerine eşitlemek yerine, anlaşılması ve doğrulanması çok daha kolay bir biçimde yazmayı seçebiliriz. Sabitleri bildirirken hangi işlemlerin kullanılabileceği hakkında daha fazla bilgi için Rust Referansı’nın sabit değerlendirme bölümüne bakabilirsiniz.

Sabitler, bildirildikleri kapsam içinde programın çalıştığı süre boyunca geçerlidir. Bu özellik; bir oyundaki herhangi bir oyuncunun kazanabileceği azami puan veya ışık hızı gibi, uygulama alanınızda programın birden fazla bölümünün bilmesi gerekebilecek değerler için sabitleri yararlı kılar.

Programınız boyunca doğrudan koda yazılmış sabit değerleri const ile isimlendirmek, bu değerin anlamını kodun gelecekteki bakımcılarına iletmek açısından faydalıdır. Ayrıca bu değerin gelecekte güncellenmesi gerektiğinde kodunuzda değiştirmeniz gereken yalnızca tek bir yer olmasını sağlar.

Gölgeleme

Bölüm 2’deki tahmin oyunu uygulamasında gördüğünüz gibi, daha önce tanımlanmış bir değişkenle aynı isimde yeni bir değişken bildirebilirsiniz. Rust geliştiricileri ilk değişkenin ikincisi tarafından gölgelendiğini (shadowed) söyler; bu da değişkenin adını kullandığınızda derleyicinin göreceği değişkenin artık ikincisi olduğu anlamına gelir. Özünde ikinci değişken ilkini gölgede bırakır ve kendisi de gölgelenene ya da bulunduğu kapsam sona erene kadar o değişken adının tüm kullanımlarını devralır. Bir değişkeni, aynı değişken adını kullanıp let anahtar kelimesini tekrarlayarak aşağıdaki gibi gölgeleyebiliriz:

Dosya adı: src/main.rs

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("İç kapsamdaki x'in değeri: {x}");
    }

    println!("x'in değeri: {x}");
}

Bu program önce x değişkenini 5 değerine bağlar. Ardından let x = kullanımını tekrarlayarak yeni bir x değişkeni oluşturur; önceki değeri alıp üzerine 1 ekler ve böylece x’in değeri 6 olur. Sonrasında süslü parantezlerle oluşturulan bir iç kapsamda, üçüncü let deyimi de x’i gölgeleyerek yeni bir değişken oluşturur ve önceki değeri 2 ile çarparak x’e 12 değerini verir. Bu iç kapsam sona erdiğinde içteki gölgeleme biter ve dış kapsamdaki, değeri hâlâ 6 olan x yeniden görünür hâle gelir. Burada bir değişkenin değeri geri alınmaz; aynı adlı farklı bağlamalar arasında kapsam değişir. Programı çalıştırdığımızda şu çıktıyı alırız:

$ cargo run
   Compiling degiskenler v0.1.0 (file:///projects/degiskenler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/degiskenler`
İç kapsamdaki x'in değeri: 12
x'in değeri: 6

Gölgeleme, bir değişkeni mut olarak işaretlemekten farklıdır; çünkü let anahtar kelimesini kullanmadan bu değişkene yanlışlıkla yeniden değer atamaya çalışırsak derleme zamanı hatası alırız. let kullanarak bir değer üzerinde birkaç dönüştürme işlemi gerçekleştirebilir, ancak bu dönüştürmeler tamamlandıktan sonra değişkenin yine değiştirilemez kalmasını sağlayabiliriz.

mut ile gölgeleme arasındaki diğer önemli fark ise şudur: let anahtar kelimesini tekrar kullandığımızda gerçekte yepyeni bir değişken oluşturduğumuz için, aynı ismi korurken değerin türünü değiştirebiliriz. Örneğin programımız kullanıcıdan, metin parçaları arasında kaç boşluk istediğini boşluk karakterleri girerek göstermesini istesin; biz de ardından bu girdiyi bir sayı olarak saklamak isteyelim:

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

İlk bosluklar değişkeni bir string dilimi (&str) türündedir, ikinci bosluklar değişkeni ise bir sayı (usize) türündedir. Gölgeleme böylece bizi bosluklar_metin ve bosluklar_sayi gibi farklı isimler türetmek zorunda kalmaktan kurtarır; bunun yerine daha yalın olan bosluklar ismini yeniden kullanabiliriz. Oysa aynı işi burada gösterildiği gibi mut kullanarak yapmaya çalışırsak derleme zamanı hatası alırız:

fn main() {
    let mut bosluklar = "   ";
    bosluklar = bosluklar.len();
}

Hata mesajı, bir değişkenin türünü değiştirmemize izin verilmediğini (mismatched types — uyuşmayan türler) belirtir:

$ cargo run
   Compiling degiskenler v0.1.0 (file:///projects/degiskenler)
error[E0308]: mismatched types
 --> src/main.rs:3:17
  |
2 |     let mut bosluklar = "   ";
  |                         ----- expected due to this value
3 |     bosluklar = bosluklar.len();
  |                 ^^^^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `degiskenler` (bin "degiskenler") due to 1 previous error

Artık değişkenlerin nasıl çalıştığını incelediğimize göre, değişkenlerin sahip olabileceği diğer veri türlerine göz atalım.

Veri Türleri

Veri Türleri

Rust’taki her değer belirli bir veri türüne (data type) sahiptir; bu bilgi Rust’a ne tür bir veriyle çalıştığını ve o veriyi nasıl işleyeceğini söyler. Bu bölümde iki veri türü alt kümesini inceleyeceğiz: skaler ve bileşik türler.

Rust’ın statik türlemeli (statically typed) bir dil olduğunu unutmayın; yani derleyicinin tüm değişkenlerin türlerini derleme zamanında bilmesi gerekir. Derleyici çoğu durumda değere ve onu nasıl kullandığımıza bakarak hangi türü istediğimizi kendiliğinden çıkarabilir. Ancak Bölüm 2’deki “Tahmini Gizli Sayıyla Karşılaştırmak” kısmında parse metodunu kullanarak bir String değerini sayısal bir türe dönüştürdüğümüzde olduğu gibi pek çok farklı türün mümkün olduğu durumlarda, aşağıdaki gibi açık bir tür bildirimi (type annotation) eklememiz gerekir:

#![allow(unused)]
fn main() {
let tahmin: u32 = "42".parse().expect("Bir sayı değil!");
}

Yukarıdaki kodda gösterilen : u32 tür bildirimini eklemezsek Rust aşağıdaki hatayı görüntüler; bu mesaj, derleyicinin hangi türü kullanmak istediğimizi anlamak için bizden daha fazla bilgiye ihtiyaç duyduğunu gösterir:

$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0284]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let tahmin = "42".parse().expect("Bir sayı değil!");
  |         ^^^^^^        ----- type must be known at this point
  |
  = note: cannot satisfy `<_ as FromStr>::Err == _`
  = note: the type must also implement `FromStr`
note: required by a bound in `core::str::<impl str>::parse`
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/str/mod.rs:2782:4
help: consider giving `tahmin` an explicit type
  |
2 |     let tahmin: /* Type */ = "42".parse().expect("Bir sayı değil!");
  |               ++++++++++++

For more information about this error, try `rustc --explain E0284`.
error: could not compile `no_type_annotations` (bin "no_type_annotations") due to 1 previous error

Diğer veri türleri için de farklı tür bildirimleri göreceksiniz.

Skaler Türler

Skaler (scalar) bir tür tek bir değeri temsil eder. Rust’ta dört temel skaler tür bulunur: tam sayılar, kayan noktalı sayılar, Boolean’lar ve karakterler. Bu türleri diğer programlama dillerinden de tanıyor olabilirsiniz. Gelin Rust’ta nasıl çalıştıklarına yakından bakalım.

Tam Sayı Türleri

Tam sayı (integer), kesirli bileşeni olmayan bir sayıdır. Bölüm 2’de tam sayı türlerinden biri olan u32 türünü kullanmıştık. Bu tür bildirimi, ilişkili değerin bellekte 32 bitlik alan kaplayan işaretsiz (unsigned) bir tam sayı olması gerektiğini belirtir (işaretli (signed) tam sayı türleri u yerine i harfiyle başlar). Tablo 3-1, Rust’taki yerleşik tam sayı türlerini gösterir. Bir tam sayı değerinin türünü bildirmek için bu varyantlardan herhangi birini kullanabiliriz.

Tablo 3-1: Rust’taki Tam Sayı Türleri

Her tam sayı türünün belirli bir boyutu ve değer aralığı vardır. İşaretli türler negatif sayıları, sıfırı ve pozitif sayıları; işaretsiz türler ise sıfırı ve pozitif sayıları temsil eder. Buradaki “işaret”, sayının kaynak kodda mutlaka + veya - ile yazılması gerektiğini değil, türün negatif değerleri temsil edip edemediğini belirtir. İşaretli sayılar bellekte ikiye tümleyen (two’s complement) temsili kullanılarak saklanır.

Her işaretli varyant, n ilgili varyantın kullandığı bit sayısı olmak üzere, −(2^{n − 1}) ile 2^{n − 1} − 1 (sınırlar dahil) aralığındaki sayıları saklayabilir. Dolayısıyla bir i8, −(2⁷) ile 2⁷ − 1 aralığındaki, yani −128 ile 127 arasındaki sayıları tutabilir. İşaretsiz varyantlar ise 0 ile 2ⁿ − 1 aralığındaki sayıları saklayabilir; örneğin bir u8, 0 ile 2⁸ − 1 aralığındaki, yani 0 ile 255 arasındaki sayıları tutabilir.

Ek olarak isize ve usize türlerinin boyutu, programınızın çalıştığı bilgisayarın mimarisine bağlıdır: 64 bitlik bir mimaride 64 bit, 32 bitlik bir mimaride ise 32 bittir.

Tam sayı sabit değerlerini (integer literals) Tablo 3-2’de gösterilen biçimlerden herhangi biriyle yazabilirsiniz. Birden fazla sayısal türe uyabilen sayı sabit değerlerinin, türü açıkça belirlemek amacıyla 57u8 örneğinde olduğu gibi bir tür son eki (type suffix) alabileceğine dikkat edin. Ayrıca sayı sabit değerlerinde okunabilirliği artırmak için görsel ayırıcı olarak _ karakteri kullanılabilir; örneğin 1_000 yazmak, 1000 yazmakla birebir aynı değere karşılık gelir.

Tablo 3-2: Rust’taki Tam Sayı Sabit Değerleri

Peki hangi tam sayı türünü kullanacağınızı nasıl bileceksiniz? Emin değilseniz Rust’ın varsayılanları genellikle iyi bir başlangıç noktasıdır: Tam sayı türleri varsayılan olarak i32 kabul edilir. isize veya usize kullanacağınız başlıca durum ise bir koleksiyonu indekslemektir.

Kayan Noktalı Türler

Rust’ta ayrıca ondalık basamak içeren kayan noktalı sayılar (floating-point numbers) için iki ilkel (primitive) tür bulunur. Rust’ın kayan noktalı türleri sırasıyla 32 bit ve 64 bit boyutundaki f32 ve f64’tür. Varsayılan tür f64’tür; çünkü modern işlemcilerde f32 ile neredeyse aynı hızda çalışırken daha yüksek duyarlılık (precision) sunar. Tüm kayan noktalı türler işaretlidir.

İşte kayan noktalı sayıların kullanımını gösteren bir örnek:

Dosya adı: src/main.rs

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

Kayan noktalı sayılar IEEE-754 standardına göre temsil edilir. f32 türü tek duyarlıklı (single-precision), f64 türü ise çift duyarlıklı (double-precision) bir kayan noktalı sayıdır.

Sayısal İşlemler

Rust, tüm sayı türleri için bekleyeceğiniz temel matematiksel işlemleri destekler: toplama, çıkarma, çarpma, bölme ve kalan (mod alma). Tam sayı bölmesi, sonucu sıfıra doğru en yakın tam sayıya yuvarlar; yani kesirli kısmı atar (truncate). Aşağıdaki kod, her bir sayısal işlemi bir let deyiminde nasıl kullanacağınızı gösterir:

Dosya adı: src/main.rs

fn main() {
    // toplama
    let toplam = 5 + 10;

    // çıkarma
    let fark = 95.5 - 4.3;

    // çarpma
    let carpim = 4 * 30;

    // bölme
    let bolum = 56.7 / 32.2;
    let kesilmis = -5 / 3; // Sonuç -1 olur

    // kalan
    let kalan = 43 % 5;
}

Bu deyimlerdeki her bir ifade matematiksel bir operatör kullanır ve değerlendirilerek tek bir değer üretir; ardından bu değer ilgili değişkene bağlanır. Ek B, Rust’ın sunduğu tüm operatörlerin tam bir listesini içerir.

Boolean Türü

Diğer pek çok programlama dilinde olduğu gibi Rust’ta da Boolean türünün iki olası değeri vardır: true ve false. Boolean değerler bellekte bir bayt yer kaplar. Rust’ta Boolean türü bool anahtar kelimesiyle belirtilir. Örneğin:

Dosya adı: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // açık tür bildirimiyle
}

Boolean değerlerini kullanmanın başlıca yolu if ifadesi gibi koşullu yapılardır. if ifadelerinin Rust’ta nasıl çalıştığını “Kontrol Akışı” bölümünde ele alacağız.

Karakter Türü

Rust’ın char türü, dilin en temel alfabetik veri türüdür. İşte char değerleri tanımlamaya dair birkaç örnek:

Dosya adı: src/main.rs

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // açık tür bildirimiyle
    let kalp_gozlu_kedi = '😻';
}

Çift tırnak kullanan string sabitlerinin (string literals) aksine, char sabitlerini tek tırnakla belirttiğimize dikkat edin. Rust’ın char türü 4 bayt boyutundadır ve bir Unicode skaler değerini temsil eder; bu sayede yalnızca ASCII karakterlerini değil, çok daha fazlasını ifade edebilir. Aksanlı ve noktalı harfler; Çince, Japonca ve Korece karakterler; emojiler ve sıfır genişlikli boşluklar Rust’ta geçerli birer char değeridir. Unicode skaler değerleri U+0000 ile U+D7FF ve U+E000 ile U+10FFFF (sınırlar dahil) aralıklarını kapsar. Bununla birlikte “karakter” aslında Unicode standardında doğrudan tanımlı bir kavram değildir; dolayısıyla bir “karakterin” ne olduğuna dair günlük sezgimiz Rust’taki char tanımıyla her zaman birebir örtüşmeyebilir. Bu konuyu Bölüm 8’deki “String’lerle UTF-8 Kodlanmış Metin Saklama” kısmında ayrıntılı olarak inceleyeceğiz.

Bileşik Türler

Bileşik türler (compound types) birden fazla değeri tek bir tür altında gruplayabilir. Rust’ta iki ilkel bileşik tür vardır: demetler (tuples) ve diziler (arrays).

Demet Türü

Demet (tuple), farklı türlerde olabilen bir grup değeri tek bir bileşik tür altında bir araya getirmenin genel bir yoludur. Demetlerin sabit bir uzunluğu vardır: Bir kez bildirildikten sonra boyutları büyüyemez veya küçülemez.

Parantez içine virgülle ayrılmış bir değer listesi yazarak bir demet oluştururuz. Demetteki her konumun kendine ait bir türü vardır ve farklı konumlardaki değerlerin türlerinin aynı olması gerekmez. Aşağıdaki örnekte isteğe bağlı tür bildirimlerini de ekledik:

Dosya adı: src/main.rs

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

Bir demet tek bir bileşik öğe olarak kabul edildiğinden tup değişkeni demetin tamamına bağlanır. Demetin içindeki tekil değerleri elde etmek için desen eşleştirme (pattern matching) kullanarak bir demet değerini aşağıdaki gibi parçalayabiliriz:

Dosya adı: src/main.rs

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("y'nin değeri: {y}");
}

Bu program önce bir demet oluşturup onu tup değişkenine bağlar. Ardından let ile birlikte bir desen kullanarak tup değerini alır ve üç ayrı değişkene (x, y ve z) ayırır. Tek bir demeti üç parçaya ayırdığı için bu işleme yapı sökümü (destructuring) denir. Son olarak program, 6.4 olan y değerini ekrana yazdırır.

Bir demet elemanına, demetin adından sonra bir nokta (.) ve erişmek istediğimiz değerin indeksini yazarak doğrudan da ulaşabiliriz. Örneğin:

Dosya adı: src/main.rs

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let bes_yuz = x.0;

    let alti_nokta_dort = x.1;

    let bir = x.2;
}

Bu program x demetini oluşturur ve ardından her bir elemanına kendi indeksi üzerinden erişir. Çoğu programlama dilinde olduğu gibi bir demetteki ilk indeks 0’dır.

Hiçbir değer içermeyen boş demetin özel bir adı vardır: birim (unit). Hem bu değer hem de karşılık gelen türü () biçiminde yazılır; boş bir değeri veya boş bir dönüş türünü temsil eder. İfadeler, başka bir değer döndürmediklerinde örtük olarak (implicitly) birim değerini döndürürler.

Dizi Türü

Birden fazla değerden oluşan bir koleksiyon elde etmenin bir diğer yolu da dizi (array) kullanmaktır. Demetten farklı olarak bir dizinin tüm elemanları aynı türde olmalıdır. Diğer bazı dillerdeki dizilerin aksine, Rust’taki diziler sabit uzunlukludur.

Bir dizideki değerleri köşeli parantezler içinde virgülle ayrılmış bir liste hâlinde yazarız:

Dosya adı: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
}

Diziler, verilerinizin öbek (heap) yerine —şimdiye kadar gördüğümüz diğer türlerde olduğu gibi— yığın (stack) üzerinde ayrılmasını istediğinizde (Bölüm 4’te yığın ve öbeği daha ayrıntılı ele alacağız) veya her zaman sabit sayıda elemana sahip olduğunuzdan emin olmak istediğinizde kullanışlıdır. Ancak bir dizi, vektör (vector) türü kadar esnek değildir. Vektör, standart kütüphane tarafından sağlanan ve içeriği öbek üzerinde tutulduğu için boyutunun büyümesine veya küçülmesine izin verilen benzer bir koleksiyon türüdür. Dizi mi yoksa vektör mü kullanacağınızdan emin değilseniz büyük olasılıkla bir vektör kullanmalısınız. Bölüm 8 vektörleri daha ayrıntılı olarak inceler.

Bununla birlikte, eleman sayısının değişmeyeceğini bildiğiniz durumlarda diziler daha uygundur. Örneğin bir programda ay adlarını kullanıyorsanız, her zaman 12 eleman içereceğini bildiğiniz için büyük olasılıkla vektör yerine bir dizi tercih edersiniz:

#![allow(unused)]
fn main() {
let aylar = ["Ocak", "Şubat", "Mart", "Nisan", "Mayıs", "Haziran", "Temmuz",
             "Ağustos", "Eylül", "Ekim", "Kasım", "Aralık"];
}

Bir dizinin türünü köşeli parantezler içinde her elemanın türünü, ardından bir noktalı virgülü ve dizideki eleman sayısını belirterek yazarız:

#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}

Burada i32 her bir elemanın türüdür. Noktalı virgülden sonraki 5 sayısı ise dizinin beş eleman içerdiğini belirtir.

Tüm elemanları aynı değere sahip olacak bir diziyi, köşeli parantez içinde önce başlangıç değerini, ardından noktalı virgülü ve son olarak dizinin uzunluğunu yazarak da başlatabilirsiniz:

#![allow(unused)]
fn main() {
let a = [3; 5];
}

a adındaki bu dizi, başlangıçta tamamı 3 değerine ayarlanmış 5 eleman içerecektir. Bu ifade let a = [3, 3, 3, 3, 3]; yazmakla birebir aynıdır, ancak çok daha özlüdür.

Dizi Elemanlarına Erişim

Bir dizi, yığın üzerinde ayrılabilen, boyutu derleme zamanında bilinen sabit büyüklükte tek parça bir bellek bloğudur. İndeksleme kullanarak bir dizinin elemanlarına şu şekilde erişebilirsiniz:

Dosya adı: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];

    let ilk = a[0];
    let ikinci = a[1];
}

Bu örnekte ilk adlı değişken, dizinin [0] indeksindeki değer olan 1 değerini alır. ikinci adlı değişken ise dizinin [1] indeksindeki 2 değerini alır.

Geçersiz Dizi Elemanlarına Erişim

Bir dizinin sonunu aşan bir indeksle dizi elemanına erişmeye çalışırsanız ne olacağına bakalım. Kullanıcıdan bir dizi indeksi almak için Bölüm 2’deki tahmin oyununa benzer aşağıdaki kodu çalıştırdığınızı düşünelim:

Dosya adı: src/main.rs

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("Lütfen bir dizi indeksi girin.");

    let mut indeks = String::new();

    io::stdin()
        .read_line(&mut indeks)
        .expect("Satırı okuyamadı!");

    let indeks: usize = indeks
        .trim()
        .parse()
        .expect("Girilen indeks bir sayı değildi!");

    let element = a[indeks];

    println!("{indeks} indeksindeki elemanın değeri: {element}");
}

Bu kod sorunsuzca derlenir. Kodu cargo run ile çalıştırıp 0, 1, 2, 3 veya 4 değerlerinden birini girerseniz program dizide o indekse karşılık gelen değeri ekrana yazdırır. Ancak dizinin sınırlarını aşan bir sayı (örneğin 10) girerseniz şuna benzer bir çıktı görürsünüz:

thread 'main' panicked at src/main.rs:19:19:
index out of bounds: the len is 5 but the index is 10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Program, indeksleme işleminde geçersiz bir değerin kullanıldığı noktada bir çalışma zamanı hatasıyla karşılaştı; bir hata mesajı yazdırarak sonlandı ve en sondaki println! deyimini çalıştırmadı. İndeksleme yoluyla bir elemana erişmeye çalıştığınızda Rust, belirttiğiniz indeksin dizi uzunluğundan küçük olup olmadığını kontrol eder. İndeks dizi uzunluğuna eşit veya ondan büyükse Rust panikler. Özellikle bu örnekte olduğu gibi derleyicinin, kodu daha sonra çalıştıracak kullanıcının hangi sayıyı gireceğini derleme zamanında bilmesi imkânsız olduğundan bu kontrolün çalışma zamanında yapılması gerekir.

Bu davranış, Rust’ın bellek güvenliği ilkelerinin iş başındaki somut bir örneğidir. Pek çok alt seviye dilde bu tür bir sınır kontrolü yapılmaz ve yanlış bir indeks verdiğinizde geçersiz bellek bölgelerine erişilebilir. Rust, geçersiz bellek erişimine izin verip çalışmaya devam etmek yerine programı derhal sonlandırarak sizi bu tür güvenlik açıklarına ve belirsiz davranışlara karşı korur. Bölüm 9’da Rust’ın hata yönetimi mekanizmalarını ve ne panikleyen ne de geçersiz bellek erişimine izin veren okunaklı, güvenli kodları nasıl yazabileceğinizi daha ayrıntılı olarak ele alacağız.

Fonksiyonlar

Fonksiyonlar

Fonksiyonlar Rust kodunda son derece yaygındır. Dildeki en önemli fonksiyonlardan birini zaten gördünüz: pek çok programın giriş noktası olan main fonksiyonu. Ayrıca yeni fonksiyonlar bildirmenizi sağlayan fn anahtar kelimesiyle de karşılaştınız.

Rust kodunda fonksiyon ve değişken adları için geleneksel yazım biçimi olarak tüm harflerin küçük yazıldığı ve kelimelerin alt çizgiyle (_) ayrıldığı snake case (yilan_bicimi) stili kullanılır. İşte örnek bir fonksiyon tanımı içeren bir program:

Dosya adı: src/main.rs

fn main() {
    println!("Merhaba, dünya!");

    baska_bir_fonksiyon();
}

fn baska_bir_fonksiyon() {
    println!("Başka bir fonksiyon.");
}

Rust’ta bir fonksiyonu fn anahtar kelimesini, ardından fonksiyon adını ve bir çift parantezi yazarak tanımlarız. Süslü parantezler ({}), derleyiciye fonksiyon gövdesinin nerede başlayıp nerede bittiğini bildirir.

Tanımladığımız herhangi bir fonksiyonu, adını ve ardından bir çift parantez yazarak çağırabiliriz. baska_bir_fonksiyon programda tanımlı olduğu için main fonksiyonunun içinden çağrılabilir. Kaynak kodda baska_bir_fonksiyon fonksiyonunu main fonksiyonundan sonra tanımladığımıza dikkat edin; ondan önce de tanımlayabilirdik. Rust, fonksiyonlarınızı dosyanın neresinde tanımladığınızla ilgilenmez; yalnızca çağıran kodun görebileceği bir kapsam (scope) içinde tanımlanmış olmaları yeterlidir.

Fonksiyonları daha yakından incelemek için fonksiyonlar adında yeni bir ikili (binary) proje başlatalım. baska_bir_fonksiyon örneğini src/main.rs dosyasına yerleştirip çalıştırdığınızda aşağıdaki çıktıyı görmelisiniz:

$ cargo run
   Compiling fonksiyonlar v0.1.0 (file:///projects/fonksiyonlar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/fonksiyonlar`
Merhaba, dünya!
Başka bir fonksiyon.

Satırlar, main fonksiyonunda yer aldıkları sırayla çalıştırılır. Önce "Merhaba, dünya!" mesajı yazdırılır, ardından baska_bir_fonksiyon çağrılır ve kendi mesajı ekrana yazdırılır.

Parametreler

Fonksiyonları, fonksiyon imzasının (signature) bir parçası olan özel değişkenlere, yani parametrelere (parameters) sahip olacak şekilde tanımlayabiliriz. Bir fonksiyonun parametreleri olduğunda, bu parametreler için fonksiyona somut değerler iletebilirsiniz. Teknik olarak bu somut değerlere argüman (argument) denir; ancak günlük kullanımda geliştiriciler hem fonksiyon tanımındaki değişkenler hem de fonksiyon çağrılırken iletilen somut değerler için parametre ve argüman kelimelerini sıklıkla birbirinin yerine kullanır.

baska_bir_fonksiyon fonksiyonunun bu sürümünde bir parametre ekliyoruz:

Dosya adı: src/main.rs

fn main() {
    baska_bir_fonksiyon(5);
}

fn baska_bir_fonksiyon(x: i32) {
    println!("x'in değeri: {x}");
}

Bu programı çalıştırmayı deneyin; aşağıdaki çıktıyı almalısınız:

$ cargo run
   Compiling fonksiyonlar v0.1.0 (file:///projects/fonksiyonlar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/fonksiyonlar`
x'in değeri: 5

baska_bir_fonksiyon bildiriminin x adında bir parametresi vardır ve x’in türü i32 olarak belirtilmiştir. baska_bir_fonksiyon fonksiyonuna 5 değerini ilettiğimizde, println! makrosu, biçimlendirme metnindeki (format string) içinde x bulunan süslü parantez çiftinin yerine 5 değerini koyar.

Fonksiyon imzalarında her parametrenin türünü mutlaka bildirmelisiniz. Bu, Rust’ın tasarımında bilinçli olarak alınmış bir karardır: Fonksiyon tanımlarında tür bildirimini zorunlu kılmak, derleyicinin kodun diğer kısımlarında hangi türü kastettiğinizi anlamak için sizden neredeyse hiçbir zaman tür bildirimi istememesi anlamına gelir. Ayrıca derleyici, fonksiyonun hangi türleri beklediğini bildiğinde çok daha açıklayıcı hata mesajları üretebilir.

Birden fazla parametre tanımlarken parametre bildirimlerini aşağıdaki gibi virgülle ayırın:

Dosya adı: src/main.rs

fn main() {
    etiketli_olcum_yazdir(5, 'h');
}

fn etiketli_olcum_yazdir(deger: i32, birim_etiketi: char) {
    println!("Ölçüm değeri: {deger}{birim_etiketi}");
}

Bu örnek, iki parametre alan etiketli_olcum_yazdir adında bir fonksiyon oluşturur. İlk parametre deger adındadır ve i32 türündedir. İkinci parametre ise birim_etiketi adındadır ve char türündedir. Fonksiyon daha sonra hem deger hem de birim_etiketi değerlerini içeren bir metin yazdırır.

Gelin bu kodu çalıştırmayı deneyelim. fonksiyonlar projenizin src/main.rs dosyasındaki mevcut programı yukarıdaki örnekle değiştirin ve cargo run komutuyla çalıştırın:

$ cargo run
   Compiling fonksiyonlar v0.1.0 (file:///projects/fonksiyonlar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/fonksiyonlar`
Ölçüm değeri: 5h

Fonksiyonu deger için 5 ve birim_etiketi için 'h' değerleriyle çağırdığımızdan program çıktısı bu değerleri içerir.

Deyimler ve İfadeler

Fonksiyon gövdeleri, isteğe bağlı olarak sonunda bir ifade (expression) bulunan bir dizi deyimden (statement) oluşur. Şimdiye kadar ele aldığımız fonksiyonların sonunda bir ifade yer almıyordu; ancak bir deyimin parçası olarak ifadelerle karşılaştınız. Rust ifade tabanlı (expression-based) bir dil olduğundan bu ayrımı anlamak son derece önemlidir. Diğer pek çok dilde aynı ayrım bulunmaz; bu nedenle deyimlerin ve ifadelerin ne olduğuna ve aralarındaki farkların fonksiyon gövdelerini nasıl etkilediğine yakından bakalım.

• Deyimler, belirli bir eylemi gerçekleştiren ve değer döndürmeyen komutlardır.
• İfadeler, değerlendirilerek bir sonuç değeri üreten kod parçalarıdır.

Gelin bazı örneklere bakalım.

Aslında deyimleri ve ifadeleri daha önce de kullandık. let anahtar kelimesiyle bir değişken oluşturup ona değer atamak bir deyimdir. Liste 3-1’de let y = 6; bir deyimdir.

fn main() {
    let y = 6;
}

Fonksiyon tanımları da birer deyimdir; yukarıdaki örneğin tamamı başlı başına bir deyimdir. (Ancak birazdan göreceğimiz gibi bir fonksiyonu çağırmak deyim değildir.)

Deyimler değer döndürmez. Bu nedenle aşağıdaki kodun yapmaya çalıştığı gibi bir let deyimini başka bir değişkene atayamazsınız; derleme hatası alırsınız:

Dosya adı: src/main.rs

fn main() {
    let x = (let y = 6);
}

Bu programı çalıştırdığınızda alacağınız hata şu şekilde görünür:

$ cargo run
   Compiling fonksiyonlar v0.1.0 (file:///projects/fonksiyonlar)
error: expected expression, found `let` statement
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^
  |
  = note: only supported directly in conditions of `if` and `while` expressions

warning: unnecessary parentheses around assigned value
 --> src/main.rs:2:13
  |
2 |     let x = (let y = 6);
  |             ^         ^
  |
  = note: `#[warn(unused_parens)]` (part of `#[warn(unused)]`) on by default
help: remove these parentheses
  |
2 -     let x = (let y = 6);
2 +     let x = let y = 6;
  |

warning: `fonksiyonlar` (bin "fonksiyonlar") generated 1 warning
error: could not compile `fonksiyonlar` (bin "fonksiyonlar") due to 1 previous error; 1 warning emitted

let y = 6 deyimi bir değer döndürmediğinden x değişkeninin bağlanabileceği herhangi bir değer yoktur (derleyici de expected expression, found `let` statement yani “ifade bekleniyordu, let deyimi bulundu” diyerek tam olarak bu noktaya işaret eder). Bu davranış, atama işleminin atanan değeri döndürdüğü C ve Ruby gibi dillerden farklıdır. O dillerde x = y = 6 yazarak hem x hem de y değişkenlerinin 6 değerini almasını sağlayabilirsiniz; Rust’ta ise bu geçerli değildir.

İfadeler değerlendirilerek bir değer üretir ve Rust’ta yazacağınız kodun geri kalanının büyük çoğunluğunu oluşturur. Örneğin 5 + 6 gibi matematiksel bir işlemi düşünün; bu işlem değerlendirildiğinde 11 değerini üreten bir ifadedir. İfadeler, deyimlerin bir parçası olabilir: Liste 3-1’deki let y = 6; deyiminde yer alan 6, değerlendirildiğinde 6 değerini üreten bir ifadedir. Bir fonksiyonu çağırmak bir ifadedir. Bir makroyu çağırmak bir ifadedir. Süslü parantezlerle oluşturulan yeni bir kapsam bloğu da bir ifadedir; örneğin:

Dosya adı: src/main.rs

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("y'nin değeri: {y}");
}

Buradaki ifade:

{
    let x = 3;
    x + 1
}

bu örnekte değerlendirilerek 4 değerini üreten bir bloktur. Bu değer, let deyiminin bir parçası olarak y değişkenine bağlanır. Şimdiye kadar gördüğünüz çoğu satırın aksine, x + 1 satırının sonunda noktalı virgül (;) bulunmadığına dikkat edin. İfadelerin sonunda noktalı virgül yer almaz. Bir ifadenin sonuna noktalı virgül eklerseniz onu bir deyime dönüştürürsünüz ve artık bir değer döndürmez. Şimdi fonksiyonların dönüş değerlerini ve ifadeleri incelerken bu kuralı aklınızda bulundurun.

Dönüş Değerleri Olan Fonksiyonlar

Fonksiyonlar, kendilerini çağıran koda değer döndürebilir. Dönüş değerlerine isim vermeyiz ancak türlerini bir ok işaretinden (->) sonra mutlaka bildirmemiz gerekir. Rust’ta bir fonksiyonun dönüş değeri, fonksiyon gövdesi bloğundaki son ifadenin değeriyle aynıdır. return anahtar kelimesini kullanıp bir değer belirterek bir fonksiyondan erken dönebilirsiniz; ancak çoğu fonksiyon son ifadeyi örtük olarak (implicitly) döndürür. İşte değer döndüren bir fonksiyon örneği:

Dosya adı: src/main.rs

fn bes() -> i32 {
    5
}

fn main() {
    let x = bes();

    println!("x'in değeri: {x}");
}

bes fonksiyonunun içinde hiçbir fonksiyon çağrısı, makro, hatta let deyimi bile yoktur; yalnızca tek başına 5 sayısı yer alır. Bu, Rust’ta tamamen geçerli bir fonksiyondur. Fonksiyonun dönüş türünün de -> i32 olarak belirtildiğine dikkat edin. Bu kodu çalıştırmayı deneyin; çıktı şöyle görünmelidir:

$ cargo run
   Compiling fonksiyonlar v0.1.0 (file:///projects/fonksiyonlar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/fonksiyonlar`
x'in değeri: 5

bes fonksiyonundaki 5, fonksiyonun dönüş değeridir; bu yüzden dönüş türü i32 olarak tanımlanmıştır. Bunu biraz daha ayrıntılı inceleyelim. Burada iki önemli nokta vardır: İlk olarak, let x = bes(); satırı bir değişkene ilk değerini vermek için bir fonksiyonun dönüş değerini kullandığımızı gösterir. bes fonksiyonu 5 döndürdüğü için bu satır aşağıdakiyle birebir aynıdır:

#![allow(unused)]
fn main() {
let x = 5;
}

İkinci olarak, bes fonksiyonu hiçbir parametre almaz ve dönüş değerinin türünü tanımlar; ancak fonksiyonun gövdesi, değerini döndürmek istediğimiz bir ifade olduğu için sonunda noktalı virgül bulunmayan tek bir 5 sayısından oluşur.

Başka bir örneğe bakalım:

Dosya adı: src/main.rs

fn main() {
    let x = arti_bir(5);

    println!("x'in değeri: {x}");
}

fn arti_bir(x: i32) -> i32 {
    x + 1
}

Bu kodu çalıştırmak ekrana x'in değeri: 6 yazdıracaktır. Peki x + 1 satırının sonuna bir noktalı virgül koyarak onu bir ifadeden bir deyime dönüştürürsek ne olur?

Dosya adı: src/main.rs

fn main() {
    let x = arti_bir(5);

    println!("x'in değeri: {x}");
}

fn arti_bir(x: i32) -> i32 {
    x + 1;
}

Bu kodu derlemek aşağıdaki gibi bir hata üretecektir:

$ cargo run
   Compiling fonksiyonlar v0.1.0 (file:///projects/fonksiyonlar)
error[E0308]: mismatched types
 --> src/main.rs:7:24
  |
7 | fn arti_bir(x: i32) -> i32 {
  |    --------            ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
8 |     x + 1;
  |          - help: remove this semicolon to return this value

For more information about this error, try `rustc --explain E0308`.
error: could not compile `fonksiyonlar` (bin "fonksiyonlar") due to 1 previous error

Ana hata mesajı olan error[E0308]: mismatched types (uyuşmayan türler), bu koddaki temel sorunu açıkça ortaya koyar. arti_bir fonksiyonunun tanımı bir i32 döndüreceğini bildirir; ancak deyimler bir değer üretmez ve bu durum boş demet olan birim tür () ile temsil edilir (expected `i32`, found `()`). Derleyicinin belirttiği gibi, fonksiyon gövdesinde noktalı virgülsüz bir sonuç ifadesi (tail expression) veya return bulunmadığından fonksiyon örtük olarak () döndürür; bu da fonksiyon imzasındaki -> i32 tanımıyla çelişerek derleme hatasına yol açar. Çıktının sonundaki help: remove this semicolon to return this value (bu değeri döndürmek için bu noktalı virgülü kaldırın) satırı ise hatayı nasıl düzelteceğimizi doğrudan gösterir.

Yorumlar

Yorumlar

Tüm programcılar kodlarını kolay anlaşılır kılmak için çaba gösterir; ancak bazen ek açıklamalar yapmak gerekir. Bu gibi durumlarda programcılar kaynak kodlarına derleyicinin yok sayacağı, fakat kodu okuyan kişilerin faydalı bulabileceği yorumlar (comments) bırakırlar.

İşte basit bir yorum:

#![allow(unused)]
fn main() {
// merhaba, dünya
}

Rust’ta yaygın yorum biçimi iki eğik çizgiyle (//) başlar ve satır sonuna kadar devam eder. Birden fazla satırı bu biçimde yorumlamak için her satırın başına // ekleriz:

#![allow(unused)]
fn main() {
// Burada oldukça karmaşık bir işlem yapıyoruz; bunu açıklamak için birden
// fazla yorum satırına ihtiyaç duyacak kadar uzun! Vay canına! Umarım bu
// yorum burada neler olup bittiğini yeterince açıklar.
}

Yorumlar, kod içeren satırların sonuna da yerleştirilebilir:

Dosya adı: src/main.rs

fn main() {
    let sansli_sayi = 7; // Bugün kendimi şanslı hissediyorum.
}

Ancak yorumların çoğunlukla bu biçimde, yani açıkladıkları kodun hemen üstünde ayrı bir satırda kullanıldığını görürsünüz:

Dosya adı: src/main.rs

fn main() {
    // Bugün kendimi şanslı hissediyorum.
    let sansli_sayi = 7;
}

Rust’ta ayrıca Bölüm 14’teki “Crates.io’da Bir Crate Yayınlama” kısmında ele alacağımız belgelendirme yorumları (documentation comments) adında başka bir yorum türü daha vardır.

Kontrol Akışı

Kontrol Akışı

Bir koşulun true olup olmamasına bağlı olarak belirli bir kodu çalıştırabilme ve bir koşul true olduğu sürece bir kodu tekrar tekrar yürütebilme olanağı, çoğu programlama dilinin temel yapı taşlarındandır. Rust kodunun yürütme akışını kontrol etmenizi sağlayan en yaygın yapılar if ifadeleri ve döngülerdir.

if İfadeleri

Bir if ifadesi, koşullara bağlı olarak kodunuzu dallandırmanıza olanak tanır. Bir koşul belirtir ve programa, “Bu koşul sağlanırsa şu kod bloğunu çalıştır; koşul sağlanmazsa bu kod bloğunu çalıştırma,” demiş olursunuz.

if ifadesini incelemek için projects dizininizde dallanmalar adında yeni bir proje oluşturun. src/main.rs dosyasına aşağıdaki kodu yazın:

Dosya adı: src/main.rs

fn main() {
    let sayi = 3;

    if sayi < 5 {
        println!("koşul doğru");
    } else {
        println!("koşul yanlış");
    }
}

Tüm if ifadeleri if anahtar kelimesiyle başlar ve ardından bir koşul gelir. Bu örnekte koşul, sayi değişkeninin 5’ten küçük bir değere sahip olup olmadığını kontrol eder. Koşul true olduğunda çalıştırılacak kod bloğunu, koşuldan hemen sonra süslü parantezler ({}) içine yerleştiririz. if ifadelerindeki koşullarla ilişkili kod bloklarına, tıpkı Bölüm 2’deki “Tahmini Gizli Sayıyla Karşılaştırmak” kısmında ele aldığımız match ifadelerindeki kollar gibi bazen kollar (arms) adı verilir.

İsteğe bağlı olarak —bu örnekte yaptığımız gibi— koşulun false olarak değerlendirilmesi durumunda programın çalıştıracağı alternatif bir kod bloğu sunmak üzere bir else ifadesi de ekleyebiliriz. Bir else ifadesi sağlamazsanız ve koşul false çıkarsa program if bloğunu doğrudan atlar ve sıradaki kod parçasına geçer.

Bu kodu çalıştırmayı deneyin; aşağıdaki çıktıyı görmelisiniz:

$ cargo run
   Compiling dallanmalar v0.1.0 (file:///projects/dallanmalar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/dallanmalar`
koşul doğru

Şimdi ne olacağını görmek için sayi değişkeninin değerini koşulu false yapacak bir değerle değiştirmeyi deneyelim:

fn main() {
    let sayi = 7;

    if sayi < 5 {
        println!("koşul doğru");
    } else {
        println!("koşul yanlış");
    }
}

Programı tekrar çalıştırın ve çıktıya bakın:

$ cargo run
   Compiling dallanmalar v0.1.0 (file:///projects/dallanmalar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/dallanmalar`
koşul yanlış

Bu koddaki koşulun mutlaka bir bool olması gerektiğini de vurgulamakta fayda var. Koşul bool türünde değilse derleme hatası alırız. Örneğin aşağıdaki kodu çalıştırmayı deneyin:

Dosya adı: src/main.rs

fn main() {
    let sayi = 3;

    if sayi {
        println!("sayi'nın değeri üç");
    }
}

Bu kez if koşulu 3 değerini üretir ve Rust derleyicisi bir hata verir:

$ cargo run
   Compiling dallanmalar v0.1.0 (file:///projects/dallanmalar)
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if sayi {
  |        ^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `dallanmalar` (bin "dallanmalar") due to 1 previous error

Derleyici hatası (expected `bool`, found integer), Rust’ın bir bool beklediğini ancak bunun yerine bir tam sayıyla karşılaştığını bildirir. Ruby ve JavaScript gibi dillerin aksine Rust, Boolean olmayan türleri otomatik olarak Boolean değerine dönüştürmeye (“truthy/falsy” değerlendirmesi yapmaya) çalışmaz. Her zaman açık davranmalı ve if yapısına koşul olarak doğrudan bir bool ifadesi vermelisiniz. Örneğin if kod bloğunun yalnızca bir sayı 0’a eşit olmadığında çalışmasını istiyorsak if ifadesini aşağıdaki gibi değiştirebiliriz:

Dosya adı: src/main.rs

fn main() {
    let sayi = 3;

    if sayi != 0 {
        println!("sayı sıfırdan farklı bir şeydi");
    }
}

Bu kodu çalıştırmak ekrana sayı sıfırdan farklı bir şeydi mesajını yazdıracaktır.

else if ile Birden Fazla Koşulu Ele Almak

if ve else yapılarını bir else if ifadesinde birleştirerek birden fazla koşulu kontrol edebilirsiniz. Örneğin:

Dosya adı: src/main.rs

fn main() {
    let sayi = 6;

    if sayi % 4 == 0 {
        println!("sayi 4'e bölünebilir");
    } else if sayi % 3 == 0 {
        println!("sayi 3'e bölünebilir");
    } else if sayi % 2 == 0 {
        println!("sayi 2'ye bölünebilir");
    } else {
        println!("sayi 4'e, 3'e veya 2'ye bölünemez");
    }
}

Bu programın izleyebileceği dört olası yürütme yolu vardır. Kodu çalıştırdıktan sonra aşağıdaki çıktıyı görmelisiniz:

$ cargo run
   Compiling dallanmalar v0.1.0 (file:///projects/dallanmalar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/dallanmalar`
sayi 3'e bölünebilir

Bu program çalıştığında her bir if ifadesini sırayla kontrol eder ve koşulu true olarak değerlendirilen ilk gövdeyi yürütür. 6 sayısı 2’ye de tam bölünebildiği hâlde ne sayi 2'ye bölünebilir çıktısını ne de else bloğundaki sayi 4'e, 3'e veya 2'ye bölünemez metnini gördüğümüze dikkat edin. Bunun nedeni, Rust’ın yalnızca koşulu true olan ilk bloğu çalıştırması ve bir eşleşme bulduktan sonra geri kalan koşulları kontrol bile etmemesidir.

Çok fazla else if ifadesi kullanmak kodunuzu karmaşıklaştırabilir; bu yüzden birden fazla else if kullanmanız gerektiğinde kodunuzu yeniden düzenlemek (refactoring) isteyebilirsiniz. Bölüm 6, bu gibi durumlar için match adında güçlü bir Rust dallanma yapısını tanıtmaktadır.

Bir let Deyiminde if Kullanmak

if bir ifade (expression) olduğundan, Liste 3-2’de görüldüğü gibi ürettiği sonucu bir değişkene atamak üzere onu bir let deyiminin (statement) sağ tarafında kullanabiliriz.

fn main() {
    let durum = true;
    let sayi = if durum { 5 } else { 6 };

    println!("sayi'nın değeri: {sayi}");
}

sayi değişkeni, if ifadesinin ürettiği sonuca bağlı olarak bir değere bağlanacaktır. Ne olacağını görmek için bu kodu çalıştırın:

$ cargo run
   Compiling dallanmalar v0.1.0 (file:///projects/dallanmalar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/dallanmalar`
sayi'nın değeri: 5

Kod bloklarının içlerindeki son ifadenin değerini ürettiğini ve sayıların da tek başlarına birer ifade olduğunu hatırlayın. Bu örnekte tüm if ifadesinin değeri, hangi kod bloğunun çalıştırıldığına bağlıdır. Dolayısıyla if ifadesinin her bir kolundan sonuç olarak dönebilecek değerlerin aynı türde olması gerekir; Liste 3-2’de hem if kolunun hem de else kolunun ürettiği sonuçlar i32 tam sayısıydı. Türler aşağıdaki örnekte olduğu gibi birbiriyle uyumsuzsa derleme hatası alırız:

Dosya adı: src/main.rs

fn main() {
    let durum = true;

    let sayi = if durum { 5 } else { "altı" };

    println!("sayi'nın değeri: {sayi}");
}

Bu kodu derlemeye çalıştığımızda bir hata alırız. if ve else kolları birbiriyle uyumsuz değer türlerine sahiptir ve Rust derleyicisi programdaki sorunun tam olarak nerede olduğunu gösterir:

$ cargo run
   Compiling dallanmalar v0.1.0 (file:///projects/dallanmalar)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:38
  |
4 |     let sayi = if durum { 5 } else { "altı" };
  |                           -          ^^^^^^ expected integer, found `&str`
  |                           |
  |                           expected because of this

For more information about this error, try `rustc --explain E0308`.
error: could not compile `dallanmalar` (bin "dallanmalar") due to 1 previous error

if bloğundaki ifade bir tam sayı üretirken else bloğundaki ifade bir string dilimi (&str) üretir. Bu kod derlenmez (`if` and `else` have incompatible types); çünkü değişkenler tek bir türe sahip olmak zorundadır ve Rust’ın sayi değişkeninin hangi türde olduğunu derleme zamanında kesin olarak bilmesi gerekir. sayi değişkeninin türünü bilmek, derleyicinin sayi değişkenini kullandığımız her yerde türün geçerli olduğunu doğrulamasını sağlar. sayi’nin türü yalnızca çalışma zamanında belirlenseydi Rust bu doğrulamayı yapamazdı; derleyicinin herhangi bir değişken için birden fazla varsayımsal türü takip etmesi gerekseydi hem derleyici çok daha karmaşık olurdu hem de kod hakkında daha az garanti verebilirdi.

Döngülerle Tekrar

Bir kod bloğunu birden fazla kez çalıştırmak çoğu zaman işe yarar. Rust bu görev için, döngü gövdesindeki kodu sonuna kadar çalıştırıp ardından hemen başa dönerek devam eden çeşitli döngüler (loops) sunar. Döngülerle denemeler yapmak için donguler adında yeni bir proje oluşturalım.

Rust’ta üç tür döngü vardır: loop, while ve for. Gelin her birini sırayla deneyelim.

loop ile Kodu Tekrarlamak

loop anahtar kelimesi, Rust’a bir kod bloğunu sonsuza dek ya da siz açıkça durmasını söyleyene kadar tekrar tekrar çalıştırmasını bildirir.

Örnek olarak donguler dizininizdeki src/main.rs dosyasını aşağıdaki gibi görünecek şekilde değiştirin:

Dosya adı: src/main.rs

fn main() {
    loop {
        println!("tekrar!");
    }
}

Bu programı çalıştırdığımızda, programı elle durdurana kadar ekrana aralıksız olarak tekrar! yazdırıldığını görürüz. Çoğu terminal, sürekli bir döngü içinde çalışan programı yarıda kesmek (interrupt) için ctrl-C klavye kısayolunu destekler. Gelin deneyelim:

$ cargo run
   Compiling donguler v0.1.0 (file:///projects/donguler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/donguler`
tekrar!
tekrar!
tekrar!
tekrar!
^Ctekrar!

^C sembolü, ctrl-C tuşlarına bastığınız noktayı gösterir.

Kesme sinyali ulaştığında yürütmenin döngünün neresinde olduğuna bağlı olarak ^C işaretinden sonra tekrar! kelimesinin bir kez daha yazdırıldığını görebilir veya görmeyebilirsiniz.

Neyse ki Rust, kod içinden döngüden çıkmanın bir yolunu da sunar. Programa döngüyü yürütmeyi ne zaman bırakacağını bildirmek için döngünün içine break anahtar kelimesini yerleştirebilirsiniz. Bölüm 2’deki “Doğru Tahminden Sonra Çıkmak” kısmında geliştirdiğimiz tahmin oyununda, kullanıcı doğru sayıyı bulup oyunu kazandığında programdan çıkmak için break kullandığımızı hatırlayın.

Tahmin oyununda ayrıca continue anahtar kelimesini de kullanmıştık; continue, bir döngü içinde programa mevcut döngü adımında (iteration) geriye kalan kodları atlamasını ve doğrudan bir sonraki adıma geçmesini söyler.

Döngülerden Değer Döndürmek

loop yapısının kullanım alanlarından biri, örneğin bir thread’in (iş parçacığı) işini tamamlayıp tamamlamadığını kontrol etmek gibi başarısız olabileceğini bildiğiniz bir işlemi yeniden denemektir. Üstelik bu işlemin sonucunu döngünün dışına, kodunuzun geri kalanına aktarmanız da gerekebilir. Bunu yapmak için döngüyü durdurmak amacıyla kullandığınız break ifadesinden sonra döndürülmesini istediğiniz değeri yazabilirsiniz; aşağıda gösterildiği gibi bu değer, kullanabilmeniz için döngünün dışına döndürülür:

fn main() {
    let mut sayac = 0;

    let sonuc = loop {
        sayac += 1;

        if sayac == 10 {
            break sayac * 2;
        }
    };

    println!("sonuc değeri: {sonuc}");
}

Döngüden önce sayac adında değiştirilebilir bir değişken bildirip ilk değerini 0 olarak veriyoruz. Ardından döngüden dönecek değeri tutmak üzere sonuc adında bir değişken tanımlıyoruz. Döngünün her adımında sayac değişkenine 1 ekliyor ve sayac değerinin 10’a eşit olup olmadığını kontrol ediyoruz. Eşit olduğunda break anahtar kelimesini sayac * 2 değeriyle birlikte kullanıyoruz. Döngü bloğundan sonra, üretilen değeri sonuc değişkenine atayan let deyimini sonlandırmak için bir noktalı virgül (};) koyuyoruz. Son olarak sonuc değişkenindeki değeri, yani bu örnekte 20 değerini ekrana yazdırıyoruz.

Bir döngünün içinden return de yapabilirsiniz. Ancak break yalnızca içinde bulunulan döngüden çıkarken, return her zaman içinde bulunulan fonksiyondan tamamen çıkar.

Döngü Etiketleriyle Belirsizliği Gidermek

İç içe geçmiş döngüleriniz varsa break ve continue varsayılan olarak o noktadaki en içteki döngüye uygulanır. İsteğe bağlı olarak bir döngü üzerinde döngü etiketi (loop label) tanımlayabilir ve ardından break veya continue ile birlikte bu etiketi kullanarak söz konusu anahtar kelimelerin en içteki döngü yerine etiketli döngüye uygulanmasını sağlayabilirsiniz. Döngü etiketleri mutlaka tek tırnak işareti (') ile başlamalıdır. İşte iç içe iki döngü içeren bir örnek:

fn main() {
    let mut ileri_sayim = 0;
    'yukari_sayma: loop {
        println!("İleri sayım = {ileri_sayim}");
        let mut geri_sayim = 10;

        loop {
            println!("Geri sayım = {geri_sayim}");
            if geri_sayim == 9 {
                break;
            }
            if ileri_sayim == 2 {
                break 'yukari_sayma;
            }
            geri_sayim -= 1;
        }

        ileri_sayim += 1;
    }
    println!("Son İlerleme = {ileri_sayim}");
}

Dıştaki döngü 'yukari_sayma etiketine sahiptir ve ileri_sayim değişkeniyle 0’dan 2’ye kadar yukarı doğru sayar. Etiketi olmayan içteki döngü ise geri_sayim değişkeniyle 10’dan 9’a kadar geriye doğru sayar. Etiket belirtmeyen ilk break yalnızca içteki döngüden çıkar. break 'yukari_sayma; deyimi ise doğrudan dıştaki döngüyü sonlandırır. Bu kod aşağıdaki çıktıyı üretir:

$ cargo run
   Compiling donguler v0.1.0 (file:///projects/donguler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.06s
     Running `target/debug/donguler`
İleri sayım = 0
Geri sayım = 10
Geri sayım = 9
İleri sayım = 1
Geri sayım = 10
Geri sayım = 9
İleri sayım = 2
Geri sayım = 10
Son İlerleme = 2

while ile Koşullu Döngüleri Sadeleştirmek

Bir programın döngü içinde bir koşulu değerlendirmesi sıklıkla gerekir. Koşul true olduğu sürece döngü çalışmaya devam eder; koşul true olmaktan çıktığında ise program break çağırarak döngüyü durdurur. Böyle bir davranışı loop, if, else ve break yapılarını bir arada kullanarak uygulamak mümkündür; dilerseniz bunu şimdi bir programda deneyebilirsiniz. Ancak bu kullanım kalıbı o kadar yaygındır ki Rust bunun için while döngüsü adı verilen yerleşik bir dil yapısı sunar. Liste 3-3’te döngüyü üç kez çalıştırmak, her adımda geriye doğru saymak ve döngü bittikten sonra bir mesaj yazdırıp çıkmak için while kullanıyoruz.

fn main() {
    let mut sayi = 3;

    while sayi != 0 {
        println!("{sayi}!");

        sayi -= 1;
    }

    println!("KALKIŞ!!!");
}

Bu yapı, loop, if, else ve break bir arada kullanıldığında gerekecek iç içe blokların çoğunu ortadan kaldırır ve kodu çok daha okunaklı kılar. Bir koşul true olarak değerlendirildiği sürece kod çalışır; aksi takdirde döngüden çıkılır.

for ile Bir Koleksiyon Üzerinde Döngü Kurmak

Bir dizi gibi bir koleksiyonun elemanları üzerinde döngü kurmak için while yapısını da kullanabilirsiniz. Örneğin Liste 3-4’teki döngü, a dizisindeki her bir elemanı ekrana yazdırır.

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut indeks = 0;

    while indeks < 5 {
        println!("değer: {}", a[indeks]);

        indeks += 1;
    }
}

Burada kod, dizideki elemanların indekslerini yukarı doğru sayar. 0 indeksinden başlar ve dizideki son indekse ulaşana dek (yani indeks < 5 koşulu artık true olmayana kadar) döngüyü sürdürür. Bu kodu çalıştırmak dizideki her bir elemanı yazdıracaktır:

$ cargo run
   Compiling donguler v0.1.0 (file:///projects/donguler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/donguler`
değer: 10
değer: 20
değer: 30
değer: 40
değer: 50

Beklendiği gibi beş dizi elemanının tamamı terminalde görünür. indeks değişkeni bir noktada 5 değerine ulaşsa da döngü, diziden altıncı bir değeri okumaya çalışmadan hemen önce sonlanır.

Ne var ki bu yaklaşım hataya açıktır; indeks değeri veya sınır koşulu yanlış yazılırsa programın çalışma zamanında paniklemesine (panic) yol açabiliriz. Örneğin a dizisinin tanımını dört elemanlı olacak şekilde değiştirip koşulu while indeks < 4 olarak güncellemeyi unutursanız kod panikler. Üstelik bu yöntem daha yavaştır; çünkü derleyici, döngünün her adımında a[indeks] erişimi sırasında indeksin dizi sınırları içinde olup olmadığını denetleyen ek çalışma zamanı kodu (bounds check) üretmek zorunda kalır.

Bunun yerine daha özlü ve güvenli bir alternatif olarak for döngüsü kullanabilir ve koleksiyondaki her öğe için belirli bir kodu çalıştırabilirsiniz. Bir for döngüsü Liste 3-5’teki gibi görünür.

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("değer: {element}");
    }
}

Bu kodu çalıştırdığımızda Liste 3-4 ile birebir aynı çıktıyı görürüz. Daha da önemlisi, artık kodun güvenliğini artırdık ve dizinin sonunu aşmaktan ya da yeterince ilerlemeyip bazı öğeleri atlamaktan kaynaklanabilecek hata olasılıklarını tamamen ortadan kaldırdık. İndeksin her adımda dizi uzunluğuyla karşılaştırılmasına gerek kalmadığından, for döngülerinden üretilen makine kodu da daha verimli çalışır.

Ayrıca for döngüsü kullandığınızda, dizideki eleman sayısını değiştirirseniz Liste 3-4’teki yöntemde olduğu gibi başka bir yerdeki sınır koşulunu güncellemeyi hatırlamanız gerekmez.

for döngülerinin sunduğu güvenlik ve sadelik, onları Rust’ta en sık kullanılan döngü yapısı hâline getirir. Liste 3-3’te while döngüsüyle yazdığımız geri sayım örneğinde olduğu gibi belirli bir kodu sabit sayıda çalıştırmak istediğiniz durumlarda bile çoğu Rust geliştiricisi (Rustacean) for döngüsünü tercih eder. Bunu yapmanın yolu, standart kütüphane tarafından sağlanan ve bir sayıdan başlayıp diğer sayıya gelmeden önceki tüm sayıları sırayla üreten Range (aralık) türünü kullanmaktır.

İşte bir for döngüsü ve aralığı tersine çeviren, henüz değinmediğimiz rev metodu kullanılarak yazılmış geri sayım örneği:

Dosya adı: src/main.rs

fn main() {
    for sayi in (1..4).rev() {
        println!("{sayi}!");
    }
    println!("KALKIŞ!!!");
}

Bu kod biraz daha hoş görünüyor, değil mi?

Özet

Başardınız! Bu oldukça kapsamlı bir bölümdü: Değişkenleri, skaler ve bileşik veri türlerini, fonksiyonları, yorumları, if ifadelerini ve döngüleri öğrendiniz! Bu bölümde ele alınan kavramlarla pratik yapmak için aşağıdaki işlevleri yerine getiren programlar geliştirmeyi deneyin:

• Sıcaklıkları Fahrenheit ve Celsius (Santigrat) birimleri arasında dönüştürün.
• n. Fibonacci sayısını üretin.
• Şarkıdaki tekrarlardan yararlanarak “The Twelve Days of Christmas” (Noel’in On İki Günü) şarkısının sözlerini ekrana yazdırın.

Devam etmeye hazır olduğunuzda, diğer programlama dillerinde yaygın olarak bulunmayan Rust’a özgü temel bir kavramı inceleyeceğiz: sahiplik (ownership).

Sahipliği Anlamak

Sahiplik (ownership), Rust’ın en ayırt edici özelliğidir ve dilin geri kalanı üzerinde derin etkilere sahiptir. Rust’ın bir çöp toplayıcıya (garbage collector) ihtiyaç duymadan bellek güvenliği garantisi sunmasını sağlar; bu nedenle sahipliğin nasıl çalıştığını anlamak büyük önem taşır. Bu bölümde sahipliğin yanı sıra onunla yakından ilişkili birkaç özelliği daha ele alacağız: ödünç alma (borrowing), dilimler (slices) ve Rust’ın verileri bellekte nasıl yerleştirdiği.

Sahiplik Nedir?

Sahiplik Nedir?

Sahiplik (ownership), bir Rust programının belleği nasıl yönettiğini belirleyen kurallar bütünüdür. Tüm programlar, çalışırken bilgisayarın belleğini nasıl kullandıklarını bir şekilde yönetmek zorundadır. Bazı dillerde program çalışırken artık kullanılmayan belleği düzenli olarak tarayıp temizleyen bir çöp toplama (garbage collection) mekanizması bulunur; bazı dillerde ise programcının belleği açıkça ayırması ve serbest bırakması gerekir. Rust üçüncü bir yaklaşım benimser: Bellek, derleyicinin derleme zamanında denetlediği kurallardan oluşan bir sahiplik sistemi aracılığıyla yönetilir. Bu kurallardan herhangi biri ihlal edilirse program derlenmez. Sahiplik sisteminin sunduğu özelliklerin hiçbiri, çalışırken programınızı yavaşlatmaz.

Sahiplik pek çok programcı için yeni bir kavram olduğundan buna alışmak biraz zaman alabilir. İyi haber şu ki Rust ve sahiplik sisteminin kuralları konusunda deneyim kazandıkça, güvenli ve verimli kodları doğal bir akışla geliştirmek sizin için giderek kolaylaşacaktır. Pes etmeden devam edin!

Sahipliği kavradığınızda, Rust’ı benzersiz kılan diğer özellikleri anlamak için sağlam bir temele sahip olacaksınız. Bu bölümde, çok yaygın bir veri yapısına odaklanan örnekler üzerinden sahipliği öğreneceksiniz: String’ler.

Sahiplik Kuralları

Öncelikle sahiplik kurallarına göz atalım. Bu kuralları somutlaştıran örnekler üzerinde çalışırken aşağıdaki üç maddeyi aklınızda bulundurun:

• Rust’taki her değerin bir sahibi (owner) vardır.
• Aynı anda yalnızca tek bir sahip olabilir.
• Sahip kapsam dışına çıktığında değer düşürülür (drop edilir).

Değişken Kapsamı

Temel Rust sözdizimini geride bıraktığımıza göre, bundan sonraki örneklerin tamamına fn main() { kodunu dahil etmeyeceğiz; dolayısıyla örnekleri kendiniz deneyerek takip ediyorsanız kodları bir main fonksiyonunun içine yerleştirmeyi unutmayın. Böylece örneklerimiz daha özlü kalacak ve basmakalıp kodlar yerine doğrudan asıl ayrıntılara odaklanabileceğiz.

Sahipliğin ilk örneği olarak bazı değişkenlerin kapsamını (scope) inceleyeceğiz. Kapsam, bir öğenin program içinde geçerli olduğu aralıktır. Aşağıdaki değişkeni ele alalım:

#![allow(unused)]
fn main() {
let metin = "merhaba";
}

metin değişkeni bir string sabitine (string literal) başvurur; string sabitlerinde metnin değeri doğrudan programımızın kaynak koduna gömülüdür. Bu değişken, tanımlandığı noktadan içinde bulunduğu kapsamın sonuna kadar geçerlidir. Liste 4-1, metin değişkeninin nerelerde geçerli olacağını yorum satırlarıyla gösteren bir programı sunmaktadır.

fn main() {
    {
        // metin burada geçerli değil, henüz tanımlanmadı
        let metin = "merhaba"; // metin bu noktadan itibaren geçerlidir

        // metin ile ilgili işlemler yap
    } // bu kapsam biter ve metin artık geçerli değildir
}

Başka bir deyişle, burada dikkat edilmesi gereken iki önemli an vardır:

• metin kapsama girdiğinde geçerlidir.
• Kapsam dışına çıkana kadar geçerliliğini korur.

Bu noktaya kadar kapsamlar ile değişkenlerin geçerlilik süresi arasındaki ilişki diğer programlama dillerindekine oldukça benzer. Şimdi String türünü tanıtarak bu temelin üzerine yeni kavramlar inşa edeceğiz.

String Türü

Sahiplik kurallarını göstermek için Bölüm 3’teki “Veri Türleri” bölümünde ele aldıklarımızdan daha karmaşık bir veri türüne ihtiyacımız var. Daha önce incelediğimiz türlerin hepsi bilinen bir boyuta sahiptir; yığında saklanabilir, kapsamları bittiğinde yığından çıkarılabilir ve kodun başka bir bölümü aynı değeri farklı bir kapsamda kullanmak istediğinde yeni ve bağımsız bir örnek oluşturmak üzere hızlıca kopyalanabilir. Biz ise öbekte saklanan verileri incelemek ve Rust’ın bu verileri ne zaman temizleyeceğini nasıl bildiğini keşfetmek istiyoruz; String türü bunun için harika bir örnektir.

Burada String türünün yalnızca sahiplikle ilgili yönlerine odaklanacağız. Bu özellikler, ister standart kütüphane tarafından sağlansın ister sizin tarafınızdan oluşturulsun, diğer karmaşık veri türleri için de geçerlidir. String türünün sahiplik dışındaki yönlerini Bölüm 8’de ayrıntılı olarak ele alacağız.

Bir metin değerinin programımıza doğrudan yazıldığı string sabitlerini zaten görmüştük. String sabitleri kullanışlıdır ancak metinlerle çalışmak isteyebileceğimiz her durum için uygun değildir. Bunun bir nedeni değiştirilemez olmalarıdır. Bir diğer nedeni ise kodumuzu yazarken her metin değerini önceden bilemememizdir: Örneğin kullanıcıdan bir girdi alıp saklamak istediğimizde ne yapacağız? Rust, tam da bu gibi durumlar için String türüne sahiptir. Bu tür, öbek üzerinde ayrılan verileri yönetir ve bu sayede derleme zamanında boyutu bilinmeyen miktarda metni saklayabilir. Aşağıdaki gibi from fonksiyonunu kullanarak bir string sabitinden String oluşturabilirsiniz:

#![allow(unused)]
fn main() {
let metin = String::from("merhaba");
}

Çift iki nokta üst üste (::) operatörü, string_from gibi bir isim kullanmak yerine bu özel from fonksiyonunu String türünün ad alanı (namespace) altında çağırmamıza olanak tanır. Bu sözdizimini Bölüm 5’teki “Metotlar” bölümünde ve Bölüm 7’de modüllerle ad alanlarını incelerken “Modül Ağacındaki Bir Öğeye Başvurmak İçin Yollar” bölümünde daha ayrıntılı ele alacağız.

Bu tür bir string değiştirilebilir:

fn main() {
    let mut metin = String::from("merhaba");

    metin.push_str(", dünya!"); // push_str() bir String'e sabit metin ekler

    println!("{metin}"); // bu `merhaba, dünya!` yazdıracak
}

Peki buradaki fark nedir? Neden String değiştirilebilirken string sabitleri değiştirilemez? Aradaki fark, bu iki türün belleği ele alış biçiminden kaynaklanır.

Bellek ve Ayırma

Bir string sabitinde içeriği derleme zamanında bildiğimiz için metin doğrudan son çalıştırılabilir ikili dosyaya gömülür. String sabitlerinin hızlı ve verimli olmasının nedeni budur. Bu kullanımda metnin içeriği baştan bilindiği için çalışma zamanında ayrıca bellek ayırmaya gerek yoktur. Ne yazık ki derleme zamanında boyutu bilinmeyen ve program çalışırken boyutu değişebilecek her bir metin parçası için ikili dosyanın içine sabit bir bellek bloğu koyamayız.

String türünde ise değiştirilebilir ve büyüyebilir bir metin parçasını desteklemek amacıyla, içeriği tutmak üzere öbekte derleme zamanında bilinmeyen miktarda bellek ayırmamız gerekir. Bu durum iki gereklilik doğurur:

• Bellek, çalışma zamanında bellek ayırıcıdan talep edilmelidir.
• String ile işimiz bittiğinde bu belleği ayırıcıya iade etmenin bir yoluna ihtiyacımız vardır.

İlk kısım bizim tarafımızdan başlatılır: String::from fonksiyonunu çağırdığımızda, arka plandaki uygulaması ihtiyaç duyduğu belleği talep eder. Bu kısım programlama dillerinin neredeyse tamamında ortaktır.

Ancak ikinci kısım dilden dile farklılaşır. Bir çöp toplayıcıya (garbage collector — GC) sahip dillerde GC, artık kullanılmayan belleği takip edip temizler ve bizim bunu düşünmemiz gerekmez. Çöp toplayıcısı olmayan çoğu dilde ise belleğin ne zaman artık kullanılmadığını tespit etmek ve tıpkı talep ederken yaptığımız gibi açıkça kod çağırarak onu serbest bırakmak bizim sorumluluğumuzdadır. Bunu hatasız yapmak tarihsel olarak zorlu bir programlama problemi olmuştur. Unutursak belleği boşa harcarız. Çok erken serbest bırakırsak elimizde geçersiz bir değişken kalır. İki kez serbest bırakırsak bu da ayrı bir hatadır. Tam olarak bir allocate (ayırma) işlemini tam olarak bir free (serbest bırakma) işlemiyle eşleştirmemiz gerekir.

Rust ise farklı bir yol izler: Bellek, kendisine sahip olan değişken kapsam dışına çıktığı anda otomatik olarak iade edilir. İşte Liste 4-1’deki kapsam örneğimizin string sabiti yerine String kullanan sürümü:

fn main() {
    {
        let metin = String::from("merhaba"); // metin bu noktadan itibaren geçerlidir

        // metin ile ilgili işlemler yap
    } // bu kapsam artık bitti ve metin artık
      // geçerli değil
}

String değerimizin kullandığı belleği ayırıcıya iade edebileceğimiz doğal bir nokta vardır: metin değişkeni kapsam dışına çıktığı an. Bir değişken kapsam dışına çıktığında Rust bizim yerimize özel bir fonksiyon çağırır. drop adı verilen bu fonksiyon, String türünün yazarının belleği iade edecek kodu yerleştirdiği yerdir. Rust, kapanış süslü parantezinde drop fonksiyonunu otomatik olarak çağırır.

Bu kalıbın Rust kodunun yazılma biçimi üzerinde derin bir etkisi vardır. Şu an basit görünebilir; ancak öbekte ayırdığımız veriyi birden fazla değişkenin kullanmasını istediğimiz daha karmaşık durumlarda kodun davranışı beklenmedik gelebilir. Gelin şimdi bu durumları yakından inceleyelim.

Değişkenlerin ve Verilerin Taşıma ile Etkileşimi

Rust’ta birden fazla değişken aynı veriyle farklı biçimlerde etkileşime girebilir. Liste 4-2, tam sayılar kullanan bir örneği göstermektedir.

fn main() {
    let x = 5;
    let y = x;
}

Bu kodun ne yaptığını muhtemelen tahmin edebiliriz: “5 değerini x değişkenine bağla; ardından x içindeki değerin bir kopyasını oluşturup y değişkenine bağla.” Artık elimizde x ve y olmak üzere iki değişken vardır ve ikisi de 5 değerine eşittir. Gerçekleşen şey de tam olarak budur; çünkü tam sayılar bilinen, sabit bir boyuta sahip basit değerlerdir ve bu iki 5 değeri doğrudan yığına itilir.

Şimdi aynı işlemin String sürümüne bakalım:

fn main() {
    let metin1 = String::from("merhaba");
    let metin2 = metin1;
}

Bu kod önceki örneğe çok benzediği için çalışma şeklinin de aynı olacağını varsayabiliriz: Yani ikinci satırın metin1 içindeki değerin bir kopyasını oluşturup metin2 değişkenine bağlayacağını düşünebiliriz. Ancak burada gerçekleşen şey tam olarak bu değildir.

String için perde arkasında neler olup bittiğini görmek üzere Şekil 4-1’e göz atın. Bir String, solda gösterildiği gibi üç bileşenden oluşur: metnin içeriğini tutan belleğe işaret eden bir işaretçi (ptr), bir uzunluk (len) ve bir kapasite (capacity). Bu veri grubu yığında saklanır. Sağda ise metnin asıl içeriğini barındıran öbek belleği yer alır.

Şekil 4-1: metin1 değişkenine bağlı "merhaba" değerini tutan bir String’in bellekteki temsili

Uzunluk (len), String içeriğinin o anda bayt cinsinden ne kadar bellek kullandığını belirtir. Kapasite (capacity) ise String’in bellek ayırıcıdan aldığı toplam bellek miktarının bayt cinsinden değeridir. Uzunluk ile kapasite arasındaki fark önemlidir, ancak bu bağlamda belirleyici olmadığından şimdilik kapasiteyi göz ardı edebiliriz.

metin1’i metin2’ye atadığımızda String’in yığın verisi kopyalanır; yani yığında bulunan işaretçiyi, uzunluğu ve kapasiteyi kopyalarız. İşaretçinin gösterdiği öbek üzerindeki veriyi ise kopyalamayız. Başka bir deyişle, bellekteki veri yerleşimi Şekil 4-2’deki gibi görünür.

Şekil 4-2: metin1 değişkeninin işaretçi, uzunluk ve kapasite değerlerinin kopyasına sahip olan metin2 değişkeninin bellekteki temsili

Bellekteki görünüm, Rust öbek verisini de kopyalasaydı ortaya çıkacak olan Şekil 4-3’teki gibi değildir. Eğer Rust böyle davransaydı, öbekteki verinin büyük olduğu durumlarda metin2 = metin1 ataması çalışma zamanı performansı açısından son derece maliyetli olabilirdi.

Şekil 4-3: Rust öbek verisini de kopyalasaydı metin2 = metin1 işleminin oluşturacağı alternatif bellek görünümü

Daha önce, bir değişken kapsam dışına çıktığında Rust’ın otomatik olarak drop fonksiyonunu çağırdığını ve o değişkene ait öbek belleğini temizlediğini belirtmiştik. Ancak Şekil 4-2’de her iki veri işaretçisinin de aynı bellek konumunu gösterdiğini görüyoruz. Bu ciddi bir sorundur: metin2 ve metin1 kapsam dışına çıktığında her ikisi de aynı belleği serbest bırakmaya çalışacaktır. Bu durum çift serbest bırakma (double free) hatası olarak bilinir ve daha önce değindiğimiz bellek güvenliği hatalarından biridir. Aynı belleği iki kez serbest bırakmak bellek bozulmasına (memory corruption) ve bunun sonucunda güvenlik açıklarına yol açabilir.

Bellek güvenliğini sağlamak amacıyla let metin2 = metin1; satırından sonra Rust, metin1 değişkenini artık geçerli kabul etmez. Dolayısıyla metin1 kapsam dışına çıktığında Rust’ın herhangi bir şeyi serbest bırakması gerekmez. metin2 oluşturulduktan sonra metin1’i kullanmaya çalıştığınızda ne olduğuna bakın; kod derlenmeyecektir:

fn main() {
    let metin1 = String::from("merhaba");
    let metin2 = metin1;

    println!("{metin1}, dünya!");
}

Rust geçersiz kılınmış değişkeni kullanmanızı engellediği için şuna benzer bir hata alırsınız:

$ cargo run
   Compiling sahipligi_anlamak v0.1.0 (file:///projects/sahipligi_anlamak)
error[E0382]: borrow of moved value: `metin1`
 --> src/main.rs:5:16
  |
2 |     let metin1 = String::from("merhaba");
  |         ------ move occurs because `metin1` has type `String`, which does not implement the `Copy` trait
3 |     let metin2 = metin1;
  |                  ------ value moved here
4 |
5 |     println!("{metin1}, dünya!");
  |                ^^^^^^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let metin2 = metin1.clone();
  |                        ++++++++

For more information about this error, try `rustc --explain E0382`.
error: could not compile `sahipligi_anlamak` (bin "sahipligi_anlamak") due to 1 previous error

Diğer programlama dilleriyle çalışırken sığ kopya (shallow copy) ve derin kopya (deep copy) terimlerini duyduysanız; öbekteki veriyi kopyalamadan yalnızca işaretçiyi, uzunluğu ve kapasiteyi kopyalama fikri kulağa sığ kopya yapmak gibi gelebilir. Ancak Rust aynı zamanda ilk değişkeni geçersiz kıldığı için bu işlem sığ kopya olarak değil, taşıma (move) olarak adlandırılır. Bu örnekte metin1’in metin2’ye taşındığını söyleriz. Dolayısıyla bellekte gerçekte olan durum Şekil 4-4’te gösterilmiştir.

Şekil 4-4: metin1 geçersiz kılındıktan sonra bellekteki temsil

Bu yaklaşım sorunumuzu tamamen çözer! Yalnızca metin2 geçerli kaldığından, kapsam dışına çıktığında belleği yalnızca o serbest bırakır ve çift serbest bırakma tehlikesi ortadan kalkar.

Buna ek olarak bu mekanizmanın ortaya koyduğu önemli bir tasarım tercihi daha vardır: Rust, verilerinizin “derin” kopyalarını asla kendiliğinden oluşturmaz. Dolayısıyla Rust’ta gerçekleşen her türlü otomatik kopyalamanın çalışma zamanı performansı açısından düşük maliyetli olduğu güvenle varsayılabilir.

Kapsam ve Atama

Kapsam, sahiplik ve belleğin drop fonksiyonu aracılığıyla serbest bırakılması arasındaki ilişkinin tersi de geçerlidir. Mevcut bir değişkene tamamen yeni bir değer atadığınızda Rust, önceki değer üzerinde derhal drop fonksiyonunu çağırır ve o değerin belleğini anında serbest bırakır. Örneğin şu kodu inceleyelim:

fn main() {
    let mut metin = String::from("merhaba");
    metin = String::from("selam");

    println!("{metin}, dünya!");
}

Başlangıçta metin adında bir değişken tanımlıyor ve ona "merhaba" değerini tutan bir String bağlıyoruz. Hemen ardından "selam" değerine sahip yeni bir String oluşturup metin değişkenine atıyoruz. Bu noktada öbekteki ilk değere başvuran hiçbir değişken kalmamıştır. Şekil 4-5, bu atama sonrasında yığın ve öbek verilerinin durumunu göstermektedir:

Şekil 4-5: Başlangıçtaki değer bütünüyle yenisiyle değiştirildikten sonra bellekteki temsil

Böylece ilk string anında kapsam dışına çıkmış olur. Rust bu değer üzerinde drop fonksiyonunu çalıştırır ve belleği hemen serbest bırakılır. Son satırda değeri yazdırdığımızda ekranda "selam, dünya!" çıktısını görürüz.

Değişkenlerin ve Verilerin Clone ile Etkileşimi

Yalnızca yığın verisini değil, String’in öbek verisini de gerçekten derinlemesine kopyalamak istiyorsak clone adındaki yaygın metodu kullanabiliriz. Metot sözdizimini Bölüm 5’te ele alacağız; ancak metotlar pek çok programlama dilinde ortak bir özellik olduğundan muhtemelen daha önce karşılaşmışsınızdır.

İşte clone metodunun çalışırkenki bir örneği:

fn main() {
    let metin1 = String::from("merhaba");
    let metin2 = metin1.clone();

    println!("metin1 = {metin1}, metin2 = {metin2}");
}

Bu kod sorunsuzca çalışır ve öbek verisinin gerçekten kopyalandığı Şekil 4-3’teki davranışı açıkça üretir.

Kodda bir clone çağrısı gördüğünüzde, arka planda o türe özgü bir kopyalama kodunun çalıştırıldığını ve bu işlemin performans açısından maliyetli olabileceğini bilirsiniz. Bu çağrı, sıradan bir atamadan farklı bir işlem yapıldığının açık bir görsel göstergesidir.

Yalnızca Yığındaki Veri: Copy

Henüz değinmediğimiz bir ayrıntı daha var. Bir kısmını Liste 4-2’de gördüğümüz, tam sayılar kullanan şu kod derlenir ve tamamen geçerlidir:

fn main() {
    let x = 5;
    let y = x;

    println!("x = {x}, y = {y}");
}

Ancak bu kod az önce öğrendiklerimizle çelişiyor gibi görünmektedir: clone çağrısı yapmadığımız hâlde x hâlâ geçerlidir ve y içine taşınmamıştır.

Bunun nedeni, bu örnekteki x ve y değişkenlerinin türü olan i32’nin Copy trait’ini uygulamasıdır. let y = x; atamasında tam sayı değeri kopyalanır ve x geçerli kalır. Bir i32 değeri, String gibi öbekteki ayrı bir verinin sahibi değildir; bu nedenle bitlerini kopyalamak değerin tamamını kopyalamak için yeterlidir. Bu tam sayı örneğinde derin kopyalama ile sığ kopyalama arasında fark yoktur ve clone çağırmaya gerek duymayız.

Burada belirleyici olan, türün Copy trait’ini uygulamasıdır; değerin yığında tutulması veya boyutunun derleme zamanında bilinmesi tek başına yeterli değildir. Örneğin String’in yığında tutulan kısmının boyutu da derleme zamanında bilinir. Ancak yığındaki bu kısım, metnin öbekteki asıl verisine işaret eden bir işaretçinin yanı sıra uzunluk ve kapasite bilgilerini de içerir. İşaretçi, asıl verinin bellekteki adresini tutar; işaretçileri ve akıllı işaretçileri Bölüm 15’te daha ayrıntılı inceleyeceğiz. Yalnızca yığındaki bitleri kopyalamak, öbekteki veriyi çoğaltmaz. String, Copy uygulamadığı için bir String değeri başka bir değişkene atandığında sahiplik taşınır ve önceki değişken geçersiz olur.

Rust, tam sayılar gibi bit düzeyinde kopyalanabilen türlerin uygulayabildiği Copy adında özel bir trait sunar (trait’leri Bölüm 10’da ayrıntılı olarak inceleyeceğiz). Bir tür Copy trait’ini uyguluyorsa onu kullanan değişkenler taşınmaz; bunun yerine önemsiz bir maliyetle kopyalanır ve başka bir değişkene atandıktan sonra da geçerli kalmaya devam eder.

Bir türün kendisi ya da parçalarından herhangi biri Drop trait’ini uygulamışsa Rust o türü Copy ile işaretlememize izin vermez. Değer kapsam dışına çıktığında özel bir temizlik işlemi yapılması gereken bir türe Copy trait’ini eklemeye çalışırsak derleme zamanı hatası alırız. Kendi türlerinizde bu trait’i uygulamak üzere ilgili türetme özniteliğini (#[derive(Copy)]) nasıl ekleyeceğinizi öğrenmek için Ek C’deki “Türetilebilir Trait’ler” bölümüne bakabilirsiniz. (Copy, Clone trait’inin bir alt trait’i olduğundan bir türün Copy uygulayabilmesi için Clone da uygulaması gerekir. Bu iki trait genellikle birlikte türetilir: #[derive(Clone, Copy)]; elle uygulamak da mümkündür.)

Peki hangi türler Copy trait’ini uygular? Emin olmak için ilgili türün dokümantasyonunu kontrol edebilirsiniz; ancak genel kural olarak basit skaler değerlerden oluşan her grup Copy uygulayabilirken, öbekte bellek ayırma gerektiren veya bir sistem kaynağını temsil eden hiçbir tür Copy uygulayamaz. Copy trait’ini uygulayan başlıca türler şunlardır:

• u32 gibi tüm tam sayı türleri.
• true ve false değerlerine sahip Boolean türü bool.
• f64 gibi tüm kayan noktalı sayı türleri.
• Karakter türü char.
• Yalnızca Copy uygulayan türleri barındırmaları koşuluyla demetler (tuples). Örneğin (i32, i32) türü Copy trait’ini uygular, ancak (i32, String) uygulamaz.

Sahiplik ve Fonksiyonlar

Bir değeri fonksiyona aktarmanın çalışma mekaniği, bir değeri değişkene atamakla oldukça benzerdir. Bir değişkeni fonksiyona geçirmek, tıpkı atama işleminde olduğu gibi değeri ya taşır ya da kopyalar. Liste 4-3, değişkenlerin nerelerde kapsama girip çıktığını gösteren açıklamalarla bu durumu örneklemektedir.

fn main() {
    let metin = String::from("merhaba"); // metin kapsama girer

    sahipligi_alir(metin); // metin'in değeri fonksiyona taşınır...
                           // ... ve bu yüzden burada artık geçerli değildir

    let x = 5; // x kapsama girer

    kopyasini_olustur(x); // i32 Copy trait'ini uyguladığı için,
                          // x fonksiyona TAŞINMAZ,
                          // bu yüzden x'i daha sonra kullanmak sorun olmaz.
} // Burada x kapsamdan çıkar, sonra da metin. Ancak metin'in değeri taşındığı için,
  // özel bir şey olmaz.

fn sahipligi_alir(bir_metin: String) {
    // bir_metin kapsama girer
    println!("{bir_metin}");
} // Burada bir_metin kapsamdan çıkar ve `drop` çağrılır. Arkadaki
  // bellek serbest bırakılır.

fn kopyasini_olustur(bir_tamsayi: i32) {
    // bir_tamsayi kapsama girer
    println!("{bir_tamsayi}");
} // Burada bir_tamsayi kapsamdan çıkar. Özel bir şey olmaz.

sahipligi_alir çağrısından sonra metin değişkenini kullanmaya çalışsaydık Rust derleme zamanı hatası verirdi. Bu statik kontroller bizi çalışma zamanı hatalarından korur. metin ve x değişkenlerini nerelerde kullanabileceğinizi ve sahiplik kurallarının sizi nerelerde engellediğini bizzat görmek için main fonksiyonuna bu değişkenleri kullanan kodlar eklemeyi deneyin.

Dönüş Değerleri ve Kapsam

Fonksiyonlardan değer döndürmek de sahipliği aktarabilir. Liste 4-4, bir değer döndüren fonksiyon örneğini Liste 4-3’tekine benzer kapsam açıklamalarıyla göstermektedir.

fn main() {
    let metin1 = sahiplik_verir(); // sahiplik_verir dönüş değerini
                                   // metin1'e taşır

    let metin2 = String::from("merhaba"); // metin2 kapsama girer

    let metin3 = alir_ve_geri_verir(metin2); // metin2, alir_ve_geri_verir'e taşınır,
                                             // o da dönüş değerini
                                             // metin3'e taşır
} // Burada metin3 kapsamdan çıkar ve düşürülür (drop). metin2 taşındığı için hiçbir şey
  // olmaz. metin1 kapsamdan çıkar ve düşürülür.

fn sahiplik_verir() -> String {
    // sahiplik_verir dönüş değerini
    // onu çağıran fonksiyona
    // taşıyacaktır

    let bir_metin = String::from("senin"); // bir_metin kapsama girer

    bir_metin // bir_metin döndürülür ve
              // çağıran fonksiyona
              // taşınır
}

// Bu fonksiyon bir String alır ve bir String döndürür.
fn alir_ve_geri_verir(bir_metin: String) -> String {
    // bir_metin kapsama
    // girer

    bir_metin // bir_metin döndürülür ve çağıran fonksiyona taşınır
}

Bir değişkenin sahipliği her seferinde aynı kalıbı izler: Bir değeri başka bir değişkene atamak onu taşır. Öbekte veri barındıran bir değişken kapsam dışına çıktığında, verinin sahipliği başka bir değişkene taşınmadığı sürece söz konusu değer drop tarafından temizlenir.

Bu yöntem çalışsa da her fonksiyonda sahipliği alıp ardından tekrar geri döndürmek biraz yorucudur. Bir fonksiyonun değeri kullanmasına izin vermek ama sahipliğini devralmasını istemiyorsak ne yapacağız? Fonksiyona gönderdiğimiz her şeyi daha sonra tekrar kullanabilmek için — fonksiyon gövdesinde üretilen asıl sonuç verilerinin yanı sıra — bir de geri döndürmek zorunda kalmak epey zahmetlidir.

Rust, Liste 4-5’te gösterildiği gibi bir demet kullanarak birden fazla değer döndürmemize olanak tanır.

fn main() {
    let metin1 = String::from("merhaba");

    let (metin2, uzunluk) = uzunlugu_hesapla(metin1);

    println!("'{metin2}' metninin uzunluğu: {uzunluk}.");
}

fn uzunlugu_hesapla(metin: String) -> (String, usize) {
    let uzunluk = metin.len(); // len() bir String'in uzunluğunu döndürür

    (metin, uzunluk)
}

Ancak bu yaklaşım, çok sık karşılaşılacak bir ihtiyaç için gereğinden fazla zahmet ve kalabalık kod demektir. Neyse ki Rust, sahipliği devretmeden bir değeri kullanabilmemiz için özel bir özelliğe sahiptir: referanslar.

Referanslar ve Ödünç Alma

Referanslar ve Ödünç Alma

Liste 4-5’teki demet kullanan kodun temel sorunu şudur: String değeri uzunlugu_hesapla fonksiyonuna taşındığı için, fonksiyon çağrısından sonra bu String’i hâlâ kullanabilmek adına onu çağıran fonksiyona geri döndürmek zorunda kalırız. Bunun yerine, String değerine bir referans verebiliriz. Referans (reference), bellekteki bir adreste saklanan veriye ulaşmak için takip edebileceğimiz bir adres olması bakımından işaretçiye (pointer) benzer; o adresteki verinin sahibi ise başka bir değişkendir. Sıradan bir işaretçiden farklı olarak referansın, kendi ömrü boyunca belirli bir türden geçerli bir değere işaret edeceği garanti edilir.

Değerin sahipliğini devralmak yerine parametre olarak bir değere referans kabul eden uzunlugu_hesapla fonksiyonunu şu şekilde tanımlayıp kullanabilirsiniz:

fn main() {
    let metin1 = String::from("merhaba");

    let uzunluk = uzunlugu_hesapla(&metin1);

    println!("'{metin1}' metninin uzunluğu: {uzunluk}.");
}

fn uzunlugu_hesapla(metin: &String) -> usize {
    metin.len()
}

Öncelikle, değişken bildirimindeki ve fonksiyonun dönüş değerindeki tüm demet kodlarının ortadan kalktığına dikkat edin. İkinci olarak, uzunlugu_hesapla fonksiyonuna &metin1 aktardığımıza ve fonksiyon tanımında String yerine &String kullandığımıza bakın. Bu & işaretleri (ampersand) referansları temsil eder ve bir değerin sahipliğini üstlenmeden ona başvurmanıza olanak tanır. Şekil 4-6 bu kavramı görselleştirmektedir.

Şekil 4-6: String türündeki metin1 değişkenine işaret eden &String türündeki metin diyagramı

Şimdi buradaki fonksiyon çağrısına daha yakından bakalım:

fn main() {
    let metin1 = String::from("merhaba");

    let uzunluk = uzunlugu_hesapla(&metin1);

    println!("'{metin1}' metninin uzunluğu: {uzunluk}.");
}

fn uzunlugu_hesapla(metin: &String) -> usize {
    metin.len()
}

&metin1 sözdizimi, metin1’in değerine başvuran ancak onun sahibi olmayan bir referans oluşturmamızı sağlar. Referans bu değerin sahibi olmadığından, kullanımı sona erdiğinde işaret ettiği değer düşürülmez (drop edilmez).

Benzer şekilde fonksiyon imzası da metin parametresinin türünün bir referans olduğunu belirtmek için & kullanır. Şimdi koda açıklayıcı yorumlar ekleyelim:

fn main() {
    let metin1 = String::from("merhaba");

    let uzunluk = uzunlugu_hesapla(&metin1);

    println!("'{metin1}' metninin uzunluğu: {uzunluk}.");
}

fn uzunlugu_hesapla(metin: &String) -> usize {
    // metin bir String'e referanstır
    metin.len()
} // Burada, metin kapsam dışına çıkar. Ancak metin referans verdiği şeyin
  // sahipliğine sahip olmadığı için String düşürülmez (drop edilmez).

metin değişkeninin geçerli olduğu kapsam herhangi bir fonksiyon parametresinin kapsamıyla aynıdır; ancak metin değerin sahibi olmadığı için, kullanımı bittiğinde referansın işaret ettiği değer düşürülmez. Fonksiyonlar asıl değerler yerine referansları parametre olarak aldığında, sahipliği geri vermek amacıyla değerleri döndürmemize gerek kalmaz; çünkü sahipliği zaten hiç devralmamışızdır.

Referans oluşturma eylemine ödünç alma (borrowing) adını veririz. Tıpkı günlük hayatta olduğu gibi, bir başkasının sahip olduğu bir eşyayı ondan ödünç alabilirsiniz. İşiniz bittiğinde ise onu geri vermeniz gerekir; eşyanın sahibi siz değilsinizdir.

Peki ödünç aldığımız bir şeyi değiştirmeye çalışırsak ne olur? Liste 4-6’daki kodu deneyin. Şimdiden söyleyelim: Çalışmayacaktır!

fn main() {
    let metin = String::from("merhaba");

    degistir(&metin);
}

fn degistir(bir_metin: &String) {
    bir_metin.push_str(", dünya");
}

İşte hata:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*bir_metin` as mutable, as it is behind a `&` reference
 --> src/main.rs:8:5
  |
8 |     bir_metin.push_str(", dünya");
  |     ^^^^^^^^^ `bir_metin` is a `&` reference, so it cannot be borrowed as mutable
  |
help: consider changing this to be a mutable reference
  |
7 | fn degistir(bir_metin: &mut String) {
  |                         +++

For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Değişkenler varsayılan olarak nasıl değiştirilemez ise referanslar da öyledir. Bir değere yalnızca sıradan (değiştirilemez) bir referansımız varsa o değeri değiştirmemize izin verilmez (hata mesajındaki *bir_metin ifadesi bir_metin referansının işaret ettiği asıl değeri temsil eder; derleyici, bu değer bir & referansı arkasında olduğu için değiştirilebilir olarak ödünç alınamayacağını bildirir).

Değiştirilebilir Referanslar

Liste 4-6’daki kodu, ödünç alınan değeri değiştirmemize izin verecek şekilde birkaç küçük dokunuşla — bir değiştirilebilir referans (mutable reference) kullanarak — düzeltebiliriz:

fn main() {
    let mut metin = String::from("merhaba");

    degistir(&mut metin);
}

fn degistir(bir_metin: &mut String) {
    bir_metin.push_str(", dünya");
}

İlk olarak metin değişkenini mut olarak tanımlarız. Ardından degistir fonksiyonunu çağırdığımız yerde &mut metin ifadesiyle değiştirilebilir bir referans oluşturur ve fonksiyon imzasını da bir_metin: &mut String yazarak değiştirilebilir referans kabul edecek biçimde güncelleriz. Bu imza, degistir fonksiyonunun ödünç aldığı değeri değiştireceğini açıkça ortaya koyar.

Değiştirilebilir referansların çok önemli bir kısıtlaması vardır: Bir değere ait etkin bir değiştirilebilir referansınız varsa, o değere başka hiçbir referansınız olamaz. metin değişkenine iki ayrı değiştirilebilir referans oluşturmayı deneyen aşağıdaki kod derlenmeyecektir:

fn main() {
    let mut metin = String::from("merhaba");

    let r1 = &mut metin;
    let r2 = &mut metin;

    println!("{r1}, {r2}");
}

İşte hata:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `metin` as mutable more than once at a time
 --> src/main.rs:5:14
  |
4 |     let r1 = &mut metin;
  |              ---------- first mutable borrow occurs here
5 |     let r2 = &mut metin;
  |              ^^^^^^^^^^ second mutable borrow occurs here
6 |
7 |     println!("{r1}, {r2}");
  |                -- first borrow later used here

For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Bu hata mesajı, metin değişkenini aynı anda birden fazla kez değiştirilebilir olarak ödünç alamayacağımız (cannot borrow `metin` as mutable more than once at a time) için kodun geçersiz olduğunu belirtir. İlk değiştirilebilir ödünç alma işlemi r1 içindedir ve println! satırında kullanılana kadar geçerliliğini korumak zorundadır; ancak biz bu değiştirilebilir referansın oluşturulması ile kullanılması arasında, r1 ile aynı veriyi ödünç alan r2 içinde ikinci bir değiştirilebilir referans oluşturmaya çalıştık.

Aynı veriye aynı anda birden fazla değiştirilebilir referans oluşturulmasını engelleyen bu kısıtlama, veri değiştirmeye izin verir ancak bunu son derece kontrollü bir biçimde yapar. Çoğu programlama dili verileri dilediğiniz zaman değiştirmenize izin verdiğinden, yeni Rust geliştiricilerinin (Rustaceans) alışmakta zorlandığı konulardan biri budur. Bu kısıtlamanın en büyük getirisi ise Rust’ın derleme zamanında veri yarışlarını önleyebilmesidir. Veri yarışı (data race), yarış koşuluna (race condition) benzer ve şu üç davranış bir arada gerçekleştiğinde ortaya çıkar:

• İki veya daha fazla işaretçi aynı veriye aynı anda erişir.
• İşaretçilerden en az biri veriye yazmak için kullanılır.
• Veriye erişimi senkronize edecek herhangi bir mekanizma kullanılmaz.

Veri yarışları tanımsız davranışa (undefined behavior) yol açar ve çalışma zamanında izlerini sürüp teşhis etmek ve düzeltmek son derece güç olabilir. Rust ise veri yarışı barındıran kodları derlemeyi reddederek bu sorunu henüz ortaya çıkmadan engeller!

Her zaman olduğu gibi, süslü parantezler kullanarak yeni bir kapsam oluşturabilir ve böylece eşzamanlı olmamak kaydıyla birden fazla değiştirilebilir referans tanımlayabiliriz:

fn main() {
    let mut metin = String::from("merhaba");

    {
        let r1 = &mut metin;
    } // r1 burada kapsam dışına çıkar, bu yüzden hiçbir sorun olmadan yeni bir referans yapabiliriz.

    let r2 = &mut metin;
}

Rust, değiştirilebilir ve değiştirilemez referansların bir arada kullanılması için de benzer bir kural uygular. Aşağıdaki kod derleme hatasıyla sonuçlanır:

fn main() {
    let mut metin = String::from("merhaba");

    let r1 = &metin; // sorun yok
    let r2 = &metin; // sorun yok
    let r3 = &mut metin; // BÜYÜK SORUN

    println!("{r1}, {r2}, ve {r3}");
}

İşte hata:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `metin` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:14
  |
4 |     let r1 = &metin; // sorun yok
  |              ------ immutable borrow occurs here
5 |     let r2 = &metin; // sorun yok
6 |     let r3 = &mut metin; // BÜYÜK SORUN
  |              ^^^^^^^^^^ mutable borrow occurs here
7 |
8 |     println!("{r1}, {r2}, ve {r3}");
  |                -- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Gördüğünüz gibi, aynı değere ait değiştirilemez bir referansımız varken aynı zamanda değiştirilebilir bir referansımız da olamaz!

Değiştirilemez bir referansı kullanan kod bölümleri, ellerindeki değerin bir anda altlarından kayıp değişmesini beklemez. Buna karşılık, birden fazla değiştirilemez referansa izin verilir; çünkü veriyi yalnızca okuyan hiçbir referansın, diğerlerinin okuduğu veriyi etkileme imkânı yoktur.

Bir referansın kapsamının tanımlandığı noktada başladığına ve o referansın son kez kullanıldığı noktaya kadar devam ettiğine dikkat edin. Örneğin aşağıdaki kod sorunsuzca derlenir; çünkü değiştirilemez referansların son kullanımı, değiştirilebilir referans tanımlanmadan hemen önceki println! satırındadır:

fn main() {
    let mut metin = String::from("merhaba");

    let r1 = &metin; // sorun yok
    let r2 = &metin; // sorun yok
    println!("{r1} ve {r2}");
    // r1 ve r2 değişkenleri bu noktadan sonra kullanılmayacak.

    let r3 = &mut metin; // sorun yok
    println!("{r3}");
}

Değiştirilemez r1 ve r2 referanslarının kapsamları, son kez kullanıldıkları println! çağrısından hemen sonra sona erer; bu da değiştirilebilir r3 referansı oluşturulmadan öncedir. Bu kapsamlar birbiriyle çakışmadığından koda izin verilir: Derleyici, süslü parantezle belirlenen blok sonuna henüz gelinmemiş olsa bile referansın o noktadan sonra artık kullanılmadığını anlayabilir.

Ödünç alma hataları zaman zaman zorlayıcı görünse de bunların aslında Rust derleyicisinin olası bir hatayı erkenden (çalışma zamanı yerine derleme zamanında) yakalayıp sorunun tam olarak nerede olduğunu size göstermesinden kaynaklandığını unutmayın. Bu sayede, programınız çalışırken verilerinizin neden beklediğiniz gibi görünmediğinin izini sürmek zorunda kalmazsınız.

Sarkan Referanslar

İşaretçilerin doğrudan kullanıldığı dillerde, bellekteki bir alanı serbest bırakırken o alana yönelen işaretçiyi korumaya devam ederek yanlışlıkla bir sarkan işaretçi (dangling pointer) — yani artık bir başkasına tahsis edilmiş olabilecek geçersiz bir bellek konumunu gösteren işaretçi — oluşturmak oldukça kolaydır. Rust’ta ise derleyici, referansların hiçbir zaman sarkan referans (dangling reference) hâline gelmeyeceğini garanti eder: Bir veriye referansınız varsa derleyici, referansın kendisi kapsam dışına çıkmadan önce verinin kapsam dışına çıkmamasını sağlar.

Rust’ın bunları derleme zamanı hatasıyla nasıl engellediğini görmek için sarkan bir referans oluşturmayı deneyelim:

fn main() {
    let hicbir_seye_referans = sarkan_isaretci();
}

fn sarkan_isaretci() -> &String {
    let metin = String::from("merhaba");

    &metin
}

İşte hata:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:25
  |
5 | fn sarkan_isaretci() -> &String {
  |                         ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
  |
5 | fn sarkan_isaretci() -> &'static String {
  |                          +++++++
help: instead, you are more likely to want to return an owned value
  |
5 - fn sarkan_isaretci() -> &String {
5 + fn sarkan_isaretci() -> String {
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Bu hata mesajı henüz ele almadığımız bir özelliğe değinmektedir: ömürler (lifetimes). Ömürleri Bölüm 10’da ayrıntılı olarak inceleyeceğiz. Ancak ömürlerle ilgili kısımları şimdilik bir kenara bırakırsanız, mesaj bu kodun neden sorunlu olduğuna dair temel ipucunu açıkça verir:

this function's return type contains a borrowed value, but there is no value
for it to be borrowed from

Başka bir deyişle derleyici, bu fonksiyonun dönüş türünün ödünç alınmış bir değer içerdiğini ancak kendisinden ödünç alınabilecek hiçbir değer bulunmadığını bildirir (sarkan_isaretci fonksiyonu hiçbir parametre almadığından, döndürülen referansın dışarıdaki geçerli bir veriden ödünç alınmış olması imkânsızdır).

sarkan_isaretci kodumuzun her aşamasında tam olarak neler olup bittiğine daha yakından bakalım:

fn main() {
    let hicbir_seye_referans = sarkan_isaretci();
}

fn sarkan_isaretci() -> &String {
    // sarkan_isaretci, bir String'e referans döndürür

    let metin = String::from("merhaba"); // metin yeni bir String'dir

    &metin // String'e, yani metin'e bir referans döndürüyoruz
} // Burada metin kapsam dışına çıkar ve düşürülür (drop edilir), bu yüzden belleği gider.
  // Tehlike!

metin değişkeni sarkan_isaretci fonksiyonunun içinde oluşturulduğu için, sarkan_isaretci kodu tamamlandığında metin değişkeninin belleği serbest bırakılacaktır. Ancak biz ona ait bir referansı döndürmeye çalıştık. Bu durum, döndürülen referansın geçersiz bir String’e işaret edeceği anlamına gelir. Bu hiç iyi bir durum değildir ve Rust bunu yapmamıza izin vermez.

Buradaki çözüm, referans yerine doğrudan String değerini döndürmektir:

fn main() {
    let metin = sarkmayan_isaretci();
}

fn sarkmayan_isaretci() -> String {
    let metin = String::from("merhaba");

    metin
}

Bu kod çalışır: String değerinin sahipliği çağıran fonksiyona taşındığı için ona ait öbek belleği bu fonksiyondan dönülürken serbest bırakılmaz. Bellek, değerin yeni sahibi onu düşürdüğünde serbest bırakılır.

Referans Kuralları

Referanslar hakkında ele aldıklarımızı özetleyelim:

• Herhangi bir anda, bir veriye ait ya yalnızca bir tane değiştirilebilir referansa ya da istediğiniz sayıda değiştirilemez referansa sahip olabilirsiniz.
• Referanslar her zaman geçerli olmalıdır.

Sırada, farklı bir referans türüne bakacağız: dilimler.

Dilim (Slice) Türü

Dilim (Slice) Türü

Dilimler (slices), bir koleksiyon içindeki bitişik bir eleman dizisine referans vermenizi sağlar. Dilim bir tür referanstır; dolayısıyla verinin sahipliğini üstlenmez.

Küçük bir programlama problemi düşünelim: Boşluklarla ayrılmış kelimelerden oluşan bir string alan ve bu string içinde bulduğu ilk kelimeyi döndüren bir fonksiyon yazın. Fonksiyon string içinde hiç boşluk bulamazsa tüm string tek bir kelime demektir; bu durumda string’in tamamı döndürülmelidir.

Dilimlerin hangi sorunu çözdüğünü anlamak için bu fonksiyonun imzasını dilim kullanmadan nasıl yazacağımız üzerinde düşünelim:

fn ilk_kelime(metin: &String) -> ?

ilk_kelime fonksiyonu &String türünde bir parametre alır. Sahipliğe ihtiyacımız olmadığı için bu tercih gayet uygundur. (İdiyomatik Rust’ta fonksiyonlar gerçekten gerekmedikçe argümanlarının sahipliğini almaz; bunun nedenleri ilerledikçe netleşecektir.) Peki bu fonksiyondan ne döndürmeliyiz? Bir string’in bir kısmını ifade etmenin henüz doğrudan bir yolu yoktur. Bununla birlikte, kelimenin sonunu belirten boşluğun indeksini döndürebiliriz. Gelin bunu Liste 4-7’de gösterildiği gibi deneyelim.

fn ilk_kelime(metin: &String) -> usize {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return i;
        }
    }

    metin.len()
}

fn main() {}

String değerini eleman eleman tarayıp her bir değerin boşluk olup olmadığını kontrol etmemiz gerektiğinden, as_bytes metoduyla String içindeki UTF-8 baytlarını &[u8] türünde bir dilim olarak ödünç alırız. Bu işlem metni kopyalamaz veya yeni bir dizi oluşturmaz:

fn ilk_kelime(metin: &String) -> usize {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return i;
        }
    }

    metin.len()
}

fn main() {}

Ardından iter metodunu kullanarak bu bayt dizisi üzerinde bir iteratör (iterator) oluştururuz:

fn ilk_kelime(metin: &String) -> usize {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return i;
        }
    }

    metin.len()
}

fn main() {}

İteratörleri Bölüm 13’te ayrıntılı olarak inceleyeceğiz. Şimdilik iter metodunun bir koleksiyondaki her elemanı sırayla döndürdüğünü, enumerate metodunun ise iter sonucunu sarmalayarak her elemanı bunun yerine bir demetin parçası olarak döndürdüğünü bilmeniz yeterlidir. enumerate çağrısından dönen demetin ilk elemanı indeks, ikinci elemanı ise ilgili elemana ait referanstır. Bu yöntem, indeksi kendi başımıza hesaplamaktan biraz daha pratiktir.

enumerate metodu bir demet döndürdüğü için bu demeti parçalarına ayırmak (destructure) amacıyla desenleri (patterns) kullanabiliriz. Desenleri Bölüm 6’da daha ayrıntılı ele alacağız. for döngüsünde, demetteki indeks için i ve demetteki tekil bayt için &oge içeren bir desen belirtiriz. .iter().enumerate() çağrısından elemana bir referans elde ettiğimiz için desende & kullanırız.

for döngüsünün içinde, bayt sabiti (byte literal) sözdizimini (b' ') kullanarak boşluğu temsil eden baytı ararız. Bir boşluk bulursak bu konumu döndürürüz. Aksi takdirde metin.len() çağrısıyla string’in uzunluğunu döndürürüz:

fn ilk_kelime(metin: &String) -> usize {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return i;
        }
    }

    metin.len()
}

fn main() {}

Artık string içindeki ilk kelimenin bittiği yerin indeksini bulabiliyoruz, ancak önemli bir sorun var. Tek başına bir usize döndürüyoruz; oysa bu sayı yalnızca &String bağlamında anlamlıdır. Başka bir deyişle, String’den bağımsız ayrı bir değer olduğu için gelecekte hâlâ geçerli kalacağının hiçbir garantisi yoktur. Liste 4-7’deki ilk_kelime fonksiyonunu kullanan Liste 4-8’deki programı inceleyelim.

fn ilk_kelime(metin: &String) -> usize {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return i;
        }
    }

    metin.len()
}

fn main() {
    let mut metin = String::from("merhaba dünya");

    let kelime = ilk_kelime(&metin); // kelime 7 değerini alacak

    metin.clear(); // bu, String'i boşaltır ve onu "" değerine eşitler

    // kelime burada hala 7 değerine sahip, ancak metin'in 7 değeriyle
    // anlamlı bir şekilde kullanabileceğimiz hiçbir içeriği kalmadı,
    // yani kelime artık tamamen geçersiz!
}

Bu program hiçbir hata vermeden derlenir; hatta metin.clear() çağrısından sonra kelime değişkenini kullansaydık bile derlenirdi. kelime değişkeni metin’in durumuna hiçbir şekilde bağlı olmadığından hâlâ 7 değerini tutar. İlk kelimeyi çıkarmak amacıyla metin değişkeniyle birlikte bu 7 değerini kullanmaya çalışabilirdik; ancak biz 7 sayısını kelime değişkenine kaydettikten sonra metin’in içeriği değiştiği için bu bir mantık hatası (bug) olurdu.

kelime içindeki indeksin metin içindeki veriyle uyumunun bozulabileceği konusunda sürekli endişelenmek yorucu ve hataya açıktır! Bir ikinci_kelime fonksiyonu yazdığımızda bu indeksleri yönetmek daha da kırılgan bir hâl alır. Böyle bir fonksiyonun imzası şuna benzemek zorunda kalırdı:

fn ikinci_kelime(metin: &String) -> (usize, usize) {

Şimdi hem bir başlangıç hem de bir bitiş indeksini takip ediyoruz; üstelik verinin belirli bir durumundan hesaplanmış ama o duruma hiçbir biçimde bağlı olmayan daha da fazla değerimiz var. Artık ortalıkta dolaşan ve birbiriyle uyumlu tutulması gereken üç ilişkisiz değişken bulunuyor.

Neyse ki Rust’ın bu soruna bir çözümü vardır: string dilimleri.

String Dilimleri

Bir string dilimi (string slice), bir String içindeki elemanların bitişik bir dizisine referanstır ve şöyle görünür:

fn main() {
    let metin = String::from("merhaba dunya");

    let merhaba = &metin[0..7];
    let dunya = &metin[8..13];
}

merhaba değişkeni tüm String’e referans vermek yerine, fazladan eklenen [0..7] kısmında belirtilen String bölümüne referans verir. Dilimleri köşeli parantezler içinde [başlangıç_indeksi..bitiş_indeksi] biçiminde bir aralık belirterek oluştururuz; burada başlangıç_indeksi dilimdeki ilk konumu, bitiş_indeksi ise dilimdeki son konumun bir fazlasını ifade eder. Dilim veri yapısı dahili olarak dilimin başlangıç konumunu ve uzunluğunu saklar; bu uzunluk bitiş_indeksi eksi başlangıç_indeksi değerine karşılık gelir. Dolayısıyla let dunya = &metin[8..13]; örneğinde dunya, metin değişkeninin 8. indeksindeki bayta yönelen bir işaretçi ve 5 uzunluk değerini barındıran bir dilim olur. (Bu örnekte "dünya" yerine bilerek yalnızca ASCII karakterlerden oluşan "dunya" yazdık; nedenini aşağıdaki UTF-8 notunda göreceksiniz.)

Şekil 4-7 bu bellek yapısını bir diyagramla göstermektedir.

Şekil 4-7: metin = String::from("merhaba dunya") değerinin &metin[8..13] bölümüne başvuran dunya string dilimi

Rust’ın .. aralık sözdiziminde 0. indeksten başlamak istiyorsanız iki noktadan önceki sayıyı yazmayabilirsiniz. Başka bir deyişle, aşağıdaki iki satır birbirine eşdeğerdir:

#![allow(unused)]
fn main() {
let metin = String::from("merhaba");

let dilim = &metin[0..2];
let dilim = &metin[..2];
}

Aynı mantıkla, diliminiz String’in son baytını da içeriyorsa sondaki sayıyı yazmayabilirsiniz. Yani şu iki satır da birbirine eşdeğerdir:

#![allow(unused)]
fn main() {
let metin = String::from("merhaba");

let uzunluk = metin.len();

let dilim = &metin[3..uzunluk];
let dilim = &metin[3..];
}

Tüm string’in bir dilimini almak için her iki değeri de atlayabilirsiniz. Dolayısıyla şunlar da eşdeğerdir:

#![allow(unused)]
fn main() {
let metin = String::from("merhaba");

let uzunluk = metin.len();

let dilim = &metin[0..uzunluk];
let dilim = &metin[..];
}

Tüm bu bilgileri göz önünde bulundurarak ilk_kelime fonksiyonunu bir dilim döndürecek biçimde yeniden yazalım. “String dilimi” anlamına gelen tür &str şeklinde yazılır:

fn ilk_kelime(metin: &String) -> &str {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return &metin[0..i];
        }
    }

    &metin[..]
}

fn main() {}

Kelimenin bitiş indeksini tıpkı Liste 4-7’de yaptığımız gibi ilk boşluk karakterini arayarak buluruz. Bir boşluk bulduğumuzda, başlangıç ve bitiş indeksleri olarak sırasıyla string’in başlangıcını ve boşluğun indeksini kullanarak bir string dilimi döndürürüz; boşluk bulamazsak da &metin[..] ile string’in tamamını dilim olarak döndürürüz.

Artık ilk_kelime fonksiyonunu çağırdığımızda, arka plandaki asıl veriye doğrudan bağlı tek bir değer elde ederiz. Bu değer, dilimin başlangıç noktasına yönelen bir referanstan ve dilimdeki eleman (bayt) sayısından oluşur.

Bir dilim döndürmek ikinci_kelime fonksiyonu için de aynı şekilde işe yarar:

fn ikinci_kelime(metin: &String) -> &str {

Derleyici String içine yönelen referansların geçerli kalmasını güvence altına alacağından, artık yanlış kullanılması çok daha zor ve yalın bir API’ye sahibiz. Liste 4-8’deki programda ilk kelimenin bitiş indeksini aldıktan sonra string’i temizlediğimiz ve elimizdeki indeksin geçersiz kaldığı hatayı hatırlıyor musunuz? O kod mantıksal açıdan hatalıydı ama anında hiçbir hata vermemişti; sorun ancak boşaltılmış bir string üzerinde ilk kelime indeksini kullanmaya devam ettiğimizde sonradan ortaya çıkacaktı. Dilimler bu hatayı imkânsız kılar ve kodumuzda bir sorun olduğunu çok daha erken fark etmemizi sağlar. ilk_kelime’nin dilim döndüren sürümünü aynı senaryoda kullanmak derleme zamanı hatası üretir:

fn ilk_kelime(metin: &String) -> &str {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return &metin[0..i];
        }
    }

    &metin[..]
}

fn main() {
    let mut metin = String::from("merhaba dünya");

    let kelime = ilk_kelime(&metin);

    metin.clear(); // hata!

    println!("ilk kelime: {kelime}");
}

İşte derleyici hatası:

$ cargo run
   Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `metin` as mutable because it is also borrowed as immutable
  --> src/main.rs:19:5
   |
17 |     let kelime = ilk_kelime(&metin);
   |                             ------ immutable borrow occurs here
18 |
19 |     metin.clear(); // hata!
   |     ^^^^^^^^^^^^^ mutable borrow occurs here
20 |
21 |     println!("ilk kelime: {kelime}");
   |                            ------ immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Ödünç alma kurallarını hatırlayalım: Bir değere ait değiştirilemez bir referansımız varken, aynı değere değiştirilebilir bir referans alamayız. clear metodunun String’i kısaltıp boşaltması gerektiği için değiştirilebilir bir referans alması gerekir. (Kodda açıkça &mut metin yazmadığımıza dikkat edin: clear gibi metotlar &mut self imzasıyla tanımlandığından Rust, metin.clear() çağrısında bu değiştirilebilir ödünç almayı sizin yerinize otomatik olarak yapar; metot sözdizimini Bölüm 5’te ele alacağız.) clear çağrısından sonraki println! satırı ise kelime içindeki referansı kullanır; dolayısıyla değiştirilemez referansın o noktada hâlâ etkin olması zorunludur. Rust, clear çağrısındaki değiştirilebilir referans (mutable borrow occurs here) ile kelime içindeki değiştirilemez referansın (immutable borrow occurs here) aynı anda var olmasına izin vermez ve derleme başarısız olur. Rust yalnızca API’mizi kullanımı daha kolay bir hâle getirmekle kalmamış, koskoca bir hata sınıfını daha derleme zamanında ortadan kaldırmıştır!

Dilim Olarak String Sabitleri

Daha önce string sabitlerinin derlenen ikili dosyanın (binary) içinde saklandığından söz ettiğimizi hatırlayın. Artık dilimleri tanıdığımıza göre string sabitlerini tam olarak anlayabiliriz:

#![allow(unused)]
fn main() {
let metin = "Merhaba, dünya!";
}

Buradaki metin değişkeninin türü &str’dir: İkili dosyanın tam o noktasına işaret eden bir dilimdir. String sabitlerinin değiştirilemez olmasının nedeni de budur; &str değiştirilemez bir referanstır.

Parametre Olarak String Dilimleri

Hem string sabitlerinin hem de String değerlerinin dilimlerini alabileceğimizi bilmek, bizi ilk_kelime fonksiyonunda yapabileceğimiz bir iyileştirmeye daha — fonksiyonun imzasına — götürür:

fn ilk_kelime(metin: &String) -> &str {

Daha deneyimli bir Rust geliştiricisi bunun yerine Liste 4-9’da gösterilen imzayı yazar; çünkü bu imza aynı fonksiyonu hem &String değerleri hem de &str değerleri üzerinde kullanmamıza olanak tanır.

fn ilk_kelime(metin: &str) -> &str {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return &metin[0..i];
        }
    }

    &metin[..]
}

fn main() {
    let benim_metnim = String::from("merhaba dünya");

    // `ilk_kelime`, `String`'lerin dilimleri (kısmi veya tam) üzerinde çalışır.
    let kelime = ilk_kelime(&benim_metnim[0..7]);
    let kelime = ilk_kelime(&benim_metnim[..]);
    // `ilk_kelime` ayrıca, `String`'lerin tam dilimlerine eşdeğer olan
    // `String` referansları üzerinde de çalışır.
    let kelime = ilk_kelime(&benim_metnim);

    let sabit_metnim = "merhaba dünya";

    // `ilk_kelime`, string sabitlerinin dilimleri (kısmi veya tam) üzerinde de çalışır.
    let kelime = ilk_kelime(&sabit_metnim[0..7]);
    let kelime = ilk_kelime(&sabit_metnim[..]);

    // String sabitleri zaten string dilimi (`&str`) olduğu için,
    // dilim sözdizimi olmadan doğrudan da çalışır!
    let kelime = ilk_kelime(sabit_metnim);
}

Elimizde bir string dilimi varsa onu doğrudan argüman olarak geçirebiliriz. Elimizde bir String varsa ya bu String’in bir dilimini ya da doğrudan String’e ait bir referansı geçirebiliriz. Bu esneklik, Bölüm 15’teki “Fonksiyon ve Metotlarda Deref Zorlaması Kullanmak” bölümünde ele alacağımız deref zorlaması (deref coercion) özelliğinden yararlanır.

Bir fonksiyonu String referansı yerine string dilimi alacak şekilde tanımlamak, hiçbir işlevsellik kaybı yaşatmadan API’mizi daha genel ve kullanışlı hâle getirir:

fn ilk_kelime(metin: &str) -> &str {
    let baytlar = metin.as_bytes();

    for (i, &oge) in baytlar.iter().enumerate() {
        if oge == b' ' {
            return &metin[0..i];
        }
    }

    &metin[..]
}

fn main() {
    let benim_metnim = String::from("merhaba dünya");

    // `ilk_kelime`, `String`'lerin dilimleri (kısmi veya tam) üzerinde çalışır.
    let kelime = ilk_kelime(&benim_metnim[0..7]);
    let kelime = ilk_kelime(&benim_metnim[..]);
    // `ilk_kelime` ayrıca, `String`'lerin tam dilimlerine eşdeğer olan
    // `String` referansları üzerinde de çalışır.
    let kelime = ilk_kelime(&benim_metnim);

    let sabit_metnim = "merhaba dünya";

    // `ilk_kelime`, string sabitlerinin dilimleri (kısmi veya tam) üzerinde de çalışır.
    let kelime = ilk_kelime(&sabit_metnim[0..7]);
    let kelime = ilk_kelime(&sabit_metnim[..]);

    // String sabitleri zaten string dilimi (`&str`) olduğu için,
    // dilim sözdizimi olmadan doğrudan da çalışır!
    let kelime = ilk_kelime(sabit_metnim);
}

Diğer Dilimler

String dilimleri, tahmin edebileceğiniz gibi stringlere özgüdür. Ancak daha genel bir dilim türü de vardır. Şu diziyi ele alalım:

#![allow(unused)]
fn main() {
let d = [1, 2, 3, 4, 5];
}

Tıpkı bir string’in belirli bir bölümüne başvurmak isteyebileceğimiz gibi, bir dizinin belirli bir bölümüne de başvurmak isteyebiliriz. Bunu şu şekilde yaparız:

#![allow(unused)]
fn main() {
let d = [1, 2, 3, 4, 5];

let dilim = &d[1..3];

assert_eq!(dilim, &[2, 3]);
}

Bu dilim &[i32] türündedir. İlk elemana yönelen bir referansı ve bir uzunluk bilgisini yığında saklayarak tıpkı string dilimleri gibi çalışır. Bu tür dilimleri diğer pek çok koleksiyon türüyle birlikte sıkça kullanacaksınız. Bu koleksiyonları Bölüm 8’de vektörleri incelerken ayrıntılı olarak ele alacağız.

Özet

Sahiplik, ödünç alma ve dilim kavramları Rust programlarında bellek güvenliğini derleme zamanında güvence altına alır. Rust dili, tıpkı diğer sistem programlama dilleri gibi bellek kullanımınız üzerinde size tam denetim verir; ancak verinin sahibi kapsam dışına çıktığında veriyi otomatik olarak temizlemesi sayesinde bu denetimi elde etmek için fazladan bellek yönetimi kodu yazmak ve bu kodların hatalarını ayıklamak zorunda kalmazsınız.

Sahiplik kavramı Rust’ın diğer pek çok parçasının nasıl çalıştığını doğrudan etkiler; bu nedenle kitabın geri kalanı boyunca bu kavramlara sık sık geri döneceğiz. Şimdi Bölüm 5’e geçelim ve birbiriyle ilişkili veri parçalarını bir struct içinde gruplandırmaya bakalım.

İlgili Verileri Yapılandırmak İçin Struct Kullanımı

Bir struct (yapı), anlamlı bir bütün oluşturan ilişkili birden fazla değeri bir araya getirip isimlendirmenizi sağlayan özel bir veri türüdür. Nesne yönelimli bir programlama diline aşinaysanız struct, bir nesnenin veri niteliklerine benzer. Bu bölümde, şimdiye kadar öğrendiklerinizden yola çıkarak demet (tuple) türü ile struct’ları karşılaştıracak, benzerlik ve farklarını ortaya koyacak ve verileri gruplandırmak için struct’ların ne zaman daha iyi bir seçenek olduğunu göstereceğiz.

Struct’ların nasıl tanımlanacağını ve örnekleneceğini inceleyeceğiz. Bir struct türüne ait davranışları belirlemek için ilişkili fonksiyonların (associated functions) —özellikle de metot olarak adlandırılan ilişkili fonksiyon türünün— nasıl tanımlanacağını ele alacağız. Struct’lar ve Bölüm 6’da göreceğimiz enum’lar, programınızın ele aldığı probleme özgü yeni türler oluşturmanın temel yapı taşlarıdır; bu türler sayesinde Rust’ın derleme zamanı tür denetiminden tam anlamıyla yararlanabilirsiniz.

Struct Tanımlama ve Örnekleme

Struct Tanımlama ve Örnekleme

Struct’lar, birbiriyle ilişkili birden fazla değeri bir arada tutmaları bakımından “Demet Türü” bölümünde ele aldığımız demetlere benzer. Tıpkı demetlerde olduğu gibi, bir struct’ın parçaları farklı türlerde olabilir. Ancak demetlerden farklı olarak struct içinde her bir veri parçasına bir ad verirsiniz; böylece değerlerin ne anlama geldiği açıkça anlaşılır. Bu isimlendirme sayesinde struct’lar demetlerden daha esnektir: Bir örneğin değerlerini belirtmek ya da onlara erişmek için verilerin sırasına bağımlı kalmazsınız.

Bir struct tanımlamak için struct anahtar kelimesini yazar ve struct’ın tamamına bir ad veririz. Struct’ın adı, bir araya getirilen veri parçalarının ortak anlamını ifade etmelidir. Ardından süslü parantezler içinde, alan (field) olarak adlandırdığımız veri parçalarının adlarını ve türlerini tanımlarız. Örneğin Liste 5-1, bir kullanıcı hesabına ait bilgileri tutan bir struct tanımını göstermektedir.

struct Kullanici {
    aktif: bool,
    kullanici_adi: String,
    eposta: String,
    giris_sayisi: u64,
}

fn main() {}

Tanımladığımız bir struct’ı kullanmak için, her bir alana somut değerler vererek o struct’ın bir örneğini (instance) oluştururuz. Örnek oluştururken önce struct’ın adını yazar, ardından içine anahtar: değer çiftlerini yerleştirdiğimiz süslü parantezler açarız; buradaki anahtarlar alanların adları, değerler ise o alanlarda saklamak istediğimiz verilerdir. Alanları, struct tanımındaki bildirim sırasıyla yazmak zorunda değiliz. Struct tanımı, tür için genel bir şablon gibidir; örnekler ise bu şablonu belirli verilerle doldurarak o türe ait somut değerler üretir. Örneğin Liste 5-2’de gösterildiği gibi belirli bir kullanıcı tanımlayabiliriz.

struct Kullanici {
    aktif: bool,
    kullanici_adi: String,
    eposta: String,
    giris_sayisi: u64,
}

fn main() {
    let kullanici1 = Kullanici {
        aktif: true,
        kullanici_adi: String::from("birkullaniciadi123"),
        eposta: String::from("birisi@example.com"),
        giris_sayisi: 1,
    };
}

Bir struct içinden belirli bir değeri okumak için nokta gösterimini (dot notation) kullanırız. Örneğin bu kullanıcının e-posta adresine erişmek istediğimizde kullanici1.eposta yazarız. Eğer örnek değiştirilebilir (mut) olarak tanımlanmışsa, nokta gösterimiyle belirli bir alana yeni bir değer atayarak o alanı güncelleyebiliriz. Liste 5-3, değiştirilebilir bir Kullanici örneğinin eposta alanındaki değerin nasıl değiştirileceğini göstermektedir.

struct Kullanici {
    aktif: bool,
    kullanici_adi: String,
    eposta: String,
    giris_sayisi: u64,
}

fn main() {
    let mut kullanici1 = Kullanici {
        aktif: true,
        kullanici_adi: String::from("birkullaniciadi123"),
        eposta: String::from("birisi@example.com"),
        giris_sayisi: 1,
    };

    kullanici1.eposta = String::from("baskaeposta@example.com");
}

Örneğin tamamının değiştirilebilir olması gerektiğine dikkat edin; Rust yalnızca belirli alanları değiştirilebilir olarak işaretlememize izin vermez. Struct örneği oluşturmak da bir ifade olduğundan, her ifadede olduğu gibi, fonksiyon gövdesinin son ifadesi olarak struct’ın yeni bir örneğini oluşturabilir ve bu örneği örtük olarak döndürebiliriz.

Liste 5-4, verilen e-posta ve kullanıcı adıyla bir Kullanici örneği döndüren kullanici_olustur fonksiyonunu göstermektedir. aktif alanına true, giris_sayisi alanına ise 1 değeri atanır.

struct Kullanici {
    aktif: bool,
    kullanici_adi: String,
    eposta: String,
    giris_sayisi: u64,
}

fn kullanici_olustur(eposta: String, kullanici_adi: String) -> Kullanici {
    Kullanici {
        aktif: true,
        kullanici_adi: kullanici_adi,
        eposta: eposta,
        giris_sayisi: 1,
    }
}

fn main() {
    let kullanici1 = kullanici_olustur(
        String::from("birisi@example.com"),
        String::from("birkullaniciadi123"),
    );
}

Fonksiyon parametrelerine struct alanlarıyla aynı adları vermek mantıklıdır; ancak eposta ve kullanici_adi adlarını hem alan adı hem de değişken olarak ikişer kez yazmak biraz zahmetlidir. Struct daha fazla alana sahip olsaydı her bir adı bu şekilde yinelemek daha da can sıkıcı hâle gelirdi. Neyse ki bunun için kullanışlı bir kısayol vardır!

Alan Başlatma Kısayolunu Kullanma

Liste 5-4’teki parametre adları ile struct alan adları birebir aynı olduğundan, alan başlatma kısayolu (field init shorthand) sözdizimini kullanarak kullanici_olustur fonksiyonunu yeniden yazabiliriz. Liste 5-5’teki yeni sürüm öncekiyle aynı şekilde çalışır, ancak kullanici_adi ve eposta adlarını tekrar etmez.

struct Kullanici {
    aktif: bool,
    kullanici_adi: String,
    eposta: String,
    giris_sayisi: u64,
}

fn kullanici_olustur(eposta: String, kullanici_adi: String) -> Kullanici {
    Kullanici {
        aktif: true,
        kullanici_adi,
        eposta,
        giris_sayisi: 1,
    }
}

fn main() {
    let kullanici1 = kullanici_olustur(
        String::from("birisi@example.com"),
        String::from("birkullaniciadi123"),
    );
}

Burada, eposta adında bir alanı bulunan Kullanici struct’ının yeni bir örneğini oluşturuyoruz. eposta alanının değerini, kullanici_olustur fonksiyonunun eposta parametresindeki değere eşitlemek istiyoruz. Alan adı ile parametre adı aynı olduğu için eposta: eposta yerine yalnızca eposta yazmamız yeterlidir.

Struct Güncelleme Sözdizimi ile Örnekler Oluşturma

Aynı türdeki mevcut bir örneğin değerlerinin çoğunu koruyup yalnızca birkaçını değiştirerek yeni bir struct örneği oluşturmak çoğu zaman işe yarar. Bunu struct güncelleme sözdizimi (struct update syntax) ile yapabilirsiniz.

Öncelikle Liste 5-6’da, güncelleme sözdizimini kullanmadan sıradan yöntemle kullanici2 içinde yeni bir Kullanici örneğini nasıl oluşturacağımızı görelim. eposta alanı için yeni bir değer belirliyor, geri kalan alanlarda ise Liste 5-2’de oluşturduğumuz kullanici1 örneğindeki değerlerin aynısını kullanıyoruz.

struct Kullanici {
    aktif: bool,
    kullanici_adi: String,
    eposta: String,
    giris_sayisi: u64,
}

fn main() {
    // --snip--

    let kullanici1 = Kullanici {
        eposta: String::from("birisi@example.com"),
        kullanici_adi: String::from("birkullaniciadi123"),
        aktif: true,
        giris_sayisi: 1,
    };

    let kullanici2 = Kullanici {
        aktif: kullanici1.aktif,
        kullanici_adi: kullanici1.kullanici_adi,
        eposta: String::from("baska@example.com"),
        giris_sayisi: kullanici1.giris_sayisi,
    };
}

Struct güncelleme sözdizimini kullanarak, Liste 5-7’de gösterildiği gibi aynı sonucu çok daha az kodla elde edebiliriz. .. sözdizimi, açıkça değer verilmeyen geri kalan alanların belirtilen örnekteki karşılıklarıyla aynı değere sahip olacağını ifade eder.

struct Kullanici {
    aktif: bool,
    kullanici_adi: String,
    eposta: String,
    giris_sayisi: u64,
}

fn main() {
    // --snip--

    let kullanici1 = Kullanici {
        eposta: String::from("birisi@example.com"),
        kullanici_adi: String::from("birkullaniciadi123"),
        aktif: true,
        giris_sayisi: 1,
    };

    let kullanici2 = Kullanici {
        eposta: String::from("baska@example.com"),
        ..kullanici1
    };
}

Liste 5-7’deki kod da kullanici2 içinde eposta alanı farklı, ancak kullanici_adi, aktif ve giris_sayisi alanları kullanici1 ile aynı değerlere sahip bir örnek oluşturur. Kalan tüm alanların değerlerinin kullanici1’deki karşılık gelen alanlardan alınacağını belirtmek için ..kullanici1 en sonda yer almalıdır; ancak struct tanımındaki alan sırasından bağımsız olarak istediğimiz sayıda alana dilediğimiz sırada açıkça değer verebiliriz.

Struct güncelleme sözdiziminin tıpkı bir atama işlemi gibi = kullandığına dikkat edin; bunun nedeni, verileri “Değişkenlerin ve Verilerin Taşıma ile Etkileşimi” bölümünde gördüğümüz şekilde taşımasıdır. Bu örnekte kullanici2 oluşturulduktan sonra artık kullanici1 örneğini bir bütün olarak kullanamayız; çünkü kullanici1’in kullanici_adi alanındaki String değeri kullanici2 içine taşınmıştır. Eğer kullanici2’ye hem eposta hem de kullanici_adi için yeni String değerleri verseydik ve böylece kullanici1 içinden yalnızca aktif ile giris_sayisi alanlarını alsaydık, kullanici2 oluşturulduktan sonra kullanici1 tamamen geçerli kalmaya devam ederdi. Hem aktif hem de giris_sayisi, Copy trait’ini uygulayan türlerde olduğundan “Yalnızca Yığındaki Veri: Copy” bölümünde ele aldığımız kurallar devreye girerdi. Ayrıca mevcut örneğimizde kullanici1.eposta alanını hâlâ kullanabiliriz; çünkü bu alanın değeri kullanici1 dışına taşınmamıştır.

Demet Struct’ları ile Farklı Türler Oluşturma

Rust ayrıca demetlere benzeyen ve demet struct’ları (tuple structs) olarak adlandırılan struct’ları da destekler. Demet struct’ları, struct adının kazandırdığı ek anlama sahiptir; ancak alanlarının isimleri yoktur, yalnızca alan türleri belirtilir. Demet struct’ları, demetin tamamına bir ad vererek onu diğer demetlerden ayrı bir tür hâline getirmek istediğinizde ve her bir alanı normal bir struct’taki gibi isimlendirmenin gereksiz yere uzun ya da yinelemeli olacağı durumlarda kullanışlıdır.

Bir demet struct’ı tanımlamak için struct anahtar kelimesiyle başlayıp struct adını yazar, ardından parantez içinde demetteki türleri belirtirsiniz. Örneğin aşağıda Renk ve Nokta adında iki demet struct’ı tanımlayıp kullanıyoruz:

struct Renk(i32, i32, i32);
struct Nokta(i32, i32, i32);

fn main() {
    let siyah = Renk(0, 0, 0);
    let orijin = Nokta(0, 0, 0);
}

siyah ve orijin değerlerinin, farklı demet struct’larının örnekleri oldukları için farklı türlere sahip olduğuna dikkat edin. Tanımladığınız her struct, içerdiği alanlar aynı türlerde olsa bile başlı başına ayrı bir türdür. Örneğin her iki tür de üç adet i32 değerinden oluşmasına rağmen, Renk türünde bir parametre bekleyen bir fonksiyona argüman olarak bir Nokta veremezsiniz. Bunun dışında demet struct örnekleri demetlere benzer: Onları tekil parçalarına ayırabilir ve belirli bir değere erişmek için nokta (.) işaretinin ardından indeks numarasını yazabilirsiniz. Ancak sıradan demetlerden farklı olarak demet struct’ları, yapı sökümü (destructuring) yaparken struct’ın tür adını belirtmenizi gerektirir. Örneğin orijin noktasındaki değerleri x, y ve z adlı değişkenlere ayırmak için let Nokta(x, y, z) = orijin; yazarız.

Birim Benzeri Struct’ları Tanımlama

Hiçbir alanı olmayan struct’lar da tanımlayabilirsiniz! Bunlara, “Demet Türü” bölümünde değindiğimiz birim türe (()) benzer biçimde davrandıkları için birim benzeri struct’lar (unit-like structs) adı verilir. Birim benzeri struct’lar, bir tür üzerinde bir trait uygulamanız gerektiğinde ancak türün kendisinde saklamak istediğiniz herhangi bir veri bulunmadığında oldukça işe yarar. Trait’leri Bölüm 10’da ele alacağız. Aşağıda HerZamanEsit adlı birim benzeri bir struct’ı tanımlayıp örnekliyoruz:

struct HerZamanEsit;

fn main() {
    let ozne = HerZamanEsit;
}

HerZamanEsit türünü tanımlamak için struct anahtar kelimesini, istediğimiz adı ve ardından noktalı virgülü yazarız. Süslü parantezlere veya normal parantezlere gerek yoktur! Ardından ozne değişkeninde bir HerZamanEsit örneği elde etmek için de benzer şekilde, herhangi bir süslü ya da normal parantez kullanmadan doğrudan tanımladığımız adı yazarız. İleride bu tür için, HerZamanEsit türünün her örneğinin diğer tüm türlerin her örneğine daima eşit kabul edileceği bir davranış uygulayacağımızı düşünün; böyle bir davranış, örneğin testlerde sonucu önceden bilinen bir karşılaştırma elde etmek için işe yarayabilir. Böyle bir davranışı uygulamak için struct içinde herhangi bir veri tutmamıza gerek yoktur! Bölüm 10’da trait’leri nasıl tanımlayacağınızı ve birim benzeri struct’lar da dahil olmak üzere herhangi bir tür üzerinde nasıl uygulayacağınızı göreceksiniz.

struct Kullanici {
    aktif: bool,
    kullanici_adi: &str,
    eposta: &str,
    giris_sayisi: u64,
}

fn main() {
    let kullanici1 = Kullanici {
        aktif: true,
        kullanici_adi: "birkullaniciadi123",
        eposta: "birisi@example.com",
        giris_sayisi: 1,
    };
}

$ cargo run
   Compiling structs v0.1.0 (file:///projects/structs)
error[E0106]: missing lifetime specifier
 --> src/main.rs:3:20
  |
3 |     kullanici_adi: &str,
  |                    ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct Kullanici<'a> {
2 |     aktif: bool,
3 ~     kullanici_adi: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:13
  |
4 |     eposta: &str,
  |             ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct Kullanici<'a> {
2 |     aktif: bool,
3 |     kullanici_adi: &str,
4 ~     eposta: &'a str,
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `structs` (bin "structs") due to 2 previous errors

Struct Kullanan Örnek Bir Program

Struct Kullanan Örnek Bir Program

Struct’ları ne zaman kullanmak isteyebileceğimizi anlamak için bir dikdörtgenin alanını hesaplayan bir program yazalım. İşe tekil değişkenler kullanarak başlayacak, ardından programı adım adım yeniden düzenleyerek (refactoring) bunların yerine struct kullanır hâle getireceğiz.

Cargo ile dikdortgenler adında yeni bir ikili proje oluşturalım; bu proje piksel cinsinden belirtilen bir dikdörtgenin genişliğini ve yüksekliğini alıp alanını hesaplayacak. Liste 5-8, projemizin src/main.rs dosyasında tam olarak bunu yapmanın bir yolunu gösteren kısa bir programdır.

fn main() {
    let genislik1 = 30;
    let yukseklik1 = 50;

    println!(
        "Dikdörtgenin alanı {} kare pikseldir.",
        alan(genislik1, yukseklik1)
    );
}

fn alan(genislik: u32, yukseklik: u32) -> u32 {
    genislik * yukseklik
}

Şimdi bu programı cargo run komutuyla çalıştırın:

$ cargo run
   Compiling dikdortgenler v0.1.0 (file:///projects/dikdortgenler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/dikdortgenler`
Dikdörtgenin alanı 1500 kare pikseldir.

Bu kod, her bir boyutu argüman olarak verip alan fonksiyonunu çağırarak dikdörtgenin alanını doğru biçimde hesaplar; ancak kodu daha anlaşılır ve okunabilir kılmak için yapabileceğimiz çok şey var.

Kodun asıl sorunu alan fonksiyonunun imzasında açıkça görülür:

fn main() {
    let genislik1 = 30;
    let yukseklik1 = 50;

    println!(
        "Dikdörtgenin alanı {} kare pikseldir.",
        alan(genislik1, yukseklik1)
    );
}

fn alan(genislik: u32, yukseklik: u32) -> u32 {
    genislik * yukseklik
}

alan fonksiyonunun tek bir dikdörtgenin alanını hesaplaması beklenir; oysa yazdığımız fonksiyon iki ayrı parametre alıyor ve programımızın hiçbir yerinde bu parametrelerin birbiriyle ilişkili olduğu belirtilmiyor. Genişlik ve yüksekliği bir arada gruplamak kodu hem daha okunabilir hem de daha yönetilebilir hâle getirecektir. Bölüm 3’teki “Demet Türü” kısmında bunu yapmanın bir yolunu zaten görmüştük: demet kullanmak.

Demetlerle Yeniden Düzenleme

Liste 5-9, programımızın demet kullanan yeni bir sürümünü göstermektedir.

fn main() {
    let dikdortgen1 = (30, 50);

    println!("Dikdörtgenin alanı {} kare pikseldir.", alan(dikdortgen1));
}

fn alan(boyutlar: (u32, u32)) -> u32 {
    boyutlar.0 * boyutlar.1
}

Bir açıdan bu program daha iyidir. Demetler veriye biraz yapı kazandırmamızı sağlar ve artık fonksiyona yalnızca tek bir argüman geçiriyoruz. Ancak başka bir açıdan bu sürüm daha belirsizdir: Demetler elemanlarına ad vermez; bu yüzden demetin parçalarına indeks numarasıyla (boyutlar.0, boyutlar.1) erişmemiz gerekir; bu da yapılan hesaplamanın ne olduğunu ilk bakışta görmeyi zorlaştırır.

Genişlik ile yüksekliği birbiriyle karıştırmak alan hesaplamasında sonucu değiştirmez, ancak dikdörtgeni ekrana çizmek isteseydik kesinlikle sorun yaratırdı! Genişlik değerinin 0 indeksinde, yükseklik değerinin ise 1 indeksinde yer aldığını sürekli aklımızda tutmamız gerekirdi. Kodumuzu bir başkası kullanacak olsaydı bunu çözmesi ve aklında tutması daha da güçleşirdi. Verimizin anlamını koda yansıtmadığımız için hata yapmaya çok daha açık bir yapı ortaya çıkmıştır.

Struct’larla Yeniden Düzenleme

Verileri etiketleyerek onlara anlam kazandırmak için struct’ları kullanırız. Liste 5-10’da gösterildiği gibi, kullandığımız demeti hem bütününe hem de her bir parçasına ad verdiğimiz bir struct’a dönüştürebiliriz.

struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };

    println!("Dikdörtgenin alanı {} kare pikseldir.", alan(&dikdortgen1));
}

fn alan(dikdortgen: &Dikdortgen) -> u32 {
    dikdortgen.genislik * dikdortgen.yukseklik
}

Burada bir struct tanımlayıp ona Dikdortgen adını verdik. Süslü parantezler içinde alanları, her ikisi de u32 türünde olan genislik ve yukseklik olarak belirledik. Ardından main içinde genişliği 30, yüksekliği 50 olan somut bir Dikdortgen örneği oluşturduk.

alan fonksiyonumuz artık dikdortgen adını verdiğimiz tek bir parametre alıyor ve bu parametrenin türü bir Dikdortgen struct örneğinin değiştirilemez referansıdır (&Dikdortgen). Bölüm 4’te değindiğimiz gibi, struct’ın sahipliğini devralmak yerine onu ödünç almak istiyoruz. Böylece main fonksiyonu dikdortgen1’in sahipliğini elinde tutar ve onu kullanmaya devam edebilir; hem fonksiyon imzasında hem de fonksiyonu çağırdığımız yerde & kullanmamızın nedeni budur.

alan fonksiyonu, Dikdortgen örneğinin genislik ve yukseklik alanlarına erişir (ödünç alınan bir struct örneğinin alanlarına erişmenin o alanlardaki değerleri taşımadığına dikkat edin; struct’ların kodda sıkça ödünç alınmasının başlıca nedenlerinden biri budur). alan fonksiyonumuzun imzası artık tam olarak ne kastettiğimizi söyler: Dikdortgen’in alanını, onun genislik ve yukseklik alanlarını kullanarak hesapla. Bu yapı genişlik ve yüksekliğin birbiriyle ilişkili olduğunu açıkça ortaya koyar ve 0 ile 1 gibi demet indeksleri yerine değerlere açıklayıcı adlar verir. Kodun anlaşılırlığı açısından bu net bir kazanımdır.

Türetilen Trait’lerle İşlevsellik Ekleme

Programımızda hata ayıklarken (debugging) bir Dikdortgen örneğini ekrana yazdırıp tüm alanlarının değerlerini görebilmek çok işe yarardı. Liste 5-11’de, önceki bölümlerde yaptığımız gibi println! makrosunu kullanmayı deniyoruz. Ne var ki bu kod derlenmeyecektir.

struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };

    println!("dikdortgen1 şöyledir: {dikdortgen1}");
}

Bu kodu derlediğimizde şu temel mesajı içeren bir hata alırız (Dikdortgen, std::fmt::Display trait’ini uygulamıyor):

error[E0277]: `Dikdortgen` doesn't implement `std::fmt::Display`

println! makrosu pek çok farklı biçimlendirme yapabilir ve süslü parantezler ({}) varsayılan olarak println! makrosuna, doğrudan son kullanıcıya yönelik çıktı üretmek için tasarlanmış Display adlı biçimlendirmeyi kullanmasını söyler. Şimdiye kadar gördüğümüz ilkel türler varsayılan olarak Display trait’ini uygular; çünkü 1 sayısını ya da başka herhangi bir ilkel türü kullanıcıya göstermenin tek bir doğal yolu vardır. Ancak struct’larda println! makrosunun çıktıyı nasıl biçimlendirmesi gerektiği net değildir, çünkü çok sayıda gösterim olasılığı bulunur: Alanlar arasında virgül olmalı mı, olmamalı mı? Süslü parantezler yazdırılmalı mı? Tüm alanlar gösterilmeli mi, yoksa bazıları gizlenmeli mi? Bu belirsizlik nedeniyle Rust ne istediğimizi tahmin etmeye çalışmaz ve struct’lar, println! ile {} yer tutucusuyla birlikte kullanılabilecek hazır bir Display uygulamasına sahip değildir.

Hata çıktısını okumaya devam edersek derleyicinin sunduğu şu yararlı yardım (help) ve not (note) mesajlarını görürüz:

help: the trait `std::fmt::Display` is not implemented for `Dikdortgen`
  --> src/main.rs:1:1
   |
 1 | struct Dikdortgen {
   | ^^^^^^^^^^^^^^^^^
   = note: in format strings you may be able to use `{:?}` (or `{:#?}` for pretty-print) instead

Hadi deneyelim! println! makro çağrımız artık println!("dikdortgen1 şöyledir: {dikdortgen1:?}"); şeklinde görünecektir. Süslü parantezlerin içine :? biçim belirtecini (specifier) eklemek, println! makrosuna Debug adlı çıktı biçimini kullanmak istediğimizi bildirir. Debug trait’i, kodumuzda hata ayıklarken struct’ımızın değerini geliştiriciler için yararlı olacak bir biçimde yazdırmamıza olanak tanır.

Kodu bu değişiklikle derleyelim. Aksi gibi, yine bir hata alıyoruz (Dikdortgen, Debug trait’ini uygulamıyor):

error[E0277]: `Dikdortgen` doesn't implement `Debug`

Ancak derleyici bize yine yol gösteren bir yardım mesajı sunar (Dikdortgen tanımına #[derive(Debug)] eklemeyi önerir):

   = help: the trait `Debug` is not implemented for `Dikdortgen`
help: consider annotating `Dikdortgen` with `#[derive(Debug)]`
   |
 1 + #[derive(Debug)]
 2 | struct Dikdortgen {
   |

Rust hata ayıklama bilgilerini yazdırma işlevselliğini gerçekten barındırır; ancak bu işlevselliği kendi struct’ımız için etkinleştirmek istiyorsak bunu açıkça belirtmemiz gerekir. Bunun için Liste 5-12’de gösterildiği gibi struct tanımının hemen üstüne #[derive(Debug)] dış özniteliğini (outer attribute) ekleriz.

#[derive(Debug)]
struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };

    println!("dikdortgen1 şöyledir: {dikdortgen1:?}");
}

Artık programı çalıştırdığımızda herhangi bir hata almayız ve aşağıdaki çıktıyı görürüz:

$ cargo run
   Compiling dikdortgenler v0.1.0 (file:///projects/dikdortgenler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/dikdortgenler`
dikdortgen1 şöyledir: Dikdortgen { genislik: 30, yukseklik: 50 }

Harika! En şık çıktı olmayabilir, ancak bu örneğin tüm alanlarının değerlerini açıkça gösteriyor; bu da hata ayıklama sırasında kesinlikle işimize yarayacaktır. Daha büyük struct’larla çalıştığımızda okuması daha kolay bir çıktı elde etmek isteriz; böyle durumlarda println! biçimlendirme metninde {:?} yerine {:#?} kullanabiliriz. Bu örnekte {:#?} biçimini kullanmak aşağıdaki çıktıyı üretir:

$ cargo run
   Compiling dikdortgenler v0.1.0 (file:///projects/dikdortgenler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/dikdortgenler`
dikdortgen1 şöyledir: Dikdortgen {
    genislik: 30,
    yukseklik: 50,
}

Debug biçimini kullanarak bir değeri yazdırmanın bir diğer yolu da dbg! makrosunu kullanmaktır. Referans alan println! makrosunun aksine dbg! makrosu bir ifadenin sahipliğini alır, kodunuzda dbg! çağrısının yapıldığı dosya ve satır numarasını o ifadenin hesaplanan değeriyle birlikte yazdırır ve ardından değerin sahipliğini geri döndürür.

Aşağıda, hem dikdortgen1 içindeki struct’ın tamamının değeriyle hem de genislik alanına atanan ara değerle ilgilendiğimiz bir örnek yer alıyor:

#[derive(Debug)]
struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

fn main() {
    let olcek = 2;
    let dikdortgen1 = Dikdortgen {
        genislik: dbg!(30 * olcek),
        yukseklik: 50,
    };

    dbg!(&dikdortgen1);
}

30 * olcek ifadesini dbg! içine alabiliriz; dbg! ifadenin değerinin sahipliğini geri döndürdüğü için genislik alanı, orada dbg! çağrısı hiç yokmuş gibi aynı değeri alacaktır. Bir sonraki çağrıda ise dbg! makrosunun dikdortgen1’in sahipliğini almasını istemediğimiz için dikdortgen1’e bir referans (&dikdortgen1) geçiriyoruz. Bu örneğin çıktısı şöyle görünür:

$ cargo run
   Compiling dikdortgenler v0.1.0 (file:///projects/dikdortgenler)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.61s
     Running `target/debug/dikdortgenler`
[src/main.rs:10:19] 30 * olcek = 60
[src/main.rs:14:5] &dikdortgen1 = Dikdortgen {
    genislik: 60,
    yukseklik: 50,
}

Çıktının ilk kısmının, 30 * olcek ifadesinde hata ayıkladığımız src/main.rs dosyasının 10. satırından geldiğini ve ifadenin sonucunun 60 olduğunu görebiliriz (tamsayılar için tanımlı Debug biçimlendirmesi yalnızca sayının kendisini yazdırır). src/main.rs dosyasının 14. satırındaki dbg! çağrısı ise Dikdortgen struct’ına referans olan &dikdortgen1’in değerini yazdırır. Bu çıktı, Dikdortgen türünün okunaklı (pretty) Debug biçimlendirmesini kullanır. Kodunuzun çalışma zamanında ne yaptığını anlamaya çalışırken dbg! makrosu gerçekten çok işinize yarayabilir!

Debug trait’ine ek olarak Rust, özel türlerimize yararlı davranışlar kazandırabilmemiz için derive özniteliğiyle birlikte kullanabileceğimiz pek çok trait sunar. Bu trait’ler ve sağladıkları davranışlar Ek C’de listelenmiştir. Bölüm 10’da bu trait’leri özelleştirilmiş davranışlarla nasıl uygulayacağınızı ve kendi trait’lerinizi nasıl oluşturacağınızı inceleyeceğiz. Ayrıca derive dışında pek çok başka öznitelik de vardır; daha fazla bilgi için Rust Referansı’ndaki “Attributes” (Öznitelikler) bölümüne bakabilirsiniz.

alan fonksiyonumuz oldukça özel amaçlıdır: Yalnızca dikdörtgenlerin alanını hesaplar. Başka hiçbir türle çalışmayacağı için bu davranışı Dikdortgen struct’ımıza daha sıkı biçimde bağlamak çok daha yerinde olur. Gelin alan fonksiyonunu Dikdortgen türümüz üzerinde tanımlı bir alan metoduna dönüştürerek bu kodu yeniden düzenlemeye nasıl devam edebileceğimize bakalım.

Metotlar

Metotlar

Metotlar fonksiyonlara benzer: Onları da fn anahtar kelimesi ve bir adla bildiririz; parametreleri ve bir dönüş değeri olabilir, ayrıca başka bir yerden çağrıldıklarında çalıştırılacak kodu barındırırlar. Fonksiyonlardan farklı olarak metotlar bir struct’ın (ya da sırasıyla Bölüm 6 ve Bölüm 18’de ele alacağımız bir enum’ın veya trait nesnesinin) bağlamında tanımlanır ve ilk parametreleri her zaman metodun üzerinde çağrıldığı struct örneğini temsil eden self olur.

Metot Sözdizimi

Parametre olarak bir Dikdortgen örneği alan alan fonksiyonunu değiştirelim ve bunun yerine Liste 5-13’te gösterildiği gibi Dikdortgen struct’ı üzerinde tanımlı bir alan metodu oluşturalım.

#[derive(Debug)]
struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

impl Dikdortgen {
    fn alan(&self) -> u32 {
        self.genislik * self.yukseklik
    }
}

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };

    println!("Dikdörtgenin alanı {} kare pikseldir.", dikdortgen1.alan());
}

Fonksiyonu Dikdortgen bağlamında tanımlamak üzere Dikdortgen için bir impl (uygulama / implementation) bloğu başlatırız. Bu impl bloğu içindeki her şey Dikdortgen türüyle ilişkilendirilir. Ardından alan fonksiyonunu impl süslü parantezlerinin içine taşır ve ilk (bu örnekte aynı zamanda tek) parametreyi hem imzada hem de gövdenin her yerinde self olacak şekilde değiştiririz. Daha önce alan fonksiyonunu çağırıp dikdortgen1’i argüman olarak geçirdiğimiz main fonksiyonunda ise artık Dikdortgen örneğimiz üzerindeki alan metodunu çağırmak için metot sözdizimini (method syntax) kullanabiliriz. Metot sözdizimi bir örnekten hemen sonra gelir: Bir nokta koyar, ardından metodun adını, parantezleri ve varsa argümanları yazarız.

alan metodunun imzasında dikdortgen: &Dikdortgen yerine &self kullanırız. Buradaki &self aslında self: &Self ifadesinin kısaltmasıdır. Bir impl bloğu içinde Self türü, o impl bloğunun ait olduğu türün takma adıdır. Metotların ilk parametresi Self türünde ve self adında olmak zorundadır; bu nedenle Rust, ilk parametre konumunda bunu yalnızca self adıyla kısaltmanıza olanak tanır. Yine de tıpkı dikdortgen: &Dikdortgen kullanımında olduğu gibi, bu metodun Self örneğini ödünç aldığını belirtmek için self kısaltmasının önüne & koymamız gerektiğine dikkat edin. Metotlar, diğer herhangi bir parametrede olduğu gibi self’in sahipliğini alabilir, burada yaptığımız gibi self’i değiştirilemez biçimde ödünç alabilir veya self’i değiştirilebilir biçimde ödünç alabilir.

Fonksiyon sürümünde &Dikdortgen kullanmamızla aynı nedenden ötürü burada da &self seçtik: Sahipliği devralmak istemiyoruz; struct içindeki verileri yalnızca okumak istiyoruz, onlara yazmak istemiyoruz. Metodun yaptığı işin bir parçası olarak üzerinde çağrıldığı örneği değiştirmesini isteseydik ilk parametre olarak &mut self kullanırdık. İlk parametre olarak yalnızca self yazıp örneğin sahipliğini alan bir metot tanımlamak nadirdir; bu teknik genellikle metot self’i başka bir şeye dönüştürdüğünde ve dönüşümden sonra çağıran kodun orijinal örneği kullanmasını engellemek istediğinizde tercih edilir.

Metot sözdizimini kullanabilmek ve her metodun imzasında self’in türünü yinelemek zorunda kalmamak bir yana, fonksiyonlar yerine metot kullanmanın asıl nedeni kod düzenidir. Bir türün örneğiyle yapabileceğimiz her şeyi tek bir impl bloğunda toplarız; böylece kodumuzu ileride kullanacak kişilerin Dikdortgen’in yeteneklerini sunduğumuz kütüphanenin farklı yerlerinde aramak zorunda kalmasını önleriz.

Bir metoda struct’ın alanlarından biriyle aynı adı vermeyi de seçebileceğimize dikkat edin. Örneğin Dikdortgen üzerinde yine genislik adında bir metot tanımlayabiliriz:

#[derive(Debug)]
struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

impl Dikdortgen {
    fn genislik(&self) -> bool {
        self.genislik > 0
    }
}

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };

    if dikdortgen1.genislik() {
        println!(
            "Dikdörtgenin sıfırdan büyük bir genişliği var; değeri: {}",
            dikdortgen1.genislik
        );
    }
}

Burada genislik metodunun, örnekteki genislik alanının değeri 0’dan büyükse true, 0 ise false döndürmesini seçtik: Aynı adlı bir metot içinde o alanı istediğimiz amaçla kullanabiliriz. main içinde dikdortgen1.genislik ifadesinin ardından parantez kullandığımızda Rust genislik metodunu kastettiğimizi anlar. Parantez kullanmadığımızda ise Rust genislik alanını kastettiğimizi bilir.

Her zaman olmasa da çoğu durumda, bir metoda bir alanla aynı adı verdiğimizde yalnızca alandaki değeri döndürmesini ve başka hiçbir şey yapmamasını isteriz. Bu tür metotlara alıcı metotlar (getters) denir ve Rust, bazı diğer dillerin aksine struct alanları için bunları otomatik olarak uygulamaz. Alıcı metotlar oldukça kullanışlıdır; çünkü alanı gizli (private), metodu ise açık (public) yaparak bu alana türün açık API’sinin bir parçası olarak salt okunur erişim sağlayabilirsiniz. Açık ve gizli kavramlarının ne olduğunu ve bir alanı ya da metodu nasıl açık veya gizli olarak belirleyeceğimizi Bölüm 7’de ele alacağız.

#![allow(unused)]
fn main() {
#[derive(Debug,Copy,Clone)]
struct Nokta {
    x: f64,
    y: f64,
}

impl Nokta {
   fn mesafe(&self, diger: &Nokta) -> f64 {
       let x_karesi = f64::powi(diger.x - self.x, 2);
       let y_karesi = f64::powi(diger.y - self.y, 2);

       f64::sqrt(x_karesi + y_karesi)
   }
}
let n1 = Nokta { x: 0.0, y: 0.0 };
let n2 = Nokta { x: 5.0, y: 6.5 };
n1.mesafe(&n2);
(&n1).mesafe(&n2);
}

Daha Fazla Parametre Alan Metotlar

Dikdortgen struct’ı üzerinde ikinci bir metot uygulayarak metot kullanımı konusunda pratik yapalım. Bu kez bir Dikdortgen örneğinin başka bir Dikdortgen örneğini almasını ve ikinci Dikdortgen tamamen self’in (birinci Dikdortgen’in) içine sığabiliyorsa true, aksi hâlde false döndürmesini istiyoruz. Yani kapsayabilir_mi metodunu tanımladıktan sonra Liste 5-14’te gösterilen programı yazabilmek istiyoruz.

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };
    let dikdortgen2 = Dikdortgen {
        genislik: 10,
        yukseklik: 40,
    };
    let dikdortgen3 = Dikdortgen {
        genislik: 60,
        yukseklik: 45,
    };

    println!(
        "dikdortgen1, dikdortgen2'yi kapsayabilir mi? {}",
        dikdortgen1.kapsayabilir_mi(&dikdortgen2)
    );
    println!(
        "dikdortgen1, dikdortgen3'ü kapsayabilir mi? {}",
        dikdortgen1.kapsayabilir_mi(&dikdortgen3)
    );
}

dikdortgen2’nin her iki boyutu da dikdortgen1’in boyutlarından küçük olduğu, buna karşılık dikdortgen3 dikdortgen1’den daha geniş olduğu için beklenen çıktı şöyle görünmelidir:

dikdortgen1, dikdortgen2'yi kapsayabilir mi? true
dikdortgen1, dikdortgen3'ü kapsayabilir mi? false

Bir metot tanımlamak istediğimizi biliyoruz, dolayısıyla bu tanım impl Dikdortgen bloğunun içinde yer alacak. Metodun adı kapsayabilir_mi olacak ve parametre olarak başka bir Dikdortgen örneğinin değiştirilemez ödünç alımını kabul edecek. Parametrenin türünün ne olacağını metodu çağıran koda bakarak da anlayabiliriz: dikdortgen1.kapsayabilir_mi(&dikdortgen2) çağrısı argüman olarak bir Dikdortgen örneği olan dikdortgen2’nin değiştirilemez ödünç alımını, yani &dikdortgen2 ifadesini geçirir. Bu oldukça mantıklıdır; çünkü dikdortgen2’yi yalnızca okumamız yeterlidir (yazmamız gerekseydi değiştirilebilir bir ödünç alıma ihtiyaç duyardık) ve kapsayabilir_mi metodunu çağırdıktan sonra dikdortgen2’yi tekrar kullanabilmek için main fonksiyonunun sahipliği elinde tutmasını isteriz. kapsayabilir_mi metodunun dönüş değeri bir mantıksal değer (bool) olacak ve metodun uygulaması self’in genişlik ve yüksekliğinin diğer Dikdortgen örneğinin sırasıyla genişlik ve yüksekliğinden büyük olup olmadığını kontrol edecektir. Yeni kapsayabilir_mi metodunu Liste 5-13’teki impl bloğuna ekleyelim; sonuç Liste 5-15’te gösterilmiştir.

#[derive(Debug)]
struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

impl Dikdortgen {
    fn alan(&self) -> u32 {
        self.genislik * self.yukseklik
    }

    fn kapsayabilir_mi(&self, diger: &Dikdortgen) -> bool {
        self.genislik > diger.genislik && self.yukseklik > diger.yukseklik
    }
}

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };
    let dikdortgen2 = Dikdortgen {
        genislik: 10,
        yukseklik: 40,
    };
    let dikdortgen3 = Dikdortgen {
        genislik: 60,
        yukseklik: 45,
    };

    println!(
        "dikdortgen1, dikdortgen2'yi kapsayabilir mi? {}",
        dikdortgen1.kapsayabilir_mi(&dikdortgen2)
    );
    println!(
        "dikdortgen1, dikdortgen3'ü kapsayabilir mi? {}",
        dikdortgen1.kapsayabilir_mi(&dikdortgen3)
    );
}

Bu kodu Liste 5-14’teki main fonksiyonuyla birlikte çalıştırdığımızda istediğimiz çıktıyı elde ederiz. Metotlar, imzada self parametresinden sonra eklediğimiz birden fazla parametre alabilir ve bu parametreler tıpkı fonksiyonlardaki parametreler gibi çalışır.

İlişkili Fonksiyonlar

Bir impl bloğu içinde tanımlanan tüm fonksiyonlara ilişkili fonksiyonlar (associated functions) denir; çünkü bu fonksiyonlar impl kelimesinden sonra adı verilen türle ilişkilendirilmiştir. İlk parametresi self olmayan (ve dolayısıyla metot olmayan) ilişkili fonksiyonlar da tanımlayabiliriz; çünkü bunların çalışmak için ilgili türün bir örneğine ihtiyacı yoktur. Bu tarz bir fonksiyonu daha önce zaten kullanmıştık: String türü üzerinde tanımlı olan String::from fonksiyonu.

Metot olmayan ilişkili fonksiyonlar çoğunlukla struct’ın yeni bir örneğini döndüren yapıcılar (constructors) olarak kullanılır. Bunlara sıklıkla new adı verilir, ancak new özel bir ad değildir ve dile yerleşik bir anahtar kelime olarak tanımlanmamıştır. Örneğin tek bir boyut parametresi alıp bunu hem genişlik hem de yükseklik olarak kullanan kare adında bir ilişkili fonksiyon sunmayı seçebiliriz; böylece aynı değeri iki kez belirtmek zorunda kalmadan kare bir Dikdortgen oluşturmayı kolaylaştırırız:

Dosya adı: src/main.rs

#[derive(Debug)]
struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

impl Dikdortgen {
    fn kare(boyut: u32) -> Self {
        Self {
            genislik: boyut,
            yukseklik: boyut,
        }
    }
}

fn main() {
    let k = Dikdortgen::kare(3);
}

Dönüş türündeki ve fonksiyon gövdesindeki Self anahtar kelimeleri, impl anahtar kelimesinden sonra gelen türün — bu örnekte Dikdortgen türünün — takma adıdır.

Bu ilişkili fonksiyonu çağırmak için struct adıyla birlikte :: sözdizimini kullanırız; let k = Dikdortgen::kare(3); ifadesi buna bir örnektir. Bu fonksiyon struct’ın ad alanı (namespace) altında yer alır: :: sözdizimi hem ilişkili fonksiyonlar hem de modüllerin oluşturduğu ad alanları için kullanılır. Modülleri Bölüm 7’de ele alacağız.

Birden Fazla impl Bloğu

Her struct’ın birden fazla impl bloğuna sahip olmasına izin verilir. Örneğin Liste 5-15, her metodun kendi ayrı impl bloğunda yer aldığı Liste 5-16’daki kodla tamamen eşdeğerdir.

#[derive(Debug)]
struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

impl Dikdortgen {
    fn alan(&self) -> u32 {
        self.genislik * self.yukseklik
    }
}

impl Dikdortgen {
    fn kapsayabilir_mi(&self, diger: &Dikdortgen) -> bool {
        self.genislik > diger.genislik && self.yukseklik > diger.yukseklik
    }
}

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };
    let dikdortgen2 = Dikdortgen {
        genislik: 10,
        yukseklik: 40,
    };
    let dikdortgen3 = Dikdortgen {
        genislik: 60,
        yukseklik: 45,
    };

    println!(
        "dikdortgen1, dikdortgen2'yi kapsayabilir mi? {}",
        dikdortgen1.kapsayabilir_mi(&dikdortgen2)
    );
    println!(
        "dikdortgen1, dikdortgen3'ü kapsayabilir mi? {}",
        dikdortgen1.kapsayabilir_mi(&dikdortgen3)
    );
}

Burada bu metotları birden fazla impl bloğuna ayırmamızı gerektiren bir neden yok; ancak bu sözdizimi geçerlidir. Jenerik türleri ve trait’leri ele alacağımız Bölüm 10’da, birden fazla impl bloğunun yararlı olduğu bir durumu göreceğiz.

Özet

Struct’lar, çalıştığınız problem alanı için anlamlı özel türler oluşturmanızı sağlar. Struct kullanarak birbiriyle ilişkili veri parçalarını bir arada tutabilir ve kodunuzu anlaşılır kılmak için her bir parçaya açıklayıcı bir ad verebilirsiniz. impl bloklarında ise türünüzle ilişkili fonksiyonlar tanımlayabilirsiniz; metotlar da struct örneklerinizin sahip olacağı davranışı belirlemenize olanak tanıyan bir tür ilişkili fonksiyondur.

Ancak özel türler oluşturmanın tek yolu struct’lar değildir: Araç çantanıza yeni bir araç daha eklemek için şimdi Rust’ın enum özelliğine geçelim.

Enum’lar ve Desen Eşleştirme

Bu bölümde, kısaca enum olarak da adlandırılan numaralandırmaları inceleyeceğiz. Enum’lar, olası varyantlarını numaralandırarak bir tür tanımlamanıza olanak tanır. İlk olarak, bir enum’ın verilerle birlikte anlamı da nasıl kodlayabildiğini göstermek için bir enum tanımlayıp kullanacağız. Daha sonra, bir değerin bir şey ya da hiçbir şey olabileceğini ifade eden ve özellikle kullanışlı bir enum olan Option türünü keşfedeceğiz. Ardından, match ifadesindeki desen eşleştirmenin (pattern matching), bir enum’ın farklı değerleri için farklı kodlar çalıştırmayı nasıl kolaylaştırdığına bakacağız. Son olarak, kodunuzdaki enum’ları işlemek için kullanabileceğiniz pratik ve özlü birer kalıp olan if let ve let...else yapılarını ele alacağız.

Bir Enum Tanımlama

Bir Enum Tanımlama

Struct’lar (örneğin genislik ve yukseklik alanlarına sahip bir Dikdortgen) birbiriyle ilişkili alanları ve verileri bir arada gruplandırmanın bir yolunu sunarken, enum’lar bir değerin olası değerler kümesinden yalnızca biri olduğunu ifade etmenin bir yolunu sunar. Örneğin, Dikdortgen türünün Daire ve Ucgen’i de kapsayan olası şekiller kümesinden biri olduğunu belirtmek isteyebiliriz. Rust, bu olasılıkları bir enum olarak kodlamamıza olanak tanır.

Gelin kodda ifade etmek isteyebileceğimiz somut bir duruma bakalım ve bu senaryoda enum’ların neden struct’lardan daha kullanışlı ve uygun olduğunu görelim. Diyelim ki IP adresleriyle çalışmamız gerekiyor. Günümüzde IP adresleri için iki ana standart kullanılmaktadır: sürüm dört ve sürüm altı. Programımızın karşılaşacağı bir IP adresi için yalnızca bu iki olasılık söz konusu olduğundan, olası tüm varyantları tek tek numaralandırabiliriz (enumerate); numaralandırma (enumeration) kavramı da adını buradan alır.

Herhangi bir IP adresi ya sürüm dört ya da sürüm altı adres olabilir, ancak aynı anda ikisi birden olamaz. IP adreslerinin bu özelliği enum veri yapısını son derece uygun kılar; çünkü bir enum değeri tanımlı varyantlarından yalnızca biri olabilir. Öte yandan hem sürüm dört hem de sürüm altı adresler temelde hâlâ birer IP adresidir; dolayısıyla her tür IP adresi için geçerli durumları işleyen kodlarda her ikisi de aynı tür olarak ele alınmalıdır.

Bu kavramı kodda bir IpAdresTuru numaralandırması tanımlayıp bir IP adresinin alabileceği olası türleri — V4 ve V6 — listeleyerek ifade edebiliriz. Bunlar enum’ın varyantlarıdır:

enum IpAdresTuru {
    V4,
    V6,
}

fn main() {
    let dort = IpAdresTuru::V4;
    let alti = IpAdresTuru::V6;

    yonlendir(IpAdresTuru::V4);
    yonlendir(IpAdresTuru::V6);
}

fn yonlendir(ip_turu: IpAdresTuru) {}

IpAdresTuru, artık kodumuzun başka yerlerinde kullanabileceğimiz özel bir veri türüdür.

Enum Değerleri

IpAdresTuru enum’ının iki varyantından her birinin örneklerini şu şekilde oluşturabiliriz:

enum IpAdresTuru {
    V4,
    V6,
}

fn main() {
    let dort = IpAdresTuru::V4;
    let alti = IpAdresTuru::V6;

    yonlendir(IpAdresTuru::V4);
    yonlendir(IpAdresTuru::V6);
}

fn yonlendir(ip_turu: IpAdresTuru) {}

Enum varyantlarının, enum’ın tanımlayıcısının ad alanı (namespace) altında yer aldığına ve ikisini ayırmak için çift iki nokta üst üste (::) kullandığımıza dikkat edin. Bu oldukça kullanışlıdır; çünkü hem IpAdresTuru::V4 hem de IpAdresTuru::V6 değerleri artık aynı türdendir: IpAdresTuru. Böylece örneğin herhangi bir IpAdresTuru değeri alan bir fonksiyon tanımlayabiliriz:

enum IpAdresTuru {
    V4,
    V6,
}

fn main() {
    let dort = IpAdresTuru::V4;
    let alti = IpAdresTuru::V6;

    yonlendir(IpAdresTuru::V4);
    yonlendir(IpAdresTuru::V6);
}

fn yonlendir(ip_turu: IpAdresTuru) {}

Ardından bu fonksiyonu her iki varyantla da çağırabiliriz:

enum IpAdresTuru {
    V4,
    V6,
}

fn main() {
    let dort = IpAdresTuru::V4;
    let alti = IpAdresTuru::V6;

    yonlendir(IpAdresTuru::V4);
    yonlendir(IpAdresTuru::V6);
}

fn yonlendir(ip_turu: IpAdresTuru) {}

Enum kullanmanın başka avantajları da vardır. IP adresi türümüz üzerinde biraz daha düşündüğümüzde, şu anki hâliyle asıl IP adresi verisini saklamanın bir yolu olmadığını görürüz; yalnızca hangi türde olduğunu biliyoruz. Bölüm 5’te struct’ları yeni öğrendiğiniz için, bu sorunu Liste 6-1’de gösterildiği gibi struct kullanarak çözmeye yönelmeniz oldukça doğaldır.

fn main() {
    enum IpAdresTuru {
        V4,
        V6,
    }

    struct IpAdres {
        tur: IpAdresTuru,
        adres: String,
    }

    let ev = IpAdres {
        tur: IpAdresTuru::V4,
        adres: String::from("127.0.0.1"),
    };

    let geridongu = IpAdres {
        tur: IpAdresTuru::V6,
        adres: String::from("::1"),
    };
}

Burada iki alana sahip bir IpAdres struct’ı tanımladık: IpAdresTuru (az önce tanımladığımız enum) türünde bir tur alanı ve String türünde bir adres alanı. Bu struct’ın iki örneğini oluşturduk. İlki olan ev, tur alanı olarak IpAdresTuru::V4 değerine ve ilişkili adres verisi olarak 127.0.0.1 metnine sahiptir. İkinci örnek olan geridongu ise tur değeri olarak IpAdresTuru enum’ının diğer varyantı olan V6’yı ve bununla ilişkili ::1 adresini barındırır. tur ve adres değerlerini bir arada tutmak için bir struct kullandık; böylece varyant ile adres verisi birbirine bağlanmış oldu.

Ancak aynı kavramı yalnızca bir enum kullanarak temsil etmek çok daha özlüdür: Bir struct’ın içine enum yerleştirmek yerine, veriyi doğrudan her bir enum varyantının içine koyabiliriz. IpAdres enum’ının bu yeni tanımı, hem V4 hem de V6 varyantlarının kendileriyle ilişkili birer String değerine sahip olacağını belirtir:

fn main() {
    enum IpAdres {
        V4(String),
        V6(String),
    }

    let ev = IpAdres::V4(String::from("127.0.0.1"));

    let geridongu = IpAdres::V6(String::from("::1"));
}

Veriyi doğrudan enum’ın her bir varyantına eklediğimiz için fazladan bir struct tanımlamaya gerek kalmaz. Burada enum’ların çalışma biçimine dair önemli bir ayrıntıyı görmek de kolaylaşır: Tanımladığımız her enum varyantının adı, aynı zamanda o enum’ın bir örneğini oluşturan bir fonksiyon hâline gelir. Yani IpAdres::V4(), bir String argümanı alan ve IpAdres türünde bir örnek döndüren bir fonksiyon çağrısıdır. Enum’ı tanımlamamızın bir sonucu olarak bu yapıcı (constructor) fonksiyonlar bizim için otomatik olarak tanımlanır.

Struct yerine enum kullanmanın bir avantajı daha vardır: Her varyant farklı türlerde ve farklı sayıda ilişkili veriye sahip olabilir. Sürüm dört IP adresleri her zaman 0 ile 255 arasında değerler alan dört sayısal bileşenden oluşur. V4 adreslerini dört adet u8 değeri olarak saklamak, V6 adreslerini ise yine tek bir String değeri olarak ifade etmek isteseydik bunu tek bir struct ile yapamazdık. Enum’lar bu durumu kolaylıkla çözer:

fn main() {
    enum IpAdres {
        V4(u8, u8, u8, u8),
        V6(String),
    }

    let ev = IpAdres::V4(127, 0, 0, 1);

    let geridongu = IpAdres::V6(String::from("::1"));
}

Sürüm dört ve sürüm altı IP adreslerini saklamak üzere veri yapıları tanımlamanın birkaç farklı yolunu gördük. Ne var ki IP adreslerini saklamak ve hangi türde olduklarını kodlamak o kadar yaygın bir ihtiyaçtır ki, standart kütüphanede doğrudan kullanabileceğimiz hazır bir tanım bulunur! Gelin standart kütüphanenin IpAddr türünü nasıl tanımladığına bakalım. Bizim tanımladığımız ve kullandığımız enum ile aynı yapıya ve varyantlara (V4 ve V6) sahiptir; ancak adres verilerini varyantların içine, her varyant için ayrı tanımlanmış iki farklı struct biçiminde gömer:

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

Bu kod, bir enum varyantının içine her türden veriyi koyabileceğinizi gösterir: örneğin metinler, sayısal türler veya struct’lar. Hatta bir enum varyantının içine başka bir enum bile yerleştirebilirsiniz! Ayrıca gördüğünüz gibi, standart kütüphanedeki türler çoğu zaman sizin tasarlayabileceğiniz yapılardan çok daha karmaşık değildir.

Standart kütüphane IpAddr için bir tanım içerse de, standart kütüphanenin bu tanımını kendi kapsamımıza dahil etmediğimiz için kendi türümüzü (hatta aynı IpAddr adıyla bile) oluşturup herhangi bir isim çakışması yaşamadan kullanabileceğimize dikkat edin. Türleri kapsama dahil etme konusunu Bölüm 7’de daha ayrıntılı olarak ele alacağız.

Gelin Liste 6-2’deki bir diğer enum örneğine bakalım: Bu enum’ın varyantlarında birbirinden çok farklı veri türleri yer alır.

enum Mesaj {
    Cik,
    Tasi { x: i32, y: i32 },
    Yaz(String),
    RenkDegistir(i32, i32, i32),
}

fn main() {}

Bu enum, farklı türlere sahip dört varyant içerir:

• Cik: Kendisiyle ilişkili hiçbir veri barındırmaz.
• Tasi: Tıpkı bir struct gibi isimlendirilmiş alanlara sahiptir.
• Yaz: Tek bir String içerir.
• RenkDegistir: Üç adet i32 değeri içerir.

Liste 6-2’deki gibi varyantlara sahip bir enum tanımlamak, farklı struct türleri tanımlamaya benzer; aradaki fark, enum’ın struct anahtar kelimesini kullanmaması ve tüm varyantların tek bir Mesaj türü altında bir arada gruplandırılmasıdır. Aşağıdaki struct’lar, önceki enum varyantlarının tuttuğu verilerin birebir aynısını tutabilirdi:

struct CikMesaji; // birim struct
struct TasiMesaji {
    x: i32,
    y: i32,
}
struct YazMesaji(String); // demet struct'ı
struct RenkDegistirMesaji(i32, i32, i32); // demet struct'ı

fn main() {}

Ancak her biri kendi ayrı türüne sahip olan bu farklı struct’ları kullansaydık, bu mesaj türlerinden herhangi birini kabul edecek bir fonksiyonu, tek bir tür olan Liste 6-2’deki Mesaj enum’ı ile tanımladığımız kadar kolay tanımlayamazdık.

Enum’lar ile struct’lar arasında bir benzerlik daha vardır: Tıpkı struct’lar üzerinde impl kullanarak metotlar tanımlayabildiğimiz gibi, enum’lar üzerinde de metotlar tanımlayabiliriz. İşte Mesaj enum’ımız üzerinde tanımlayabileceğimiz cagir adlı bir metot:

fn main() {
    enum Mesaj {
        Cik,
        Tasi { x: i32, y: i32 },
        Yaz(String),
        RenkDegistir(i32, i32, i32),
    }

    impl Mesaj {
        fn cagir(&self) {
            // metot gövdesi burada tanımlanabilir
        }
    }

    let m = Mesaj::Yaz(String::from("merhaba"));
    m.cagir();
}

Metodun gövdesi, metodun üzerinde çağrıldığı değeri elde etmek için self parametresini kullanır. Bu örnekte Mesaj::Yaz(String::from("merhaba")) değerine sahip bir m değişkeni oluşturduk; m.cagir() çalıştığında cagir metodunun gövdesindeki self tam olarak bu değeri temsil edecektir.

Şimdi standart kütüphanede çok yaygın ve son derece kullanışlı olan başka bir enum’a bakalım: Option.

Option Enum’ı

Bu alt bölümde, standart kütüphane tarafından tanımlanan bir diğer enum olan Option türünü örnek olay olarak inceleyeceğiz. Option türü, bir değerin var olabileceği (bir şey olduğu) ya da yok olabileceği (hiçbir şey olmadığı) çok yaygın senaryoyu kodlar.

Örneğin, boş olmayan bir listedeki ilk öğeyi isterseniz bir değer elde edersiniz. Boş bir listedeki ilk öğeyi isterseniz hiçbir şey elde edemezsiniz. Bu kavramı doğrudan tür sistemi üzerinden ifade etmek, ele almanız gereken tüm durumları gerçekten ele alıp almadığınızı derleyicinin denetleyebilmesi anlamına gelir; bu özellik, diğer programlama dillerinde son derece sık karşılaşılan yazılım hatalarını daha derleme aşamasında önleyebilir.

Programlama dili tasarımı çoğu zaman hangi özellikleri dile dahil ettiğiniz üzerinden düşünülür; ancak dışarıda bıraktığınız özellikler de bir o kadar önemlidir. Rust, diğer pek çok dilde bulunan null özelliğine sahip değildir. Null, ortada hiçbir değer bulunmadığını belirten özel bir değerdir. Null kavramına sahip dillerde değişkenler her zaman iki durumdan birinde olabilir: null veya null olmayan.

Null kavramının mucidi Tony Hoare, 2009 yılındaki “Null Referanslar: Milyar Dolarlık Hata” (“Null References: The Billion Dollar Mistake”) başlıklı sunumunda bu durumu şöyle anlatmıştır:

Buna kendi milyar dolarlık hatam (billion-dollar mistake) diyorum. O dönemde nesne yönelimli bir dilde referanslar için ilk kapsamlı tür sistemini tasarlıyordum. Amacım, derleyici tarafından otomatik olarak yürütülen denetimlerle tüm referans kullanımlarının kesinlikle güvenli olmasını sağlamaktı. Ne var ki uygulaması çok kolay olduğu için sisteme bir null referans ekleme cazibesine karşı koyamadım. Bu tercih; son kırk yılda muhtemelen bir milyar dolarlık zarara ve sıkıntıya mal olan sayısız hataya, güvenlik açığına ve sistem çökmesine yol açtı.

Null değerleriyle ilgili temel sorun şudur: Null olan bir değeri sanki geçerli (null olmayan) bir değermiş gibi kullanmaya çalışırsanız bir tür çalışma zamanı hatasıyla karşılaşırsınız. Null veya null olmama durumu dilin her yerine yayılmış olduğundan, bu tür bir hatayı yapmak son derece kolaydır.

Bununla birlikte null’ın ifade etmeye çalıştığı kavram hâlâ yararlıdır: Herhangi bir nedenle o an geçersiz ya da mevcut olmayan bir değeri temsil etmek.

Dolayısıyla asıl sorun kavramın kendisinde değil, bu kavramın uygulanış biçimindedir. Bu nedenle Rust’ta null yoktur; ancak bir değerin var veya yok olma durumunu tür düzeyinde kodlayan bir enum vardır. Bu enum Option<T> olarak adlandırılır ve standart kütüphanede şu şekilde tanımlanır:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Option<T> enum’ı o kadar kullanışlıdır ki her Rust programında kendiliğinden kapsamda bulunan öğeler kümesi olan prelude (ön tanımlı kapsam) içine bile dahil edilmiştir; yani onu use ile açıkça kapsama dahil etmenize gerek yoktur. Üstelik varyantları da prelude içindedir: Some ve None varyantlarını Option:: öneki yazmadan doğrudan kullanabilirsiniz. Yine de Option<T> sıradan bir enum’dır; Some(T) ve None da hâlâ Option<T> türünün varyantlarıdır.

<T> sözdizimi, Rust’ın henüz ele almadığımız bir özelliğidir. Bu, jenerik (generic) bir tür parametresidir; jenerik türleri Bölüm 10’da ayrıntılı olarak inceleyeceğiz. Şimdilik bilmeniz gereken tek şey şudur: <T>, Option enum’ının Some varyantının herhangi bir türden tek bir veri tutabileceği ve T yerine geçen her somut türün Option<T> türünün tamamını farklı bir tür hâline getirdiği anlamına gelir. Sayı ve karakter (char) türlerini tutmak için Option değerlerinin kullanıldığı bazı örneklere bakalım:

fn main() {
    let bir_sayi = Some(5);
    let bir_karakter = Some('e');

    let olmayan_sayi: Option<i32> = None;
}

bir_sayi değişkeninin türü Option<i32>’dir. bir_karakter değişkeninin türü ise bundan farklı bir tür olan Option<char>’dır. Some varyantının içine somut bir değer verdiğimiz için Rust bu türleri kendiliğinden çıkarabilir. olmayan_sayi değişkeninde ise Rust bizden Option türünün tamamını açıkça belirtmemizi ister: Derleyici, yalnızca bir None değerine bakarak karşılık gelen Some varyantının hangi türde değer tutacağını çıkaramaz. Burada olmayan_sayi değişkeninin Option<i32> türünde olmasını istediğimizi Rust’a açıkça bildiririz.

Elimizde bir Some değeri olduğunda, ortada bir değer bulunduğunu ve bu değerin Some içinde tutulduğunu biliriz. Elimizde bir None değeri olduğunda ise bu, bir bakıma null ile aynı anlama gelir: Geçerli bir değerimiz yoktur. Öyleyse Option<T> kullanmak, null’a sahip olmaktan neden daha iyidir?

Kısaca söylemek gerekirse, Option<T> ile T (burada T herhangi bir tür olabilir) birbirinden farklı türler olduğu için derleyici, bir Option<T> değerini sanki kesinlikle geçerli bir T değeriymiş gibi doğrudan kullanmamıza izin vermez. Örneğin aşağıdaki kod, bir i8 değerine doğrudan bir Option<i8> eklemeye çalıştığı için derlenmeyecektir:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let toplam = x + y;
}

Bu kodu çalıştırdığımızda şuna benzer bir hata mesajı alırız:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:5:20
  |
5 |     let toplam = x + y;
  |                    ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`
help: the following other types implement trait `Add<Rhs>`
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/ops/arith.rs:98:8
  |
  = note: `i8` implements `Add`
 ::: /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/ops/arith.rs:113:0
  |
  = note: in this macro invocation
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/internal_macros.rs:22:8
  |
  = note: `&i8` implements `Add<i8>`
 ::: /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/internal_macros.rs:33:8
  |
  = note: `i8` implements `Add<&i8>`
 ::: /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/internal_macros.rs:44:8
  |
  = note: `&i8` implements `Add`
  = note: this error originates in the macro `add_impl` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` (bin "enums") due to 1 previous error

İlk bakışta oldukça yoğun bir çıktı! Özünde bu hata mesajı (cannot add `Option<i8>` to `i8`), i8 ile Option<i8> farklı türler olduğu için Rust’ın bu iki değeri nasıl toplayacağını bilmediğini (yani i8 türü için Option<i8> ile toplama işlemini tanımlayan Add<Option<i8>> trait’inin uygulanmadığını) belirtir. Rust’ta i8 gibi bir türde değere sahip olduğumuzda, derleyici her zaman geçerli bir değere sahip olduğumuzu garanti eder. Bu değeri kullanmadan önce null olup olmadığını kontrol etmek zorunda kalmadan güvenle ilerleyebiliriz. Yalnızca elimizde bir Option<i8> (veya üzerinde çalıştığımız değerin türü her neyse) olduğunda bir değerin bulunmama ihtimalini düşünmemiz gerekir; derleyici de değeri kullanmadan önce bu durumu ele aldığımızdan emin olur.

Başka bir deyişle, bir Option<T> üzerinde T türüne ait işlemleri gerçekleştirebilmek için önce onu bir T değerine dönüştürmeniz gerekir. Bu zorunluluk, null kaynaklı en yaygın hatalardan birini yakalamaya yardımcı olur: Gerçekte null olan bir değerin null olmadığını varsaymak.

Null olabilecek bir değeri yanlışlıkla geçerli varsayma riskini ortadan kaldırmak, kodunuza çok daha fazla güvenmenizi sağlar. Yok olma ihtimali taşıyan bir değere sahip olmak istediğinizde, o değerin türünü Option<T> yaparak bu durumu açıkça tercih etmeniz gerekir. Ardından bu değeri her kullandığınızda, değerin mevcut olmadığı (None) durumu açıkça ele almanız zorunludur. Türü Option<T> olmayan her yerde ise değerin geçerli olduğunu güvenle varsayabilirsiniz. Bu yaklaşım, null kavramının kontrolsüz yaygınlığını sınırlamak ve Rust kodunun güvenliğini artırmak adına bilinçli olarak alınmış bir tasarım kararıdır.

Peki Option<T> türünde bir değere sahip olduğunuzda, içindeki T değerini kullanabilmek için onu Some varyantından nasıl çıkarırsınız? Option<T> enum’ı, farklı senaryolarda işinize yarayacak çok sayıda metoda sahiptir; bunların tamamını dokümantasyonundan inceleyebilirsiniz. Option<T> üzerindeki metotlara aşina olmak, Rust yolculuğunuzda size büyük kolaylık sağlayacaktır.

Genel olarak bir Option<T> değerini kullanmak için her bir varyantı ele alacak kodlara sahip olmak istersiniz: Yalnızca elinizde bir Some(T) değeri olduğunda çalışacak ve içteki T değerini kullanmasına izin verilen bir kod; bir de yalnızca None değeriniz olduğunda çalışacak ve elinde kullanılabilir bir T değeri bulunmayan başka bir kod. match ifadesi, enum’larla birlikte kullanıldığında tam olarak bu işi yapan bir kontrol akışı yapısıdır: Değerin, enum’ın hangi varyantı olduğuna bağlı olarak farklı kod dallarını çalıştırır ve bu kodlar eşleşen değerin içindeki verileri doğrudan kullanabilir.

match Kontrol Akışı Yapısı

match Kontrol Akışı Yapısı

Rust, bir değeri bir dizi desenle (pattern) karşılaştırmanıza ve hangi desenin eşleştiğine bağlı olarak ilgili kodu çalıştırmanıza olanak tanıyan match adında son derece güçlü bir kontrol akışı yapısına sahiptir. Desenler; sabit değerlerden, değişken adlarından, joker desenlerden (wildcards) ve daha pek çok bileşenden oluşabilir; Bölüm 19 tüm farklı desen türlerini ve ne işe yaradıklarını ayrıntılı olarak ele alır. match yapısının gücü, desenlerin yüksek ifade yeteneğinden ve derleyicinin olası tüm durumların eksiksiz biçimde ele alındığını doğrulamasından gelir.

Bir match ifadesini bozuk para ayırma makinesi gibi düşünebilirsiniz: Madeni paralar, üzerinde farklı boyutlarda delikler sıralanan bir raydan aşağı kayar ve her para, karşısına çıkıp içine sığabildiği ilk delikten aşağı düşer. Aynı şekilde değerler de bir match ifadesindeki her bir desenden sırayla geçer ve değerin “uyduğu” ilk desende, çalıştırılmak üzere o desenle ilişkili kod bloğuna düşer.

Madeni paralardan söz etmişken gelin match kullanımı için onları örnek alalım! Liste 6-3’te gösterildiği gibi, türü bilinmeyen bir ABD madeni parasını alan ve tıpkı para sayma makinesi gibi hangi madeni para olduğunu belirleyip değerini kuruş (sent) cinsinden döndüren bir fonksiyon yazabiliriz.

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus,
}

fn kurus_degeri(para: MadeniPara) -> u8 {
    match para {
        MadeniPara::Kurus => 1,
        MadeniPara::BesKurus => 5,
        MadeniPara::OnKurus => 10,
        MadeniPara::YirmiBesKurus => 25,
    }
}

fn main() {}

Gelin kurus_degeri fonksiyonundaki match ifadesini adım adım inceleyelim. İlk olarak match anahtar kelimesini ve ardından bir ifadeyi yazarız; bu örnekte söz konusu ifade para değeridir. Bu yapı if ile kullanılan koşul ifadesine çok benzer, ancak aralarında büyük bir fark vardır: if yapısında koşulun bir Boole (bool) değeri üretmesi gerekirken, burada ifade herhangi bir türde olabilir. Bu örnekteki para değerinin türü, ilk satırda tanımladığımız MadeniPara enum’ıdır.

Ardından match kolları (match arms) gelir. Bir kol iki bölümden oluşur: bir desen ve çalıştırılacak kod. Buradaki ilk kolun deseni MadeniPara::Kurus değeridir; hemen ardından deseni ve çalıştırılacak kodu birbirinden ayıran => operatörü gelir. Bu koldaki kod yalnızca 1 değeridir. Her kol bir sonrakinden virgülle ayrılır.

match ifadesi çalıştırıldığında, elde edilen değeri her bir kolun deseniyle sırasıyla karşılaştırır. Bir desen değerle eşleşirse o desenle ilişkili kod çalıştırılır. Desen değerle eşleşmezse, tıpkı bozuk para ayırma makinesinde olduğu gibi akış bir sonraki kola geçer. İhtiyaç duyduğumuz kadar kol tanımlayabiliriz: Liste 6-3’te match ifademizin dört kolu vardır.

Her kolla ilişkili kod bir ifadedir (expression) ve eşleşen koldaki ifadenin ürettiği değer, match ifadesinin tamamı için döndürülen değer olur.

Liste 6-3’te olduğu gibi her kolun yalnızca tek bir değer ürettiği kısa durumlarda match kollarında genellikle süslü parantez kullanmayız. Bir match kolunda birden fazla satır kod çalıştırmak istiyorsanız süslü parantez kullanmanız gerekir; bu durumda kolu takip eden virgül isteğe bağlıdır. Örneğin aşağıdaki kod, fonksiyon her MadeniPara::Kurus değeriyle çağrıldığında ekrana "Şanslı kuruş!" yazdırır, ancak yine de bloğun son ifadesi olan 1 değerini döndürür:

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus,
}

fn kurus_degeri(para: MadeniPara) -> u8 {
    match para {
        MadeniPara::Kurus => {
            println!("Şanslı kuruş!");
            1
        }
        MadeniPara::BesKurus => 5,
        MadeniPara::OnKurus => 10,
        MadeniPara::YirmiBesKurus => 25,
    }
}

fn main() {}

Değerlere Bağlanan Desenler

match kollarının bir diğer kullanışlı özelliği, desenle eşleşen değerlerin içindeki parçalara bağlanabilmeleridir. Enum varyantlarının barındırdığı değerleri bu sayede dışarı çıkarabiliriz.

Örnek olarak enum varyantlarımızdan birini içinde veri tutacak şekilde değiştirelim. Amerika Birleşik Devletleri, 1999’dan 2008’e kadar 50 eyaletin her biri için bir yüzünde farklı tasarımlar bulunan çeyreklikler (25 kuruşluk/sentlik madeni paralar) bastı. Başka hiçbir madeni parada eyalet tasarımı yer almadığından bu ek bilgi yalnızca çeyrekliklerde bulunur. Bu bilgiyi Liste 6-4’te yaptığımız gibi YirmiBesKurus varyantını içinde bir Eyalet değeri barındıracak şekilde değiştirerek enum tanımımıza ekleyebiliriz.

#[derive(Debug)] // birazdan eyaleti inceleyebilmek için
enum Eyalet {
    Alabama,
    Alaska,
    // --snip--
}

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus(Eyalet),
}

fn main() {}

Bir arkadaşımızın 50 eyalet çeyrekliğinin tamamını biriktirmeye çalıştığını düşünelim. Bozuk paralarımızı türlerine göre ayırırken her çeyreklikle ilişkili eyaletin adını da yüksek sesle söyleyeceğiz; böylece arkadaşımızın koleksiyonunda henüz olmayan bir eyalet çıkarsa onu koleksiyonuna ekleyebilecek.

Aşağıdaki kodun match ifadesinde, MadeniPara::YirmiBesKurus varyantının değerleriyle eşleşen desene eyalet adında bir değişken ekliyoruz. Bir MadeniPara::YirmiBesKurus değeri eşleştiğinde eyalet değişkeni o çeyrekliğin eyalet değerine bağlanır. Ardından bu koldaki kod içinde eyalet değişkenini aşağıdaki gibi kullanabiliriz:

#[derive(Debug)]
enum Eyalet {
    Alabama,
    Alaska,
    // --snip--
}

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus(Eyalet),
}

fn kurus_degeri(para: MadeniPara) -> u8 {
    match para {
        MadeniPara::Kurus => 1,
        MadeniPara::BesKurus => 5,
        MadeniPara::OnKurus => 10,
        MadeniPara::YirmiBesKurus(eyalet) => {
            println!("{eyalet:?} eyaletinden çeyreklik!");
            25
        }
    }
}

fn main() {
    kurus_degeri(MadeniPara::YirmiBesKurus(Eyalet::Alaska));
}

kurus_degeri(MadeniPara::YirmiBesKurus(Eyalet::Alaska)) çağrısı yaptığımızda para parametresi MadeniPara::YirmiBesKurus(Eyalet::Alaska) değerini alır. Bu değeri her bir match koluyla sırayla karşılaştırdığımızda MadeniPara::YirmiBesKurus(eyalet) koluna ulaşana kadar hiçbir desen eşleşmez. Bu noktada eyalet değişkeni Eyalet::Alaska değerine bağlanır. Böylece bu değişkeni println! ifadesinde kullanabilir ve MadeniPara enum’ının YirmiBesKurus varyantı içindeki eyalet verisini elde edebiliriz.

Option<T> match Deseni

Önceki bölümde Option<T> kullanırken Some varyantının içindeki T değerini elde etmek istemiştik; tıpkı MadeniPara enum’ında yaptığımız gibi Option<T> türünü de match kullanarak işleyebiliriz! Bu kez madeni paraları karşılaştırmak yerine Option<T> varyantlarını karşılaştıracağız, ancak match ifadesinin çalışma mantığı birebir aynı kalır.

Diyelim ki parametre olarak bir Option<i32> alan ve içinde bir değer varsa bu değere 1 ekleyen bir fonksiyon yazmak istiyoruz. Eğer içinde bir değer yoksa fonksiyon None döndürmeli ve başka hiçbir işlem yapmaya çalışmamalıdır.

match sayesinde bu fonksiyonu yazmak son derece kolaydır ve Liste 6-5’teki gibi görünür.

fn main() {
    fn bir_ekle(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let bes = Some(5);
    let alti = bir_ekle(bes);
    let hicbiri = bir_ekle(None);
}

bir_ekle fonksiyonunun ilk çağrılışını daha yakından inceleyelim. bir_ekle(bes) çağrısı yaptığımızda bir_ekle gövdesindeki x değişkeni Some(5) değerini alır. Ardından bu değeri her bir match koluyla sırayla karşılaştırırız:

fn main() {
    fn bir_ekle(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let bes = Some(5);
    let alti = bir_ekle(bes);
    let hicbiri = bir_ekle(None);
}

Some(5) değeri None deseniyle eşleşmez; bu yüzden bir sonraki kola geçeriz:

fn main() {
    fn bir_ekle(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let bes = Some(5);
    let alti = bir_ekle(bes);
    let hicbiri = bir_ekle(None);
}

Some(5) değeri Some(i) deseniyle eşleşir mi? Evet, eşleşir! İkisi de aynı varyanttır. i değişkeni Some içindeki değere bağlanır ve 5 değerini alır. Ardından bu match kolundaki kod çalıştırılır: i değerine 1 eklenir ve içinde toplam 6 değerini taşıyan yeni bir Some varyantı oluşturulup döndürülür.

Şimdi Liste 6-5’te x parametresinin None olduğu ikinci bir_ekle çağrısına bakalım. match ifadesine girer ve x değerini ilk kolla karşılaştırırız:

fn main() {
    fn bir_ekle(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let bes = Some(5);
    let alti = bir_ekle(bes);
    let hicbiri = bir_ekle(None);
}

Eşleşti! Eklenecek bir değer olmadığından akış burada tamamlanır ve => operatörünün sağ tarafındaki None değeri döndürülür. İlk kol eşleştiği için diğer kollar hiç kontrol edilmez.

match ile enum’ları bir arada kullanmak pek çok senaryoda son derece işlevseldir. Rust kodlarında şu yapıyı çok sık göreceksiniz: Bir enum üzerinde match uygula, içindeki veriyi bir değişkene bağla ve bu veriye dayanarak ilgili kodu çalıştır. İlk başta biraz yabancı gelebilir, ancak bir kez alıştığınızda bu yapının kullandığınız tüm programlama dillerinde olmasını isteyeceksiniz. Rust kullanıcılarının her zaman en sevdiği özelliklerin başında gelir.

Eşleşmeler Kapsamlıdır

match ifadelerinin ele almamız gereken önemli bir yönü daha vardır: Kolların desenleri olası tüm durumları kapsamak zorundadır. bir_ekle fonksiyonumuzun hata barındıran ve derlenmeyecek olan aşağıdaki sürümüne bakalım:

fn main() {
    fn bir_ekle(x: Option<i32>) -> Option<i32> {
        match x {
            Some(i) => Some(i + 1),
        }
    }

    let bes = Some(5);
    let alti = bir_ekle(bes);
    let hicbiri = bir_ekle(None);
}

Burada None durumunu ele almadık; dolayısıyla bu kod hataya yol açacaktır. Neyse ki bu, Rust derleyicisinin anında yakalayabildiği türden bir hatadır. Bu kodu derlemeye çalıştığımızda aşağıdaki hatayı alırız:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
 --> src/main.rs:3:15
  |
3 |         match x {
  |               ^ pattern `None` not covered
  |
note: `Option<i32>` defined here
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/option.rs:598:0
 ::: /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/option.rs:602:4
  |
  = note: not covered
  = note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
4 ~             Some(i) => Some(i + 1),
5 ~             None => todo!(),
  |

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Rust, olası her durumu kapsamadığımızı bilir; üstelik hangi deseni unuttuğumuzu bile tam olarak söyler! Rust’ta eşleşmeler kapsamlıdır (exhaustive): Kodun geçerli olabilmesi için olası her durumu sonuna kadar, eksiksiz biçimde ele almalıyız. Özellikle Option<T> söz konusu olduğunda, Rust None durumunu açıkça işlemeyi unutmamızı engelleyerek ortada bir değer yokken (null benzeri bir durumdayken) sanki geçerli bir değer varmış gibi varsayımda bulunmamızın önüne geçer; böylece önceki bölümde bahsettiğimiz milyar dolarlık hatayı derleme zamanında imkânsız hâle getirir.

Tümünü Yakalama Desenleri ve _ Yer Tutucusu

Enum’ları ve match yapısını kullanarak belirli birkaç değer için özel işlemler yapabilir, kalan diğer tüm değerler için ise tek bir varsayılan işlem uygulayabiliriz. Şöyle bir oyun geliştirdiğimizi düşünelim: Zar attığınızda 3 gelirse oyuncunuz hareket etmez, bunun yerine süslü yeni bir şapka kazanır. Eğer 7 gelirse oyuncunuz süslü şapkasını kaybeder. Diğer tüm zar değerlerinde ise oyuncunuz oyun tahtasında gelen sayı kadar kare ilerler. Aşağıda bu mantığı uygulayan bir match ifadesi yer alıyor; bu örnekte zar atışının sonucu rastgele üretilmek yerine doğrudan koda sabit olarak yazılmış ve diğer işlemlerin ayrıntıları konumuzun dışında olduğundan gövdesi boş fonksiyonlarla temsil edilmiştir:

fn main() {
    let zar_atisi = 9;
    match zar_atisi {
        3 => suslu_sapka_ekle(),
        7 => suslu_sapkayi_cikar(),
        diger => oyuncuyu_tasi(diger),
    }

    fn suslu_sapka_ekle() {}
    fn suslu_sapkayi_cikar() {}
    fn oyuncuyu_tasi(kare_sayisi: u8) {}
}

İlk iki kolun desenleri 3 ve 7 sabit değerleridir. Kalan olası tüm değerleri kapsayan son kolun deseni ise diger adını verdiğimiz değişkendir. diger kolunda çalışan kod, yakalanan bu değişkeni oyuncuyu_tasi fonksiyonuna argüman olarak aktararak kullanır.

Bir u8 türünün alabileceği olası tüm değerleri tek tek listelememiş olsak da bu kod sorunsuzca derlenir; çünkü son desen özel olarak listelenmeyen tüm değerlerle eşleşir. Bu tümünü yakalama deseni (catch-all pattern), match ifadesinin kapsamlı olma zorunluluğunu karşılar. Desenler sırayla değerlendirildiği için tümünü yakalayan kolu en sona koymamız gerektiğine dikkat edin. Eğer bu kolu daha üst bir sıraya koysaydık ondan sonraki kollar asla çalışmazdı; nitekim tümünü yakalayan bir koldan sonra başka kollar eklerseniz Rust ulaşılamaz desen konusunda sizi uyarır!

Rust ayrıca tümünü yakalayan bir kol istediğimizde ancak yakalanan değeri kullanmak istemediğimizde başvurabileceğimiz özel bir desene sahiptir: _, herhangi bir değerle eşleşen fakat o değere bağlanmayan özel bir yer tutucu desendir. Bu desen Rust’a söz konusu değeri kullanmayacağımızı bildirir; böylece Rust ne değeri taşır ne de kullanılmayan bir değişken hakkında uyarı verir.

Gelin oyunun kurallarını değiştirelim: Artık 3 veya 7 dışında bir sayı atarsanız tekrar zar atmanız gerekiyor. Yakalanan değere artık ihtiyacımız olmadığından kodumuzu diger adlı değişken yerine _ kullanacak şekilde güncelleyebiliriz:

fn main() {
    let zar_atisi = 9;
    match zar_atisi {
        3 => suslu_sapka_ekle(),
        7 => suslu_sapkayi_cikar(),
        _ => tekrar_zar_at(),
    }

    fn suslu_sapka_ekle() {}
    fn suslu_sapkayi_cikar() {}
    fn tekrar_zar_at() {}
}

Son kolda diğer tüm değerleri açıkça yok saydığımız için bu örnek de kapsamlılık şartını eksiksiz karşılar; unuttuğumuz hiçbir durum yoktur.

Son olarak oyunun kurallarını bir kez daha değiştirelim: 3 veya 7 dışında bir sayı attığınızda sıranızda başka hiçbir şey olmasın. Bunu, _ kolunda çalıştırılacak kod olarak birim değerini (“Demet Türü” bölümünde bahsettiğimiz boş demet türü ()) yazarak ifade edebiliriz:

fn main() {
    let zar_atisi = 9;
    match zar_atisi {
        3 => suslu_sapka_ekle(),
        7 => suslu_sapkayi_cikar(),
        _ => (),
    }

    fn suslu_sapka_ekle() {}
    fn suslu_sapkayi_cikar() {}
}

Burada Rust’a önceki kolların desenleriyle eşleşmeyen hiçbir değeri kullanmayacağımızı ve bu durumda herhangi bir kod çalıştırmak istemediğimizi açıkça belirtmiş oluyoruz.

Desenler ve eşleştirme hakkında Bölüm 19’da ele alacağımız daha pek çok ayrıntı var. Şimdilik, match ifadesinin biraz ayrıntılı ve uzun kalabildiği durumlarda oldukça pratik birer alternatif sunan if let ve let...else yapılarına geçeceğiz.

if let ve let...else ile Özlü Kontrol Akışı

if let ve let...else ile Özlü Kontrol Akışı

if let sözdizimi, if ve let anahtar kelimelerini birleştirerek yalnızca tek bir desenle eşleşen değerleri işleyip geri kalanları yok saymanın daha özlü bir yolunu sunar. Liste 6-6’da, max_ayari değişkenindeki Option<u8> değerini eşleştiren ancak yalnızca değer Some varyantı olduğunda kod çalıştırmak istediğimiz programı inceleyelim.

fn main() {
    let max_ayari = Some(3u8);
    match max_ayari {
        Some(max) => println!("Maksimum değer {max} olarak ayarlandı"),
        _ => (),
    }
}

Değer Some ise, varyantın içindeki veriyi desendeki max değişkenine bağlayarak ekrana yazdırırız. None değeriyle ise hiçbir işlem yapmak istemiyoruz. Ancak match ifadesinin tüm durumları kapsama zorunluluğunu karşılamak için, tek bir varyantı işledikten sonra bile _ => () kolunu eklemek zorunda kalırız; bu da her seferinde yazılması can sıkıcı bir kalıp koddur.

Bunun yerine aynı mantığı if let kullanarak çok daha kısa bir biçimde yazabiliriz. Aşağıdaki kod, Liste 6-6’daki match ifadesiyle birebir aynı şekilde çalışır:

fn main() {
    let max_ayari = Some(3u8);
    if let Some(max) = max_ayari {
        println!("Maksimum değer {max} olarak ayarlandı");
    }
}

if let sözdizimi, aralarında eşittir (=) işareti bulunan bir desen ve bir ifade alır. Çalışma mantığı match ile aynıdır: Eşittir işaretinin sağındaki ifade match yapısına verilen değere, solundaki desen ise ilk match koluna karşılık gelir. Bu örnekte desen Some(max) şeklindedir ve max değişkeni Some varyantının içindeki değere bağlanır. Ardından max değişkenini, tıpkı eşdeğer match kolunda yaptığımız gibi if let bloğunun gövdesinde kullanabiliriz. if let bloğu içindeki kod, yalnızca değer belirtilen desenle eşleştiğinde çalışır.

if let kullanmak; daha az kod yazmak, daha az girinti kullanmak ve kalıp kodlardan kurtulmak demektir. Buna karşılık, match yapısının zorunlu kıldığı ve olası hiçbir durumu gözden kaçırmamanızı güvence altına alan kapsamlılık denetiminden vazgeçmiş olursunuz. match ile if let arasında seçim yapmak, içinde bulunduğunuz senaryoda ne amaçladığınıza ve kodda özlü bir anlatım kazanmanın kapsamlılık denetiminden vazgeçmeye değip değmeyeceğine bağlıdır.

Başka bir deyişle if let yapısını, değer belirli bir desenle eşleştiğinde kod çalıştıran ve diğer tüm değerleri yok sayıp geçen bir match ifadesi için sözdizimsel şeker (syntax sugar) olarak düşünebilirsiniz.

Bir if let ifadesine else bloğu da ekleyebiliriz. else bloğunun içindeki kod, if let ve else yapısına eşdeğer bir match ifadesindeki _ koluna yazacağımız kodla birebir aynı işlevi görür. Liste 6-4’te tanımladığımız ve YirmiBesKurus varyantının içinde bir Eyalet değeri barındırdığı MadeniPara enum’ını hatırlayın. Gördüğümüz çeyreklik (25 kuruşluk) dışındaki tüm madeni paraları saymak, aynı zamanda çeyrekliklerin hangi eyalete ait olduğunu duyurmak isteseydik bunu şöyle bir match ifadesiyle yazabilirdik:

#[derive(Debug)]
enum Eyalet {
    Alabama,
    Alaska,
    // --snip--
}

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus(Eyalet),
}

fn main() {
    let para = MadeniPara::Kurus;
    let mut sayac = 0;
    match para {
        MadeniPara::YirmiBesKurus(eyalet) => {
            println!("{eyalet:?} eyaletinden çeyreklik!")
        }
        _ => sayac += 1,
    }
}

Ya da aynı işlemi aşağıdaki gibi bir if let ve else ifadesiyle gerçekleştirebilirdik:

#[derive(Debug)]
enum Eyalet {
    Alabama,
    Alaska,
    // --snip--
}

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus(Eyalet),
}

fn main() {
    let para = MadeniPara::Kurus;
    let mut sayac = 0;
    if let MadeniPara::YirmiBesKurus(eyalet) = para {
        println!("{eyalet:?} eyaletinden çeyreklik!");
    } else {
        sayac += 1;
    }
}

let...else ile “Mutlu Yolda” Kalmak

Programlamada sıkça karşılaşılan bir akış biçimi, beklenen bir değer mevcut olduğunda bazı hesaplamalar yapmak, aksi takdirde ise doğrudan varsayılan bir değer döndürmektir. Eyalet verisi taşıyan madeni paralar örneğimizden devam edelim: Çeyrekliğin üzerindeki eyaletin ne kadar eski olduğuna bakarak esprili bir mesaj üretmek isteseydik, Eyalet üzerinde eyaletin yaşını (belirli bir tarihte var olup olmadığını) kontrol eden şöyle bir metot tanımlayabilirdik:

#[derive(Debug)] // birazdan eyaleti inceleyebilmek için
enum Eyalet {
    Alabama,
    Alaska,
    // --snip--
}

impl Eyalet {
    fn su_tarihte_var_miydi(&self, yil: u16) -> bool {
        match self {
            Eyalet::Alabama => yil >= 1819,
            Eyalet::Alaska => yil >= 1959,
            // -- snip --
        }
    }
}

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus(Eyalet),
}

fn eyalet_ceyrekligini_tanimla(para: MadeniPara) -> Option<String> {
    if let MadeniPara::YirmiBesKurus(eyalet) = para {
        if eyalet.su_tarihte_var_miydi(1900) {
            Some(format!("{eyalet:?} Amerika'ya göre oldukça eski!"))
        } else {
            Some(format!("{eyalet:?} nispeten yeni."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(tanim) =
        eyalet_ceyrekligini_tanimla(MadeniPara::YirmiBesKurus(Eyalet::Alaska))
    {
        println!("{tanim}");
    }
}

Ardından Liste 6-7’de olduğu gibi, madeni paranın türünü eşleştirmek için if let kullanabilir ve koşul gövdesinin kapsamında geçerli bir eyalet değişkeni bağlayabiliriz.

#[derive(Debug)] // birazdan eyaleti inceleyebilmek için
enum Eyalet {
    Alabama,
    Alaska,
    // --snip--
}

impl Eyalet {
    fn su_tarihte_var_miydi(&self, yil: u16) -> bool {
        match self {
            Eyalet::Alabama => yil >= 1819,
            Eyalet::Alaska => yil >= 1959,
            // -- snip --
        }
    }
}

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus(Eyalet),
}

fn eyalet_ceyrekligini_tanimla(para: MadeniPara) -> Option<String> {
    if let MadeniPara::YirmiBesKurus(eyalet) = para {
        if eyalet.su_tarihte_var_miydi(1900) {
            Some(format!("{eyalet:?} Amerika'ya göre oldukça eski!"))
        } else {
            Some(format!("{eyalet:?} nispeten yeni."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(tanim) =
        eyalet_ceyrekligini_tanimla(MadeniPara::YirmiBesKurus(Eyalet::Alaska))
    {
        println!("{tanim}");
    }
}

Bu yaklaşım işimizi görür, ancak asıl mantığı if let bloğunun içine doğru iter; yapılacak işlemler karmaşıklaştıkça en üst düzeydeki dalların birbirleriyle nasıl ilişkili olduğunu takip etmek zorlaşabilir. Rust’ta ifadelerin değer üretme özelliğinden yararlanarak, Liste 6-8’de olduğu gibi if let ifadesinden ya eyalet değerini üretebilir ya da fonksiyondan erken dönüş yapabiliriz. (Benzer bir yapıyı match ile de kurabilirsiniz.)

#[derive(Debug)] // birazdan eyaleti inceleyebilmek için
enum Eyalet {
    Alabama,
    Alaska,
    // --snip--
}

impl Eyalet {
    fn su_tarihte_var_miydi(&self, yil: u16) -> bool {
        match self {
            Eyalet::Alabama => yil >= 1819,
            Eyalet::Alaska => yil >= 1959,
            // -- snip --
        }
    }
}

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus(Eyalet),
}

fn eyalet_ceyrekligini_tanimla(para: MadeniPara) -> Option<String> {
    let eyalet = if let MadeniPara::YirmiBesKurus(eyalet) = para {
        eyalet
    } else {
        return None;
    };

    if eyalet.su_tarihte_var_miydi(1900) {
        Some(format!("{eyalet:?} Amerika'ya göre oldukça eski!"))
    } else {
        Some(format!("{eyalet:?} nispeten yeni."))
    }
}

fn main() {
    if let Some(tanim) =
        eyalet_ceyrekligini_tanimla(MadeniPara::YirmiBesKurus(Eyalet::Alaska))
    {
        println!("{tanim}");
    }
}

Ne var ki bu yapıyı okumak da kendi içinde biraz yorucudur! if let ifadesinin bir dalı değişkene atanacak bir değer üretirken, diğer dalı fonksiyondan tamamen çıkış yapar.

Bu yaygın akış kalıbını çok daha temiz ifade edebilmek için Rust’ta let...else sözdizimi bulunur. let...else yapısı, if let sözdizimine çok benzer biçimde sol tarafta bir desen ve sağ tarafta bir ifade alır; ancak bir if bloğu yoktur, yalnızca else bloğu vardır. Desen eşleşirse, eşleşen değer desendeki değişkene doğrudan dış kapsamda bağlanır. Desen eşleşmezse program akışı else koluna girer ve bu kolun fonksiyondan dönerek (veya akışı keserek) mevcut kapsamdan çıkması gerekir.

Liste 6-9’da, if let yerine let...else kullanıldığında Liste 6-8’deki kodun nasıl göründüğünü inceleyebilirsiniz.

#[derive(Debug)] // birazdan eyaleti inceleyebilmek için
enum Eyalet {
    Alabama,
    Alaska,
    // --snip--
}

impl Eyalet {
    fn su_tarihte_var_miydi(&self, yil: u16) -> bool {
        match self {
            Eyalet::Alabama => yil >= 1819,
            Eyalet::Alaska => yil >= 1959,
            // -- snip --
        }
    }
}

enum MadeniPara {
    Kurus,
    BesKurus,
    OnKurus,
    YirmiBesKurus(Eyalet),
}

fn eyalet_ceyrekligini_tanimla(para: MadeniPara) -> Option<String> {
    let MadeniPara::YirmiBesKurus(eyalet) = para else {
        return None;
    };

    if eyalet.su_tarihte_var_miydi(1900) {
        Some(format!("{eyalet:?} Amerika'ya göre oldukça eski!"))
    } else {
        Some(format!("{eyalet:?} nispeten yeni."))
    }
}

fn main() {
    if let Some(tanim) =
        eyalet_ceyrekligini_tanimla(MadeniPara::YirmiBesKurus(Eyalet::Alaska))
    {
        println!("{tanim}");
    }
}

Bu sayede fonksiyonun ana gövdesinin, if let örneğindeki gibi iki dal arasında bambaşka kontrol akışlarına bölünmeden, girintisiz biçimde doğrudan “mutlu yolda” (happy path) — yani beklenen ana işleyiş akışında — kaldığına dikkat edin.

Programınızda match kullanarak ifade etmenin fazla ayrıntılı kaldığı bir mantıkla karşılaştığınızda, if let ve let...else yapılarının da Rust araç çantanızda bulunduğunu unutmayın.

Özet

Bu bölümde, numaralandırılmış bir değerler kümesinden yalnızca biri olabilen özel türler tanımlamak için enum’ların nasıl kullanılacağını ele aldık. Standart kütüphanedeki Option<T> türünün, hataları derleme zamanında önlemek üzere tür sisteminden yararlanmanıza nasıl yardımcı olduğunu gördük. Enum değerleri kendi içlerinde veri barındırdığında, ele almanız gereken durum sayısına bağlı olarak bu verileri çıkarmak ve kullanmak için match, if let veya let...else yapılarından yararlanabilirsiniz.

Rust programlarınız artık çalıştığınız problem alanındaki kavramları struct’lar ve enum’lar aracılığıyla ifade edebilir. API’nizde kullanmak üzere özel türler oluşturmak tür güvenliği sağlar: Derleyici, her fonksiyonun yalnızca beklediği türdeki değerleri almasını güvence altına alır.

Kullanıcılarınıza kullanımı anlaşılır ve yalnızca gerçekten ihtiyaç duyacakları öğeleri dışarıya açan iyi düzenlenmiş bir API sunabilmek için şimdi Rust’ın modül sistemine geçelim.

Paketler, Crate’ler ve Modüllerle Büyüyen Projeleri Yönetme

Büyük programlar yazdıkça kodunuzu düzenli tutmak giderek daha önemli hâle gelir. Birbiriyle ilişkili işlevleri gruplandırıp farklı özelliklere ait kodları birbirinden ayırarak, belirli bir özelliği uygulayan kodu nerede bulacağınızı ve bir özelliğin çalışma biçimini değiştirmek için nereye bakmanız gerektiğini netleştirirsiniz.

Şimdiye kadar yazdığımız programlar tek bir dosyadaki tek bir modül içindeydi. Bir proje büyüdükçe kodu önce birden fazla modüle, ardından da birden fazla dosyaya bölerek düzenlemelisiniz. Bir paket birden fazla ikili crate (binary crate) ve isteğe bağlı olarak bir kütüphane crate’i (library crate) içerebilir. Paket daha da büyüdükçe, bazı bölümlerini dış bağımlılık hâline gelecek ayrı crate’lere ayırabilirsiniz. Bu bölüm tüm bu teknikleri ele alır. Birlikte gelişen ve birbiriyle ilişkili paketlerden oluşan çok büyük projeler içinse Cargo, Bölüm 14’teki “Cargo Çalışma Alanları” kısmında inceleyeceğimiz çalışma alanlarını (workspaces) sunar.

Ayrıca uygulama ayrıntılarının kapsüllenmesini (encapsulation) de ele alacağız; kapsülleme, kodu daha üst düzeyde yeniden kullanmanıza olanak tanır: Bir işlemi bir kez uyguladıktan sonra diğer kodlar, iç işleyişin nasıl kurgulandığını bilmek zorunda kalmadan kodunuzu açık (public) arayüzü üzerinden çağırabilir. Kodunuzu yazış biçiminiz, hangi kısımların diğer kodların kullanımına açık olduğunu ve hangi kısımların değiştirme hakkını saklı tuttuğunuz gizli (private) uygulama ayrıntıları olduğunu belirler. Bu da zihninizde tutmanız gereken ayrıntı miktarını sınırlandırmanın bir diğer yoludur.

Bununla ilişkili bir diğer kavram da kapsamdır (scope): Kodun yazıldığı iç içe geçmiş bağlamda, “kapsam içinde” tanımlı kabul edilen belirli bir adlar kümesi bulunur. Kodu okurken, yazarken ve derlerken hem programcıların hem de derleyicilerin, belirli bir noktadaki belirli bir adın değişkene, fonksiyona, struct’a, enum’a, modüle, sabite ya da başka bir öğeye mi karşılık geldiğini ve o öğenin ne anlama geldiğini bilmesi gerekir. Yeni kapsamlar oluşturabilir ve hangi adların kapsam içinde veya kapsam dışında yer alacağını değiştirebilirsiniz. Aynı kapsamda aynı ada sahip iki öğe bulunamaz; olası ad çakışmalarını çözmek içinse çeşitli araçlar mevcuttur.

Rust; hangi ayrıntıların dışarıya açılacağı, hangilerinin gizli tutulacağı ve programlarınızdaki her kapsamda hangi adların bulunacağı da dahil olmak üzere kodunuzun organizasyonunu yönetmenize olanak tanıyan bir dizi özelliğe sahiptir. Bazen topluca modül sistemi (module system) olarak adlandırılan bu özellikler şunlardır:

• Paketler: Crate’leri derlemenize, test etmenize ve paylaşmanıza olanak tanıyan bir Cargo özelliğidir.
• Crate’ler: Bir kütüphane veya çalıştırılabilir dosya üreten bir modül ağacıdır.
• Modüller ve use: Yolların organizasyonunu, kapsamını ve gizliliğini kontrol etmenizi sağlar.
• Yollar: Struct, fonksiyon veya modül gibi bir öğeyi isimlendirme biçimidir.

Bu bölümde tüm bu özellikleri inceleyecek, birbirleriyle nasıl etkileşime girdiklerini ele alacak ve kapsamı yönetmek için bunları nasıl kullanacağınızı açıklayacağız. Bölümün sonunda modül sistemini sağlam biçimde kavrayacak ve kapsamlarla bir profesyonel gibi çalışabileceksiniz!

Paketler ve Crate'ler

Paketler ve Crate’ler

Modül sisteminin ele alacağımız ilk parçaları paketler ve crate’lerdir.

Bir crate, Rust derleyicisinin tek seferde ele aldığı en küçük kod parçasıdır; yani bir derleme birimidir (compilation unit). cargo yerine doğrudan rustc çalıştırıp derleyiciye tek bir kaynak kod dosyası iletseniz bile (Bölüm 1’deki “Rust Programlamanın Temelleri” kısmında yaptığımız gibi), derleyici bu dosyayı bir crate olarak kabul eder. Crate’ler modüller içerebilir ve ilerleyen alt bölümlerde göreceğimiz gibi bu modüller, crate ile birlikte derlenen başka dosyalarda tanımlanmış olabilir.

Bir crate iki biçimden birinde olabilir: ikili crate (binary crate) veya kütüphane crate’i (library crate). İkili crate’ler, komut satırı aracı veya sunucu gibi doğrudan çalıştırılabilir bir dosyaya derleyebildiğiniz programlardır. Her ikili crate’in, program başlatıldığında ne yapılacağını belirleyen main adında bir fonksiyona sahip olması gerekir. Şimdiye kadar oluşturduğumuz tüm crate’ler ikili crate’lerdi.

Kütüphane crate’lerinin bir main fonksiyonu yoktur ve bu crate’ler çalıştırılabilir bir dosyaya derlenmez. Bunun yerine, birden fazla projeyle paylaşılması amaçlanan işlevselliği tanımlarlar. Örneğin, Bölüm 2’de kullandığımız rand crate’i rastgele sayı üretme işlevselliği sunar. Rust geliştiricileri çoğu zaman “crate” dediklerinde kütüphane crate’ini kasteder ve “crate” terimini genel programlama kavramı olan “kütüphane” ile eş anlamlı kullanırlar.

Crate kökü (crate root), Rust derleyicisinin derlemeye başladığı ve crate’inizin kök modülünü oluşturan kaynak dosyadır (modülleri “Modüllerle Kapsam ve Gizliliği Kontrol Etme” kısmında ayrıntılı olarak inceleyeceğiz).

Bir paket (package), belirli bir işlevsellik kümesi sunan bir veya daha fazla crate’ten oluşan bir bütündür. Her paket, içindeki crate’lerin nasıl derleneceğini tanımlayan bir Cargo.toml dosyası barındırır. Aslında Cargo’nun kendisi de kodunuzu derlemek için kullandığınız komut satırı aracına ait ikili crate’i barındıran bir pakettir. Cargo paketi aynı zamanda bu ikili crate’in bağımlı olduğu bir kütüphane crate’i de içerir. Başka projeler de Cargo komut satırı aracıyla aynı mantığı kullanmak için Cargo’nun kütüphane crate’ine bağımlı olabilir.

Bir paket dilediğiniz sayıda ikili crate içerebilir; ancak en fazla bir kütüphane crate’i barındırabilir. Öte yandan bir paket, ister kütüphane ister ikili crate olsun, en az bir crate içermek zorundadır.

Bir paket oluşturduğumuzda neler olduğuna adım adım bakalım. Önce cargo new benim-projem komutunu giriyoruz:

$ cargo new benim-projem
     Created binary (application) `benim-projem` package
$ ls benim-projem
Cargo.toml
src
$ ls benim-projem/src
main.rs

cargo new benim-projem komutunu çalıştırdıktan sonra Cargo’nun neleri oluşturduğunu görmek için ls komutunu kullanıyoruz. Proje dizini olan benim-projem içinde, bize bir paket kazandıran Cargo.toml dosyası yer alır. Ayrıca main.rs dosyasını barındıran bir src dizini de bulunur. Cargo.toml dosyasını metin düzenleyicinizde açarsanız src/main.rs dosyasından hiç söz edilmediğini görürsünüz. Cargo, src/main.rs dosyasının paketle aynı adı taşıyan bir ikili crate’in crate kökü olduğu kuralını izler. Benzer şekilde Cargo, paket dizininde src/lib.rs dosyası varsa paketin yine kendisiyle aynı adı taşıyan bir kütüphane crate’i içerdiğini ve crate kökünün src/lib.rs olduğunu bilir. Cargo, kütüphaneyi veya ikili dosyayı derlemek üzere bu crate kök dosyalarını rustc derleyicisine iletir.

Burada yalnızca src/main.rs dosyasını barındıran bir paketimiz var; yani paket yalnızca benim-projem adında tek bir ikili crate içeriyor. Bir pakette hem src/main.rs hem de src/lib.rs bulunuyorsa o paket, her ikisi de paketle aynı adı taşıyan iki crate içerir: bir ikili crate ve bir kütüphane crate’i. Ayrıca src/bin dizinine dosyalar yerleştirerek bir paketin birden fazla ikili crate barındırmasını sağlayabilirsiniz; bu dizindeki her dosya ayrı bir ikili crate olur.

Modüllerle Kapsam ve Gizliliği Kontrol Etme

Modüllerle Kapsam ve Gizliliği Kontrol Etme

Bu alt bölümde modüllerden ve modül sisteminin diğer parçalarından söz edeceğiz: öğeleri adlandırmanızı sağlayan yollar (paths), bir yolu kapsama dahil eden use anahtar kelimesi ve öğeleri dışarıya açık hâle getiren pub anahtar kelimesi. Ayrıca as anahtar kelimesini, harici paketleri ve glob operatörünü de ele alacağız.

Modüller Hızlı Başvuru Özeti

Ayrıntılara geçmeden önce modüllerin, yolların, use ve pub anahtar kelimelerinin derleyicide nasıl çalıştığına ve çoğu geliştiricinin kodunu nasıl düzenlediğine dair hızlı bir başvuru özeti sunuyoruz. Bu bölüm boyunca bu kuralların her birini örneklerle inceleyeceğiz; ancak modüllerin çalışma biçimini hatırlamak istediğinizde burası geri dönebileceğiniz harika bir başvuru noktasıdır.

• Crate kökünden başlama: Bir crate derlenirken derleyici, derlenecek kodu bulmak için önce crate kök dosyasına (kütüphane crate’leri için genellikle src/lib.rs, ikili crate’ler içinse src/main.rs) bakar.
• Modül bildirme: Crate kök dosyasında yeni modüller bildirebilirsiniz; örneğin mod bahce; bildirimiyle bir “bahce” modülü bildirdiğinizi varsayalım. Derleyici, bu modülün kodunu şu konumlarda arar:
  • Satır içinde: mod bahce bildiriminden sonra noktalı virgül yerine açılan süslü parantezlerin içinde
  • src/bahce.rs dosyasında
  • src/bahce/mod.rs dosyasında
• Alt modül bildirme: Crate kökü dışındaki herhangi bir dosyada alt modüller bildirebilirsiniz. Örneğin src/bahce.rs içinde mod sebzeler; bildiriminde bulunabilirsiniz. Derleyici, alt modülün kodunu üst modülün adını taşıyan dizin altında şu konumlarda arar:
  • Satır içinde: doğrudan mod sebzeler bildiriminin ardından, noktalı virgül yerine açılan süslü parantezlerin içinde
  • src/bahce/sebzeler.rs dosyasında
  • src/bahce/sebzeler/mod.rs dosyasında
• Modüllerdeki kodlara giden yollar: Bir modül crate’inizin parçası hâline geldiğinde, gizlilik kuralları izin verdiği sürece aynı crate’in herhangi bir yerinden ilgili yolu kullanarak o modüldeki koda başvurabilirsiniz. Örneğin bahce altındaki sebzeler modülünde yer alan bir Kuskonmaz türüne crate::bahce::sebzeler::Kuskonmaz yoluyla ulaşılır.
• Gizli ve açık erişim: Bir modülün içindeki kod, varsayılan olarak üst modüllerine karşı gizlidir (private). Bir modülü açık (public) hâle getirmek için mod yerine pub mod ile bildirin. Açık bir modülün içindeki öğeleri de dışarıya açmak için bildirimlerinin önüne pub ekleyin.
• use anahtar kelimesi: Bir kapsam içinde use anahtar kelimesi, uzun yolların tekrarını azaltmak amacıyla öğeler için kısayollar oluşturur. crate::bahce::sebzeler::Kuskonmaz yoluna başvurabilen herhangi bir kapsamda use crate::bahce::sebzeler::Kuskonmaz; ile bir kısayol tanımlayabilirsiniz; bundan sonra o kapsamda bu türü kullanmak için yalnızca Kuskonmaz yazmanız yeterlidir.

Burada, bu kuralları somutlaştırmak için arka_bahce adlı bir ikili crate oluşturuyoruz. Yine arka_bahce adını taşıyan crate dizini şu dosya ve dizinleri içerir:

arka_bahce
├── Cargo.lock
├── Cargo.toml
└── src
    ├── bahce
    │   └── sebzeler.rs
    ├── bahce.rs
    └── main.rs

Bu örnekte crate kök dosyası src/main.rs dosyasıdır ve içeriği şöyledir:

use crate::bahce::sebzeler::Kuskonmaz;

pub mod bahce;

fn main() {
    let bitki = Kuskonmaz {};
    println!("{bitki:?} yetiştiriyorum!");
}

pub mod bahce; satırı, derleyiciye src/bahce.rs dosyasında bulduğu kodu derlemeye dahil etmesini söyler. Bu dosyanın içeriği şöyledir:

pub mod sebzeler;

Buradaki pub mod sebzeler; bildirimi de src/bahce/sebzeler.rs dosyasındaki kodun dahil edileceği anlamına gelir. O kod ise şöyledir:

#[derive(Debug)]
pub struct Kuskonmaz {}

Şimdi bu kuralların ayrıntılarına inelim ve pratikte nasıl çalıştıklarını görelim!

İlgili Kodu Modüllerde Gruplama

Modüller, okunabilirlik ve kolay yeniden kullanım amacıyla bir crate içindeki kodu düzenlememize olanak tanır. Bir modülün içindeki kod varsayılan olarak gizli olduğundan, modüller öğelerin gizliliğini (privacy) kontrol etmemizi de sağlar. Gizli öğeler, dışarıdan kullanıma kapalı olan iç uygulama ayrıntılarıdır. Modülleri ve içlerindeki öğeleri açık hâle getirmeyi seçebiliriz; böylece dışarıdaki kodların bunları kullanmasına ve bunlara bağımlı olmasına izin vermiş oluruz.

Örnek olarak bir restoranın işlevselliğini sunan bir kütüphane crate’i yazalım. Bir restoranın gerçek işleyişini kodlamaktan ziyade kodun organizasyonuna odaklanmak için fonksiyonların yalnızca imzalarını tanımlayacak, gövdelerini ise boş bırakacağız.

Restoran sektöründe bir işletmenin alanları genellikle ön kısım (müşteri salonu — front of house) ve arka kısım (mutfak ve geri plan — back of house) olarak ikiye ayrılır. Ön kısım, müşterilerin ağırlandığı alandır; karşılama görevlilerinin müşterileri masalara yerleştirdiği, garsonların sipariş ve ödeme aldığı, barmenlerin ise içecekleri hazırladığı bölümleri kapsar. Arka kısım ise şef ve aşçıların mutfakta yemek pişirdiği, bulaşıkçıların temizlik yaptığı ve yöneticilerin idari işleri yürüttüğü bölümdür.

Crate’imizi bu düzene göre yapılandırmak için fonksiyonlarını iç içe geçmiş modüller hâlinde organize edebiliriz. cargo new restoran --lib komutunu çalıştırarak restoran adında yeni bir kütüphane oluşturun. Ardından bazı modülleri ve fonksiyon imzalarını tanımlamak için Liste 7-1’deki kodu src/lib.rs dosyasına yazın; bu kod restoranın ön kısmını oluşturur.

mod restoran_on_kisim {
    mod karsilama {
        fn bekleme_listesine_ekle() {}

        fn masaya_oturt() {}
    }

    mod servis {
        fn siparis_al() {}

        fn siparis_servis_et() {}

        fn odeme_al() {}
    }
}

Bir modülü, mod anahtar kelimesinin ardından modülün adını (bu örnekte restoran_on_kisim) yazarak tanımlarız. Modülün gövdesi ise süslü parantezler içine yazılır. Bir modülün içine, buradaki karsilama ve servis modüllerinde olduğu gibi başka modüller yerleştirebiliriz. Modüller ayrıca struct’lar, enum’lar, sabitler, trait’ler ve Liste 7-1’deki gibi fonksiyonlar da dahil olmak üzere diğer öğelerin tanımlarını barındırabilir.

Modülleri kullanarak birbiriyle ilişkili tanımları bir araya toplayabilir ve bu tanımların neden ilişkili olduğunu verdiğimiz modül adıyla ifade edebiliriz. Bu kodu kullanan geliştiriciler, tüm tanımları baştan sona okumak zorunda kalmadan gruplar üzerinden kodda gezinebilir ve aradıkları tanımları çok daha kolay bulabilirler. Koda yeni bir işlevsellik ekleyecek geliştiriciler de programın düzenini bozmamak için yeni kodu nereye yerleştirmeleri gerektiğini bilirler.

Daha önce src/main.rs ve src/lib.rs dosyalarının crate kökü olarak adlandırıldığından bahsetmiştik. Bu adlandırmanın nedeni, bu iki dosyadan herhangi birinin içeriğinin, crate’in modül ağacı (module tree) olarak bilinen modül yapısının en tepesinde crate adında bir modül oluşturmasıdır.

Liste 7-2, Liste 7-1’deki yapının modül ağacını göstermektedir.

crate
 └── restoran_on_kisim
     ├── karsilama
     │   ├── bekleme_listesine_ekle
     │   └── masaya_oturt
     └── servis
         ├── siparis_al
         ├── siparis_servis_et
         └── odeme_al

Bu ağaç, bazı modüllerin diğer modüllerin içinde nasıl iç içe yer aldığını gösterir; örneğin karsilama, restoran_on_kisim modülünün içindedir. Ağaç ayrıca bazı modüllerin birbirinin kardeşi (sibling) olduğunu, yani aynı modül içinde tanımlandığını da gösterir; karsilama ve servis, restoran_on_kisim içinde tanımlanmış kardeş modüllerdir. Bir A modülü B modülünün içindeyse; A’nın B modülünün alt modülü (çocuğu / child), B’nin ise A modülünün üst modülü (ebeveyni / parent) olduğunu söyleriz. Tüm modül ağacının, derleyici tarafından örtük olarak oluşturulan crate adlı kök modülün altında yer aldığına dikkat edin.

Modül ağacı size bilgisayarınızdaki dosya sisteminin dizin ağacını anımsatmış olabilir; bu çok yerinde bir benzetmedir! Tıpkı dosya sistemindeki dizinler gibi, kodunuzu düzenlemek için modülleri kullanırsınız. Yine bir dizindeki dosyalarda olduğu gibi, modüllerimizi bulmanın da bir yoluna ihtiyacımız vardır.

Modül Ağacındaki Bir Öğeye Başvurmak İçin Yollar

Modül Ağacındaki Bir Öğeye Başvurmak İçin Yollar

Rust’a modül ağacındaki bir öğeyi nerede bulacağını göstermek için, tıpkı bir dosya sisteminde gezinirken kullandığımız gibi bir yol (path) kullanırız. Bir fonksiyonu çağırmak için onun yolunu bilmemiz gerekir.

Bir yol iki biçimde yazılabilir:

• Mutlak yol (absolute path), crate kökünden başlayan tam yoldur; harici bir crate’teki kod için crate adıyla, içinde bulunduğumuz crate’teki kod içinse doğrudan crate kelimesiyle başlar.
• Göreli yol (relative path), geçerli modülden başlar ve self, super ya da geçerli modül içindeki bir tanımlayıcıyı kullanır.

Hem mutlak hem de göreli yollarda başlangıç öğesini, birbirinden çift iki nokta üst üste (::) ile ayrılmış bir veya daha fazla tanımlayıcı izler.

Liste 7-1’e geri dönelim ve bekleme_listesine_ekle fonksiyonunu çağırmak istediğimizi varsayalım. Bu aslında şu soruyu sormakla aynıdır: bekleme_listesine_ekle fonksiyonunun yolu nedir? Liste 7-3, Liste 7-1’in bazı modül ve fonksiyonları çıkarılmış hâlini içerir.

Crate kökünde tanımlanan restoranda_yemek_ye adlı yeni bir fonksiyondan bekleme_listesine_ekle fonksiyonunu çağırmanın iki yolunu göstereceğiz. Bu yollar doğrudur; ancak bu örneğin olduğu gibi derlenmesini engelleyecek bir sorun vardır. Nedenini birazdan açıklayacağız.

restoranda_yemek_ye fonksiyonu, kütüphane crate’imizin açık API’sinin bir parçası olduğu için onu pub anahtar kelimesiyle işaretliyoruz. “Yolları pub Anahtar Kelimesiyle Dışarıya Açma” kısmında pub hakkında daha fazla ayrıntıya gireceğiz.

mod restoran_on_kisim {
    mod karsilama {
        fn bekleme_listesine_ekle() {}
    }
}

pub fn restoranda_yemek_ye() {
    // Mutlak yol
    crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();

    // Göreli yol
    restoran_on_kisim::karsilama::bekleme_listesine_ekle();
}

restoranda_yemek_ye içinde bekleme_listesine_ekle fonksiyonunu ilk çağırdığımızda mutlak bir yol kullanıyoruz. bekleme_listesine_ekle fonksiyonu restoranda_yemek_ye ile aynı crate içinde tanımlandığından, mutlak yolu başlatmak için crate anahtar kelimesini kullanabiliriz. Ardından bekleme_listesine_ekle fonksiyonuna ulaşana kadar birbirini izleyen modüllerin her birini yola dahil ederiz. Aynı yapıya sahip bir dosya sistemi hayal edebilirsiniz: bekleme_listesine_ekle programını çalıştırmak için /restoran_on_kisim/karsilama/bekleme_listesine_ekle yolunu belirtirdik; crate kökünden başlamak üzere crate adını kullanmak, kabuğunuzda dosya sistemi kökünden başlamak için / kullanmaya benzer.

restoranda_yemek_ye içinde bekleme_listesine_ekle fonksiyonunu ikinci kez çağırdığımızda ise göreli bir yol kullanıyoruz. Yol, modül ağacında restoranda_yemek_ye ile aynı seviyede tanımlanmış olan restoran_on_kisim modülünün adıyla başlar. Bunun dosya sistemindeki karşılığı restoran_on_kisim/karsilama/bekleme_listesine_ekle yolunu kullanmak olurdu. Bir modül adıyla başlamak, yolun göreli olduğu anlamına gelir.

Göreli mi yoksa mutlak yol mu kullanacağınız, projenize göre vereceğiniz bir karardır ve öğeyi tanımlayan kodu, o öğeyi kullanan koddan ayrı mı yoksa onunla birlikte mi taşıma olasılığınızın daha yüksek olduğuna bağlıdır. Örneğin restoran_on_kisim modülünü ve restoranda_yemek_ye fonksiyonunu birlikte musteri_deneyimi adlı bir modülün içine taşırsak, bekleme_listesine_ekle için yazdığımız mutlak yolu güncellememiz gerekir; ancak göreli yol geçerliliğini korur. Buna karşılık restoranda_yemek_ye fonksiyonunu tek başına yemek adlı ayrı bir modüle taşırsak, bekleme_listesine_ekle çağrısının mutlak yolu aynı kalır ama göreli yolun güncellenmesi gerekir. Kod tanımlarını ve öğe çağrılarını birbirinden bağımsız olarak taşıma ihtimalimiz daha yüksek olduğundan, genel tercihimiz mutlak yolları kullanmaktır.

Şimdi Liste 7-3’ü derlemeyi deneyelim ve henüz neden derlenmediğini öğrenelim! Aldığımız hatalar Liste 7-4’te gösterilmiştir.

$ cargo build
   Compiling restoran v0.1.0 (file:///projects/restoran)
error[E0603]: module `karsilama` is private
 --> src/lib.rs:9:31
  |
9 |     crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();
  |                               ^^^^^^^^^  ---------------------- function `bekleme_listesine_ekle` is not publicly re-exported
  |                               |
  |                               private module
  |
note: the module `karsilama` is defined here
 --> src/lib.rs:2:5
  |
2 |     mod karsilama {
  |     ^^^^^^^^^^^^^

error[E0603]: module `karsilama` is private
  --> src/lib.rs:12:24
   |
12 |     restoran_on_kisim::karsilama::bekleme_listesine_ekle();
   |                        ^^^^^^^^^  ---------------------- function `bekleme_listesine_ekle` is not publicly re-exported
   |                        |
   |                        private module
   |
note: the module `karsilama` is defined here
  --> src/lib.rs:2:5
   |
 2 |     mod karsilama {
   |     ^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restoran` (lib) due to 2 previous errors

Hata mesajları karsilama modülünün gizli olduğunu söylüyor (module `karsilama` is private). Başka bir deyişle, karsilama modülü ve bekleme_listesine_ekle fonksiyonu için yazdığımız yollar doğrudur; ancak gizli bölümlere erişim iznimiz olmadığı için Rust bunları kullanmamıza izin vermez. Rust’ta tüm öğeler (fonksiyonlar, metotlar, struct’lar, enum’lar, modüller ve sabitler) üst modüllere karşı varsayılan olarak gizlidir. Bir fonksiyon veya struct gibi bir öğeyi gizli yapmak istiyorsanız onu bir modülün içine yerleştirirsiniz.

Üst modüldeki öğeler alt modüllerin içindeki gizli öğeleri kullanamaz; ancak alt modüllerdeki öğeler kendi ata modüllerindeki öğeleri kullanabilir. Bunun nedeni, alt modüllerin kendi uygulama ayrıntılarını sarmalayıp gizlemesi, buna karşılık tanımlandıkları dış bağlamı görebilmesidir. Benzetmemize devam edecek olursak, gizlilik kurallarını bir restoranın arka ofisi gibi düşünebilirsiniz: Orada olup bitenler restoran müşterilerine karşı gizlidir, ancak ofis yöneticileri işlettikleri restorandaki her şeyi görebilir ve yönetebilir.

Rust’ta modül sistemi, iç uygulama ayrıntılarını gizlemek varsayılan davranış olacak şekilde tasarlanmıştır. Bu sayede içteki kodun hangi kısımlarını dıştaki kodu bozmadan değiştirebileceğinizi net biçimde bilirsiniz. Yine de Rust, bir öğeyi açık hâle getiren pub anahtar kelimesini kullanarak alt modüllerdeki kodun iç kısımlarını dıştaki ata modüllere açma seçeneğini de size sunar.

Yolları pub Anahtar Kelimesiyle Dışarıya Açma

Liste 7-4’te karsilama modülünün gizli olduğunu bildiren hataya geri dönelim. Üst modüldeki restoranda_yemek_ye fonksiyonunun, alt modüldeki bekleme_listesine_ekle fonksiyonuna erişebilmesini istiyoruz; bu yüzden karsilama modülünü Liste 7-5’te gösterildiği gibi pub anahtar kelimesiyle işaretliyoruz.

mod restoran_on_kisim {
    pub mod karsilama {
        fn bekleme_listesine_ekle() {}
    }
}

// -- snip --
pub fn restoranda_yemek_ye() {
    // Mutlak yol
    crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();

    // Göreli yol
    restoran_on_kisim::karsilama::bekleme_listesine_ekle();
}

Ne yazık ki Liste 7-5’teki kod da Liste 7-6’da gösterildiği gibi hâlâ derleyici hatalarıyla sonuçlanır.

$ cargo build
   Compiling restoran v0.1.0 (file:///projects/restoran)
error[E0603]: function `bekleme_listesine_ekle` is private
  --> src/lib.rs:10:42
   |
10 |     crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();
   |                                          ^^^^^^^^^^^^^^^^^^^^^^ private function
   |
note: the function `bekleme_listesine_ekle` is defined here
  --> src/lib.rs:3:9
   |
 3 |         fn bekleme_listesine_ekle() {}
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0603]: function `bekleme_listesine_ekle` is private
  --> src/lib.rs:13:35
   |
13 |     restoran_on_kisim::karsilama::bekleme_listesine_ekle();
   |                                   ^^^^^^^^^^^^^^^^^^^^^^ private function
   |
note: the function `bekleme_listesine_ekle` is defined here
  --> src/lib.rs:3:9
   |
 3 |         fn bekleme_listesine_ekle() {}
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restoran` (lib) due to 2 previous errors

Ne oldu? mod karsilama tanımının önüne pub anahtar kelimesini eklemek modülü açık hâle getirir. Bu değişiklikle birlikte restoran_on_kisim modülüne erişebiliyorsak karsilama modülüne de erişebiliriz. Ancak karsilama modülünün içeriği hâlâ gizlidir; modülü açık yapmak içindeki öğeleri otomatik olarak açık yapmaz. Bir modül üzerindeki pub anahtar kelimesi, yalnızca ata modüllerindeki kodların o modüle başvurmasına izin verir, içindeki koda erişmesini sağlamaz. Modüller birer kapsayıcı olduğundan yalnızca modülü açık hâle getirerek yapabileceğimiz pek bir şey yoktur; bir adım daha ileri gidip modül içindeki öğelerden birini veya birkaçını da açık hâle getirmeyi seçmeliyiz.

Liste 7-6’daki hatalar bekleme_listesine_ekle fonksiyonunun gizli olduğunu söylüyor (function `bekleme_listesine_ekle` is private). Gizlilik kuralları modüllerin yanı sıra struct’lar, enum’lar, fonksiyonlar ve metotlar için de geçerlidir.

Liste 7-7’de olduğu gibi tanımının önüne pub anahtar kelimesini ekleyerek bekleme_listesine_ekle fonksiyonunu da açık hâle getirelim.

mod restoran_on_kisim {
    pub mod karsilama {
        pub fn bekleme_listesine_ekle() {}
    }
}

// -- snip --
pub fn restoranda_yemek_ye() {
    // Mutlak yol
    crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();

    // Göreli yol
    restoran_on_kisim::karsilama::bekleme_listesine_ekle();
}

Artık kod derlenecektir! pub anahtar kelimesini eklemenin, gizlilik kuralları çerçevesinde bu yolları restoranda_yemek_ye içinde kullanmamıza neden izin verdiğini görmek için mutlak ve göreli yollara adım adım bakalım.

Mutlak yolda, crate’imizin modül ağacının kökü olan crate ile başlarız. restoran_on_kisim modülü crate kökünde tanımlanmıştır. restoran_on_kisim açık olmasa da restoranda_yemek_ye fonksiyonuyla aynı modülde tanımlandığından (yani ikisi aynı kapsamdaki kardeş öğeler olduğundan), restoranda_yemek_ye içinden restoran_on_kisim modülüne başvurabiliriz. Sırada pub ile işaretlenmiş karsilama modülü vardır. karsilama modülünün üst modülüne erişebildiğimiz için karsilama modülüne de erişebiliriz. Son olarak bekleme_listesine_ekle fonksiyonu pub ile işaretlenmiştir ve üst modülüne erişebildiğimiz için bu fonksiyon çağrısı sorunsuz çalışır!

Göreli yolda ise ilk adım dışında mantık mutlak yolla tamamen aynıdır: Yol, crate kökünden başlamak yerine restoran_on_kisim ile başlar. restoran_on_kisim modülü restoranda_yemek_ye ile aynı modül içinde tanımlandığından, restoranda_yemek_ye fonksiyonunun tanımlı olduğu modülden başlayan göreli yol geçerlidir. Ardından hem karsilama modülü hem de bekleme_listesine_ekle fonksiyonu pub ile işaretlendiği için yolun geri kalanı da erişilebilirdir ve fonksiyon çağrısı geçerlidir!

Kütüphane crate’inizi diğer projelerin de kodunuzu kullanabilmesi için paylaşmayı planlıyorsanız açık API’niz, crate’inizin kullanıcılarıyla yaptığınız ve kodunuzla nasıl etkileşime girebileceklerini belirleyen sözleşmenizdir. İnsanların crate’inize güvenle bağımlı olmasını kolaylaştırmak adına açık API’nizdeki değişiklikleri yönetirken dikkat edilmesi gereken pek çok nokta vardır. Bu konular bu kitabın kapsamı dışındadır; konuyla ilgileniyorsanız Rust API Yönergeleri kılavuzunu inceleyebilirsiniz.

super ile Göreli Yollara Başlama

Yolun başında super kullanarak geçerli modül veya crate kökü yerine doğrudan üst modülden başlayan göreli yollar oluşturabiliriz. Bu, bir dosya sistemi yoluna bir üst dizine çıkmak anlamına gelen .. sözdizimiyle başlamaya benzer. super kullanmak, üst modülde yer aldığını bildiğimiz bir öğeye başvurmamızı sağlar; modül üst modülüyle yakından ilişkiliyse ve üst modülün ileride modül ağacında başka bir konuma taşınma ihtimali varsa bu yöntem modül ağacını yeniden düzenlemeyi kolaylaştırır.

Bir şefin hatalı bir siparişi düzeltip bizzat müşteriye götürdüğü durumu modelleyen Liste 7-8’deki kodu ele alalım. restoran_arka_kisim modülünde tanımlanan yanlis_siparisi_duzelt fonksiyonu, super ile başlayan yolu belirterek üst modülde tanımlı siparisi_teslim_et fonksiyonunu çağırır.

fn siparisi_teslim_et() {}

mod restoran_arka_kisim {
    fn yanlis_siparisi_duzelt() {
        siparisi_pisir();
        super::siparisi_teslim_et();
    }

    fn siparisi_pisir() {}
}

yanlis_siparisi_duzelt fonksiyonu restoran_arka_kisim modülü içinde yer aldığından, restoran_arka_kisim modülünün üst modülüne — bu örnekte kök modül olan crate kapsamına — çıkmak için super kullanabiliriz. Oradan siparisi_teslim_et fonksiyonunu arar ve buluruz. Başardık! restoran_arka_kisim modülü ile siparisi_teslim_et fonksiyonunun birbiriyle ilişkili kalacağını ve crate’in modül ağacını yeniden düzenlemeye karar verirsek birlikte taşınacaklarını düşünüyoruz. Bu nedenle super kullandık; böylece bu kod gelecekte başka bir modüle taşındığında güncellememiz gereken yer sayısı daha az olacaktır.

Struct’ları ve Enum’ları Açık Yapma

Struct’ları ve enum’ları açık olarak tanımlamak için de pub anahtar kelimesini kullanabiliriz; ancak pub kullanımının struct’lar ve enum’larla ilgili birkaç ek ayrıntısı vardır. Bir struct tanımının önüne pub koyarsak struct’ın kendisini açık yaparız, fakat struct’ın alanları gizli kalmaya devam eder. Her bir alanı duruma göre tek tek açık yapıp yapmamayı seçebiliriz. Liste 7-9’da açık bir tost alanına ve gizli bir mevsim_meyvesi alanına sahip olan açık bir restoran_arka_kisim::Kahvalti struct’ı tanımladık. Bu yapı, müşterinin yemekle birlikte gelen ekmek türünü seçebildiği, ancak yemeğe hangi meyvenin eşlik edeceğine mevsime ve stok durumuna göre şefin karar verdiği gerçek bir restoran işleyişini modeller. Eldeki meyveler hızla değiştiği için müşteriler meyveyi seçemez, hatta hangi meyveyi alacaklarını bile göremez.

mod restoran_arka_kisim {
    pub struct Kahvalti {
        pub tost: String,
        mevsim_meyvesi: String,
    }

    impl Kahvalti {
        pub fn yaz(tost: &str) -> Kahvalti {
            Kahvalti {
                tost: String::from(tost),
                mevsim_meyvesi: String::from("şeftali"),
            }
        }
    }
}

pub fn restoranda_yemek_ye() {
    // Çavdar tostu ile bir yaz kahvaltısı sipariş edin.
    let mut ogun = restoran_arka_kisim::Kahvalti::yaz("Çavdar");
    // Hangi ekmeği istediğimiz konusundaki fikrimizi değiştirelim.
    ogun.tost = String::from("Buğday");
    println!("Lütfen {} tost istiyorum", ogun.tost);

    // Aşağıdaki satırın yorumunu kaldırırsak derlenmeyecektir; öğünle birlikte gelen
    // mevsim meyvesini görmemize veya değiştirmemize izin verilmez.
    // ogun.mevsim_meyvesi = String::from("yaban mersini");
}

restoran_arka_kisim::Kahvalti struct’ındaki tost alanı açık olduğu için restoranda_yemek_ye içinde nokta gösterimini kullanarak tost alanına yazabilir ve bu alanı okuyabiliriz. Buna karşılık mevsim_meyvesi alanı gizli olduğundan restoranda_yemek_ye içinde bu alanı kullanamayız. Nasıl bir derleyici hatası aldığınızı görmek için mevsim_meyvesi alanının değerini değiştiren satırı yorumdan çıkarmayı deneyin!

Ayrıca restoran_arka_kisim::Kahvalti gizli bir alana sahip olduğu için, bu struct’ın bir Kahvalti örneği oluşturan açık bir ilişkili fonksiyon sunması gerektiğine dikkat edin (burada yaz mevsimini ifade edecek şekilde ona yaz adını verdik). Kahvalti böyle bir fonksiyona sahip olmasaydı, restoranda_yemek_ye içinde gizli mevsim_meyvesi alanına değer atayamayacağımız için Kahvalti türünden bir örnek de oluşturamazdık.

Buna karşılık bir enum’ı açık yaparsak tüm varyantları da otomatik olarak açık olur. Liste 7-10’da gösterildiği gibi yalnızca enum anahtar kelimesinden önce pub yazmamız yeterlidir.

mod restoran_arka_kisim {
    pub enum Meze {
        Corba,
        Salata,
    }
}

pub fn restoranda_yemek_ye() {
    let siparis1 = restoran_arka_kisim::Meze::Corba;
    let siparis2 = restoran_arka_kisim::Meze::Salata;
}

Meze enum’ını açık hâle getirdiğimiz için restoranda_yemek_ye içinde Corba ve Salata varyantlarını doğrudan kullanabiliriz.

Varyantları açık olmadıkça enum’lar pek işe yaramaz; her seferinde tüm enum varyantlarına tek tek pub eklemek zorunda kalmak zahmetli olacağından enum varyantlarının varsayılan durumu açık olmaktır. Struct’lar ise alanları dışarıya açık olmadan da çoğu zaman oldukça kullanışlıdır; bu nedenle struct alanları, pub ile aksi belirtilmedikçe her şeyin varsayılan olarak gizli olduğu genel kuralı izler.

Henüz ele almadığımız ve pub ile ilgili bir durum daha var; o da modül sisteminin son özelliği olan use anahtar kelimesidir. Önce use anahtar kelimesini tek başına inceleyecek, ardından pub ve use anahtar kelimelerini nasıl birleştireceğimizi göstereceğiz.

use Anahtar Kelimesi ile Yolları Kapsama Dahil Etme

use Anahtar Kelimesi ile Yolları Kapsama Dahil Etme

Fonksiyonları çağırmak için yolları her seferinde uzun uzun yazmak zahmetli ve tekrarlayıcı gelebilir. Liste 7-7’de bekleme_listesine_ekle fonksiyonuna ulaşmak için ister mutlak ister göreli yolu seçelim, bekleme_listesine_ekle fonksiyonunu her çağırmak istediğimizde restoran_on_kisim ve karsilama modüllerini de belirtmek zorundaydık. Neyse ki bu süreci basitleştirmenin bir yolu vardır: use anahtar kelimesiyle bir yol için tek seferlik bir kısayol oluşturabilir ve ardından aynı kapsamın her yerinde bu daha kısa adı kullanabiliriz.

Liste 7-11’de, restoranda_yemek_ye içinde bekleme_listesine_ekle fonksiyonunu çağırmak için yalnızca karsilama::bekleme_listesine_ekle yazmamız yeterli olacak şekilde crate::restoran_on_kisim::karsilama modülünü restoranda_yemek_ye fonksiyonunun bulunduğu kapsama dahil ediyoruz.

mod restoran_on_kisim {
    pub mod karsilama {
        pub fn bekleme_listesine_ekle() {}
    }
}

use crate::restoran_on_kisim::karsilama;

pub fn restoranda_yemek_ye() {
    karsilama::bekleme_listesine_ekle();
}

Bir kapsama use ile bir yol eklemek, dosya sisteminde sembolik bağlantı (symbolic link) oluşturmaya benzer. Crate köküne use crate::restoran_on_kisim::karsilama eklediğimizde, tıpkı karsilama modülü doğrudan crate kökünde tanımlanmış gibi karsilama adı o kapsamda geçerli bir isim hâline gelir. use ile kapsama dahil edilen yollar da diğer tüm yollar gibi gizlilik kurallarına tabidir.

use deyiminin kısayolu yalnızca yazıldığı kapsam için oluşturduğuna dikkat edin. Liste 7-12, restoranda_yemek_ye fonksiyonunu musteri adlı yeni bir alt modüle taşır; bu alt modül use deyiminden farklı bir kapsam oluşturduğu için fonksiyon gövdesi derlenmeyecektir.

mod restoran_on_kisim {
    pub mod karsilama {
        pub fn bekleme_listesine_ekle() {}
    }
}

use crate::restoran_on_kisim::karsilama;

mod musteri {
    pub fn restoranda_yemek_ye() {
        karsilama::bekleme_listesine_ekle();
    }
}

Derleyici hatası, kısayolun musteri modülü içinde artık geçerli olmadığını gösterir:

$ cargo build
   Compiling restoran v0.1.0 (file:///projects/restoran)
error[E0433]: cannot find module or crate `karsilama` in this scope
  --> src/lib.rs:11:9
   |
11 |         karsilama::bekleme_listesine_ekle();
   |         ^^^^^^^^^ use of unresolved module or unlinked crate `karsilama`
   |
   = help: if you wanted to use a crate named `karsilama`, use `cargo add karsilama` to add it to your `Cargo.toml`
help: consider importing this module through its public re-export
   |
10 +     use crate::karsilama;
   |

warning: unused import: `crate::restoran_on_kisim::karsilama`
 --> src/lib.rs:7:5
  |
7 | use crate::restoran_on_kisim::karsilama;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default

For more information about this error, try `rustc --explain E0433`.
warning: `restoran` (lib) generated 1 warning
error: could not compile `restoran` (lib) due to 1 previous error; 1 warning emitted

Ayrıca use deyiminin kendi kapsamında artık kullanılmadığına dair bir uyarı (unused import) üretildiğine de dikkat edin! Bu sorunu çözmek için ya use deyimini de musteri modülünün içine taşıyabilir ya da musteri alt modülünün içinden üst modüldeki kısayola super::karsilama ile başvurabilirsiniz.

Deyimsel use Yolları Oluşturma

Liste 7-11’de, Liste 7-13’teki gibi aynı sonucu elde etmek üzere use yolunu doğrudan bekleme_listesine_ekle fonksiyonuna kadar uzatmak yerine neden use crate::restoran_on_kisim::karsilama yazıp ardından restoranda_yemek_ye içinde karsilama::bekleme_listesine_ekle çağrısı yaptığımızı merak etmiş olabilirsiniz.

mod restoran_on_kisim {
    pub mod karsilama {
        pub fn bekleme_listesine_ekle() {}
    }
}

use crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle;

pub fn restoranda_yemek_ye() {
    bekleme_listesine_ekle();
}

Hem Liste 7-11 hem de Liste 7-13 aynı işi görse de bir fonksiyonu use ile kapsama dahil etmenin deyimsel (idiomatic) yolu Liste 7-11’deki kullanımdır. Fonksiyonun üst modülünü use ile kapsama dahil etmek, fonksiyonu çağırırken bu üst modülü belirtmemizi gerektirir. Çağrı noktasında üst modülü yazmak, tam yolun tekrarını en aza indirirken fonksiyonun yerel olarak tanımlanmadığını da açıkça gösterir. Liste 7-13’teki kodda ise bekleme_listesine_ekle fonksiyonunun nerede tanımlandığı belirsizdir.

Öte yandan struct’ları, enum’ları ve fonksiyon dışındaki diğer öğeleri use ile kapsama dahil ederken öğenin tam yolunu belirtmek deyimseldir. Liste 7-14, standart kütüphanedeki HashMap struct’ını bir ikili crate’in kapsamına dahil etmenin deyimsel yolunu gösterir.

use std::collections::HashMap;

fn main() {
    let mut harita = HashMap::new();
    harita.insert(1, 2);
}

Bu kullanım geleneğinin arkasında teknik bir zorunluluk yoktur; yalnızca zaman içinde yerleşmiş bir uzlaşıdır ve geliştiriciler Rust kodunu bu biçimde okuyup yazmaya alışmıştır.

Bu geleneğin istisnası, use deyimleriyle aynı ada sahip iki öğeyi aynı kapsama dahil etmemiz gereken durumlardır; çünkü Rust aynı kapsamda isim çakışmasına izin vermez. Liste 7-15, aynı adı taşıyan ancak farklı üst modüllerde bulunan iki Result türünün kapsama nasıl dahil edileceğini ve bunlara nasıl başvurulacağını gösterir.

use std::fmt;
use std::io;

fn fonksiyon1() -> fmt::Result {
    // --snip--
    Ok(())
}

fn fonksiyon2() -> io::Result<()> {
    // --snip--
    Ok(())
}

Gördüğünüz gibi, üst modülleri kullanmak iki Result türünü birbirinden ayırt eder. Bunun yerine use std::fmt::Result ve use std::io::Result yazsaydık aynı kapsamda iki ayrı Result türümüz olurdu ve Result yazdığımızda Rust hangisini kastettiğimizi bilemezdi.

as Anahtar Kelimesiyle Yeni İsimler Verme

Aynı ada sahip iki türü use ile aynı kapsama dahil etme sorununun bir çözümü daha vardır: Yoldan sonra as anahtar kelimesini kullanarak türe yeni bir yerel ad, yani takma ad (alias) verebiliriz. Liste 7-16, iki Result türünden birini as ile yeniden adlandırarak Liste 7-15’teki kodu yazmanın alternatif yolunu gösterir.

use std::fmt::Result;
use std::io::Result as IoResult;

fn fonksiyon1() -> Result {
    // --snip--
    Ok(())
}

fn fonksiyon2() -> IoResult<()> {
    // --snip--
    Ok(())
}

İkinci use deyiminde std::io::Result türü için IoResult yeni adını seçtik; bu ad, aynı kapsama dahil ettiğimiz std::fmt içindeki Result ile çakışmayacaktır. Hem Liste 7-15 hem de Liste 7-16 deyimsel kabul edilir; dolayısıyla hangisini tercih edeceğiniz size kalmıştır!

pub use ile İsimleri Yeniden Dışa Aktarma

Bir ismi use anahtar kelimesiyle kapsama dahil ettiğimizde bu isim, içe aktarıldığı kapsam açısından gizli kalır. O kapsamın dışındaki kodların da bu isme sanki doğrudan o kapsamda tanımlanmış gibi başvurabilmesini sağlamak için pub ve use anahtar kelimelerini birleştirebiliriz. Bu tekniğe yeniden dışa aktarma (re-exporting) denir; çünkü bir öğeyi kendi kapsamımıza dahil ederken aynı zamanda başkalarının da kendi kapsamlarına dahil edebileceği şekilde dışarıya açmış oluruz.

Liste 7-17, Liste 7-11’deki kodda kök modülde yer alan use deyiminin pub use olarak değiştirilmiş hâlini gösterir.

mod restoran_on_kisim {
    pub mod karsilama {
        pub fn bekleme_listesine_ekle() {}
    }
}

pub use crate::restoran_on_kisim::karsilama;

pub fn restoranda_yemek_ye() {
    karsilama::bekleme_listesine_ekle();
}

Bu değişiklikten önce harici kodların bekleme_listesine_ekle fonksiyonunu restoran::restoran_on_kisim::karsilama::bekleme_listesine_ekle() yolunu kullanarak çağırması gerekirdi; üstelik bunun çalışabilmesi için restoran_on_kisim modülünün de pub olarak işaretlenmesi şarttı. Kök modüldeki pub use deyimi karsilama modülünü yeniden dışa aktardığından, harici kodlar artık doğrudan restoran::karsilama::bekleme_listesine_ekle() yolunu kullanabilir.

Yeniden dışa aktarma, kodunuzun iç yapısı ile kodunuzu çağıran geliştiricilerin problem alanını (domain) düşünme biçimi birbirinden farklı olduğunda son derece yararlıdır. Örneğin bu restoran benzetmesinde işletmeciler işleri “ön kısım” ve “arka kısım” ayrımıyla düşünür; oysa müşteriler restoranın bölümlerini büyük olasılıkla bu kavramlarla düşünmez. pub use sayesinde kodumuzu içeride bir yapıyla geliştirebilir, dışarıya ise daha yalın ve farklı bir yapıyla sunabiliriz. Böylece kütüphanemiz hem üzerinde çalışan geliştiriciler hem de onu kullanan programcılar için iyi düzenlenmiş olur. Bölüm 14’teki “Kullanışlı Bir Açık API Dışa Aktarmak” başlığında bir başka pub use örneğini ve bunun crate dokümantasyonunu nasıl etkilediğini inceleyeceğiz.

Harici Paketleri Kullanma

Bölüm 2’de rastgele sayılar üretmek için rand adlı harici bir paketi kullanan bir tahmin oyunu projesi geliştirdik. rand paketini projemizde kullanmak için Cargo.toml dosyamıza şu satırı eklemiştik:

rand = "0.10.1"

Cargo.toml dosyasına rand paketini bir bağımlılık olarak eklemek, Cargo’ya rand paketini ve onun ihtiyaç duyduğu bağımlılıkları crates.io adresinden indirip projemiz için kullanılabilir hâle getirmesini söyler.

Ardından rand tanımlarını paketimizin kapsamına dahil etmek için crate’in adı olan rand ile başlayan bir use satırı ekledik ve kapsama dahil etmek istediğimiz öğeleri belirttik. Bölüm 2’deki “Rastgele Bir Sayı Üretmek” kısmında rand::prelude modülündeki öğeleri kapsama dahil ettiğimizi ve rand::rng fonksiyonunu çağırdığımızı hatırlayın:

use std::io;

use rand::prelude::*;

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    println!("Gizli sayı: {gizli_sayi}");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");
}

Rust topluluğunun üyeleri crates.io adresinde pek çok paketi kullanıma sunmuştur ve bunlardan herhangi birini kendi paketinize dahil etmek aynı adımları gerektirir: Paketi Cargo.toml dosyanızda listelemek ve crate’indeki öğeleri kapsamınıza dahil etmek için use kullanmak.

Standart kütüphane olan std’nin de paketimiz açısından harici bir crate olduğuna dikkat edin. Standart kütüphane Rust diliyle birlikte geldiğinden std’yi dahil etmek için Cargo.toml dosyamızı değiştirmemize gerek yoktur. Ancak oradaki öğeleri paketimizin kapsamına dahil etmek için yine de use ile başvurmamız gerekir. Örneğin HashMap için şu satırı kullanırız:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
}

Bu, standart kütüphane crate’inin adı olan std ile başlayan mutlak bir yoldur.

use Listelerini Sadeleştirmek İçin İç İçe Yollar Kullanma

Aynı crate’te ya da aynı modülde tanımlanmış birden çok öğeyi kullanıyorsak her bir öğeyi ayrı satırda listelemek dosyalarımızda dikey olarak çok yer kaplayabilir. Örneğin Liste 2-4’teki tahmin oyununda yer alan şu iki use deyimi std içinden öğeleri kapsama dahil eder:

// --snip--
use std::cmp::Ordering;
use std::io;
// --snip--

use rand::prelude::*;

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    println!("Gizli sayı: {gizli_sayi}");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    println!("Tahmininiz: {tahmin}");

    let tahmin: u32 = tahmin.trim().parse().expect("Lütfen bir sayı girin!");

    match tahmin.cmp(&gizli_sayi) {
        Ordering::Less => println!("Çok küçük!"),
        Ordering::Greater => println!("Çok büyük!"),
        Ordering::Equal => println!("Kazandınız!"),
    }
}

Bunun yerine aynı öğeleri tek satırda kapsama dahil etmek için iç içe yollar (nested paths) kullanabiliriz. Bunu Liste 7-18’de gösterildiği gibi yolun ortak kısmını, ardından çift iki nokta üst üste işaretini (::) ve yolların farklılaşan kısımlarını süslü parantezler içinde listeleyerek yaparız.

use rand::prelude::*;
// --snip--
use std::{cmp::Ordering, io};
// --snip--

fn main() {
    println!("Sayıyı tahmin et!");

    let gizli_sayi = rand::rng().random_range(1..=100);

    println!("Gizli sayı: {gizli_sayi}");

    println!("Lütfen tahmininizi girin.");

    let mut tahmin = String::new();

    io::stdin()
        .read_line(&mut tahmin)
        .expect("Satır okunamadı");

    let tahmin: u32 = tahmin.trim().parse().expect("Lütfen bir sayı yazın!");

    println!("Tahmininiz: {tahmin}");

    match tahmin.cmp(&gizli_sayi) {
        Ordering::Less => println!("Çok küçük!"),
        Ordering::Greater => println!("Çok büyük!"),
        Ordering::Equal => println!("Kazandınız!"),
    }
}

Daha büyük programlarda aynı crate’ten ya da modülden pek çok öğeyi iç içe yollarla kapsama dahil etmek, gereken ayrı use deyimlerinin sayısını önemli ölçüde azaltabilir!

İç içe yolu bir yolun herhangi bir seviyesinde kullanabiliriz; bu, alt yollardan birini paylaşan iki use deyimini birleştirirken işe yarar. Örneğin Liste 7-19 iki use deyimi gösterir: Biri std::io modülünü, diğeri ise std::io::Write öğesini kapsama dahil eder.

use std::io;
use std::io::Write;

Bu iki yolun ortak kısmı std::io’dur ve bu aynı zamanda birinci yolun tamamıdır. Bu iki yolu tek bir use deyiminde birleştirmek için Liste 7-20’de gösterildiği gibi iç içe yol içinde self anahtar kelimesini kullanabiliriz.

use std::io::{self, Write};

Bu satır hem std::io modülünü hem de std::io::Write öğesini kapsama dahil eder.

Glob Operatörü ile Öğeleri İçe Aktarma

Bir yolda tanımlı tüm açık öğeleri kapsama dahil etmek istiyorsak o yolun ardından * glob operatörünü yazabiliriz:

#![allow(unused)]
fn main() {
use std::collections::*;
}

Bu use deyimi, std::collections içinde tanımlı tüm açık öğeleri geçerli kapsama dahil eder. Glob operatörünü kullanırken dikkatli olun! Glob kullanımı, hangi isimlerin kapsamda bulunduğunu ve programınızda geçen bir ismin nerede tanımlandığını anlamanızı zorlaştırabilir. Ayrıca kullandığınız bağımlılık kendi tanımlarını değiştirirse içe aktardığınız öğeler de değişir; örneğin bağımlılık, aynı kapsamda sizin tanımladığınız bir öğeyle aynı adı taşıyan yeni bir tanım eklerse bağımlılığı güncellediğinizde derleyici hatalarıyla karşılaşabilirsiniz.

Glob operatörü, test yazarken test edilecek her şeyi tests modülünün içine almak için sıkça kullanılır; bunu Bölüm 11’deki “Nasıl Test Yazılır” kısmında ele alacağız. Glob operatörü bazen prelude (ön tanımlı kapsam) deseninin bir parçası olarak da kullanılır: Bu desen hakkında daha fazla bilgi için standart kütüphane dokümantasyonuna bakabilirsiniz.

Modülleri Farklı Dosyalara Ayırma

Modülleri Farklı Dosyalara Ayırma

Bu bölümdeki tüm örneklerde şimdiye kadar birden fazla modülü tek bir dosyada tanımladık. Modüller büyüdüğünde, kod içinde gezinmeyi kolaylaştırmak amacıyla modül tanımlarını ayrı dosyalara taşımak isteyebilirsiniz.

Örneğin, birden fazla restoran modülü barındıran Liste 7-17’deki koddan başlayalım. Tüm modülleri crate kök dosyasında tanımlamak yerine her birini ayrı dosyalara ayıracağız. Bu örnekte crate kök dosyası src/lib.rs dosyasıdır; ancak aynı yöntem, crate kök dosyası src/main.rs olan ikili crate’lerde de işe yarar.

İlk olarak restoran_on_kisim modülünü kendi dosyasına çıkaracağız. restoran_on_kisim modülünün süslü parantezleri arasındaki kodu kaldırıp geriye yalnızca mod restoran_on_kisim; bildirimini bırakın; böylece src/lib.rs dosyası Liste 7-21’deki hâlini alacaktır. Liste 7-22’deki src/restoran_on_kisim.rs dosyasını oluşturana kadar bu kodun derlenmeyeceğini unutmayın.

mod restoran_on_kisim;

pub use crate::restoran_on_kisim::karsilama;

pub fn restoranda_yemek_ye() {
    karsilama::bekleme_listesine_ekle();
}

Ardından, daha önce süslü parantezlerin içinde yer alan kodu Liste 7-22’de gösterildiği gibi src/restoran_on_kisim.rs adlı yeni bir dosyaya yerleştirin. Derleyici, crate kökünde restoran_on_kisim adında gövdesiz bir modül bildirimiyle (mod restoran_on_kisim;) karşılaştığı için modülün kodunu bu dosyada araması gerektiğini bilir.

pub mod karsilama {
    pub fn bekleme_listesine_ekle() {}
}

Modül ağacınızda bir dosyayı yüklemek için mod bildirimini yalnızca bir kez kullanmanız gerektiğine dikkat edin. Derleyici, dosyanın projenin bir parçası olduğunu ve mod deyimini koyduğunuz yere göre kodun modül ağacının neresinde konumlandığını bu tek bildirimle öğrenir. Bundan sonra projenizdeki diğer dosyalar, yüklenen bu dosyanın koduna “Modül Ağacındaki Bir Öğeye Başvurmak İçin Yollar” kısmında ele aldığımız gibi modülün bildirildiği konuma giden bir yol üzerinden başvurmalıdır. Başka bir deyişle mod, diğer programlama dillerinde görmüş olabileceğiniz C/C++ #include veya Python/JavaScript import benzeri bir dosya içe aktarma işlemi değildir.

Şimdi de karsilama modülünü kendi dosyasına çıkaracağız. Bu süreç biraz farklıdır; çünkü karsilama, kök modülün değil restoran_on_kisim modülünün bir alt modülüdür. karsilama modülünün dosyasını, modül ağacındaki ata modüllerinin adını taşıyacak yeni bir dizine — bu örnekte src/restoran_on_kisim dizinine — yerleştireceğiz.

karsilama modülünü taşımaya başlamak için src/restoran_on_kisim.rs dosyasını yalnızca karsilama modülünün bildirimini içerecek şekilde değiştiriyoruz:

pub mod karsilama;

Ardından src/restoran_on_kisim adında bir dizin ve bu dizinin içinde karsilama modülündeki tanımları barındıracak karsilama.rs dosyasını oluşturuyoruz:

pub fn bekleme_listesine_ekle() {}

Eğer bunun yerine karsilama.rs dosyasını doğrudan src dizinine koysaydık derleyici, karsilama.rs içindeki kodun restoran_on_kisim modülünün bir alt modülü olarak değil, doğrudan crate kökünde bildirilen bir karsilama modülünde yer almasını beklerdi. Derleyicinin hangi modülün kodu için hangi dosyaya bakacağını belirleyen kuralları sayesinde, dizin ve dosya yapısı modül ağacıyla birebir örtüşür.

Her modülün kodunu ayrı bir dosyaya taşıdık ve modül ağacı aynı kaldı. restoranda_yemek_ye içindeki fonksiyon çağrıları, tanımlar artık farklı dosyalarda bulunsa bile hiçbir değişiklik gerektirmeden çalışmaya devam edecektir. Bu teknik, modüller büyüdükçe onları yeni dosyalara taşımanıza olanak tanır.

src/lib.rs içindeki pub use crate::restoran_on_kisim::karsilama deyiminin de değişmediğine ve use anahtar kelimesinin crate’in bir parçası olarak hangi dosyaların derlendiği üzerinde hiçbir etkisi olmadığına dikkat edin. mod anahtar kelimesi modülleri bildirir; Rust da o modülün içeriğini oluşturacak kod için modülle aynı adı taşıyan dosyaya bakar.

Özet

Rust, bir paketi birden fazla crate’e ve bir crate’i birden fazla modüle bölmenize, aynı zamanda bir modülde tanımlanan öğelere başka bir modülden başvurabilmenize olanak tanır. Bunu mutlak veya göreli yollar belirterek yapabilirsiniz. Bu yollar, aynı kapsamda bir öğeyi birden fazla kez kullanırken daha kısa bir isim yazabilmeniz için use deyimiyle kapsama dahil edilebilir. Modül kodu varsayılan olarak gizlidir; ancak pub anahtar kelimesini ekleyerek tanımları dışarıya açık hâle getirebilirsiniz.

Bir sonraki bölümde, standart kütüphanede yer alan ve düzenli biçimde yapılandırdığınız kodunuzda kullanabileceğiniz bazı koleksiyon veri yapılarını inceleyeceğiz.

Yaygın Koleksiyonlar

Rust’ın standart kütüphanesi, koleksiyonlar (collections) adı verilen oldukça kullanışlı pek çok veri yapısı içerir. Diğer veri türlerinin çoğu belirli tek bir değeri temsil ederken, koleksiyonlar birden fazla değeri barındırabilir. Yerleşik dizi ve demet türlerinin aksine, bu koleksiyonların işaret ettiği veriler öbekte (heap) saklanır; bu da veri miktarının derleme zamanında bilinmesi gerekmediği ve program çalışırken büyüyüp küçülebileceği anlamına gelir. Her koleksiyon türünün farklı yetenekleri ve maliyetleri vardır; mevcut durumunuza en uygun olanı seçmek zamanla geliştireceğiniz bir beceridir. Bu bölümde, Rust programlarında çok sık kullanılan üç koleksiyonu ele alacağız:

• Bir vektör (Vec<T>), değişken sayıda değeri bellekte yan yana saklamanızı sağlar.
• Bir string (String), karakterlerden oluşan bir koleksiyondur. Daha önce String türünden bahsetmiştik; ancak bu bölümde onu derinlemesine inceleyeceğiz.
• Bir hash map (HashMap<K, V>), bir değeri belirli bir anahtarla ilişkilendirmenizi sağlar. Bu tür, eşlem (map) adı verilen daha genel bir veri yapısının özel bir uygulamasıdır.

Standart kütüphane tarafından sağlanan diğer koleksiyon türleri hakkında bilgi edinmek için standart kütüphane belgelendirmesine göz atabilirsiniz.

Şimdi vektörlerin, string’lerin ve hash map’lerin nasıl oluşturulup güncelleneceğini ve her birini neyin özel kıldığını inceleyeceğiz.

Vektörlerle Değer Listeleri Saklama

Vektörlerle Değer Listeleri Saklama

İnceleyeceğimiz ilk koleksiyon türü, vektör (vector) olarak da bilinen Vec<T> türüdür. Vektörler, tüm değerleri bellekte yan yana yerleştiren tek bir veri yapısı içinde birden fazla değer saklamanızı sağlar. Vektörler yalnızca aynı türdeki değerleri tutabilir. Bir dosyadaki metin satırları veya bir alışveriş sepetindeki ürünlerin fiyatları gibi bir öğe listeniz olduğunda oldukça kullanışlıdırlar.

Yeni Bir Vektör Oluşturma

Yeni ve boş bir vektör oluşturmak için Liste 8-1’de gösterildiği gibi Vec::new fonksiyonunu çağırırız.

fn main() {
    let v: Vec<i32> = Vec::new();
}

Burada açık bir tür bildirimi eklediğimize dikkat edin. Bu vektöre herhangi bir değer eklemediğimiz için Rust, ne tür elemanlar saklamayı planladığımızı bilemez. Bu önemli bir noktadır. Vektörler jenerikler kullanılarak uygulanmıştır; kendi türlerinizle jenerikleri nasıl kullanacağınızı Bölüm 10’da ele alacağız. Şimdilik standart kütüphanenin sunduğu Vec<T> türünün herhangi bir türü barındırabileceğini bilmeniz yeterlidir. Belirli bir türü tutacak bir vektör oluşturduğumuzda, bu türü açılı parantezler (< >) içinde belirtebiliriz. Liste 8-1’de Rust’a, v değişkenindeki Vec<T> yapısının i32 türünden elemanlar tutacağını söyledik.

Çoğu zaman başlangıç değerlerine sahip bir Vec<T> oluşturursunuz ve Rust saklamak istediğiniz değerin türünü kendiliğinden çıkarır; bu nedenle açık tür bildirimine nadiren ihtiyaç duyarsınız. Rust bu amaçla, verdiğiniz değerleri tutan yeni bir vektör oluşturan kullanışlı vec! makrosunu sunar. Liste 8-2; 1, 2 ve 3 değerlerini tutan yeni bir Vec<i32> oluşturur. Tam sayı türünün i32 olmasının nedeni, Bölüm 3’teki “Veri Türleri” kısmında ele aldığımız üzere varsayılan tam sayı türünün i32 olmasıdır.

fn main() {
    let v = vec![1, 2, 3];
}

Başlangıçta i32 değerleri verdiğimiz için Rust, v’nin türünün Vec<i32> olduğunu çıkarabilir ve tür bildirimine gerek kalmaz. Şimdi bir vektörün nasıl değiştirileceğine bakalım.

Bir Vektörü Güncelleme

Bir vektör oluşturup ardından ona elemanlar eklemek için Liste 8-3’te gösterildiği gibi push metodunu kullanabiliriz.

fn main() {
    let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);
}

Bölüm 3’te ele aldığımız üzere, her değişkende olduğu gibi değerini değiştirebilmek istiyorsak onu mut anahtar kelimesiyle değiştirilebilir yapmamız gerekir. İçine yerleştirdiğimiz sayıların tamamı i32 türündedir ve Rust bunu veriden çıkarabildiği için Vec<i32> tür bildirimine ihtiyacımız yoktur.

Vektörlerin Elemanlarını Okuma

Bir vektörde saklanan bir değere başvurmanın iki yolu vardır: indeksleme yoluyla veya get metodunu kullanarak. Aşağıdaki örneklerde, daha net anlaşılması adına bu işlemlerden döndürülen değerlerin türlerini açıkça belirttik.

Liste 8-4, indeksleme sözdizimi ve get metodu ile bir vektördeki değere erişmenin her iki yolunu da gösterir.

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let ucuncu: &i32 = &v[2];
    println!("Üçüncü eleman: {ucuncu}");

    let ucuncu: Option<&i32> = v.get(2);
    match ucuncu {
        Some(ucuncu) => println!("Üçüncü eleman: {ucuncu}"),
        None => println!("Üçüncü bir eleman yok."),
    }
}

Buradaki birkaç ayrıntıya dikkat edin. Vektörler sıfırdan başlayarak sayılarla indekslendiği için üçüncü elemanı almak üzere 2 indeks değerini kullanırız. & ve [] kullanmak bize ilgili indeksteki elemana bir referans (&i32) verir. İndeksi argüman olarak geçirerek get metodunu kullandığımızda ise match ile işleyebileceğimiz bir Option<&T> elde ederiz.

Rust, mevcut eleman aralığının dışındaki bir indeks değerini kullanmaya çalıştığınızda programın nasıl davranacağını seçebilmeniz için elemana erişmenin bu iki yolunu sunar. Örnek olarak, beş elemanlı bir vektörümüz olduğunda ve Liste 8-5’te gösterildiği gibi her iki yöntemle indeksi 100 olan elemana erişmeye çalıştığımızda ne olacağına bakalım.

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let olmayan_eleman = &v[100];
    let olmayan_eleman = v.get(100);
}

Bu kodu çalıştırdığımızda, ilk satırdaki [] yöntemi var olmayan bir elemana başvurduğu için programın panik yapmasına neden olur. Bu yöntem, vektörün sonunu aşan bir elemana erişilmeye çalışıldığında programınızın anında durmasını istiyorsanız en uygun seçenektir.

get metoduna vektör sınırlarının dışında bir indeks geçirildiğinde ise metot panik yapmadan None döndürür. Normal çalışma koşullarında vektör aralığının dışındaki bir elemana erişme ihtimali varsa bu yöntemi tercih edersiniz. Bu durumda kodunuz, Bölüm 6’da ele aldığımız gibi Some(&eleman) veya None olasılıklarının her ikisini de yönetecek mantığa sahip olur. Örneğin indeks değeri kullanıcının klavyeden girdiği bir sayıdan geliyor olabilir. Kullanıcı yanlışlıkla çok büyük bir sayı girerse ve program None değeri alırsa, kullanıcıya mevcut vektörde kaç öğe bulunduğunu bildirip geçerli bir değer girmesi için yeni bir şans tanıyabilirsiniz. Bu yaklaşım, basit bir yazım hatası yüzünden programı çökertmekten çok daha kullanıcı dostudur!

Program geçerli bir referans elde ettiğinde, ödünç alma denetleyicisi (borrow checker) bu referansın ve vektör içeriğine yönelik diğer tüm referansların geçerli kalmasını güvence altına almak için (Bölüm 4’te incelenen) sahiplik ve ödünç alma kurallarını uygular. Aynı kapsamda hem değiştirilebilir hem de değiştirilemez referanslara sahip olamayacağınızı söyleyen kuralı hatırlayın. Bu kural, bir vektördeki ilk elemana değiştirilemez bir referans (ilk) tutarken vektörün sonuna yeni bir eleman eklemeye çalıştığımız Liste 8-6’da devreye girer. Fonksiyonun devamında bu referansı tekrar kullanmaya çalıştığımız için program derlenmeyecektir.

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    let ilk = &v[0];

    v.push(6);

    println!("İlk eleman: {ilk}");
}

Bu kodu derlemek aşağıdaki hatayla sonuçlanır:

$ cargo run
   Compiling koleksiyonlar v0.1.0 (file:///projects/koleksiyonlar)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:6:5
  |
4 |     let ilk = &v[0];
  |                - immutable borrow occurs here
5 |
6 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
7 |
8 |     println!("İlk eleman: {ilk}");
  |                            --- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `koleksiyonlar` (bin "koleksiyonlar") due to 1 previous error

Liste 8-6’daki kod ilk bakışta çalışması gerekiyormuş gibi görünebilir: İlk elemana tutulan bir referans, vektörün sonuna yapılan eklemeyi neden umursasın ki? Bu hatanın nedeni vektörlerin bellekte çalışma biçimidir: Vektörler tüm değerleri öbekte (heap) yan yana sakladığından, vektörün sonuna yeni bir eleman eklemek — eğer vektörün şu anda tutulduğu bellek bölgesinde tüm elemanları yan yana sığdıracak yeterli boş kapasite kalmadıysa — öbekte daha büyük yeni bir bellek alanı tahsis etmeyi, eski elemanları bu yeni alana kopyalamayı ve eski bellek alanını serbest bırakmayı gerektirebilir. Böyle bir yeniden tahsis (reallocation) gerçekleştiğinde, ilk elemana tutulan ilk referansı artık serbest bırakılmış geçersiz bir bellek adresine (sarkan referans) işaret ediyor olurdu. Ödünç alma kuralları, programların bu tehlikeli duruma düşmesini derleme zamanında engeller.

Bir Vektördeki Değerler Üzerinde Yineleme Yapma

Bir vektördeki her bir elemana sırayla erişmek istediğimizde, indeks kullanarak tek tek erişmek yerine tüm elemanlar üzerinde yineleme (iteration) yaparız. Liste 8-7, i32 değerlerinden oluşan bir vektörün her bir elemanına değiştirilemez referanslar almak ve bunları yazdırmak için for döngüsünün nasıl kullanılacağını gösterir.

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
        println!("{i}");
    }
}

Tüm elemanlarda değişiklik yapmak amacıyla değiştirilebilir bir vektördeki her elemanın değiştirilebilir referansı üzerinde de yineleme yapabiliriz. Liste 8-8’deki for döngüsü her bir elemana 50 ekleyecektir.

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }
}

Değiştirilebilir referansın işaret ettiği değeri değiştirmek için, += operatörünü kullanmadan önce i içindeki değere ulaşmak amacıyla * başvuru çözme operatörünü (dereference operator) kullanmamız gerekir (i değişkeninin türü &mut i32 olduğundan, *i ifadesi referansı takip ederek asıl i32 değerine erişir). Başvuru çözme operatörü hakkında daha ayrıntılı bilgiyi Bölüm 15’teki “Referansı İzleyerek Değere Ulaşmak” kısmında ele alacağız.

Bir vektör üzerinde ister değiştirilemez ister değiştirilebilir şekilde yineleme yapmak, ödünç alma denetleyicisinin kuralları sayesinde tamamen güvenlidir. Liste 8-7 ve Liste 8-8’deki for döngüsü gövdelerinin içinde vektöre öğe eklemeye veya vektörden öğe çıkarmaya çalışsaydık, Liste 8-6’daki kodda aldığımıza benzer bir derleyici hatası alırdık. for döngüsünün vektöre tuttuğu referans, döngü devam ederken vektörün bütününün eşzamanlı olarak değiştirilmesini engeller.

Birden Fazla Türü Saklamak İçin Enum Kullanma

Vektörler yalnızca aynı türdeki değerleri saklayabilir. Bu kısıtlama kimi zaman zahmetli görünebilir; farklı türlerdeki öğelerden oluşan bir listeyi saklamaya ihtiyaç duyduğumuz kullanım senaryoları kesinlikle vardır. Neyse ki bir enum’ın tüm varyantları aynı enum türü altında tanımlanır; dolayısıyla farklı türlerdeki elemanları temsil edecek tek bir türe ihtiyaç duyduğumuzda bir enum tanımlayıp kullanabiliriz!

Örneğin bir elektronik tablodaki bir satırdan değerler almak istediğimizi ve bu satırdaki bazı sütunların tam sayılar, bazılarının kayan noktalı sayılar, bazılarının ise metinler (String) içerdiğini varsayalım. Varyantları bu farklı değer türlerini barındıracak bir enum tanımlayabiliriz; böylece tüm varyantlar aynı tür — yani tanımladığımız enum türü — olarak kabul edilir. Ardından bu enum türünü tutacak bir vektör oluşturarak dolaylı yoldan farklı türlerdeki verileri bir arada saklayabiliriz. Bunu Liste 8-9’da gösterdik.

fn main() {
    enum ElektronikTabloHucresi {
        Tamsayi(i32),
        Ondalikli(f64),
        Metin(String),
    }

    let satir = vec![
        ElektronikTabloHucresi::Tamsayi(3),
        ElektronikTabloHucresi::Metin(String::from("mavi")),
        ElektronikTabloHucresi::Ondalikli(10.12),
    ];
}

Rust’ın her bir elemanı öbekte saklamak için tam olarak ne kadar bellek gerekeceğini belirleyebilmesi için, vektörde hangi türlerin yer alacağını derleme zamanında bilmesi gerekir. Ayrıca bu vektörde hangi türlere izin verildiğini açıkça belirtmemiz gerekir. Eğer Rust bir vektörün herhangi bir türü barındırmasına izin verseydi, elemanlar üzerinde gerçekleştirilen işlemlerde bu türlerden bir veya birkaçının hataya yol açma riski doğardı. Bir enum ile birlikte match ifadesi kullanmak, Bölüm 6’da ele aldığımız gibi Rust’ın olası her durumun işlendiğini derleme zamanında garanti altına almasını sağlar.

Programınızın çalışma zamanında vektörde saklamak üzere karşılaşacağı tüm türlerin kümesini önceden bilmiyorsanız enum tekniği işinize yaramayacaktır. Bunun yerine, Bölüm 18’de inceleyeceğimiz bir trait nesnesi (trait object) kullanabilirsiniz.

Vektörleri kullanmanın en yaygın yollarından bazılarını ele aldığımıza göre, standart kütüphanenin Vec<T> üzerinde tanımladığı diğer pek çok kullanışlı metodu görmek için API belgelendirmesini mutlaka inceleyin. Örneğin push metoduna ek olarak pop metodu, vektörün son elemanını çıkarıp (Option<T> olarak) döndürür.

Bir Vektörü Düşürmek Elemanlarını da Düşürür

Diğer herhangi bir struct gibi bir vektör de Liste 8-10’da gösterildiği üzere kapsam dışına çıktığında bellekten serbest bırakılır.

fn main() {
    {
        let v = vec![1, 2, 3, 4];

        // v ile bir şeyler yapın
    } // <- v kapsam dışına çıkar ve burada serbest bırakılır
}

Vektör düşürüldüğünde tüm içeriği de düşürülür; yani barındırdığı tam sayılar (veya String gibi kendisi de öbek belleğine sahip karmaşık öğeler varsa bunların öbek verileri) bellekten temizlenir. Ödünç alma denetleyicisi, bir vektörün içeriğine yapılan herhangi bir referansın yalnızca vektörün kendisi geçerliyken kullanılmasını güvence altına alır.

Şimdi bir sonraki koleksiyon türüne geçelim: String!

String'lerle UTF-8 Kodlanmış Metin Saklama

String’lerle UTF-8 Kodlanmış Metin Saklama

Bölüm 4’te string’lerden bahsetmiştik; şimdi onları daha derinlemesine inceleyeceğiz. Rust’a yeni başlayanlar genellikle üç nedenin bir araya gelmesi yüzünden string’lerde takılır: Rust’ın olası hataları erkenden açığa çıkarma eğilimi, string’lerin pek çok programcının sandığından çok daha karmaşık bir veri yapısı olması ve UTF-8 kodlaması. Başka programlama dillerinden geliyorsanız bu etkenlerin birleşimi ilk başta zor görünebilir.

String’leri koleksiyonlar bağlamında ele alıyoruz; çünkü string’ler bir bayt koleksiyonu ve bu baytlar metin olarak yorumlandığında faydalı işlevler sunan metotlar bütünü olarak uygulanmıştır. Bu bölümde, her koleksiyon türünde bulunan oluşturma, güncelleme ve okuma gibi String üzerindeki temel işlemleri inceleyeceğiz. Ayrıca String’in diğer koleksiyonlardan ayrıldığı yönleri, özellikle de insanların ve bilgisayarların String verisini yorumlama biçimleri arasındaki farklar yüzünden bir String içine indeksleme yapmanın neden karmaşık olduğunu ele alacağız.

String’leri Tanımlama

Öncelikle string terimiyle ne kastettiğimizi tanımlayalım. Rust’ın çekirdek dilinde yalnızca tek bir string türü vardır: genellikle ödünç alınmış biçimi olan &str şeklinde gördüğümüz str string dilimi. Bölüm 4’te, başka bir yerde saklanan UTF-8 kodlu metin verilerine referans veren string dilimlerinden bahsetmiştik. Örneğin string sabitleri (string literals) programın ikili dosyasında saklanır ve bu nedenle birer string dilimidir.

Çekirdek dile yerleşik olmak yerine Rust’ın standart kütüphanesi tarafından sağlanan String türü ise büyüyebilen, değiştirilebilir, sahipli (owned) ve UTF-8 kodlu bir string türüdür (verisini öbekte, yani heap üzerinde tutar). Rust geliştiricileri Rust’taki “string’lerden” söz ettiğinde, bu türlerden yalnızca birini değil, hem String hem de string dilimi &str türlerini kastediyor olabilir. Bu bölüm büyük ölçüde String üzerine odaklanacak olsa da her iki tür de Rust’ın standart kütüphanesinde yoğun biçimde kullanılır ve hem String hem de string dilimleri UTF-8 kodludur.

Yeni Bir String Oluşturma

Vec<T> ile kullanılabilen işlemlerin birçoğu String için de geçerlidir; çünkü String, ek birtakım güvenceler, kısıtlamalar ve yeteneklerle donatılmış bir bayt vektörü sarmalayıcısı olarak uygulanmıştır. Vec<T> ve String ile aynı şekilde çalışan fonksiyonlara güzel bir örnek, Liste 8-11’de gösterildiği gibi yeni bir örnek oluşturmak için kullanılan new fonksiyonudur.

fn main() {
    let mut s = String::new();
}

Bu satır, daha sonra içine veri yükleyebileceğimiz s adında yeni ve boş bir string oluşturur. Çoğu zaman string’i başlatmak istediğimiz bir başlangıç verimiz olur. Bunun için, string sabitlerinin de uyguladığı Display trait’ini uygulayan her tür üzerinde kullanılabilen to_string metodundan yararlanırız. Liste 8-12 iki örnek göstermektedir.

fn main() {
    let veri = "başlangıç içeriği";

    let s = veri.to_string();

    // Bu metot doğrudan bir string sabiti üzerinde de çalışır:
    let s = "başlangıç içeriği".to_string();
}

Bu kod, başlangıç içeriği metnini barındıran bir string oluşturur.

Bir string sabitinden String oluşturmak için String::from fonksiyonunu da kullanabiliriz. Liste 8-13’teki kod, to_string kullanan Liste 8-12’deki kodla tamamen eşdeğerdir.

fn main() {
    let s = String::from("başlangıç içeriği");
}

String’ler çok çeşitli amaçlarla kullanıldığından, string’lerle çalışmak için bize pek çok seçenek sunan farklı jenerik API’ler mevcuttur. Bunların bazıları ilk bakışta fazlalık gibi görünebilir, ancak hepsinin kendine özgü bir kullanım yeri vardır! Bu örnekte String::from ve to_string birebir aynı işi yapar; hangisini seçeceğiniz tamamen stil ve okunabilirlik tercihinize bağlıdır.

String’lerin UTF-8 kodlu olduğunu unutmayın; dolayısıyla Liste 8-14’te gösterildiği gibi uygun biçimde kodlanmış her türlü metin verisini içlerinde saklayabiliriz.

fn main() {
    let merhaba = String::from("السلام عليكم");
    let merhaba = String::from("Dobrý den");
    let merhaba = String::from("Hello");
    let merhaba = String::from("שלום");
    let merhaba = String::from("नमस्ते");
    let merhaba = String::from("こんにちは");
    let merhaba = String::from("안녕하세요");
    let merhaba = String::from("你好");
    let merhaba = String::from("Olá");
    let merhaba = String::from("Здравствуйте");
    let merhaba = String::from("Hola");
}

Bunların tamamı geçerli String değerleridir.

Bir String’i Güncelleme

Bir String’in boyutu büyüyebilir ve tıpkı Vec<T> türünde olduğu gibi, içine daha fazla veri ekledikçe içeriği değişebilir. Ek olarak, String değerlerini birleştirmek için + operatörünü veya format! makrosunu rahatlıkla kullanabilirsiniz.

push_str veya push ile Ekleme Yapma

Liste 8-15’te gösterildiği gibi, bir string dilimi eklemek üzere push_str metodunu kullanarak bir String’i büyütebiliriz.

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar");
}

Bu iki satırdan sonra s değişkeni foobar değerini barındıracaktır. push_str metodu bir string dilimi alır; çünkü eklediğimiz parametrenin sahipliğini almak istemeyebiliriz. Örneğin Liste 8-16’daki kodda, s2’nin içeriğini s1’e ekledikten sonra da s2’yi kullanabilmek istiyoruz.

fn main() {
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2);
    println!("s2 değeri: {s2}");
}

Eğer push_str metodu s2’nin sahipliğini alsaydı, son satırda değerini yazdıramazdık. Oysa bu kod tam beklediğimiz gibi çalışır!

push metodu ise parametre olarak tek bir karakter (char) alır ve onu String’in sonuna ekler. Liste 8-17, push metodunu kullanarak bir String’e l harfini eklemektedir.

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}

Bunun sonucunda s değişkeni lol değerini içerecektir.

+ veya format! ile Birleştirme

Çoğu zaman mevcut iki string’i birleştirmek istersiniz. Bunu yapmanın yollarından biri, Liste 8-18’de gösterildiği gibi + operatörünü kullanmaktır.

fn main() {
    let s1 = String::from("Merhaba, ");
    let s2 = String::from("dünya!");
    let s3 = s1 + &s2; // not: s1 buraya taşındı ve artık kullanılamaz
}

s3 string’i Merhaba, dünya! metnini barındıracaktır. Birleştirme işleminden sonra s1’in neden artık geçerli olmadığını ve s2 için neden bir referans kullandığımızı, + operatörünü kullandığımızda çağrılan metodun imzası açıklar. + operatörü, imzası şuna benzeyen add metodunu çağırır:

fn add(self, s: &str) -> String {

Standart kütüphanede add metodunun jenerikler ve ilişkili türler kullanılarak tanımlandığını görürsünüz. Burada jeneriklerin yerine, bu metodu String değerleriyle çağırdığımızda ortaya çıkan somut türleri yazdık. Jenerikleri Bölüm 10’da ele alacağız. Bu imza, + operatörünün incelikli kısımlarını anlamamız için gereken ipuçlarını verir.

İlk olarak, s2’nin başında & vardır; yani ilk string’e ikinci string’in bir referansını ekliyoruz. Bunun nedeni add fonksiyonundaki s parametresidir: Bir String’e yalnızca bir string dilimi (&str) ekleyebiliriz; iki String değerini doğrudan birbirine ekleyemeyiz. Ama bir dakika — &s2 ifadesinin türü, add’in ikinci parametresinde belirtildiği gibi &str değil, &String türüdür. Öyleyse Liste 8-18 neden derleniyor?

add çağrısında &s2’yi kullanabilmemizin nedeni, derleyicinin &String argümanını &str türüne zorlayabilmesidir. add metodunu çağırdığımızda Rust, burada &s2 ifadesini &s2[..] dilimine dönüştüren bir deref zorlaması (deref coercion) uygular. Deref zorlamasını Bölüm 15’te daha derinlemesine inceleyeceğiz. add metodu s parametresinin sahipliğini almadığı için s2, bu işlemden sonra da geçerli bir String olarak kalır.

İkinci olarak, imzada self parametresinin başında & bulunmadığı için add metodunun self’in sahipliğini aldığını görebiliriz. Bu durum, Liste 8-18’deki s1 değişkeninin add çağrısının içine taşınacağı ve sonrasında artık geçerli olmayacağı anlamına gelir. Dolayısıyla let s3 = s1 + &s2; deyimi her iki string’i kopyalayıp yeni bir string oluşturacakmış gibi görünse de aslında s1’in sahipliğini alır, s2’nin içeriğinin bir kopyasını onun sonuna ekler ve ardından sonuç değerinin sahipliğini döndürür. Başka bir deyişle, çok sayıda kopyalama yapıyormuş gibi görünse de yapmaz; bu uygulama kopyalamaktan çok daha verimlidir.

Birden fazla string’i birleştirmemiz gerektiğinde + operatörünün kullanımı hantal bir hâl alır:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

Bu noktada s değişkeninin değeri tic-tac-toe olur. Ancak bunca + ve " karakteri arasında ne olup bittiğini anlamak güçtür. String’leri daha karmaşık biçimlerde birleştirmek için bunun yerine format! makrosunu kullanabiliriz:

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = String::from("toe");

    let s = format!("{s1}-{s2}-{s3}");
}

Bu kod da s değişkenini tic-tac-toe olarak ayarlar. format! makrosu tıpkı println! gibi çalışır; ancak çıktıyı ekrana yazdırmak yerine içeriği barındıran yeni bir String döndürür. format! kullanan sürüm çok daha kolay okunur; üstelik format! makrosunun ürettiği kod referansları kullandığından parametrelerinin hiçbirinin sahipliğini almaz.

String’leri İndeksleme

Diğer pek çok programlama dilinde, bir string içindeki tekil karakterlere indeks numarasıyla başvurarak erişmek geçerli ve yaygın bir işlemdir. Ancak Rust’ta indeksleme sözdizimini kullanarak bir String’in parçalarına erişmeye çalışırsanız derleme hatası alırsınız. Liste 8-19’daki geçersiz kodu inceleyelim.

fn main() {
    let s1 = String::from("merhaba");
    let m = s1[0];
}

Bu kod aşağıdaki hatayla sonuçlanacaktır:

$ cargo run
   Compiling koleksiyonlar v0.1.0 (file:///projects/koleksiyonlar)
error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:16
  |
3 |     let m = s1[0];
  |                ^ string indices are ranges of `usize`
  |
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
help: `usize` implements trait `SliceIndex<T>`
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/slice/index.rs:179:0
  |
  = note: `SliceIndex<[T]>`
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/bstr/traits.rs:197:0
  |
  = note: `SliceIndex<ByteStr>`
  = note: required for `String` to implement `Index<{integer}>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `koleksiyonlar` (bin "koleksiyonlar") due to 1 previous error

Hata mesajı durumu açıkça özetliyor: Rust string’leri tam sayıyla indekslemeyi desteklemez (the type `str` cannot be indexed by `{integer}` — derleyici bunun yerine .chars().nth() veya .bytes().nth() kullanılabileceğini belirtir). Peki ama neden? Bu soruyu yanıtlamak için Rust’ın string’leri bellekte nasıl sakladığını incelememiz gerekir.

İç Temsil

Bir String, bir Vec<u8> üzerindeki sarmalayıcıdır. Liste 8-14’teki uygun biçimde kodlanmış UTF-8 örnek string’lerimizden bazılarına bakalım. İlk olarak şunu ele alalım:

fn main() {
    let merhaba = String::from("السلام عليكم");
    let merhaba = String::from("Dobrý den");
    let merhaba = String::from("Hello");
    let merhaba = String::from("שלום");
    let merhaba = String::from("नमस्ते");
    let merhaba = String::from("こんにちは");
    let merhaba = String::from("안녕하세요");
    let merhaba = String::from("你好");
    let merhaba = String::from("Olá");
    let merhaba = String::from("Здравствуйте");
    let merhaba = String::from("Hola");
}

Bu durumda uzunluk (merhaba.len()) 4 olacaktır; yani "Hola" string’ini saklayan vektör 4 bayt uzunluğundadır. UTF-8 ile kodlandığında bu harflerin her biri 1 bayt yer kaplar. Ancak aşağıdaki satır sizi şaşırtabilir (bu string’in 3 rakamıyla değil, büyük Kiril harfi Ze (З) ile başladığına dikkat edin):

fn main() {
    let merhaba = String::from("السلام عليكم");
    let merhaba = String::from("Dobrý den");
    let merhaba = String::from("Hello");
    let merhaba = String::from("שלום");
    let merhaba = String::from("नमस्ते");
    let merhaba = String::from("こんにちは");
    let merhaba = String::from("안녕하세요");
    let merhaba = String::from("你好");
    let merhaba = String::from("Olá");
    let merhaba = String::from("Здравствуйте");
    let merhaba = String::from("Hola");
}

Bu string’in ne kadar uzun olduğu sorulsaydı 12 diyebilirdiniz. Oysa Rust’ın yanıtı 24’tür: "Здравствуйте" metnini UTF-8 ile kodlamak için gereken bayt sayısı budur; çünkü bu string’deki her bir Unicode skaler değeri bellekte 2 bayt yer kaplar. Dolayısıyla string’in baytları üzerindeki bir indeks her zaman geçerli bir Unicode skaler değerine karşılık gelmez. Bunu görmek için şu geçersiz Rust kodunu düşünün:

let merhaba = "Здравствуйте";
let cevap = &merhaba[0];

cevap değişkeninin ilk harf olan З olmayacağını artık biliyorsunuz. UTF-8 ile kodlandığında З harfinin ilk baytı 208, ikincisi ise 151’dir; dolayısıyla cevap değerinin 208 olması gerekirmiş gibi görünür, ancak 208 tek başına geçerli bir karakter değildir. Bu string’in ilk harfini isteyen bir kullanıcı büyük olasılıkla 208 sayısının dönmesini istemeyecektir; fakat Rust’ın bayt indeksi 0’da sahip olduğu tek veri budur. String yalnızca Latin harfleri içerse bile kullanıcılar genellikle ham bayt değerinin dönmesini istemez: &"hi"[0] bayt değerini döndüren geçerli bir kod olsaydı 'h' değil, 104 döndürürdü.

Sonuç olarak Rust, beklenmedik bir değer döndürmekten ve hemen fark edilemeyecek hatalara yol açmaktan kaçınmak için bu kodu hiç derlemez ve olası yanlış anlaşılmaları geliştirme sürecinin henüz başında engeller.

Baytlar, Skaler Değerler ve Grafem Kümeleri

UTF-8 ile ilgili bir diğer önemli nokta da Rust açısından string’leri ele almanın aslında üç farklı yolu olmasıdır: baytlar (bytes), skaler değerler (scalar values) ve grafem kümeleri (grapheme clusters) — yani bizim günlük dilde harf dediğimiz şeye en yakın birimler.

Devanagari alfabesiyle yazılmış Hintçe “नमस्ते” kelimesine bakarsak, bu kelime bellekte şu şekilde bir u8 değerleri vektörü olarak saklanır:

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

Bu 18 bayttır ve bilgisayarların bu veriyi nihayetinde bellekte saklama biçimidir. Aynı veriye Rust’ın char türünün karşılığı olan Unicode skaler değerleri olarak bakarsak veri şöyle görünür:

['न', 'म', 'स', '्', 'त', 'े']

Burada altı adet char değeri vardır; ancak dördüncü ve altıncı öğeler tek başına harf değildir: Bunlar kendi başlarına anlam taşımayan birleştirici ses/aksan işaretleridir (diacritics). Son olarak, aynı veriye grafem kümeleri olarak bakarsak bir insanın bu Hintçe kelimeyi oluşturan dört harf diye adlandıracağı birimleri elde ederiz:

["न", "म", "स्", "ते"]

Rust, metin hangi insan dilinde olursa olsun her programın kendi ihtiyacına uygun yorumlama biçimini seçebilmesi için bilgisayarların sakladığı ham string verisini yorumlamanın farklı yollarını sunar.

Rust’ın bir karakter elde etmek amacıyla String içine indeksleme yapmamıza izin vermemesinin son bir nedeni daha vardır: İndeksleme işlemlerinin her zaman sabit zaman (O(1)) alması beklenir. Ancak UTF-8 kodlu bir String ile bu performansı garanti etmek mümkün değildir; çünkü Rust’ın kaç adet geçerli karakter bulunduğunu belirlemek için metnin başından ilgili indekse kadar tüm baytları taraması gerekirdi.

String’leri Dilimleme

String indeksleme işleminin dönüş türünün ne olması gerektiği — bir bayt değeri mi, bir karakter mi, bir grafem kümesi mi yoksa bir string dilimi mi — net olmadığından bir string içine doğrudan indeksleme yapmak genellikle kötü bir fikirdir. Bu nedenle, string dilimleri oluşturmak için gerçekten indeks kullanmanız gerekiyorsa Rust sizden daha açık olmanızı ister.

[] operatörünü tek bir sayıyla kullanmak yerine, belirli baytları içeren bir string dilimi oluşturmak için [] operatörünü bir aralık ile kullanabilirsiniz:

#![allow(unused)]
fn main() {
let merhaba = "Здравствуйте";

let s = &merhaba[0..4];
}

Burada s, string’in ilk 4 baytını barındıran bir &str olacaktır. Bu karakterlerin her birinin 2 bayt olduğundan daha önce bahsetmiştik; dolayısıyla s diliminin değeri Зд olur.

Bir karakterin baytlarının yalnızca bir kısmını &merhaba[0..1] gibi bir ifadeyle dilimlemeye çalışsaydık, tıpkı bir vektörde geçersiz bir indekse erişildiğinde olduğu gibi Rust çalışma zamanında panik üretirdi:

$ cargo run
   Compiling koleksiyonlar v0.1.0 (file:///projects/koleksiyonlar)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/koleksiyonlar`

thread 'main' (6017738) panicked at src/main.rs:4:21:
end byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2 of string)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Panik mesajında da görüldüğü üzere, bitiş bayt indeksi 1 geçerli bir karakter sınırı değildir ve 'З' karakterinin baytlarının (0..2) ortasına denk gelir. Bu nedenle aralık kullanarak string dilimleri oluştururken dikkatli olmalısınız; aksi hâlde programınızın çökmesine yol açabilirsiniz. Vektörlerdeki get metodunda olduğu gibi, panik yapmayan bir alternatif olarak merhaba.get(0..1) çağrısını kullanabilirsiniz: Bu metot, aralık string sınırları içindeyse, başlangıcı bitişinden büyük değilse ve iki uç da UTF-8 karakter sınırına denk geliyorsa dilimi Some içinde döndürür; aksi hâlde None döndürür.

String’ler Üzerinde Yineleme Yapma

String parçaları üzerinde çalışmanın en doğru yolu, karakterleri mi yoksa baytları mı istediğinizi açıkça belirtmektir. Tekil Unicode skaler değerleri için chars metodunu kullanın. "Зд" üzerinde chars metodunu çağırmak metni ayırarak char türünde iki değer üretir; her bir elemana erişmek için sonuç üzerinde yineleme yapabilirsiniz:

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

Bu kod ekrana şunu yazdıracaktır:

З
д

Alternatif olarak bytes metodu her bir ham baytı döndürür; üzerinde çalıştığınız alana göre bu yöntem daha uygun olabilir:

#![allow(unused)]
fn main() {
for b in "Зд".bytes() {
    println!("{b}");
}
}

Bu kod, bu string’i oluşturan 4 baytı yazdıracaktır:

208
151
208
180

Ancak geçerli Unicode skaler değerlerinin 1 bayttan daha fazlasından oluşabileceğini her zaman aklınızda bulundurun.

Devanagari alfabesinde olduğu gibi string’lerden grafem kümeleri elde etmek karmaşık bir işlemdir; bu nedenle bu işlevsellik standart kütüphane tarafından sunulmaz. İhtiyacınız olan işlev buysa crates.io üzerinde bu amaca yönelik crate’ler (örneğin unicode-segmentation) bulabilirsiniz.