Rust Programlama Dili

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

Metnin bu sürümü, projelerinizi Rust 2024 Sürümü (Edition) kurallarını kullanacak şekilde yapılandırmak için tüm projelerin Cargo.toml dosyasında edition = "2024" ayarı ile Rust 1.90.0 (2025-09-18 sürümü) veya üzerini kullandığınızı varsayar. Rust’ı yükleme veya güncelleme talimatları için Bölüm 1’deki “Kurulum” bölümüne ve sürümler (editions) hakkında bilgi için Ek E’ye bakın.

HTML formatı https://doc.rust-lang.org/stable/book/ adresinde çevrimiçi olarak ve rustup ile yapılan Rust kurulumlarında çevrimdışı (offline) olarak mevcuttur; açmak için rustup doc --book komutunu çalıştırın.

Birçok topluluk çevirisi de mevcuttur.

Bu metin, No Starch Press’ten ciltsiz (paperback) ve e-kitap formatında edinilebilir.

🚨 Daha etkileşimli bir öğrenme deneyimi mi istiyorsunuz? Testler, vurgulama (highlighting), görselleştirmeler ve daha fazlasını içeren farklı bir Rust Kitabı sürümünü deneyin: https://rust-book.cs.brown.edu

Önsöz

Rust programlama dili, meraklılardan oluşan küçük ve yeni gelişen bir topluluk tarafından yaratılıp kuluçkaya yatırılmasından bu yana, dünyanın en sevilen ve en çok talep gören programlama dillerinden biri haline gelerek kısa birkaç yıl içinde uzun bir yol kat etti. Geriye dönüp bakıldığında, Rust’ın gücünün ve vaatlerinin dikkat çekmesi ve sistem programlamada bir yer edinmesi kaçınılmazdı. Kaçınılmaz olmayan şey ise, açık kaynak topluluklarına nüfuz eden ve endüstriler çapında geniş ölçekli benimsenmeyi hızlandıran ilgi ve inovasyondaki küresel büyümeydi.

Şu noktada, ilgi ve benimsenmedeki bu patlamayı açıklamak için Rust’ın sunduğu harika özellikleri işaret etmek kolaydır. Diğer harika özelliklerin yanı sıra kim bellek güvenliği (memory safety) ve yüksek performans ve dost canlısı bir derleyici (compiler) ve harika araçlar (tooling) istemez ki? Bugün gördüğünüz Rust dili, sistem programlamasındaki yıllarca süren araştırmaları canlı ve tutkulu bir topluluğun pratik bilgeliğiyle birleştiriyor. Bu dil amaca yönelik tasarlandı ve özenle işlendi, geliştiricilere güvenli, hızlı ve güvenilir kod yazmayı kolaylaştıran bir araç sundu.

Ancak Rust’ı gerçekten özel kılan şey, hedeflerinize ulaşmanız için siz kullanıcıyı güçlendirme köklerine sahip olmasıdır. Bu, başarılı olmanızı isteyen bir dildir ve güçlendirme ilkesi, bu dili inşa eden, sürdüren ve savunan topluluğun özünde yer alır. Bu temel metnin önceki sürümünden bu yana Rust, gerçekten küresel ve güvenilir bir dil olarak daha da gelişti. Rust Projesi, artık Rust’ın güvenli, istikrarlı ve sürdürülebilir olmasını sağlamak için önemli girişimlere yatırım yapan Rust Vakfı (Rust Foundation) tarafından güçlü bir şekilde desteklenmektedir.

Rust Programlama Dili kitabının bu baskısı, dilin yıllar içindeki evrimini yansıtan ve değerli yeni bilgiler sağlayan kapsamlı bir güncellemedir. Ancak bu sadece sözdizimi (syntax) ve kütüphaneler için bir rehber değil, aynı zamanda kaliteye, performansa ve düşünceli tasarıma değer veren bir topluluğa katılmaya davettir. İster Rust’ı ilk kez keşfetmek isteyen deneyimli bir geliştirici olun, ister becerilerini geliştirmek isteyen deneyimli bir Rustacean (Rust kullanıcısı) olun, bu baskı herkese uygun bir şeyler sunuyor.

Rust yolculuğu işbirliği, öğrenme ve yineleme (iteration) yolculuğu olmuştur. Dilin ve ekosisteminin büyümesi, arkasındaki canlı ve çeşitli topluluğun doğrudan bir yansımasıdır. Çekirdek dil tasarımcılarından sıradan katılımcılara kadar binlerce geliştiricinin katkıları, Rust’ı bu kadar benzersiz ve güçlü bir araç yapan şeydir. Bu kitabı elinize alarak sadece yeni bir programlama dili öğrenmiyorsunuz; yazılımı daha iyi, daha güvenli ve çalışması daha keyifli hale getiren bir harekete katılıyorsunuz.

Rust topluluğuna hoş geldiniz!

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

Giriş

Not: Kitabın bu sürümü, No Starch Press tarafından basılı ve e-kitap formatında sunulan The Rust Programming Language kitabı ile aynıdır.

Rust hakkında giriş seviyesinde bir kitap olan 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 birbirine ters düşer; Rust bu çatışmaya meydan okuyor. Güçlü teknik kapasite ile harika bir geliştirici deneyimini dengeleyen Rust, geleneksel olarak bu tür bir kontrolle ilişkilendirilen tüm zorluklar olmadan alt düzey detayları (örneğin bellek kullanımı gibi) kontrol etme seçeneği sunar.

Rust Kimler İçin?

Rust, birçok farklı nedenden ötürü pek çok insan için idealdir. Gelin en önemli gruplardan birkaçına bakalım.

Geliştirici Ekipleri

Rust, farklı düzeylerde sistem programlama bilgisine sahip geliştiricilerden oluşan büyük ekipler arasında işbirliği yapmak için üretken bir araç olduğunu kanıtlıyor. Alt düzey kodlar, diğer çoğu dilde ancak kapsamlı testler ve deneyimli geliştiriciler tarafından yapılan dikkatli kod incelemeleriyle yakalanabilen çeşitli ince hatalara eğilimlidir. Rust’ta ise derleyici, eşzamanlılık (concurrency) hataları da dahil olmak üzere bu yakalaması zor hatalara sahip kodları derlemeyi reddederek bir bekçi (gatekeeper) rolü üstlenir. Ekip, derleyiciyle birlikte çalışarak zamanını hataların peşinden koşmak yerine programın mantığına odaklanarak geçirebilir.

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

• Rust ile birlikte gelen bağımlılık yöneticisi ve derleme aracı olan Cargo, Rust ekosistemi genelinde bağımlılıkları eklemeyi, derlemeyi ve yönetmeyi zahmetsiz ve tutarlı hale getirir.
• rustfmt formatlama aracı, geliştiriciler arasında tutarlı bir kodlama stili sağlar.
• Rust Language Server, kod tamamlama ve satır içi hata mesajları için entegre geliştirme ortamı (IDE) entegrasyonuna güç verir.

Geliştiriciler, Rust ekosistemindeki bu ve diğer araçları kullanarak sistem düzeyinde kod yazarken dahi üretken olabilirler.

Öğrenciler

Rust, sistem kavramları hakkında bilgi edinmek isteyen öğrenciler ve meraklılar içindir. Birçok kişi işletim sistemi geliştirme gibi konuları Rust kullanarak öğrendi. Topluluk çok misafirperverdir ve öğrencilerin sorularını yanıtlamaktan mutluluk duyar. Bu kitap gibi çabalar aracılığıyla Rust ekipleri, sistem kavramlarını özellikle programlamaya yeni başlayanlar olmak üzere daha fazla insan için daha erişilebilir hale getirmek istiyor.

Şirketler

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

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 mutluluk duyarız.

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

Rust, bir dilde hız ve kararlılık (stability) arzulayanlar içindir. Hız derken, hem Rust kodunun ne kadar hızlı çalışabildiğini hem de Rust’ın size ne kadar hızlı program yazdırdığını kastediyoruz. Rust derleyicisinin kontrolleri, özellik eklemeleri ve yeniden yapılandırma yoluyla kararlılığı sağlar. Bu durum, geliştiricilerin genellikle değiştirmekten korktuğu, bu tür kontrollere sahip olmayan dillerdeki kırılgan eski (legacy) kodlarla tam bir tezat oluşturur. Rust, sıfır maliyetli soyutlamalar için çabalayarak (elle yazılmış kod kadar hızlı bir şekilde alt düzey koda derlenen üst düzey özellikler), güvenli kodun aynı zamanda hızlı kod olmasını sağlamaya çalışır.

Rust dili, diğer birçok kullanıcıyı da desteklemeyi umuyor; burada bahsedilenler sadece en büyük paydaşlardan bazıları. Genel olarak Rust’ın en büyük hedefi, güvenlik ve üretkenlik, hız ve ergonomi sunarak programcıların on yıllardır kabul ettiği ödünleşimleri (trade-offs) ortadan kaldırmaktır. Rust’a bir şans verin ve seçimlerinin sizin için işe yarayıp yaramadığına bakın.

Bu Kitap Kimler İçin?

Bu kitap, başka bir programlama dilinde kod yazdığınızı varsayar, ancak hangisi olduğu konusunda herhangi bir varsayımda bulunmaz. Materyali çok çeşitli programlama altyapılarından gelenler için geniş ölçüde erişilebilir hale getirmeye çalıştık. Programlamanın ne olduğu veya onun hakkında nasıl düşünülmesi gerektiği hakkında konuşarak çok fazla zaman harcamıyoruz. Programlamaya tamamen yeniyseniz, özellikle programlamaya giriş sağlayan bir kitap okumanız sizin için daha faydalı olacaktır.

Bu Kitap Nasıl Kullanılır?

Genel olarak, bu kitap sizin onu baştan sona sırayla okuduğunuzu varsayar. İlerleyen bölümler önceki bölümlerdeki kavramlar üzerine inşa edilir ve önceki bölümler belirli bir konudaki ayrıntılara inmeyebilir, ancak bu konuyu ilerleyen bölümlerde tekrar ele alacaktır.

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 bir yönü hakkında bilgi edineceksiniz. Proje bölümlerinde ise şu ana kadar öğ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 yönelik uygulamalı bir giriştir. Burada kavramları üst düzeyde ele alıyoruz; sonraki bölümler ek ayrıntılar sağlayacaktır. Eğer hemen ellerinizi kirletmek (pratik yapmak) istiyorsanız, Bölüm 2 tam size göre. Eğer bir sonrakine geçmeden önce her ayrıntıyı öğrenmeyi tercih eden, özellikle titiz bir öğreniciyseniz, Bölüm 2’yi atlayıp diğer programlama dillerindekine benzer Rust özelliklerini kapsayan Bölüm 3’e geçmek isteyebilirsiniz; daha sonra, öğrendiğiniz ayrıntıları uygulayacağınız bir proje üzerinde çalışmak istediğinizde Bölüm 2’ye dönebilirsiniz.

Bölüm 4’te Rust’ın sahiplik sistemini öğreneceksiniz. Bölüm 5 struct’ları ve metotları tartışıyor. Bölüm 6 enum’ları, match ifadelerini ve if let ile let...else kontrol akışı (control flow) yapılarını kapsıyor. Özel türler (custom types) oluşturmak için struct’ları ve enum’ları kullanacaksınız.

Bölüm 7’de Rust’ın modül sistemini, kodunuzu ve genel uygulama programlama arayüzünü (API) düzenlemek için gizlilik kurallarını öğreneceksiniz. Bölüm 8, standart kütüphanenin sağladığı bazı yaygın koleksiyon veri yapılarını tartışır: vektörler, string’ler ve hash map’ler. Bölüm 9, Rust’ın hata yönetimi (error-handling) felsefesini ve tekniklerini inceler.

Bölüm 10, birden fazla türe uygulanan kod tanımlama gücü veren generic’leri (jenerikler), trait’leri (özellikler) ve lifetime’ları (yaşam süreleri) derinlemesine inceler. Bölüm 11 tamamen test etme ile ilgilidir, ki bu Rust’ın güvenlik garantilerinde bile programınızın mantığının doğru olduğundan emin olmak için gereklidir. Bölüm 12’de, dosyalar içinde metin arayan grep komut satırı aracının işlevlerinin bir alt kümesinin kendi uygulamamızı geliştireceğiz. Bunun için önceki bölümlerde tartıştığımız birçok kavramı kullanacağız.

Bölüm 13, fonksiyonel programlama dillerinden gelen Rust özellikleri olan closure’ları (kapanışlar) ve iterator’leri (yineleyiciler) inceler. Bölüm 14’te Cargo’yu daha derinlemesine inceleyecek ve kütüphanelerinizi başkalarıyla paylaşmak için en iyi uygulamalar hakkında konuşacağız. Bölüm 15, standart kütüphanenin sağladığı akıllı işaretçileri (smart pointers) ve onların işlevselliğini sağlayan trait’leri tartışır.

Bölüm 16’da farklı eşzamanlı (concurrent) programlama modellerini gözden geçirecek ve Rust’ın birden fazla thread’de (iş parçacığı) korkusuzca programlama yapmanıza nasıl yardımcı olduğunu konuşacağız. Bölüm 17’de, Rust’ın async ve await sözdizimini; task’lar (görevler), future’lar ve stream’ler (akışlar) ve bunların sağladığı hafif eşzamanlılık modeliyle birlikte inceleyerek bu konuyu daha da ileri taşıyoruz.

Bölüm 18, Rust’ın deyimlerinin (idioms) aşina olabileceğiniz nesne yönelimli programlama (OOP) ilkeleriyle nasıl karşılaştırıldığına bakar. Bölüm 19, Rust programları boyunca fikirleri ifade etmenin güçlü yolları olan pattern’ler (desenler) ve pattern matching (desen eşleştirme) üzerine bir referanstır. Bölüm 20, unsafe (güvensiz) Rust, makrolar ve lifetime’lar, trait’ler, türler, fonksiyonlar ve closure’lar hakkında daha fazlasını içeren, ilgi çekici ileri düzey konuların bir karışımını içerir.

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

Son olarak, bazı ekler dil hakkında daha referans benzeri bir formatta faydalı bilgiler içerir. 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 (derivable) trait’leri, Ek D bazı yararlı geliştirme araçlarını ve Ek E Rust sürümlerini (editions) kapsar. Ek F’de kitabın çevirilerini bulabilirsiniz ve Ek G’de Rust’ın nasıl yapıldığını ve gecelik (nightly) Rust’ın ne olduğunu ele alacağız.

Bu kitabı okumanın yanlış bir yolu yoktur: Eğer ileri atlamak istiyorsanız, durmayın! Herhangi bir kafa karışıklığı yaşarsanız önceki bölümlere geri dönmeniz gerekebilir. Ancak sizin için ne işe yarıyorsa onu yapın.

Rust öğrenme sürecinin önemli bir parçası, derleyicinin görüntülediği hata mesajlarını nasıl okuyacağınızı öğrenmektir: Bunlar sizi çalışan koda doğru yönlendirecektir. Bu nedenle, derleyicinin her durumda size göstereceği hata mesajıyla birlikte, derlenmeyen birçok örnek sunacağız. Rastgele bir örnek girip çalıştırırsanız, derlenmeyebileceğini bilin! Çalıştırmaya çalıştığınız örneğin hata verip vermeyeceğini görmek için etrafındaki metni okuduğunuzdan emin olun. Çoğu durumda, sizi derlenmeyen herhangi bir kodun doğru sürümüne yönlendireceğiz. Ferris ayrıca, çalışması amaçlanmayan kodu ayırt etmenize yardımcı olacaktır:

Ferris	Anlamı
	Bu kod derlenmez!
	Bu kod panik yaratır!
	Bu kod istenen davranışı üretmez.

Çoğu durumda, sizi derlenmeyen herhangi bir kodun doğru sürümüne yönlendireceğiz.

Kaynak Kod

Bu kitabın oluşturulduğu kaynak dosyalar GitHub’ta bulunabilir.

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 kurulumu
• Ekrana Hello, world! 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’ı, 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 indireceğiz. İndirme işlemi için internet bağlantısına ihtiyacınız olacak.

Not: Herhangi bir nedenden dolayı rustup kullanmayı tercih etmezseniz, daha fazla seçenek için lütfen Diğer Rust Kurulum Yöntemleri sayfasına bakın.

Aşağıdaki adımlar, Rust derleyicisinin en son kararlı (stable) sürümünü kurar. Rust’ın kararlılık garantileri, kitaptaki derlenen tüm örneklerin daha yeni Rust sürümleriyle de derlenmeye devam edeceğini garanti eder. Çıktı, sürümler arasında biraz farklılık gösterebilir çünkü Rust hata mesajlarını ve uyarıları sıklıkla iyileştirir. Başka bir deyişle, bu adımları kullanarak kurduğunuz daha yeni, kararlı herhangi bir Rust sürümü, bu kitabın içeriğiyle beklendiği gibi çalışmalıdır.

Linux veya macOS Üzerinde rustup Kurulumu

Eğer 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. Şifreniz istenebilir. Eğer kurulum başarılı olursa, şu satır görünecektir:

Rust is installed now. Great!

Ayrıca bir bağlayıcıya (linker) ihtiyacınız olacaktır; bu, Rust’ın derlenmiş çıktılarını tek bir dosyada birleştirmek için kullandığı bir programdır. Büyük ihtimalle sisteminizde zaten bir tane vardır. Eğer bağlayıcı hataları alırsanız, genellikle bir bağlayıcı da içeren bir C derleyicisi kurmalısınız. Bir C derleyicisi aynı zamanda faydalıdır çünkü bazı yaygın Rust paketleri C koduna bağımlıdır ve bir C derleyicisine ihtiyaç duyacaktır.

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

$ xcode-select --install

Linux kullanıcıları 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’ı kurmak için talimatları izleyin. Kurulumun bir noktasında sizden Visual Studio’yu kurmanız istenecektir. Bu, programları derlemek için gereken bağlayıcıyı (linker) ve yerel kütüphaneleri (native libraries) sağlar. Bu adımda daha fazla yardıma ihtiyacınız olursa https://rust-lang.github.io/rustup/installation/windows-msvc.html adresine bakın.

Bu kitabın geri kalanı hem cmd.exe hem de PowerShell’de çalışan komutlar kullanır. Eğer belirli farklılıklar varsa, 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ış olan en son kararlı sürüme ait sürüm numarasını, commit hash’ini ve commit tarihini şu formatta görmelisiniz:

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

Eğer bu bilgiyi görüyorsanız, Rust’ı başarıyla kurmuşsunuz demektir! Eğer bu bilgiyi görmüyorsanız, Rust’ın sisteminizin %PATH% değişkeninde olup olmadığını aşağıdaki gibi 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

Eğer tüm bunlar doğruysa ve Rust hala çalışmıyorsa, yardım alabileceğiniz birkaç yer var. Diğer Rustacean’larla (kendimize taktığımız komik bir lakap) nasıl iletişime geçeceğinizi topluluk sayfasında bulabilirsiniz.

Güncelleme ve Kaldırma

Rust rustup aracılığıyla kurulduktan sonra, yeni yayınlanan bir sürüme güncellemek kolaydır. Terminalinizden şu güncelleme betiğini çalıştırın:

$ rustup update

Rust’ı ve rustup’ı kaldırmak için, terminalinizden şu kaldırma betiğini çalıştırın:

$ rustup self uninstall

Yerel Belgeleri Okumak

Rust kurulumu, çevrimdışı 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üphane tarafından sağlanan bir türün veya fonksiyonun ne yaptığından veya nasıl kullanılacağından emin olmadığınızda, bunu öğrenmek için uygulama programlama arayüzü (API) belgelerini kullanın!

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 (text editor) işinizi görecektir! Ancak, birçok metin düzenleyicisinin ve entegre geliştirme ortamının (IDE) yerleşik Rust desteği vardır. Rust web sitesindeki araçlar sayfasında her zaman birçok düzenleyici ve IDE’nin oldukça güncel bir listesini bulabilirsiniz.

Bu Kitapla Çevrimdışı Çalışmak

Birçok örnekte, 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 bu bağımlılıkları (dependencies) ö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ı daha sonra ayrıntılı olarak açıklayacağız.)

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

Bu işlem, bu paketlerin indirmelerini önbelleğe alacak (cache) ve böylece bunları daha sonra indirmeniz gerekmeyecektir. Bu komutu çalıştırdıktan sonra, get-dependencies klasörünü tutmanıza gerek yoktur. Bu komutu çalıştırdıysanız, ağ kullanmaya çalışmak yerine önbelleğe alınmış bu sürümleri kullanmak için kitabın geri kalanındaki tüm cargo komutlarıyla birlikte --offline bayrağını (flag) 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 bir gelenektir, bu yüzden biz de burada aynısını yapacağız!

Not: Bu kitap, komut satırına temel düzeyde aşina olduğunuzu varsayar. Rust, kullandığınız düzenleyici, araçlar veya kodunuzun nerede bulunduğu konusunda herhangi bir özel talepte bulunmaz; bu nedenle komut satırı yerine bir IDE kullanmayı tercih ederseniz, favori IDE’nizi kullanmaktan çekinmeyin. Günümüzde pek çok IDE’nin belirli düzeyde Rust desteği vardır; detaylar için IDE’nin kendi dokümantasyonunu inceleyin. Rust ekibi, rust-analyzer üzerinden mükemmel bir IDE desteği sunmaya odaklanmıştır. Daha fazla detay için Ek D bölümüne bakabilirsiniz.

Proje Dizinini Ayarlamak

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

Bir terminal açın ve bir projects dizini ile bu projects dizini içinde “Merhaba, dünya!” projesi için bir dizin oluşturmak üzere aşağıdaki komutları girin.

Linux, macOS ve Windows’ta 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 dosyaları her zaman .rs uzantısıyla biter. Dosya adınızda birden fazla kelime kullanıyorsanız, bunları ayırmak için alt çizgi (underscore) kullanmak 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 (string) yazdırılmalıdır. Eğer bu çıktıyı göremiyorsanız, yardım alma yolları için Kurulum bölümündeki “Sorun Giderme” kısmına tekrar başvurun.

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

Hadi bu “Merhaba, dünya!” programını detaylıca 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 (executable) her Rust programında her zaman çalışan ilk koddur. Burada, ilk satır hiçbir parametresi olmayan ve hiçbir şey döndürmeyen main adında bir fonksiyonu bildirir (declare). Eğer parametreleri olsaydı, bunlar parantezlerin (()) içine yazılırdı.

Fonksiyonun gövdesi {} içine sarılmıştır. Rust, tüm fonksiyon gövdelerinin etrafında süslü parantezler (curly brackets) gerektirir. Açılış süslü parantezini fonksiyon bildirimiyle aynı satıra yerleştirmek ve aralarına bir boşluk eklemek iyi bir stil olarak kabul edilir.

Not: Rust projeleri genelinde standart bir stile bağlı kalmak isterseniz, kodunuzu belirli bir stilde biçimlendirmek için rustfmt adı verilen otomatik bir biçimlendirme aracı kullanabilirsiniz (rustfmt hakkında daha fazla bilgi için Ek D’ye bakın). Rust ekibi bu aracı tıpkı rustc gibi standart Rust dağıtımına dahil etmiştir, bu yüzden bilgisayarınızda halihazırda kurulu olmalıdır!

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

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

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

Birincisi, println! bir Rust makrosunu çağırır. Eğer bunun yerine bir fonksiyon çağırsaydı, println olarak (sonunda ! olmadan) girilirdi. Rust makroları, Rust sözdizimini (syntax) genişletmek için kod üreten kod yazmanın bir yoludur ve bunları Bölüm 20’de daha detaylı tartışacağız. Şimdilik, sadece bir ! kullanmanı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!’e bir argüman olarak aktarıyoruz ve metin ekrana yazdırılıyor.

Üçüncüsü, satırı bu ifadenin bittiğini ve bir sonrakinin başlamaya hazır olduğunu belirten bir noktalı virgülle (;) 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, onu Rust derleyicisini (compiler) kullanarak, rustc komutunu girip kaynak dosyanızın adını vererek şu şekilde derlemelisiniz:

$ rustc main.rs

Eğer C veya C++ altyapınız varsa, bunun gcc veya clang’e benzediğini fark edeceksiniz. Başarılı bir şekilde derlendikten sonra, Rust çalıştırılabilir bir ikili dosya (binary executable) çıktısı verir.

Linux, macOS ve Windows’ta PowerShell’de, shell’inizde ls komutunu girerek çalıştırılabilir dosyayı görebilirsiniz:

$ ls
main  main.rs

Linux ve macOS’te iki dosya göreceksiniz. Windows’ta PowerShell ile, CMD kullanarak göreceğiniz aynı üç dosyayı göreceksiniz. Windows’ta CMD ile şunu girerdiniz:

> dir /B %= /B seçeneği sadece dosya adlarını göster demektir =%
main.exe
main.pdb
main.rs

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

$ ./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ırmayı ayrı adımlar olarak gerçekleştirmeye alışkın olmayabilirsiniz. Rust, önceden derlenen (ahead-of-time compiled) bir dildir; yani bir programı derleyip çalıştırılabilir dosyasını 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, (sırasıyla) bir Ruby, Python veya JavaScript implementasyonunun sistemlerinde kurulu olması gerekir. Ancak o dillerde, programınızı derlemek ve çalıştırmak için sadece bir komuta ihtiyacınız vardır. Dil tasarımında her şey bir ödünleşimdir.

Sadece rustc ile derlemek basit programlar için iyidir, ancak projeniz büyüdükçe tüm seçenekleri yönetmek ve kodunuzu paylaşmayı kolaylaştırmak isteyeceksiniz. Bir sonraki bölümde, gerçek dünyadaki Rust programlarını yazmanıza yardımcı olacak Cargo aracını size tanıtacağız.

Merhaba, Cargo!

Merhaba, Cargo!

Cargo, Rust’ın derleme (build) sistemi ve paket yöneticisidir. Çoğu Rustacean (Rust programcısı) projelerini yönetmek için bu aracı kullanır; çünkü Cargo, kodunuzu derlemek, kodunuzun bağımlı olduğu kütüphaneleri indirmek ve o kütüphaneleri derlemek gibi sizin için pek çok işi halleder. (Kodunuzun ihtiyaç duyduğu bu kütüphanelere bağımlılıklar (dependencies) diyoruz.)

Şu ana kadar yazdığımız gibi en basit Rust programlarının herhangi bir bağımlılığı yoktur. “Merhaba, dünya!” projesini Cargo ile oluştursaydık, Cargo’nun yalnızca kodunuzu derlemeyle ilgilenen kısmını kullanırdı. Daha karmaşık Rust programları yazdıkça bağımlılıklar ekleyeceksiniz ve eğer bir projeye Cargo kullanarak başlarsanız, bağımlılık eklemek çok daha kolay olacaktır.

Rust projelerinin büyük çoğunluğu Cargo kullandığı için, bu kitabın geri kalanı da sizin Cargo kullandığınızı varsayar. “Kurulum” bölümünde bahsedilen resmi yükleyicileri kullandıysanız Cargo, Rust ile birlikte kurulu gelir. Eğer Rust’ı başka bir yolla kurduysanız, terminalinize şunu yazarak Cargo’nun kurulu olup olmadığını kontrol edin:

$ cargo --version

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

Cargo ile Proje Oluşturmak

Cargo’yu kullanarak yeni bir proje oluşturalım ve orijinal “Merhaba, dünya!” projemizden nasıl farklı olduğuna bakalım. projects dizininize (veya kodunuzu nerede saklamaya karar verdiyseniz oraya) geri dönün. Ardından, herhangi bir işletim sisteminde aşağıdakini ç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ı verdik ve Cargo, dosyalarını aynı isimde bir dizin içinde oluşturur.

merhaba_cargo dizinine gidin ve 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.

Ayrıca bir .gitignore dosyası ile birlikte yeni bir Git deposu (repository) da başlatmıştır (initialize). Eğer mevcut bir Git deposunun içinde cargo new komutunu çalıştırırsanız Git dosyaları oluşturulmaz; cargo new --vcs=git kullanarak bu davranışı geçersiz kılabilirsiniz.

Not: Git yaygın bir sürüm kontrol sistemidir (version control system). --vcs bayrağını (flag) kullanarak cargo new komutunun farklı bir sürüm kontrol sistemi kullanmasını sağlayabilir veya hiçbir sürüm kontrol sistemi kullanmamasını belirtebilirsiniz. Mevcut seçenekleri görmek için cargo new --help komutunu çalıştırın.

Cargo.toml dosyasını tercih ettiğiniz metin düzenleyicide açın. 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 formatı olan TOML (Tom’s Obvious, Minimal Language) formatındadır.

İlk satır olan [package], aşağıdaki ifadelerin 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 ayarlar: isim, sürüm (version) ve kullanılacak Rust sürümü (edition). edition anahtarından Ek E’de bahsedeceğiz.

Son satır olan [dependencies], projenizin bağımlılıklarından herhangi birini listelemeniz için bir bölümün başlangıcıdır. Rust’ta kod paketlerine crate (kasa) adı verilir. Bu proje için başka bir crate’e ihtiyacımız olmayacak, ancak Bölüm 2’deki ilk projede olacak, bu yüzden o zaman bu bağımlılıklar (dependencies) bölümünü kullanacağız.

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

Dosya adı: src/main.rs

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

Cargo, tıpkı Liste 1-1’de yazdığımız gibi, sizin için bir “Merhaba, dünya!” programı oluşturdu! Şu ana kadar projemiz ile Cargo’nun oluşturduğu proje arasındaki farklar; Cargo’nun kodu src dizinine koyması ve en üst (top-level) dizinde bir Cargo.toml yapılandırma dosyamızın olması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 kodunuzla ilgisi olmayan diğer şeyler içindir. Cargo kullanmak projelerinizi düzenlemenize yardımcı olur. Her şeyin bir yeri vardır ve her şey yerli yerindedir.

“Merhaba, dünya!” projesinde yaptığımız gibi Cargo kullanmayan bir projeye başladıysanız, onu Cargo kullanan bir projeye dönüştürebilirsiniz. Proje kodunu src dizinine taşıyın ve uygun bir Cargo.toml dosyası oluşturun. Bu Cargo.toml dosyasını elde etmenin kolay bir yolu, onu sizin için otomatik olarak oluşturacak olan cargo init komutunu çalıştırmaktır.

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

Şimdi “Merhaba, dünya!” programını Cargo ile derleyip çalıştırdığımızda nelerin farklı olduğuna bakalım! merhaba_cargo dizininizden şu 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ı geçerli dizininizde oluşturmak yerine target/debug/merhaba_cargo (veya Windows’ta target\debug\merhaba_cargo.exe) konumunda oluşturur. Varsayılan (default) derleme bir hata ayıklama derlemesi olduğundan, Cargo ikili dosyayı debug adlı bir dizine koyar. Çalıştırılabilir dosyayı şu komutla çalıştırabilirsiniz:

$ ./target/debug/merhaba_cargo # veya Windows'ta .\target\debug\merhaba_cargo.exe
Merhaba, dünya!

Eğer her şey yolunda giderse, terminale Merhaba, dünya! yazdırılmalıdır. cargo build komutunu ilk kez çalıştırmak, Cargo’nun en üst düzeyde (top-level) yeni bir dosya oluşturmasına da neden olur: Cargo.lock. Bu dosya projenizdeki bağımlılıkların kesin (exact) sürümlerini takip eder. Bu projenin bağımlılığı yoktur, bu nedenle dosya biraz boştur. Bu dosyayı hiçbir zaman manuel olarak değiştirmenize gerek kalmayacaktır; Cargo içeriğini sizin yerinize yönetir.

Az önce cargo build ile bir proje derledik ve ./target/debug/merhaba_cargo ile çalıştırdık, ancak kodu derlemek ve ardından ortaya çıkan ç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`
Merhaba, dünya!

cargo run kullanmak, cargo build komutunu çalıştırmayı ve ardından ikili dosyanın tüm yolunu kullanmayı hatırlamak zorunda kalmaktan daha uygundur, bu yüzden çoğu geliştirici cargo run kullanır.

Dikkat ederseniz bu kez Cargo’nun merhaba_cargo projesini derlediğini (compiling) belirten bir çıktı görmedik. Cargo dosyaların değişmediğini anladı, bu yüzden yeniden derlemek yerine sadece ikili dosyayı çalıştırdı. Eğer kaynak kodunuzu değiştirmiş 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`
Merhaba, dünya!

Cargo ayrıca cargo check adında bir komut da sağlar. Bu komut, kodunuzun derlendiğinden emin olmak için kodunuzu hızlıca kontrol eder ancak çalıştırılabilir bir dosya (executable) ü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 istemeyesiniz? Çoğu zaman cargo check, çalıştırılabilir bir dosya üretme adımını atladığı için cargo build’den çok daha hızlıdır. Kodu yazarken çalışmanızı sürekli olarak kontrol ediyorsanız, cargo check kullanmak projenizin hala derlenip derlenmediğini bilme sürecinizi hızlandıracaktır! Bu nedenle pek çok Rustacean programlarını yazarken derlendiğinden emin olmak için periyodik olarak cargo check çalıştırır. Daha sonra, çalıştırılabilir dosyayı kullanmaya hazır olduklarında cargo build komutunu çalıştırırlar.

Cargo hakkında şu ana kadar öğrendiklerimizi özetleyelim:

• cargo new kullanarak bir proje oluşturabiliriz.
• cargo build kullanarak bir projeyi derleyebiliriz.
• cargo run kullanarak bir projeyi tek adımda derleyip çalıştırabiliriz.
• Hataları kontrol etmek için bir ikili dosya üretmeden cargo check kullanarak bir projeyi derleyebiliriz.
• Cargo derleme sonucunu kodumuzla aynı dizine kaydetmek yerine, onu target/debug dizininde saklar.

Cargo kullanmanın bir diğer avantajı da, hangi işletim sisteminde çalışırsanız çalışın komutların aynı olmasıdır. Dolayısıyla, bu noktada artık Linux ve macOS ile Windows için özel (farklı) talimatlar sunmayacağız.

Yayın (Release) İçin Derlemek

Projeniz sonunda yayınlanmaya (release) 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şturacaktır. Optimizasyonlar Rust kodunuzun daha hızlı çalışmasını sağlar, ancak bunları açmak programınızın derlenmesi için geçen süreyi uzatır. İşte bu yüzden iki farklı profil vardır: biri geliştirme için, yani hızlı ve sık bir şekilde yeniden derlemek istediğiniz zaman; diğeri ise bir kullanıcıya vereceğiniz, tekrar tekrar derlenmeyecek ve mümkün olduğunca hızlı çalışacak son programı derlemek içindir. Eğer kodunuzun çalışma süresini test ediyorsanız (benchmarking), cargo build --release komutunu çalıştırdığınızdan ve target/release dizinindeki çalıştırılabilir dosya ile test ettiğinizden emin olun.

Cargo Geleneklerinden Yararlanmak

Basit projelerde Cargo sadece rustc kullanmaya kıyasla çok fazla bir değer (fayda) sağlamaz, ancak programlarınız daha karmaşık hale geldikçe değerini kanıtlayacaktır. Programlar birden fazla dosyaya yayıldığında veya bir bağımlılığa (dependency) ihtiyaç duyduğunda, derlemeyi Cargo’nun koordine etmesine izin vermek çok daha kolaydır.

merhaba_cargo projesi basit olsa da, artık Rust kariyerinizin geri kalanında kullanacağınız gerçek araçların çoğunu kullanıyor. Aslında, mevcut herhangi bir proje üzerinde çalışmak için Git kullanarak kodu almak, o projenin dizinine gitmek ve derlemek için aşağıdaki komutları kullanabilirsiniz:

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

Cargo hakkında daha fazla bilgi için kendi dokümantasyonuna göz atın.

Özet

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

• rustup kullanarak en son kararlı Rust sürümünü kurmak.
• Daha yeni bir Rust sürümüne güncellemek.
• Yerel olarak yüklenmiş dokümantasyonu açmak.
• Doğrudan rustc kullanarak bir “Merhaba, dünya!” programı yazmak ve çalıştırmak.
• Cargo’nun geleneklerini kullanarak yeni bir proje oluşturmak ve çalıştırmak.

Rust kodu okumaya ve yazmaya alışmak adına daha kapsamlı bir program geliştirmek için şimdi harika bir zaman. Bu yüzden, 2. Bölüm’de bir tahmin oyunu programı geliştireceğiz. Eğer öncelikle genel programlama kavramlarının Rust’ta nasıl çalıştığını öğrenerek başlamayı tercih ederseniz, Bölüm 3’e bakabilir ve ardından Bölüm 2’ye geri dönebilirsiniz.

Tahmin Oyunu Programlama

Birlikte uygulamalı bir proje üzerinde çalışarak Rust’a giriş yapalım! Bu bölüm, bazı yaygın Rust kavramlarını gerçek bir programda nasıl kullanacağınızı göstererek size tanıtır. let, match, metotlar, ilişkili fonksiyonlar (associated functions), harici crate’ler ve daha fazlası hakkında bilgi edineceksiniz! İlerleyen bölümlerde bu fikirleri daha ayrıntılı olarak inceleyeceğiz. Bu bölümde sadece temel bilgilerin pratiğini yapacaksınız.

Klasik bir başlangıç programlama problemini uygulayacağız: bir tahmin oyunu. Şöyle çalışıyor: Program 1 ile 100 arasında rastgele bir tam sayı üretecek. Daha sonra oyuncudan bir tahmin girmesini isteyecek. Bir tahmin girildikten sonra, program tahminin çok düşük veya çok yüksek olduğunu belirtecek. Tahmin doğruysa, oyun bir tebrik mesajı yazdıracak ve kapanacak.

Yeni Bir Proje Kurulumu

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

$ 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 dizini yeni projenin dizinine değiştirir.

Oluşturulan Cargo.toml dosyasına bakın:

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!” programı üretir. 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ı derleyelim ve aynı adımda cargo run komutunu kullanarak çalıştıralım:

$ cargo run
   Compiling tahmin_oyunu v0.1.0 ($PROJE/listings/ch02-guessing-game-tutorial/no-listing-01-cargo-new)
    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 projede hızlıca ardışık geliştirmeler yapmanız ve bir sonrakine geçmeden önce her iterasyonu hızlıca test etmeniz gerektiğinde çok işe yarar.

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

Bir Tahmini İşlemek

Tahmin oyunu programının ilk bölümü kullanıcıdan girdi isteyecek, bu girdiyi işleyecek ve girdinin beklenen biçimde olup olmadığını kontrol edecektir. Başlamak için, oyuncunun bir tahmin girmesine izin vereceğiz. Liste 2-1’deki kodu src/main.rs dosyasına girin.

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, bu yüzden satır satır üzerinden geçelim. Kullanıcı girdisini almak ve ardından sonucu çıktı olarak yazdırmak için io (girdi/çıktı) kütüphanesini 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}");
}

Varsayılan olarak Rust, standart kütüphanede tanımlanmış ve her programın kapsamına dahil ettiği bir dizi öğeye sahiptir. Bu diziye prelude (başlangıç) denir ve içindeki her şeyi standart kütüphane dokümantasyonunda görebilirsiniz.

Eğer kullanmak istediğiniz bir tür prelude içinde değilse, o türü bir use ifadesi ile açıkça kapsama dahil etmeniz gerekir. std::io kütüphanesini kullanmak, kullanıcı girdisini kabul etme yeteneği de dahil olmak üzere size bir dizi yararlı özellik sağlar.

Bölüm 1’de gördüğünüz gibi, main fonksiyonu programa 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 (syntax) yeni bir fonksiyon tanımlar; () parantezleri parametre olmadığını gösterir; ve { süslü parantezi fonksiyonun gövdesini başlatır.

Yine Bölüm 1’de öğrendiğiniz gibi, println! ekrana bir metin (string) 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 metin yazdırıyor ve kullanıcıdan girdi talep ediyor.

Değerleri Değişkenlerle Saklamak

Sırada, kullanıcı girdisini saklamak için aşağıdaki gibi bir değişken (variable) oluşturacağı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}");
}

Şimdi program ilginçleşmeye başlıyor! Bu küçük satırda pek çok şey oluyor. Değişkeni oluşturmak için let ifadesini kullanıyoruz. İş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, yani değişkene bir değer verdiğimizde bu değer değişmez. Bu kavramı Bölüm 3’teki “Değişkenler ve Değiştirilebilirlik” kısmında ayrıntılı olarak tartışacağız. Bir değişkeni değiştirilebilir yapmak için değişken adından önce mut ekleriz:

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

Not: // sözdizimi, satırın sonuna kadar devam eden bir yorum (comment) başlatır. Rust, yorumlardaki her şeyi görmezden gelir. Yorumları Bölüm 3’te daha ayrıntılı olarak tartışacağız.

Tahmin oyunu programına dönecek olursak, artık let mut tahmin’in tahmin adında değiştirilebilir bir değişken tanıtacağını biliyorsunuz. Eşittir işareti (=), Rust’a değişkeni şu an bir şeye bağlamak istediğimizi söyler. Eşittir işaretinin sağında, tahmin değişkeninin bağlandığı değer bulunur; bu değer, yeni bir String örneği döndüren bir fonksiyon olan String::new’i çağırmanın sonucudur. String, standart kütüphane tarafından sağlanan; genişleyebilir, UTF-8 kodlu bir metin türüdür.

::new satırındaki :: sözdizimi, new’in String türünün ilişkili (associated) bir fonksiyonu olduğunu gösterir. Bir ilişkili fonksiyon, bir tür (burada String) üzerinde uygulanan (implemented) fonksiyondur. Bu new fonksiyonu yeni ve boş bir metin (string) oluşturur. Birçok türde bir new fonksiyonu bulacaksınız, çünkü bu, yeni bir değer üreten bir fonksiyon için yaygın olarak kullanılan bir isimdir.

Özetle, let mut tahmin = String::new(); satırı, şu anda 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üphaneden girdi/çıktı işlevselliğini use std::io; ile dahil ettiğimizi hatırlayın. Şimdi io modülünden stdin fonksiyonunu çağıracağız, bu da kullanıcı girdisini ele almamızı sağlayacak:

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}");
}

Eğer io modülünü programın başında use std::io; ile içe aktarmasaydık (import), yine de bu fonksiyon çağrısını std::io::stdin olarak yazarak kullanabilirdik. stdin fonksiyonu, terminaliniz için standart girdiye erişimi temsil eden bir tür olan std::io::Stdin örneğini döndürür.

Ardından gelen .read_line(&mut tahmin) satırı, kullanıcıdan girdi almak için standart girdi arayüzünde read_line metotunu çağırır. Ayrıca, kullanıcı girdisinin hangi metne (string) kaydedileceğini söylemek için &mut tahmin ifadesini read_line’a argüman olarak veriyoruz. read_line’ın tüm işi, kullanıcının standart girdiye yazdıklarını almak ve bunu bir metne eklemektir (içeriğinin üzerine yazmadan). Bu nedenle o metni bir argüman olarak aktarıyoruz. Metin argümanı değiştirilebilir olmalıdır, böylece metot metnin içeriğini değiştirebilir.

& işareti, bu argümanın bir referans olduğunu gösterir. Bu, veriyi belleğe birden fazla kez kopyalamanıza gerek kalmadan kodunuzun birden fazla parçasının aynı veriye erişmesine izin veren bir yoldur. Referanslar karmaşık bir özelliktir ve Rust’ın en büyük avantajlarından biri referansları kullanmanın ne kadar güvenli ve kolay olmasıdır. Bu programı bitirmek için bu detayların çoğunu bilmenize gerek yoktur. Şimdilik bilmeniz gereken tek şey, tıpkı değişkenler gibi, referansların da varsayılan olarak değiştirilemez olduğudur. Bu nedenle onu değiştirilebilir yapmak için &tahmin yerine &mut tahmin yazmanız gerekir. (Bölüm 4, referansları daha kapsamlı bir şekilde açıklayacaktır.)

Potansiyel Bir Hatayı Result ile Ele Almak

Hala aynı kod satırı üzerinde çalışıyoruz. Şimdi kodun üçüncü satırını tartışıyoruz, ancak bunun hala tek bir mantıksal kod satırının bir parçası olduğunu unutmayın. Sonraki kısım bu metottur:

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 ş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 iyisidir. .method_adi() sözdizimi ile bir metot çağırdığınızda uzun satırları bölmeye yardımcı olması için yeni bir satır (newline) ve diğer boşlukları (whitespace) kullanmak genellikle akıllıcadır. Şimdi bu satırın ne işe yaradığını tartışalım.

Daha önce bahsedildiği gibi, read_line kullanıcının girdiği her şeyi ona aktardığımız metne (string) koyar, ancak aynı zamanda bir Result değeri döndürür. Result, çoğunlukla bir enum olarak adlandırılan bir enumeration’dır. Bu, birden fazla olası durumdan birinde olabilen bir türdür. Her olası duruma varyant (variant) diyoruz.

Bölüm 6 enum’ları daha ayrıntılı olarak ele alacaktır. Bu Result türlerinin amacı, hata ayıklama bilgilerini kodlamaktır.

Result’ın varyantları Ok ve Err’dir. Ok varyantı işlemin başarılı olduğunu gösterir ve başarıyla üretilen değeri içerir. Err varyantı işlemin başarısız olduğu anlamına gelir ve işlemin nasıl veya neden başarısız olduğuna dair bilgiler içerir.

Result türündeki değerler, tıpkı herhangi bir türdeki değerler gibi, üzerlerinde tanımlanmış metotlara sahiptir. Bir Result örneğinin çağırabileceğiniz bir expect metodu vardır. Eğer bu Result örneği bir Err değeriyse, expect programın çökmesine (crash) neden olur ve expect’e argüman olarak verdiğiniz mesajı görüntüler. Eğer read_line metodu bir Err döndürdüyse, bu muhtemelen altta yatan işletim sisteminden kaynaklanan bir hatanın sonucu olacaktır. Eğer bu Result örneği bir Ok değeriyse, expect, Ok’un barındırdığı dönüş değerini alacak ve kullanabilmeniz için sadece bu değeri size döndürecektir. Bu durumda, bu değer kullanıcının girdisindeki bayt (byte) sayısıdır.

Eğer expect’i çağırmazsanız, program derlenecektir ancak bir uyarı (warning) alacaksınız:

$ cargo build
   Compiling tahmin_oyunu v0.1.0 ($PROJE/listings/ch02-guessing-game-tutorial/no-listing-02-without-expect)
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, read_line’dan dönen Result değerini kullanmadığınız konusunda sizi uyararak programın olası bir hatayı ele almadığını belirtir.

Uyarıyı bastırmanın doğru yolu, aslında hata yönetimi (error-handling) kodunu yazmaktır; ancak bizim durumumuzda bir sorun oluştuğunda programın çökmesini istiyoruz, bu nedenle expect kullanabiliriz. Hatalardan kurtulmayı (recovering from errors) Bölüm 9’da öğreneceksiniz.

println! Yer Tutucuları (Placeholders) ile Değerleri Yazdırmak

Kapanış süslü parantezini saymazsak, şu ana kadarki kodda tartışılacak sadece bir satır daha 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 içeren metni yazdırır. {} şeklindeki süslü parantez takımı bir yer tutucudur (placeholder): {}’yi, bir değeri yerinde tutan küçük yengeç kıskaçları gibi düşünün. Bir değişkenin değerini yazdırırken, değişken adı süslü parantezlerin içine gidebilir. Bir ifadenin değerlendirilmesinin sonucunu yazdırırken, format dizisine (format string) boş süslü parantezler yerleştirin, ardından format dizisinden sonra virgülle ayrılmış bir ifadeler listesi (list of expressions) ekleyin; bu ifadeler her bir boş süslü parantez yer tutucusunda aynı sırayla yazdırılacaktır. Bir değişkeni ve bir ifadenin sonucunu tek bir println! çağrısıyla yazdırmak şu şekilde görünecektir:

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

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

Bu kod 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 komutunu kullanarak ç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ıyoruz ve ardından onu yazdırıyoruz.

Gizli Bir Sayı Üretmek

Sırada, kullanıcının tahmin etmeye çalışacağı gizli bir sayı üretmemiz gerekiyor. Oyunun birden fazla kez oynanmasının eğlenceli olması için gizli sayı her seferinde farklı olmalıdır. Oyunun çok zor olmaması için 1 ile 100 arasında rastgele bir sayı kullanacağız. Rust henüz standart kütüphanesinde rastgele sayı işlevselliği içermiyor. Ancak Rust ekibi, söz konusu işlevselliğe sahip bir rand crate’i sağlıyor.

Bir Crate ile İşlevselliği Artırmak

Bir crate’in, Rust kaynak kodu dosyalarından oluşan bir koleksiyon olduğunu hatırlayın. Geliştirdiğimiz proje çalıştırılabilir bir crate’tir. rand crate’i ise, başka programlarda kullanılması amaçlanan ve kendi başına çalıştırılamayan kodlar içeren bir kütüphane (library) crate’idir.

Harici crate’lerin koordinasyonu, Cargo’nun gerçekten parladığı yerdir. rand kullanan bir kod yazabilmemiz için önce Cargo.toml dosyasını değiştirip rand crate’ini bir bağımlılık (dependency) olarak eklememiz gerekir. Şimdi o dosyayı açın ve Cargo’nun sizin için oluşturduğu [dependencies] bölüm başlığının hemen altına şu satırı ekleyin. rand’i bu sürüm numarasıyla birlikte aynen burada verdiğimiz gibi belirttiğinizden emin olun, aksi takdirde bu öğreticideki kod örnekleri çalışmayabilir:

Dosya adı: Cargo.toml

[dependencies]
rand = "0.8.5"

Cargo.toml dosyasında, bir başlıktan sonra gelen her şey, başka bir bölüm başlayana kadar devam eden o bölümün parçasıdır. [dependencies] bölümünde Cargo’ya, projenizin hangi harici crate’lere bağımlı olduğunu ve bu crate’lerin hangi sürümlerini gerektirdiğinizi söylersiniz. Bu örnekte, rand crate’ini semantik (anlamsal) sürüm belirteci 0.8.5 ile belirtiyoruz. Cargo, sürüm numaralarını yazmak için bir standart olan Semantik Sürümlemeyi (bazen SemVer olarak adlandırılır) anlar. 0.8.5 belirteci aslında ^0.8.5 için bir kısaltmadır ve bu da en az 0.8.5 olan ancak 0.9.0’ın altında kalan tüm sürümleri kapsadığı anlamına gelir.

Cargo bu sürümlerin 0.8.5 sürümüyle uyumlu genel API’lere sahip olduğunu kabul eder ve bu spesifikasyon, bu bölümdeki kodla hâlâ derlenebilecek en son yama sürümünü (patch release) almanızı garanti eder. Sürümü 0.9.0 veya daha büyük olanların ise aşağıdaki örneklerin kullandığıyla aynı API’ye sahip olması garanti edilmez.

Şimdi koddaki hiçbir şeyi değiştirmeden Liste 2-2’de gösterildiği gibi projeyi derleyelim.

$ cargo build
  Updating crates.io index
   Locking 15 packages to latest Rust 1.85.0 compatible versions
    Adding rand v0.8.5 (available: v0.9.0)
 Compiling proc-macro2 v1.0.93
 Compiling unicode-ident v1.0.17
 Compiling libc v0.2.170
 Compiling cfg-if v1.0.0
 Compiling byteorder v1.5.0
 Compiling getrandom v0.2.15
 Compiling rand_core v0.6.4
 Compiling quote v1.0.38
 Compiling syn v2.0.98
 Compiling zerocopy-derive v0.7.35
 Compiling zerocopy v0.7.35
 Compiling ppv-lite86 v0.2.20
 Compiling rand_chacha v0.3.1
 Compiling rand v0.8.5
 Compiling tahmin_oyunu v0.1.0 (file:///projects/tahmin_oyunu)
  Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.48s

Farklı sürüm numaraları görebilirsiniz (ancak SemVer sayesinde hepsi kodla uyumlu olacaktır!) ve farklı satırlar (işletim sistemine bağlı olarak) olabilir, ve satırlar farklı bir sırada olabilir.

Harici bir bağımlılığı dahil ettiğimizde, Cargo o bağımlılığın ihtiyaç duyduğu her şeyin en son sürümlerini, Crates.io’daki verilerin bir kopyası olan kayıt defterinden (registry) getirir (fetch). Crates.io, Rust ekosistemindeki insanların başkalarının kullanması için açık kaynaklı Rust projelerini yayınladıkları yerdir.

Cargo, kayıt defterini güncelledikten sonra [dependencies] bölümünü kontrol eder ve listelenen fakat henüz indirilmemiş crate’leri indirir. Bu örnekte sadece rand’i bir bağımlılık olarak listelemiş olsak da, Cargo ayrıca rand’in çalışması için bağımlı olduğu diğer crate’leri de alır. Crate’leri indirdikten sonra, Rust bunları derler ve ardından bağımlılıklar mevcut olacak şekilde projeyi derler.

Eğer hiçbir değişiklik yapmadan cargo build komutunu hemen tekrar çalıştırırsanız, Finished satırı haricinde herhangi bir çıktı almazsınız. Cargo, bağımlılıkları daha önceden indirip derlediğini ve sizin Cargo.toml dosyanızda bunlar hakkında hiçbir şeyi değiştirmediğinizi bilir. Ayrıca kodunuz hakkında da hiçbir şeyi değiştirmediğinizi bilir, bu yüzden onu da yeniden derlemez. Yapacak bir şeyi olmadığı için basitçe çıkış yapar.

Eğer src/main.rs dosyasını açıp önemsiz bir değişiklik yaparsanız ve ardından kaydedip tekrar derlerseniz, yalnızca iki satır çı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 dosyanızdaki ufak değişikliğinizle güncellediğini gösterir. Bağımlılıklarınız değişmedi, bu yüzden Cargo, bunlar için zaten indirip derlediği şeyleri yeniden kullanabileceğini biliyor.

Tekrarlanabilir Derlemeleri Sağlamak (Reproducible Builds)

Cargo, siz veya başka herhangi bir kişi kodunuzu her derlediğinde aynı artefaktı (artifact) yeniden derleyebilmenizi sağlayan bir mekanizmaya sahiptir: Cargo, siz aksi bir şey belirtene kadar yalnızca belirttiğiniz bağımlılık sürümlerini kullanacaktır. Örneğin, gelecek hafta rand crate’inin 0.8.6 sürümünün çıktığını, ve bu sürümün önemli bir hata düzeltmesi içerdiğini, ancak kodunuzu bozacak bir gerileme (regression) de barındırdığını varsayalım. Bunun üstesinden gelmek için, Rust ilk cargo build komutunu çalıştırdığınızda Cargo.lock dosyasını oluşturur, ve biz şu an tahmin_oyunu dizinimizde buna sahibiz.

Bir projeyi ilk kez derlediğinizde, Cargo kriterlere uyan bağımlılıkların tüm sürümlerini belirler (figures out) ve daha sonra bunları Cargo.lock dosyasına yazar. Projenizi gelecekte derlediğinizde Cargo, Cargo.lock dosyasının mevcut olduğunu görecek ve sürümleri yeniden belirleme işini yapmaktansa orada belirtilen sürümleri kullanacaktır. Bu, tekrarlanabilir bir derlemeye otomatik olarak sahip olmanızı sağlar. Başka bir deyişle, siz açıkça yükseltme (upgrade) yapana kadar, Cargo.lock dosyası sayesinde projeniz 0.8.5 sürümünde kalacaktır. Cargo.lock dosyası, tekrarlanabilir derlemeler için önemli olduğundan, genellikle projenizdeki geri kalan kodlarla birlikte sürüm kontrolüne (source control) dahil edilir.

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

Bir crate’i güncellemek istediğinizde, Cargo update komutunu sağlar; bu komut Cargo.lock dosyasını yok sayacak ve Cargo.toml dosyasındaki spesifikasyonlarınıza uyan en son sürümleri belirleyecektir. Ardından Cargo, bu sürümleri Cargo.lock dosyasına yazacaktır. Aksi takdirde, varsayılan olarak Cargo yalnızca 0.8.5’ten büyük ve 0.9.0’dan küçük sürümleri arayacaktır. Eğer rand crate’i iki yeni sürüm olan 0.8.6 ve 0.999.0’ı yayınlamışsa, cargo update çalıştırdığınızda şunu görürdünüz:

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

Cargo, 0.999.0 sürümünü yok sayar. Bu noktada Cargo.lock dosyanızda artık kullandığınız rand crate sürümünün 0.8.6 olduğunu belirten bir değişiklik fark edersiniz. rand 0.999.0 sürümünü veya 0.999.x serisindeki herhangi bir sürümü kullanmak için, bunun yerine Cargo.toml dosyanızı şu şekilde güncellemeniz gerekir (bu değişikliği yapmayın çünkü aşağıdaki örnekler rand 0.8 kullandığınızı varsayıyor):

[dependencies]
rand = "0.999.0"

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

Cargo ve ekosistemi hakkında söylenecek çok daha fazla şey var ve bunları Bölüm 14’te tartışacağız; ancak şimdilik bilmeniz gerekenler bunlar. Cargo, kütüphaneleri yeniden kullanmayı çok kolaylaştırdığı için, Rust geliştiricileri (Rustaceans) bir dizi paketten birleştirilmiş daha küçük projeler yazabilirler.

Rastgele Bir Sayı Üretmek

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

use std::io;

use rand::Rng;

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

    let gizli_sayi = rand::thread_rng().gen_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}");
}

Öncelikle, use rand::Rng; satırını ekliyoruz. Rng trait’i (özelliği), rastgele sayı üreteçlerinin (generators) uyguladığı metotları tanımlar ve bu metotları kullanabilmemiz için bu trait kapsamda olmalıdır. Bölüm 10, trait’leri detaylı bir şekilde ele alacaktır.

Sonrasında ortaya iki satır ekliyoruz. İlk satırda, kullanacağımız belirli rastgele sayı üretecini bize veren rand::thread_rng fonksiyonunu çağırıyoruz: Bu üreteç, yürütmenin mevcut iş parçacığına özeldir (local) ve işletim sistemi tarafından tohumlanır (seeded). Sonra da rastgele sayı üreteci üzerinde gen_range metodunu çağırıyoruz. Bu metot, use rand::Rng; ifadesi ile kapsama dahil ettiğimiz Rng trait’i tarafından tanımlanmıştır. gen_range metodu argüman olarak bir aralık ifadesi (range expression) alır ve o aralıkta rastgele bir sayı üretir. Burada kullandığımız aralık ifadesi türü baslangic..=bitis (start..=end) formundadır ve alt ile üst sınırları dahil eder; bu nedenle 1 ile 100 arasında bir sayı talep etmek için 1..=100 belirtmemiz gerekir.

Not: Bir crate’ten hangi trait’leri kullanacağınızı ve hangi metotları ile fonksiyonları çağıracağınızı hemen bilemezsiniz; bu yüzden her crate’in kullanımı ile ilgili talimatları içeren dokümantasyonları vardır. Cargo’nun başka bir şık özelliği de, cargo doc --open komutunu çalıştırmanın tüm bağımlılıklarınız tarafından sağlanan belgeleri yerel olarak oluşturması (build) ve bunları tarayıcınızda açmasıdır. Örneğin, rand crate’indeki diğer işlevlerle ilgileniyorsanız, cargo doc --open çalıştırın ve soldaki kenar çubuğundan (sidebar) rand’a tıklayın.

İkinci yeni satır gizli sayıyı yazdırır. Bu, programı geliştirirken onu test edebilmek için kullanışlıdır, ancak nihai sürümden bunu sileceğiz. Program, başlar başlamaz cevabı yazdırıyorsa pek de bir oyun 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

Farklı rastgele sayılar almalısınız ve hepsi de 1 ile 100 arasında sayılar olmalıdır. Harika iş çıkardınız!

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

Artık kullanıcı girdisine ve rastgele bir sayıya sahip olduğumuza göre, onları karşılaştırabiliriz. Bu adım Liste 2-4’te gösterilmektedir. Not: Bu kod daha sonra açıklayacağımız nedenlerden ötürü henüz derlenmeyecektir.

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

use rand::Rng;

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

    let gizli_sayi = rand::thread_rng().gen_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!"),
    }
}

Öncelikle, standart kütüphaneden std::cmp::Ordering adlı bir türü kapsama dahil eden başka bir use ifadesi ekliyoruz. Ordering türü başka bir enum’dur ve Less (Daha Küçük), Greater (Daha Büyük) ve Equal (Eşit) varyantlarına sahiptir. Bunlar, iki değeri karşılaştırdığınızda mümkün olan üç sonuçtur.

Sonra en alta 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 herhangi bir şey üzerinde çağrılabilir. Ne ile karşılaştırma yapmak istiyorsanız onun bir referansını alır: Burada tahmin’i gizli_sayi ile karşılaştırıyor. Sonrasında, use ifadesiyle kapsama dahil ettiğimiz Ordering enum’ının bir varyantını döndürür. cmp çağrısından, tahmin ve gizli_sayi değerleriyle hangi Ordering varyantının döndüğüne bağlı olarak bundan sonra ne yapacağımıza karar vermek için bir match ifadesi kullanıyoruz.

Bir match ifadesi kollardan (arms) oluşur. Bir kol (arm), eşleştirilecek bir desenden (pattern) ve match’e verilen değer o kolun desenine uyduğunda çalıştırılması gereken koddan oluşur. Rust, match’e verilen değeri alır ve sırayla her bir kolun deseni boyunca bakar. Desenler (patterns) ve match yapısı çok güçlü Rust özellikleridir: Kodunuzun karşılaşabileceği çeşitli durumları ifade etmenizi ve hepsini 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 ele alınacaktır.

Burada kullandığımız match ifadesi ile bir örnek üzerinden gidelim. Diyelim ki kullanıcı 50 tahmininde bulundu ve bu kez rastgele üretilen gizli sayı 38.

Kod 50’yi 38 ile karşılaştırdığında, cmp metodu Ordering::Greater (Daha Büyük) döndürecektir, çünkü 50, 38’den büyüktür. match ifadesi Ordering::Greater değerini alır ve her bir kolun desenini (pattern) kontrol etmeye başlar. İlk kolun deseni olan Ordering::Less’e bakar ve Ordering::Greater değerinin Ordering::Less (Daha Küçük) ile eşleşmediğini görür; bu yüzden o koldaki kodu yok sayar ve bir sonraki kola geçer. Sonraki kolun deseni Ordering::Greater’dır, ki bu da Ordering::Greater ile eşleşir! O koldaki ilişkili kod çalıştırılacak ve ekrana Çok büyük! yazdıracaktır. match ifadesi ilk başarılı eşleşmeden sonra sona erer, bu senaryoda artık son kola bakmayacaktır.

Fakat Liste 2-4’teki kod henüz derlenmeyecektir. Deneyelim:

$ cargo build
   Compiling libc v0.2.86
   Compiling getrandom v0.2.2
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.10
   Compiling rand_core v0.6.2
   Compiling rand_chacha v0.3.0
   Compiling rand v0.8.5
   Compiling tahmin_oyunu v0.1.0 ($PROJE/listings/ch02-guessing-game-tutorial/listing-02-04)
error[E0308]: mismatched types
   --> src/main.rs:27:22
    |
 27 |     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
   --> $HOME/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/cmp.rs:991:8
    |
991 |     fn cmp(&self, other: &Self) -> Ordering;
    |        ^^^

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

Hatanın özü uyumsuz türler (mismatched types) olduğunu belirtiyor. Rust güçlü, statik bir tür sistemine (static type system) sahiptir. Ancak, aynı zamanda tür çıkarımı (type inference) da vardır. let mut tahmin = String::new() yazdığımızda, Rust tahmin’in bir String olması gerektiği çıkarımını yapabildi ve bizim türü yazmamıza gerek bırakmadı. Öte yandan, gizli_sayi bir sayı türüdür. Rust’ın 1 ile 100 arasında değer alabilen birkaç sayı türü vardır: 32 bitlik bir sayı olan i32; işaretsiz (unsigned) 32 bitlik bir sayı olan u32; 64 bitlik bir sayı olan i64; ve diğerleri. Aksi belirtilmediği sürece Rust varsayılan olarak i32 kullanır. Eğer Rust’ın başka bir sayısal tür çıkarımı yapmasına neden olacak tür bilgisini başka bir yere eklemediyseniz, gizli_sayi’nın türü budur. Hatanın nedeni, Rust’ın bir metin türü (string) ile bir sayı türünü karşılaştıramamasıdır.

Nihayetinde, programın girdi olarak okuduğu String’i bir sayı türüne dönüştürmek istiyoruz, böylece onu gizli sayıyla sayısal olarak karşılaştırabileceğiz. 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::Rng;

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

    let gizli_sayi = rand::thread_rng().gen_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!"),
    }
}

O satır şudur:

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

tahmin adında bir değişken oluşturuyoruz. Ama bir dakika, programda zaten tahmin adında bir değişken yok muydu? Var, ancak Rust yararlı bir şekilde tahmin’in önceki değerini yenisiyle gölgelendirmemize (shadow) olanak tanır. Gölgelendirme, bizi örneğin tahmin_str ve tahmin gibi iki farklı değişken oluşturmaya zorlamak yerine tahmin değişken adını yeniden kullanmamıza olanak tanır. Bunu Bölüm 3’te daha ayrıntılı ele alacağız, ancak şimdilik bu özelliğin genellikle bir değeri bir türden diğerine dönüştürmek istediğinizde kullanıldığını bilin.

Bu yeni değişkeni tahmin.trim().parse() ifadesine bağlıyoruz. İfadedeki tahmin, girdiyi metin (string) olarak barındıran orijinal tahmin değişkenine işaret eder. Bir String örneği üzerindeki trim metodu, metnin başındaki ve sonundaki tüm boşlukları ortadan kaldıracaktır. Metni (string) yalnızca sayısal veri içerebilen bir u32’ye dönüştürmeden önce bunu yapmamız gerekir. Kullanıcının read_line’ı tamamlamak ve tahminini girmek için enter (giriş) tuşuna basması gerekir; bu da metne bir yeni satır (newline) karakteri ekler. Örneğin, kullanıcı 5 yazıp enter’a basarsa, tahmin şöyle görünür: 5\n. \n “yeni satırı” temsil eder. (Windows’ta enter’a basmak satır başı ve yeni satır, \r\n ile sonuçlanır.) trim metodu \n veya \r\n’i ortadan kaldırarak sadece 5 olmasını sağlar.

Metinler (strings) üzerindeki parse metodu, bir metni başka bir türe dönüştürür. Burada, onu bir metinden bir sayıya dönüştürmek için kullanıyoruz. let tahmin: u32 diyerek Rust’a tam olarak istediğimiz sayı türünü söylemeliyiz. tahmin’den sonraki iki nokta üst üste (:), Rust’a değişkenin türünü belirteceğimizi söyler. Rust’ın birkaç yerleşik sayı türü vardır; burada gördüğünüz u32 işaretsiz, 32 bitlik bir tam sayıdır. Küçük pozitif bir sayı için iyi bir varsayılan seçimdir. Diğer sayı türlerini Bölüm 3’te öğreneceksiniz.

Ek olarak, bu örnek programdaki u32 bildirmi (annotation) ve gizli_sayi ile yapılan karşılaştırma, Rust’ın gizli_sayi’nın da bir u32 olması gerektiği çıkarımını yapacağı anlamına gelir. Yani, artık karşılaştırma aynı türden iki değer arasında olacaktır!

parse metodu yalnızca mantıksal olarak sayılara dönüştürülebilen karakterler üzerinde çalışacaktır ve bu nedenle kolayca hatalara neden olabilir. Örneğin, metin A👍% içerseydi, bunu bir sayıya dönüştürmenin hiçbir yolu olmazdı. Başarısız olabileceği için parse metodu da read_line metodunun yaptığı gibi (daha önce “Potansiyel Bir Hatayı Result ile Ele Almak” kısmında tartışılmıştı) bir Result türü döndürür. Bu Result’ı, expect metodunu tekrar kullanarak aynı şekilde ele alacağız. Eğer parse metodu, metinden bir sayı oluşturamadığı için bir Err Result varyantı döndürürse, expect çağrısı oyunu çökertecek (crash) ve ona verdiğimiz mesajı yazdıracaktır. Eğer parse, metni başarıyla bir sayıya dönüştürebilirse, Result’ın Ok varyantını döndürür; ve expect, Ok değerinden istediğimiz numarayı döndürecektir.

Programı şimdi ç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şluklar eklenmiş olmasına rağmen, program yine de kullanıcının 76 tahmininde bulunduğunu anladı (figured out). Farklı türdeki girdilerle farklı davranışları doğrulamak için programı birkaç kez çalıştırın: Sayıyı doğru tahmin edin, çok büyük bir sayı tahmin edin ve çok küçük bir sayı tahmin edin.

Şu anda oyunun büyük bir kısmı çalışıyor, ancak kullanıcı yalnızca bir tahmin yapabiliyor. Bir döngü (loop) 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ı tahmin etmeleri için daha fazla şans vermek adına bir döngü ekleyeceğiz:

Dosya adı: src/main.rs

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

use rand::Rng;

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

    let gizli_sayi = rand::thread_rng().gen_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, tahmini giriş isteminden itibaren her şeyi bir döngü içine taşıdık. Döngünün içindeki satırların her birini fazladan dört boşluk (space) girintilediğinizden (indent) emin olun ve programı tekrar çalıştırın. Program artık sonsuza dek başka bir tahmin isteyecektir, ki bu aslında yeni bir sorun ortaya çıkarır. Kullanıcı çıkamayacak gibi görünüyor!

Kullanıcı her zaman ctrl-C klavye kısayolunu kullanarak programı durdurabilir. Ancak, “Tahmini Gizli Sayıyla Karşılaştırmak” kısmındaki parse tartışmasında bahsedildiği gibi, bu doyumsuz canavardan kaçmanın başka bir yolu daha var: Eğer kullanıcı sayı olmayan bir girdi girerse, program çökecektir (crash). Aşağıda gösterildiği gibi kullanıcının çıkabilmesini (quit) sağlamak için bundan faydalanabiliriz:

$ 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' panicked at src/main.rs:28:47:
Lütfen bir sayı yazın!: ParseIntError { kind: InvalidDigit }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

cikis (quit) yazmak oyundan çıkmanızı sağlayacaktır, ancak fark edeceğiniz üzere başka herhangi bir sayısal olmayan girdi de aynısını yapacaktır. Bu, en hafif tabirle ideal bir durum değildir (suboptimal); oyunun, doğru sayı tahmin edildiğinde de durmasını istiyoruz.

Doğru Tahminden Sonra Çıkmak

Kullanıcı kazandığında oyundan çıkmasını sağlamak için bir break (kır) ifadesi ekleyerek oyunu programlayalım:

Dosya adı: src/main.rs

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

use rand::Rng;

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

    let gizli_sayi = rand::thread_rng().gen_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! ifadesinden sonra break satırını eklemek, kullanıcı gizli sayıyı doğru tahmin ettiğinde programın döngüden çıkmasını sağlar. Döngüden çıkmak aynı zamanda programdan çıkmak anlamına da gelir, çünkü döngü main’in son kısmıdır.

Geçersiz Girdiyi Ele Almak

Oyunun davranışını daha da iyileştirmek için, kullanıcı sayısal olmayan bir girdi girdiğinde programı çökertmek (crash) yerine, kullanıcının tahmin etmeye devam edebilmesi için oyunun sayı olmayan veriyi görmezden gelmesini sağlayalım. Bunu Liste 2-5’te gösterildiği gibi, tahmin’in String’den u32’ye dönüştürüldüğü satırı değiştirerek yapabiliriz.

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

use rand::Rng;

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

    let gizli_sayi = rand::thread_rng().gen_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(num) => num,
            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;
            }
        }
    }
}

Bir hata durumunda programı çökertmekten ziyade hatayı yönetmeye (handle the error) geçmek için, bir expect çağrısından çıkıp match ifadesine geçiş yapıyoruz. parse’ın 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 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. O Ok değeri, ilk kolun deseniyle eşleşecek ve match ifadesi, sadece parse’ın ürettiği ve Ok değerinin içine koyduğu sayi (num) değerini döndürecektir. Bu sayı, oluşturduğumuz yeni tahmin değişkeninde tam da istediğimiz yere gelecektir.

Eğer parse metni bir sayıya dönüştüremezse (not able), hata hakkında daha fazla bilgi barındıran bir Err değeri döndürür. Err değeri, ilk match kolundaki Ok(sayi) deseni ile eşleşmez, ancak ikinci koldaki Err(_) deseni ile eşleşir. Alt çizgi (_), her şeyi yakalayan (catch-all) bir değerdir; bu örnekte, içlerinde ne bilgi olursa olsun tüm Err değerleriyle eşleşmek istediğimizi söylüyoruz. Böylece, program ikinci kolun kodu olan continue’yu (devam et) çalıştırır; bu da programa loop’un bir sonraki döngüsüne (iteration) geçmesini ve başka bir tahmin istemesini söyler. Yani etkin olarak, program parse’ın karşılaşabileceği tüm hataları yok sayar!

Artık programdaki her şey beklendiği gibi çalışmalıdır. 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 ayarlama (tweak) ile tahmin oyununu bitireceğiz. Programın hâlâ gizli sayıyı yazdırdığını hatırlayın. Bu, test için iyi çalıştı, ancak oyunu mahvediyor. Gizli sayıyı çıktı olarak veren println! ifadesini silelim. Liste 2-6 son kodu göstermektedir.

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

use rand::Rng;

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

    let gizli_sayi = rand::thread_rng().gen_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(num) => num,
            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 inşa ettiniz. Tebrikler!

Özet

Bu proje sizi birçok yeni Rust kavramıyla uygulamalı olarak tanıştırmanın bir yoluydu: let, match, fonksiyonlar, harici crate’lerin kullanımı ve daha fazlası. Sonraki birkaç bölümde bu kavramlar hakkında daha fazla ayrıntı öğreneceksiniz. Bölüm 3, çoğu programlama dilinin sahip olduğu değişkenler, veri türleri ve fonksiyonlar gibi kavramları ele alır ve bunların Rust’ta nasıl kullanılacağını gösterir. Bölüm 4, Rust’ı diğer dillerden farklı kılan bir özellik olan sahipliği araştırır. Bölüm 5 struct’ları (yapıları) ve metot sözdizimini (method syntax) tartışı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 ortaya çıkan kavramları ve bunların Rust’ta nasıl çalıştığını kapsar. Çoğu programlama dili temelinde birbiriyle pek çok ortak noktaya sahiptir. Bu bölümde sunulan kavramların hiçbiri Rust’a özgü değildir, ancak bunları Rust bağlamında tartışacağız ve bunların kullanımı etrafındaki gelenekleri (conventions) açıklayacağız.

Özellikle değişkenler, temel veri türleri (basic types), fonksiyonlar (functions), yorumlar (comments) ve kontrol akışı (control flow) hakkında bilgi edineceksiniz. Bu temeller her Rust programında bulunacaktır ve bunları erkenden öğrenmek size başlamanız için güçlü bir temel sağlayacaktır.

Değişkenler ve Değiştirilebilirlik

Değişkenler ve Değiştirilebilirlik (Mutability)

“Değerleri Değişkenlerle Saklamak” bölümünde bahsedildiği gibi, değişkenler varsayılan olarak değiştirilemezdir. Bu, kodunuzu Rust’ın sunduğu güvenlik ve kolay eşzamanlılık (concurrency) avantajlarından yararlanacak şekilde yazmanız için Rust’ın size verdiği birçok küçük dürtmeden biridir. Ancak yine de değişkenlerinizi değiştirilebilir yapma seçeneğiniz vardır. Rust’ın sizi neden değiştirilemezliği tercih etmeye teşvik ettiğini ve neden bazen bundan vazgeçmek isteyebileceğinizi keşfedelim.

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

Ardından, yeni degiskenler dizininizde src/main.rs dosyasını açın ve kodunu henüz derlenmeyecek olan şu 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}");
}

Programı kaydedin ve cargo run kullanarak çalıştırın. Aşağıdaki çıktıda gösterildiği gibi, değiştirilemezlik (immutability) hatasıyla ilgili bir hata mesajı almalısınız:

$ cargo run
   Compiling variables v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-01-variables-are-immutable)
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 `variables` (bin "variables") due to 1 previous error

Bu örnek derleyicinin programlarınızdaki hataları bulmanıza nasıl yardımcı olduğunu gösterir. Derleyici hataları sinir bozucu olabilir, ancak aslında yalnızca programınızın sizin istediğiniz şeyi henüz güvenli bir şekilde yapmadığı anlamına gelirler; sizin iyi bir programcı olmadığınız anlamına gelmezler! Deneyimli Rustacean’lar bile hâlâ derleyici hataları almaktadır.

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 çünkü değiştirilemez x değişkenine ikinci bir değer atamaya çalıştınız.

Değiştirilemez olarak belirlenmiş bir değeri değiştirmeye çalıştığımızda derleme zamanı (compile-time) hataları almamız önemlidir, çünkü bizzat bu durum hatalara (bug) yol açabilir. Kodumuzun bir kısmı bir değerin asla değişmeyeceği varsayımıyla çalışırsa ve kodumuzun başka bir kısmı o değeri değiştirirse, kodun ilk kısmının tasarlandığı şeyi yapmaması mümkündür. Bu tür bir hatanın nedenini oluştuktan sonra takip etmek zor olabilir, özellikle de kodun ikinci 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, bu nedenle bunu kendiniz takip etmek zorunda kalmazsınız. Böylece kodunuzun mantığını anlamak daha kolaydır.

Ancak değiştirilebilirlik (mutability) çok faydalı olabilir ve kod yazmayı daha kullanışlı hale 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 diğer kısımlarının bu değişkenin değerini değiştireceğini belirterek, kodu gelecekte okuyacak kişilere niyetinizi iletir.

Örneğin, src/main.rs dosyasını şu şekilde 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}");
}

Şimdi programı çalıştırdığımızda şunu elde ederiz:

$ cargo run
   Compiling variables v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-02-adding-mut)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
     Running `target/debug/variables`
x'in değeri: 5
x'in değeri: 6

mut kullanıldığında x’e bağlı olan değeri 5’ten 6’ya değiştirmemize izin verilir. Nihayetinde, değiştirilebilirliği kullanıp kullanmamaya karar vermek size bağlıdır ve o belirli durumda neyin en açık (anlaşılır) olduğunu düşündüğünüze göre değişir.

Sabitleri Bildirmek (Constants)

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

İlk olarak, sabitlerle birlikte mut kullanmanıza izin verilmez. Sabitler sadece varsayılan olarak değiştirilemez değildirler; onlar her zaman değiştirilemezdirler. Sabitleri let anahtar kelimesi yerine const anahtar kelimesini kullanarak bildirirsiniz (declare) ve değerin türü mutlaka belirtilmelidir (annotated). 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 şu anda ayrıntılar için endişelenmeyin. Sadece her zaman türü belirtmeniz gerektiğini bilin.

Sabitler, küresel kapsam (global scope) da dahil olmak üzere herhangi bir kapsamda bildirilebilirler; bu durum onları, kodun birçok parçasının bilmesi gereken değerler için kullanışlı hale getirir.

Son fark ise sabitlerin, sadece çalışma zamanında hesaplanabilecek bir değere değil, yalnızca sabit bir ifadeye (constant expression) ayarlanabilmesidir.

İş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 (THREE_HOURS_IN_SECONDS) ve değeri, 60 (bir dakikadaki saniye sayısı), 60 (bir saatteki dakika sayısı) ve 3’ün (bu programda saymak istediğimiz saat sayısı) çarpılması sonucuna ayarlanmıştır. Rust’ın sabitler için adlandırma geleneği, tüm harfleri büyük yazmak ve kelimeler arasında alt çizgi kullanmaktır. Derleyici, derleme zamanında sınırlı bir dizi işlemi değerlendirebilir; bu da sabiti doğrudan 10.800 değerine ayarlamak yerine, bu değeri anlaması ve doğrulaması daha kolay bir şekilde yazmayı seçmemizi sağlar. 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 bakın.

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

Programınız boyunca kullanılan sabit (hardcoded) değerleri const (sabit) olarak adlandırmak, bu değerin anlamını kodun gelecekteki bakımcılarına iletmek açısından faydalıdır. Ayrıca, sabit kodlanmış değerin gelecekte güncellenmesi gerektiğinde kodunuzda değiştirmeniz gereken yalnızca bir yer olmasına da yardımcı olur.

Gölgelendirme (Shadowing)

Bölüm 2’deki tahmin oyunu eğitiminde gördüğünüz gibi, önceki bir değişkenle aynı isimde yeni bir değişken bildirebilirsiniz (declare). Rust geliştiricileri (Rustaceans) ilk değişkenin ikincisi tarafından gölgelendiğini (shadowed) söyler; bu, değişkenin adını kullandığınızda derleyicinin göreceği şeyin ikinci değişken olduğu anlamına gelir. Aslında ikinci değişken, kendisi gölgelenene veya kapsam sona erene kadar değişken adının tüm kullanımlarını kendine alarak ilkini gölgede bırakır (overshadows). Bir değişkeni aynı değişkenin adını kullanarak ve let anahtar kelimesinin kullanımını tekrarlayarak aşağıdaki gibi gölgelendirebiliriz:

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’i 5 değerine bağlar. Ardından, let x = komutunu tekrarlayarak yeni bir x değişkeni oluşturur, orijinal değeri alır ve 1 ekler, böylece x’in değeri 6 olur. Sonra, süslü parantezlerle (curly brackets) oluşturulan bir iç kapsamda (inner scope), üçüncü let ifadesi de x’i gölgelendirir ve önceki değeri 2 ile çarparak x’e 12 değerini veren yeni bir değişken oluşturur. O kapsam sona erdiğinde iç gölgelendirme biter ve x tekrar 6 olur. Bu programı çalıştırdığımızda şu çıktıyı verecektir:

$ cargo run
   Compiling variables v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-03-shadowing)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/variables`
İç kapsamdaki x'in değeri: 12
x'in değeri: 6

Gölgelendirme, bir değişkeni mut olarak işaretlemekten farklıdır; çünkü let anahtar kelimesini kullanmadan kazara bu değişkene yeniden atama (reassign) yapmaya çalışırsak derleme zamanı (compile-time) hatası alırız. let kullanarak, bir değer üzerinde birkaç dönüştürme (transformation) işlemi gerçekleştirebiliriz, ancak bu dönüştürmeler tamamlandıktan sonra değişkenin değiştirilemez kalmasını sağlayabiliriz.

mut ve gölgelendirme arasındaki diğer fark ise şudur: let anahtar kelimesini tekrar kullandığımızda etkili bir şekilde yeni bir değişken oluşturduğumuz için, değerin türünü değiştirebilir ancak aynı ismi yeniden kullanabiliriz. Örneğin, programımızın bir kullanıcıdan biraz metin arasına ne kadar boşluk istediğini boşluk karakterleri girerek göstermesini istediğini, ve ardından bu girdiyi bir sayı olarak saklamak istediğimizi varsayalım:

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

İlk bosluklar değişkeni bir metin (string) türüdür ve ikinci bosluklar değişkeni bir sayı türüdür. Gölgelendirme böylece bizi bosluklar_str ve bosluklar_sayi gibi farklı isimler bulmak zorunda kalmaktan kurtarır; bunun yerine daha basit olan bosluklar ismini yeniden kullanabiliriz. Ancak, burada gösterildiği gibi bunun için mut kullanmaya çalışırsak, derleme zamanı (compile-time) hatası alırız:

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

Hata, bir değişkenin türünü değiştirmemize (mutate) izin verilmediğini söylüyor:

$ cargo run
   Compiling variables v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-05-mut-cant-change-types)
error[E0308]: mismatched types
 --> src/main.rs:4:17
  |
3 |     let mut bosluklar = "   ";
  |                         ----- expected due to this value
4 |     bosluklar = bosluklar.len();
  |                 ^^^^^^^^^^^^^^^ expected `&str`, found `usize`

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

Artık değişkenlerin nasıl çalıştığını keşfettiğimize göre, sahip olabilecekleri daha fazla veri türüne (data types) bakalım.

Veri Türleri

Veri Türleri

Rust’taki her değer, Rust’a ne tür bir veri belirtildiğini söyleyen belirli bir veri türüne (data type) sahiptir, böylece o veriyle nasıl çalışacağını bilir. İki veri türü alt kümesini inceleyeceğiz: skaler (scalar) ve bileşik (compound).

Rust’ın statik tipli (statically typed) bir dil olduğunu aklınızda bulundurun; bu, derleme zamanında tüm değişkenlerin türlerini bilmesi gerektiği anlamına gelir. Derleyici genellikle değere ve onu nasıl kullandığımıza bağlı olarak hangi türü kullanmak istediğimizi çıkarabilir. Bölüm 2’deki “Tahmini Gizli Sayıyla Karşılaştırmak” kısmında parse kullanarak bir String’i sayısal bir türe dönüştürdüğümüz zaman olduğu gibi birçok türün mümkün olduğu durumlarda, şu şekilde bir tür bildirimi eklemeliyiz:

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

Önceki kodda gösterilen : u32 tür bildirimini eklemezsek, Rust aşağıdaki hatayı görüntüler; bu da derleyicinin hangi türü kullanmak istediğimizi bilmek için bizden daha fazla bilgiye ihtiyacı olduğu anlamına gelir:

$ cargo build
   Compiling no_type_annotations v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/output-only-01-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 == _`
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 farklı tür bildirimleri göreceksiniz.

Skaler Türler (Scalar Types)

Bir skaler tür, tek bir değeri temsil eder. Rust’ın dört ana skaler türü vardır: tam sayılar (integers), kayan noktalı sayılar (floating-point numbers), Boolean’lar ve karakterler. Bunları diğer programlama dillerinden tanıyabilirsiniz. Rust’ta nasıl çalıştıklarına bir göz atalım.

Tam Sayı Türleri (Integer Types)

Bir tam sayı, kesirli bileşeni olmayan bir sayıdır. Bölüm 2’de bir tam sayı türü kullandık: u32 türü. Bu tür bildirimi, ilişkilendirildiği değerin 32 bitlik alan kaplayan işaretsiz (unsigned) bir tam sayı olması gerektiğini gösterir (işaretli (signed) tam sayı türleri u yerine i ile 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 (variants) herhangi birini kullanabiliriz.

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

Her varyant işaretli veya işaretsiz olabilir ve açık bir boyuta sahiptir. İşaretli ve işaretsiz terimleri, sayının negatif olmasının mümkün olup olmadığını ifade eder; diğer bir deyişle, sayının bir işaret alması gerekip gerekmediğini (işaretli) veya sadece pozitif olup bu nedenle işaretsiz olarak temsil edilip edilemeyeceğini (işaretsiz) belirtir. Tıpkı kağıt üzerine sayı yazmak gibidir: İşaret önemli olduğunda bir sayı artı veya eksi işaretiyle gösterilir; ancak sayının pozitif olduğunu varsaymak güvenliyse, herhangi bir işaret olmadan gösterilir. İşaretli sayılar ikiye tümleyen (two’s complement) temsili kullanılarak saklanır.

Her işaretli varyant −(2^{n − 1}) ile 2^{n − 1} − 1 (dahil) arasında sayılar saklayabilir; buradaki n, o varyantın kullandığı bit sayısıdır. Dolayısıyla, bir i8, −(2⁷) ile 2⁷ − 1 arasında sayılar saklayabilir, bu da -128 ile 127 arasına eşittir. İşaretsiz varyantlar ise 0 ile 2ⁿ − 1 arasında sayılar saklayabilir, yani bir u8, 0 ile 2⁸ − 1 arasında sayılar saklayabilir ki bu da 0 ile 255 arasına eşittir.

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

Tam sayı sabitlerini (literals) Tablo 3-2’de gösterilen formlardan herhangi birinde yazabilirsiniz. Birden fazla sayısal tür olabilen sayı sabitlerinin, türü belirlemek için 57u8 gibi bir tür son ekine (suffix) izin verdiğini unutmayın. Sayı sabitleri, sayıyı okumayı kolaylaştırmak için görsel bir ayırıcı olarak _ kullanabilir; örneğin 1_000, 1000 belirtmişsiniz gibi aynı değere sahip olacaktır.

Tablo 3-2: Rust’taki Tam Sayı Sabitleri

Peki hangi tür tam sayıyı kullanacağınızı nasıl bileceksiniz? Eğer emin değilseniz, Rust’ın varsayılanları genellikle başlamak için iyi yerlerdir: Tam sayı türleri varsayılan olarak i32’dir. isize veya usize kullanacağınız ana durum, bir çeşit koleksiyonu indekslediğiniz zamandır.

Kayan Noktalı (Floating-Point) Türler

Rust ayrıca ondalık noktaları olan kayan noktalı sayılar için iki ilkel (primitive) türe sahiptir. Rust’ın kayan noktalı türleri, sırasıyla 32 bit ve 64 bit boyutunda olan f32 ve f64’tür. Varsayılan tür f64’tür çünkü modern CPU’larda kabaca f32 ile aynı hızdadır ancak daha fazla hassasiyete (precision) sahiptir. Tüm kayan noktalı türler işaretlidir (signed).

İşte kayan noktalı sayıları iş başında 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.

Sayısal İşlemler

Rust, tüm sayı türleri için beklediğiniz temel matematiksel işlemleri destekler: toplama, çıkarma, çarpma, bölme ve kalan (remainder). Tam sayı bölmesi (integer division) en yakın tam sayıya doğru (sıfıra doğru) keser (truncate). Aşağıdaki kod, let ifadesinde her bir sayısal işlemi 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; // Results in -1

    // kalan
    let kalan = 43 % 5;
}

Bu ifadelerdeki (statements) her bir ifade matematiksel bir operatör kullanır ve tek bir değere dönüşür (evaluates), bu değer daha sonra bir değişkene bağlanır. Ek B, Rust’ın sağladığı tüm operatörlerin bir listesini içerir.

Boolean Türü

Çoğu diğer programlama dilinde olduğu gibi, Rust’taki Boolean türünün iki olası değeri vardır: true ve false. Boolean’ların boyutu bir bayttır. Rust’taki Boolean türü bool kullanılarak belirtilir. Örneğin:

Dosya adı: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

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

Karakter (Character) Türü

Rust’ın char türü, dilin en temel alfabetik türüdür. İşte char değerlerini bildirmeye ilişkin bazı örnekler:

Dosya adı: src/main.rs

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let kalp_gozlu_kedi = '😻';
}

Çift tırnak kullanan metin 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 da onun sadece ASCII’den çok daha fazlasını temsil edebileceği anlamına gelir. Aksanlı harfler; Çince, Japonca ve Korece karakterler; emojiler; ve sıfır genişlikli boşluklar (zero-width spaces) Rust’ta geçerli char değerleridir. Unicode skaler değerleri U+0000 ile U+D7FF ve U+E000 ile U+10FFFF (dahil) arasında değişir. Ancak, “karakter” aslında Unicode’da tam olarak karşılığı olan bir kavram değildir, dolayısıyla bir “karakterin” ne olduğuna dair insani sezginiz (intuition) Rust’taki bir char ile örtüşmeyebilir. Bu konuyu Bölüm 8’deki “Metinleri (Strings) Kullanarak UTF-8 Kodlu Metinleri Saklamak” kısmında ayrıntılı olarak tartışacağız.

Bileşik Türler (Compound Types)

Bileşik türler birden fazla değeri tek bir türde gruplayabilir. Rust’ın iki ilkel bileşik türü vardır: tuple’lar ve array’ler (diziler).

Tuple Türü

Bir tuple, çeşitli türlere sahip bir dizi değeri tek bir bileşik türde (compound type) bir arada gruplamanın genel bir yoludur. Tuple’ların sabit bir uzunluğu vardır: Bir kez bildirildiklerinde boyutları büyüyemez veya küçülemez.

Değerlerin virgülle ayrılmış bir listesini parantez içine yazarak bir tuple oluştururuz. Tuple’daki her pozisyonun (konum) bir türü vardır ve tuple’daki farklı değerlerin türlerinin aynı olması gerekmez. Bu örnekte isteğe bağlı tür bildirimleri ekledik:

Dosya adı: src/main.rs

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

Bir tuple tek bir bileşik eleman olarak kabul edildiği için tup değişkeni tüm tuple’a bağlanır (binds). Bireysel değerleri tuple’dan çıkarmak için, bir tuple değerini parçalamak (destructure) amacıyla desen eşleştirmeyi şu şekilde kullanabiliriz:

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 tuple oluşturur ve onu tup değişkenine bağlar. Daha sonra tup’ı alıp onu üç ayrı değişkene (x, y ve z) dönüştürmek için let ile birlikte bir desen kullanır. Tek bir tuple’ı üç parçaya böldüğü için buna parçalama (destructuring) denir. Son olarak program, 6.4 olan y değerini yazdırır.

Bir tuple elemanına doğrudan bir nokta (.) ve ardından erişmek istediğimiz değerin indeksini (index) kullanarak da erişebiliriz. Ö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 tuple’ını oluşturur ve daha sonra kendi indekslerini kullanarak tuple’ın her bir elemanına erişir. Çoğu programlama dilinde olduğu gibi, tuple’daki ilk indeks 0’dır.

Hiçbir değere sahip olmayan tuple’ın özel bir adı vardır, birim (unit). Bu değer ve onun karşılık gelen türü de () olarak yazılır ve boş bir değeri veya boş bir dönüş türünü temsil eder. İfadeler (expressions), başka bir değer döndürmezlerse kapalı olarak (implicitly) birim değerini döndürürler.

Array (Dizi) Türü

Birden fazla değere sahip bir koleksiyon oluşturmanın başka bir yolu da array (dizi) kullanmaktır. Bir tuple’dan farklı olarak, bir array’in her elemanı aynı türde olmalıdır. Diğer bazı dillerdeki array’lerin aksine, Rust’taki array’lerin sabit bir uzunluğu vardır.

Bir array’deki değerleri köşeli parantezler içinde virgülle ayrılmış bir liste olarak yazarız:

Dosya adı: src/main.rs

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

Array’ler, verilerinizin şimdiye kadar gördüğümüz diğer türlerdeki gibi heap (yığın) alanı yerine stack (yığıt) üzerinde tahsis edilmesini (allocated) istediğinizde (Bölüm 4’te stack ve heap’i daha ayrıntılı tartışacağız) veya her zaman sabit sayıda elemana sahip olduğunuzdan emin olmak istediğinizde kullanışlıdır. Ancak bir array, bir vektör (vector) türü kadar esnek değildir. Bir vektör, standart kütüphane tarafından sağlanan ve boyutu büyüyebilen veya küçülebilen benzer bir koleksiyon türüdür çünkü içeriği heap üzerinde yaşar. Array 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 detaylı tartışır.

Bununla birlikte, eleman sayısının değişmeyeceğini bildiğiniz durumlarda array’ler daha kullanışlıdır. Örneğin, bir programda ayların isimlerini kullanıyor olsaydınız, her zaman 12 eleman içereceğini bildiğiniz için muhtemelen bir vektör yerine bir array kullanırdınız:

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

Bir array’in türünü yazarken köşeli parantezler içinde her bir elemanın türünü, ardından noktalı virgül ve dizideki eleman sayısını şu şekilde yazarsınız:

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

Burada, her elemanın türü i32’dir. Noktalı virgülden sonra gelen 5 sayısı, dizinin beş eleman içerdiğini belirtir.

Her bir eleman için aynı değere sahip bir array’i şu şekilde başlatabilirsiniz: önce başlangıç değerini, ardından bir noktalı virgülü ve ardından köşeli parantezler içindeki dizinin uzunluğunu belirtebilirsiniz:

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

a adındaki dizi, başlangıçta tamamı 3 değerine ayarlanacak olan 5 eleman içerecektir. Bu, let a = [3, 3, 3, 3, 3]; yazmakla aynı şeydir ancak daha kısa bir yoldur.

Array Elemanlarına Erişim

Bir array, stack üzerinde tahsis edilebilen bilinen, sabit boyutlu tek bir bellek yığınıdır (chunk of memory). İndekslemeyi kullanarak array 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 adındaki değişken dizideki [0] indeksindeki değer olduğu için 1 değerini alacaktır. ikinci adındaki değişken dizideki [1] indeksinden 2 değerini alacaktır.

Geçersiz Array Elemanlarına Erişim (Invalid Array Element Access)

Bir array’in sonundan daha ileri bir noktasındaki (past the end of the array) bir elemanına erişmeye çalışırsanız ne olacağına bakalım. Kullanıcıdan bir array indeksi almak için Bölüm 2’deki tahmin oyununa benzer şekilde bu kodu çalıştırdığınızı varsayalım:

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 sayi değildi!");

    let element = a[indeks];

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

Bu kod başarıyla derlenir. Bu kodu cargo run komutunu kullanarak çalıştırırsanız ve 0, 1, 2, 3 veya 4 değerlerinden birini girerseniz, program array’deki o indekse karşılık gelen değeri yazdıracaktır. Eğer dizinin sonunu geçen bir sayı (örneğin 10) girerseniz, şöyle bir çıktı göreceksiniz:

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ğer kullanıldığı noktada bir çalışma zamanı hatası verdi. Program bir hata mesajıyla kapandı ve son println! ifadesini çalıştırmadı. İndekslemeyi kullanarak bir elemana erişmeye çalıştığınızda Rust, belirttiğiniz indeksin dizi uzunluğundan daha az olup olmadığını kontrol edecektir. İndeks dizi uzunluğundan büyük veya ona eşitse, Rust paniğe neden olur. Bu kontrolün çalışma zamanında gerçekleşmesi gerekir, özellikle de bu durumda, çünkü derleyicinin bir kullanıcının kodu çalıştırdığında ne değer gireceğini bilmesi imkansızdır.

Bu, Rust’ın bellek güvenliği prensiplerinin iş başındaki bir örneğidir. Birçok alt seviye dilde bu tür bir kontrol yapılmaz ve yanlış bir indeks sağladığınızda geçersiz belleğe erişilebilir. Rust, bellek erişimine izin verip devam etmek yerine hemen programdan çıkarak sizi bu tür hatalara karşı korur. Bölüm 9, Rust’ın hata yönetimini ve panik yaratmayan ya da geçersiz bellek erişimine izin vermeyen okunabilir, güvenli kodu nasıl yazabileceğinizi daha ayrıntılı tartışacaktır.

Fonksiyonlar

Fonksiyonlar

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

Rust kodu, fonksiyon ve değişken isimleri için geleneksel stil olarak snake_case (yılan stili) kullanır; bu stilde tüm harfler küçüktür ve kelimeler alt çizgiyle ayrı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!("Baska bir fonksiyon.");
}

Rust’ta bir fonksiyonu, fn ifadesini, 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 söyler.

Tanımladığımız herhangi bir fonksiyonu, adını ve ardından bir çift parantez yazarak çağırabiliriz. baska_bir_fonksiyon programda tanımlandığı için main fonksiyonunun içinden çağrılabilir. baska_bir_fonksiyon’u kaynak kodunda main fonksiyonundan sonra tanımladığımıza dikkat edin; ondan önce de tanımlayabilirdik. Rust, fonksiyonlarınızı nerede tanımladığınızla ilgilenmez, yalnızca çağırıcı tarafından görülebilen bir kapsamda bir yerlerde tanımlanmış olmalarına bakar.

Fonksiyonları daha fazla keşfetmek için fonksiyonlar adında yeni bir ikili proje başlatalım. baska_bir_fonksiyon örneğini src/main.rs dosyasına yerleştirin ve çalıştırın. Aşağıdaki çıktıyı görmelisiniz:

$ cargo run
   Compiling functions v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-16-functions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/functions`
Merhaba, dünya!
Baska bir fonksiyon.

Satırlar, main fonksiyonunda göründükleri sıraya göre çalıştırılır. Önce “Merhaba, dünya!” mesajı yazdırılır ve ardından baska_bir_fonksiyon çağrılır ve onun mesajı yazdırılır.

Parametreler

Fonksiyonları, bir fonksiyonun imzasının bir parçası olan özel değişkenler olan parametreleri olacak şekilde tanımlayabiliriz. Bir fonksiyonun parametreleri olduğunda, o parametreler için fonksiyona somut (concrete) değerler sağlayabilirsiniz. Teknik olarak, somut değerlere argümanlar denir, ancak günlük konuşmada insanlar parametre ve argüman kelimelerini bir fonksiyonun tanımındaki değişkenler veya bir fonksiyonu çağırdığınızda iletilen somut değerler için birbirinin yerine kullanma eğilimindedir.

baska_bir_fonksiyon’un bu versiyonunda 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 functions v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-17-functions-with-parameters)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/functions`
x'in değeri: 5

baska_bir_fonksiyon bildiriminin x adında bir parametresi vardır. x’in türü i32 olarak belirtilmiştir. baska_bir_fonksiyon’a 5 değerini verdiğimizde, println! makrosu 5’i, biçim dizisinde (format string) x içeren süslü parantez çiftinin bulunduğu yere koyar.

Fonksiyon imzalarında, her parametrenin türünü mutlaka bildirmelisiniz. Bu, Rust’ın tasarımında alınmış bilinçli bir karardır: Fonksiyon tanımlarında tür bildirimi gerektirmek, derleyicinin kodun başka bir yerinde ne tür bir veri demek istediğinizi anlamak için bu bildirimleri kullanmanıza neredeyse hiç ihtiyaç duymayacağı anlamına gelir. Derleyici ayrıca, fonksiyonun hangi türleri beklediğini bilirse daha yararlı hata mesajları da verebilir.

Birden fazla parametre tanımlarken, parametre bildirimlerini şu şekilde virgüllerle 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 parametreye sahip etiketli_olcum_yazdir adında bir fonksiyon oluşturur. İlk parametre deger olarak adlandırılır ve bir i32’dir. İkincisi birim_etiketi (unit_label) olarak adlandırılır ve char türündedir. Fonksiyon daha sonra hem deger hem de birim_etiketi’ni içeren bir metin yazdırır.

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

$ cargo run
   Compiling functions v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-18-functions-with-multiple-parameters)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/functions`
Ölçüm değeri: 5h

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

İfadeler (Statements) ve İbareler (Expressions)

Fonksiyon gövdeleri, isteğe bağlı olarak bir ibare ile biten bir dizi ifadeden (statements) oluşur. Şimdiye kadar ele aldığımız fonksiyonlar bitirici bir ibare (ending expression) içermiyordu, ancak bir ifadenin bir parçası olarak bir ibare gördünüz. Rust ibare tabanlı bir dil olduğu için, bu anlaşılması gereken önemli bir ayrımdır. Diğer dillerin aynı ayrımları yoktur, bu yüzden ifadelerin ve ibarelerin ne olduğuna ve farklılıklarının fonksiyonların gövdelerini nasıl etkilediğine bir bakalım.

• İfadeler (Statements), bir eylem gerçekleştiren ancak bir değer döndürmeyen talimatlardır.
• İbareler (Expressions) ise bir değer üretecek şekilde hesaplanan kod parçalarıdır.

Bazı örneklere bakalım.

Aslında daha önce de ifadeler (statements) ve ibareler (expressions) kullandık. Bir değişken oluşturmak ve let anahtar kelimesiyle ona bir değer atamak bir ifadedir. Liste 3-1’de, let y = 6; bir ifadedir.

fn main() {
    let y = 6;
}

Fonksiyon tanımları da ifadelerdir; önceki örneğin tamamı başlı başına bir ifadedir. (Kısaca göreceğimiz gibi, bir fonksiyon çağırmak bir ifade (statement) değildir.)

İfadeler (statements) değer döndürmezler. Bu nedenle, aşağıdaki kodun yapmaya çalıştığı gibi bir let ifadesini başka bir değişkene atayamazsınız; bir hata 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ünecektir:

$ cargo run
   Compiling functions v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-19-statements-vs-expressions)
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: `functions` (bin "functions") generated 1 warning
error: could not compile `functions` (bin "functions") due to 1 previous error; 1 warning emitted

let y = 6 ifadesi bir değer döndürmez, bu yüzden x’in bağlanacağı bir şey yoktur. Bu durum, atamanın (assignment) atamanın kendi değerini döndürdüğü C ve Ruby gibi diğer dillerde olanlardan farklıdır. Bu dillerde, x = y = 6 yazarak hem x hem de y’nin 6 değerine sahip olmasını sağlayabilirsiniz; Rust’ta ise durum böyle değildir.

İbareler (Expressions) ise bir değere dönüşür ve Rust’ta yazacağınız kodun büyük bir bölümünü oluştururlar. Örneğin 5 + 6 gibi, 11 değerini üreten matematiksel bir işlemi (ibareyi) ele alalım. İbareler, ifadelerin parçası olabilir: Liste 3-1’de, let y = 6; ifadesindeki 6, 6 değerini üreten bir ibaredir. Bir fonksiyonu çağırmak bir ibaredir. Bir makroyu çağırmak bir ibaredir. Süslü parantezlerle oluşturulan yeni bir kapsam bloğu da bir ibaredir, örneğin:

Dosya adı: src/main.rs

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

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

Şu ibare:

{
    let x = 3;
    x + 1
}

Bu örnekte 4 değerini üreten (evaluates) bir bloktur. Bu değer, let ifadesinin bir parçası olarak y’ye bağlanır. x + 1 satırının sonunda, şimdiye kadar gördüğünüz çoğu satırın aksine noktalı virgül (;) olmadığına dikkat edin. İbarelerin (expressions) sonunda noktalı virgül bulunmaz. Bir ibarenin sonuna noktalı virgül eklerseniz, onu bir ifadeye (statement) dönüştürürsünüz ve bu durumda bir değer döndürmez. Sırada, fonksiyonların dönüş değerlerini (return values) ve ibareleri incelerken bunu aklınızda bulundurun.

Dönüş Değerleri Olan Fonksiyonlar (Functions with Return Values)

Fonksiyonlar, kendilerini çağıran koda değerler döndürebilirler. Dönüş değerlerini adlandırmayız, ancak türlerini bir ok işaretinden (->) sonra bildirmemiz (declare) gerekir. Rust’ta, bir fonksiyonun dönüş değeri, fonksiyonun gövdesinin bloğundaki son ibarenin değeriyle eş anlamlıdır. return anahtar kelimesini kullanarak ve bir değer belirterek bir fonksiyondan erkenden dönebilirsiniz (return early), ancak çoğu fonksiyon son ibareyi örtük olarak (implicitly) döndürür. İşte bir 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 (five) fonksiyonunun içinde hiçbir fonksiyon çağrısı, makro ve hatta let ifadesi (statement) yoktur—sadece 5 sayısı vardı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ı şu şekilde görünmelidir:

$ cargo run
   Compiling functions v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-21-function-return-values)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/functions`
x'in değeri: 5

bes fonksiyonundaki 5, fonksiyonun dönüş değeridir ve bu yüzden dönüş türü i32’dir. Bunu biraz daha detaylı inceleyelim. İki önemli kısım vardır: İlk olarak, let x = bes(); satırı bir değişkeni başlatmak (initialize) için bir fonksiyonun dönüş değerini kullandığımızı gösterir. bes fonksiyonu 5 döndürdüğü için, bu satır şununla aynıdır:

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

İkincisi, bes fonksiyonunun hiçbir parametresi yoktur ve dönüş değerinin türünü tanımlar, ancak fonksiyonun gövdesi, döndürmek istediğimiz değere sahip bir ibare olduğu için, noktalı virgülü olmayan yalnız bir 5’tir.

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 kod çalıştırıldığında x'in değeri: 6 (The value of x is: 6) yazdıracaktır. Peki x + 1 içeren satırın sonuna bir noktalı virgül koyarsak ve onu bir ibareden bir ifadeye (statement) çevirirsek 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 functions v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-23-statements-dont-return-values)
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 `functions` (bin "functions") due to 1 previous error

Ana hata mesajı olan mismatched types (uyumsuz türler), bu kodun temel sorununu ortaya koyar. arti_bir (plus_one) fonksiyonunun tanımı bir i32 döndüreceğini söyler, ancak ifadeler (statements) bir değer üretmez; bu durum birim türü olan () ile ifade edilir. Bu nedenle, hiçbir şey döndürülmez, bu da fonksiyon tanımıyla çelişir ve bir hataya neden olur. Bu çıktıda Rust, muhtemelen bu sorunu düzeltmeye yardımcı olacak bir mesaj sağlar: Noktalı virgülün kaldırılmasını önerir, ki bu da hatayı düzeltecektir.

Yorumlar

Yorumlar

Tüm programcılar kodlarının kolay anlaşılır olması için çaba gösterir, ancak bazen fazladan açıklamaya gerek duyulur. Bu gibi durumlarda programcılar, kaynak kodlarına derleyicinin (compiler) görmezden geleceği, ancak kaynak kodunu okuyan kişilerin yararlı bulabileceği yorumlar (comments) bırakırlar.

İşte basit bir yorum:

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

Rust’ta, geleneksel yorum stili, bir yoruma iki eğik çizgi (slash) ile başlar ve yorum satır sonuna kadar devam eder. Tek bir satırı aşan yorumlar için, şu şekilde her satıra // eklemeniz gerekecektir:

#![allow(unused)]
fn main() {
// Burada çok karmaşık bir şey yapıyoruz, o kadar uzun ki
// bunu yapmak için birden fazla yorum satırına ihtiyacımız var! Vay canına! 
// Umarım bu yorum neler olup bittiğini açıklar.
}

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

Dosya adı: src/main.rs

fn main() {
    let sanli_sayi = 7; // I'm feeling lucky today
}

Ancak yorumların daha çok bu formatta, yani not düştüğü kodun üstünde ayrı bir satırda kullanıldığını göreceksiniz:

Dosya adı: src/main.rs

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

Rust’ın ayrıca Bölüm 14’teki “Crates.io’da Crate Yayınlamak” kısmında tartışacağımız dokümantasyon yorumları (documentation comments) adında başka bir yorum türü daha vardır.

Kontrol Akışı

Kontrol Akışı (Control Flow)

Bir koşulun true (doğru) olup olmadığına bağlı olarak bazı kodları çalıştırabilme veya bir koşul true olduğu sürece bazı kodları tekrar tekrar çalıştırabilme yeteneği, çoğu programlama dilinde temel yapı taşlarıdır. Rust kodunun yürütme akışını kontrol etmenizi sağlayan en yaygın yapılar if ifadeleri ve döngülerdir (loops).

if İfadeleri (Expressions)

Bir if ifadesi, koşullara bağlı olarak kodunuzu dallandırmanıza (branch) olanak tanır. Bir koşul sağlarsınız ve ardından, “Eğer bu koşul karşılanırsa, bu kod bloğunu çalıştır. Eğer koşul karşılanmazsa, bu kod bloğunu çalıştırma” dersiniz.

if ifadesini keşfetmek için projects dizininizde dallanmalar (branches) adında yeni bir proje oluşturun. src/main.rs dosyasına aşağıdakini girin:

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 durumda koşul, sayi (number) değişkeninin 5’ten küçük bir değere sahip olup olmadığını kontrol eder. Koşul true (doğru) ise çalıştırılacak kod bloğunu, hemen koşuldan sonra süslü parantezler içine yerleştiririz. if ifadelerindeki koşullarla ilişkili kod bloklarına bazen Bölüm 2’nin “Tahmini Gizli Sayıyla Karşılaştırmak” kısmında tartıştığımız match ifadelerindeki kollar gibi kollar (arms) denir.

İsteğe bağlı olarak (ki burada yapmayı seçtik), koşulun false (yanlış) çıkması durumunda programa çalıştırılması için alternatif bir kod bloğu vermek üzere bir else ifadesi de ekleyebiliriz. Eğer bir else ifadesi sağlamazsanız ve koşul false ise, program sadece if bloğunu atlar ve bir sonraki kod parçasına geçer.

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

$ cargo run
   Compiling branches v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-26-if-true)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/branches`
koşul doğru

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 branches v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-27-if-false)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/branches`
koşul yanlış

Ayrıca bu koddaki koşulun mutlaka bir bool (Boolean) olması gerektiğini de belirtmekte fayda var. Eğer koşul bir bool değilse bir hata alırız. Örneğin, şu kodu çalıştırmayı deneyin:

Dosya adı: src/main.rs

fn main() {
    let sayi = 3;

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

if koşulu bu sefer 3 değerini üretiyor ve Rust bir hata fırlatıyor:

$ cargo run
   Compiling branches v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-28-if-condition-must-be-bool)
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 `branches` (bin "branches") due to 1 previous error

Hata, Rust’ın bir bool beklediğini ancak bir tam sayı aldığını gösterir. Ruby ve JavaScript gibi dillerin aksine Rust, Boolean olmayan türleri otomatik olarak bir Boolean’a dönüştürmeye çalışmaz. Açık olmalısınız ve if’e koşul olarak her zaman bir Boolean sağlamalısınız. Örneğin if kod bloğunun yalnızca bir sayı 0’a eşit olmadığında çalışmasını istiyorsak, if ifadesini şu şekilde değiştirebiliriz:

Dosya adı: src/main.rs

fn main() {
    let sayi = 3;

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

Bu kodu çalıştırmak sayı sıfırdan farklı bir şeydi (number was something other than zero) yazdıracaktır.

else if İle Birden Fazla Koşulu Ele Almak

if ve else’i bir else if ifadesinde birleştirerek birden fazla koşul kullanabilirsiniz. Ö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ı yol vardır. Çalıştırdıktan sonra aşağıdaki çıktıyı görmelisiniz:

$ cargo run
   Compiling branches v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-30-else-if)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/branches`
sayi 3'e bölünebilir

Bu program çalıştığında, her bir if ifadesini sırayla kontrol eder ve koşulun true olduğu ilk gövdeyi çalıştırır. 6 sayısının 2’ye bölünebilmesine rağmen, sayı 2'ye bölünebilir (number is divisible by 2) çıktısını ya da else bloğundan gelen sayı 4'e, 3'e veya 2'ye bölünemez (number is not divisible by 4, 3, or 2) metnini görmediğimize dikkat edin. Bunun nedeni, Rust’ın bloğu yalnızca true olan ilk koşul için çalıştırmasıdır ve bir tane bulduğunda geri kalanları kontrol dahi etmez.

Çok fazla else if ifadesi kullanmak kodunuzu karmaşıklaştırabilir, bu nedenle birden fazla varsa kodunuzu yeniden yapılandırmak isteyebilirsiniz. Bölüm 6, bu tür durumlar için match adında güçlü bir Rust dallanma yapısını açıklamaktadır.

Bir let İfadesinde (Statement) if Kullanmak

if bir ibare olduğundan, Liste 3-2’de olduğu gibi sonucunu bir değişkene atamak (assign) için onu bir let ifadesinin sağ tarafında kullanabiliriz.

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

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

sayi değişkeni, if ifadesinin sonucuna bağlı olarak bir değere bağlanacaktır (bound). Ne olduğunu görmek için bu kodu çalıştırın:

$ cargo run
   Compiling branches v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/listing-03-02)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/branches`
sayi'nin değeri: 5

Kod bloklarının, içlerindeki son ibarenin değerine dönüştüğünü ve sayıların da kendi başlarına birer ibare olduğunu unutmayın. Bu durumda, tüm if ifadesinin değeri hangi kod bloğunun çalıştırıldığına bağlıdır. Bu da if’in her bir kolundan (arm) sonuç olma potansiyeline sahip olan değerlerin aynı türde olması gerektiği anlamına gelir; Liste 3-2’de hem if kolunun hem de else kolunun sonuçları i32 tam sayılarıydı. Eğer türler uyumsuzsa (mismatched), aşağıdaki örnekte olduğu gibi bir hata alırız:

Dosya adı: src/main.rs

fn main() {
    let durum = true;

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

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

Bu kodu derlemeye çalıştığımızda bir hata alırız. if ve else kollarının uyumsuz değer türleri vardır ve Rust, sorunun programda tam olarak nerede bulunacağını gösterir:

$ cargo run
   Compiling branches v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-31-arms-must-return-same-type)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:42
  |
4 |     let sayi = if condition { 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 `branches` (bin "branches") due to 1 previous error

if bloğundaki ibare bir tam sayı üretirken, else bloğundaki ibare bir metin (string) üretir. Bu işe yaramaz, çünkü değişkenler tek bir türe sahip olmalıdır ve Rust’ın derleme zamanında sayi değişkeninin hangi türde olduğunu kesin olarak bilmesi gerekir. sayi’nin türünü bilmek, derleyicinin sayi’yi 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 belirlenirse Rust bunu yapamazdı; derleyicinin herhangi bir değişken için birden fazla varsayımsal türü izlemesi gerekseydi, derleyici daha karmaşık olurdu ve kod hakkında daha az garanti verebilirdi.

Döngülerle (Loops) Tekrar

Bir kod bloğunu birden fazla kez çalıştırmak genellikle faydalıdır. Bu görev için Rust, döngü gövdesindeki kodu sonuna kadar çalıştıracak ve ardından hemen tekrar başa dönecek çeşitli döngüler (loops) sağlar. Döngülerle denemeler yapmak için donguler (loops) adında yeni bir proje oluşturalım.

Rust’ın üç çeşit döngüsü vardır: loop, while ve for. Her birini deneyelim.

loop İle Kodu Tekrarlamak

loop anahtar kelimesi, Rust’a bir kod bloğunu sonsuza kadar veya siz onu açıkça durdurana kadar tekrar tekrar çalıştırmasını söyler.

Bir örnek olarak, donguler dizininizdeki src/main.rs dosyasını şu şekilde görünecek biçimde değiştirin:

Dosya adı: src/main.rs

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

Bu programı çalıştırdığımızda, programı manuel olarak durdurana kadar sürekli olarak tekrar! (again!) yazdırıldığını göreceğiz. Çoğu terminal, sürekli bir döngüde sıkışmış bir programı kesintiye uğratmak (interrupt) için ctrl-C klavye kısayolunu destekler. Bir deneyin:

$ 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 yeri temsil eder.

Kesme (interrupt) sinyalini aldığında kodun döngünün neresinde olduğuna bağlı olarak, ^C’den sonra tekrar! kelimesinin yazdırıldığını görebilir veya görmeyebilirsiniz.

Neyse ki Rust, kodu kullanarak bir döngüden çıkmanın bir yolunu da sağlar. Programa döngüyü yürütmeyi ne zaman durduracağını söylemek için döngünün içine break (kır) anahtar kelimesini yerleştirebilirsiniz. Bölüm 2’nin “Doğru Tahminden Sonra Çıkmak” kısmındaki tahmin oyununda, kullanıcı doğru sayıyı tahmin edip oyunu kazandığında programdan çıkmak için bunu yaptığımızı hatırlayın.

Tahmin oyununda ayrıca continue (devam et) kullandık, bu kelime bir döngü içinde programa o döngü adımındaki (iteration) geri kalan tüm kodu atlamasını ve bir sonraki adıma (iteration) geçmesini söyler.

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

loop’un kullanım alanlarından biri, bir iş parçacığının işini tamamlayıp tamamlamadığını kontrol etmek gibi, başarısız olabileceğini bildiğiniz bir işlemi yeniden denemektir. Ayrıca bu işlemin sonucunu döngüden çıkarıp kodunuzun geri kalanına aktarmanız 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 ekleyebilirsiniz; burada gösterildiği gibi, bu değer daha sonra kullanabilmeniz için döngüden dışarı döndürülecektir:

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 (counter) adında bir değişken bildiriyor ve onu 0’a ayarlıyoruz. Sonra, döngüden dönen değeri tutması için sonuc (result) adında bir değişken bildiriyoruz. Döngünün her adımında (iteration) sayac değişkenine 1 ekliyor ve ardından sayac’ın 10’a eşit olup olmadığını kontrol ediyoruz. Eşit olduğunda, break anahtar kelimesini sayac * 2 değeriyle kullanıyoruz. Döngüden sonra, sonuc değişkenine değer atayan ifadeyi (statement) sonlandırmak için bir noktalı virgül kullanıyoruz. Son olarak sonuc değişkenindeki değeri yazdırıyoruz, ki bu örnekte bu 20’dir.

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

Döngü Etiketleri (Loop Labels) ile Belirsizliği Gidermek

Eğer iç içe geçmiş döngüleriniz varsa, break ve continue o noktadaki en içteki (innermost) döngüye uygulanır. İsteğe bağlı olarak bir döngüde bir döngü etiketi (loop label) belirtebilirsiniz; daha sonra bu etiketi break veya continue ile kullanarak bu anahtar kelimelerin en içteki döngü yerine etiketlenmiş döngüye uygulanacağını belirtebilirsiniz. Döngü etiketleri tek bir tırnak (single quote) ile başlamalıdır. İşte içi içe iki döngü içeren bir örnek:

fn main() {
    let mut ileri_sayim = 0;
    'yukari_sayma: loop {
        println!("İleri ayı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 ('counting_up) etiketine sahiptir ve 0’dan 2’ye kadar yukarı sayacaktır. Etiketi olmayan içteki döngü ise 10’dan 9’a kadar geriye sayar. Etiket belirtmeyen ilk break sadece iç döngüden çıkacaktır. break 'yukari_sayma; ifadesi ise dış döngüden çıkacaktır. Bu kod şunu yazdırır:

$ cargo run
   Compiling loops v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/no-listing-32-5-loop-labels)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.06s
     Running `target/debug/loops`
İleri ayım = 0
Geri sayım = 10
Geri sayım = 9
İleri ayım = 1
Geri sayım = 10
Geri sayım = 9
İleri ayım = 2
Geri sayım = 10
Son İlerleme = 2

while İle Koşullu Döngüleri Düzene Sokmak (Streamlining)

Bir programın genellikle bir döngü içinde bir koşulu değerlendirmesi gerekecektir. Koşul true olduğu sürece (while) döngü çalışır. Koşul true olmayı bıraktığında, program break çağrısı yaparak döngüyü durdurur. Bunun gibi bir davranışı loop, if, else ve break kombinasyonu kullanarak uygulamak mümkündür; isterseniz bunu şimdi bir programda deneyebilirsiniz. Ancak bu kalıp (pattern) o kadar yaygındır ki, Rust bunun için while döngüsü adı verilen yerleşik (built-in) bir dil yapısına sahiptir. Liste 3-3’te, programı üç kez döngüye sokmak, her seferinde geriye doğru saymak ve ardından döngüden 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 kullansaydınız gerekli olacak olan çok sayıda iç içe geçmeyi (nesting) ortadan kaldırır ve daha açıktır (clearer). Bir koşul true olarak değerlendirildiği sürece kod çalışır; aksi halde döngüden çıkar.

for İle Bir Koleksiyon Üzerinde Döngü Kurmak (Looping Through)

Bir array (dizi) gibi bir koleksiyonun elemanları üzerinde döngü kurmak için while yapısını kullanmayı seçebilirsiniz. Örneğin Liste 3-4’teki döngü, a dizisindeki her bir elemanı 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 üzerinden yukarı doğru sayar. 0 indeksinden (index) başlar ve dizideki son indekse ulaşana kadar (yani, indeks < 5 artık true olmayana kadar) döngüye devam eder. Bu kodu çalıştırmak, dizideki her bir elemanı yazdıracaktır:

$ cargo run
   Compiling loops v0.1.0 ($PROJE/listings/ch03-common-programming-concepts/listing-03-04)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/loops`
değer: 10
değer: 20
değer: 30
değer: 40
değer: 50

Beklendiği gibi beş dizi değerinin tümü terminalde belirir. indeks (index) bir noktada 5 değerine ulaşacak olsa da, döngü diziden altıncı bir değeri getirmeye çalışmadan önce çalışmayı durdurur.

Bununla birlikte, bu yaklaşım hataya açıktır (error-prone); indeks değeri veya test koşulu yanlışsa programın panik yapmasına neden olabiliriz. Örneğin, a dizisinin tanımını dört elemanı olacak şekilde değiştirdiyseniz ancak durumu while indeks < 4 olarak güncellemeyi unuttuysanız, kod panikler. Ayrıca derleyici, döngüdeki her bir adımda (iteration) indeksin dizinin sınırları içinde olup olmadığına dair koşullu kontrolü gerçekleştirmek için çalışma zamanı kodu eklediği için yavaştır.

Daha öz bir alternatif olarak, bir for döngüsü kullanabilir ve bir koleksiyondaki her öğe için biraz kod çalıştırabilirsiniz. Bir for döngüsü, Liste 3-5’teki kod 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’teki ile aynı çıktıyı göreceğiz. Daha da önemlisi, artık kodun güvenliğini artırdık ve dizinin sonunun ötesine geçmekten veya yeterince ileri gitmeyip bazı öğeleri kaçırmaktan kaynaklanabilecek hata (bug) olasılığını ortadan kaldırdık. İndeksin her adımda dizinin uzunluğuyla karşılaştırılmasına gerek olmadığı için, for döngülerinden üretilen makine kodu (machine code) da daha verimli olabilir.

for döngüsünü kullanırsanız, Liste 3-4’te kullanılan yöntemde yapacağınız gibi, dizideki değerlerin sayısını değiştirdiğinizde başka herhangi bir kodu değiştirmeyi hatırlamanız gerekmez.

for döngülerinin güvenliği ve kısalığı (conciseness), onları Rust’ta en sık kullanılan döngü yapısı yapar. Liste 3-3’te while döngüsünü kullanan geri sayım örneğinde olduğu gibi, bir kodu belirli bir sayıda çalıştırmak istediğiniz durumlarda bile çoğu Rustacean bir for döngüsü kullanır. Bunu yapmanın yolu, standart kütüphane tarafından sağlanan ve bir sayıdan başlayıp başka bir sayıdan önce bitecek şekilde sırayla (in sequence) tüm sayıları üreten bir Aralık (Range) kullanmaktır.

Aralığı (range) tersine çevirmek için henüz bahsetmediğimiz başka bir metot olan rev’i ve bir for döngüsünü kullanan geri sayımın nasıl görüneceği aşağıda verilmiştir:

Dosya adı: src/main.rs

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

Bu kod biraz daha güzel, değil mi?

Özet

Başardınız! Bu epey büyük bir bölümdü: Değişkenler, skaler ve bileşik veri türleri, fonksiyonlar, yorumlar, if ifadeleri ve döngüler hakkında bilgi edindiniz! Bu bölümde tartışılan kavramlarla pratik yapmak için, şunları yapacak programlar oluşturmayı deneyin:

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

İlerlemeye hazır olduğunuzda, Rust’ta diğer programlama dillerinde yaygın olarak bulunmayan bir konudan bahsedeceğiz: Sahiplik.

Sahipliği Anlamak

Sahiplik, Rust’ın en özgün ö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 (memory safety) garantisi sağlamasına olanak tanır, bu yüzden sahipliğin nasıl çalıştığını anlamak çok önemlidir. Bu bölümde, sahipliğin yanı sıra bununla bağlantılı bazı özellikleri de konuşacağız: ödünç alma, dilimler ve Rust’ın verileri bellekte nasıl düzenlediği.

Sahiplik Nedir?

Sahiplik Nedir?

Sahiplik, 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 kullanacaklarını yönetmek zorundadır. Bazı dillerde, program çalışırken artık kullanılmayan belleği düzenli olarak arayan bir çöp toplayıcı (garbage collection) bulunur; diğer dillerde ise programcı belleği açıkça ayırmalı ve serbest bırakmalıdır. Rust üçüncü bir yaklaşım kullanır: Bellek, derleyicinin kontrol ettiği bir dizi kuralla sahiplik sistemi üzerinden yönetilir. Kurallardan herhangi biri ihlal edilirse, program derlenmez. Sahiplik özelliklerinin hiçbiri, programınız çalışırken onu yavaşlatmaz.

Sahiplik birçok programcı için yeni bir kavram olduğundan, alışmak biraz zaman alabilir. İyi haber şu ki, Rust’ta ve sahiplik sisteminin kurallarında ne kadar deneyim kazanırsanız, güvenli ve verimli kod geliştirmeyi o kadar doğal bulacaksınız. Üzerinde çalışmaya devam edin!

Sahipliği anladığınızda, Rust’ı benzersiz yapan ö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 bazı örnekler üzerinde çalışarak sahipliği öğreneceksiniz: stringler (metinler).

Sahiplik Kuralları

Öncelikle, sahiplik kurallarına bir göz atalım. Onları gösteren örnekler üzerinde çalışırken bu kuralları aklınızda bulundurun:

• Rust’taki her değerin bir sahibi vardır.
• Aynı anda sadece bir sahip olabilir.
• Sahip kapsamın dışına çıktığında, değer düşürülecektir (drop).

Değişken Kapsamı (Variable Scope)

Temel Rust sözdizimini geçtiğimize göre, örneklerdeki tüm fn main() { kodlarını dahil etmeyeceğiz, bu yüzden takip ediyorsanız, aşağıdaki örnekleri manuel olarak bir main fonksiyonunun içine koyduğunuzdan emin olun. Sonuç olarak, örneklerimiz biraz daha özlü olacak ve klişe kodlardan (boilerplate) ziyade asıl detaylara odaklanmamızı sağlayacak.

Sahipliğin ilk örneği olarak, bazı değişkenlerin kapsamına bakacağız. Bir 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, stringin değerinin programımızın metnine doğrudan (hardcoded) yazıldığı bir string literalini (sabit metni) ifade eder. Değişken, tanımlandığı andan mevcut kapsamın sonuna kadar geçerlidir. Liste 4-1, metin değişkeninin nerede geçerli olacağını açıklayan yorumlarla birlikte bir programı göstermektedir.

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 iki önemli zaman noktası vardır:

• metin kapsama girdiğinde geçerlidir.
• Kapsamdan çıkana kadar geçerliliğini korur.

Bu noktada, kapsamlar ve değişkenlerin ne zaman geçerli olduğu arasındaki ilişki diğer programlama dillerindekine benzer. Şimdi String türünü tanıtarak bu anlayışın üzerine 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 ele alınan türlerin boyutu bilinmektedir, stack’te saklanabilir ve kapsamları sona erdiğinde stack’ten çıkarılabilirler. Kodun başka bir bölümünün aynı değeri farklı bir kapsamda kullanması gerekiyorsa yeni, bağımsız bir örnek oluşturmak için hızlı ve kolay bir şekilde kopyalanabilirler. Ancak, heap’te depolanan verilere bakmak ve Rust’ın bu verileri ne zaman temizleyeceğini nasıl bildiğini keşfetmek istiyoruz ve String türü bunun için harika bir örnektir.

String’in sahiplikle ilgili olan kısımlarına yoğunlaşacağız. Bu yönler, standart kütüphane tarafından sağlanmış veya sizin tarafınızdan oluşturulmuş olsun, diğer karmaşık veri türleri için de geçerlidir. String’in sahiplik dışı yönlerini Bölüm 8’de tartışacağız.

Bir string değerinin programımıza doğrudan kodlandığı string literallerini (sabit metinleri) zaten görmüştük. Sabit metinler kullanışlıdır, ancak metin kullanmak isteyebileceğimiz her durum için uygun değillerdir. Bunun bir nedeni değişmez olmalarıdır. Bir diğeri ise kodumuzu yazarken her metin değerinin bilinememesidir: Örneğin, ya kullanıcı girdisini alıp saklamak istiyorsak? Rust’ın bu tür durumlar için String türü vardır. Bu tür, heap üzerinde ayrılan verileri yönetir ve bu nedenle derleme zamanında bize bilinmeyen miktarda metni depolayabilir. from fonksiyonunu kullanarak bir string literalinden bir String oluşturabilirsiniz, örneğin:

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

Çift iki nokta üst üste :: operatörü, bu özel from fonksiyonunu string_from gibi bir isim kullanmak yerine String türü altında isimlendirmemize (namespace) olanak tanır. Bu sözdizimini Bölüm 5’teki “Metotlar” bölümünde ve Bölüm 7’deki modüllerle isimlendirme uzaylarından bahsederken “Modül Ağacındaki Bir Öğeye Başvurmak İçin Yollar” bölümünde daha fazla tartışacağız.

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

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 literaller değiştirilemez? Fark, bu iki türün bellekle nasıl başa çıktığına bağlıdır.

Bellek ve Ayırma (Memory and Allocation)

Sabit bir metin söz konusu olduğunda, içeriği derleme zamanında biliyoruz, bu yüzden metin doğrudan son çalıştırılabilir dosyanın içine yerleştirilir (hardcoded). String literallerinin hızlı ve verimli olmasının nedeni budur. Ancak bu özellikler yalnızca metin literalinin değişmezliğinden (immutability) gelir. 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 bir bellek yığını koyamayız.

String türüyle, değiştirilebilir, büyüyebilir bir metin parçasını desteklemek için, içerikleri tutmak üzere derleme zamanında bilinmeyen miktarda bir belleği heap’te ayırmamız gerekir. Bu şu anlama gelir:

• Çalışma zamanında bellek ayırıcıdan (memory allocator) bellek talep edilmelidir.
• String’imizle işimiz bittiğinde bu belleği ayırıcıya iade etmenin bir yoluna ihtiyacımız var.

İlk kısım bizim tarafımızdan yapılır: String::from’u çağırdığımızda, onun uygulaması ihtiyaç duyduğu belleği talep eder. Bu, programlama dillerinde neredeyse evrenseldir.

Ancak ikinci kısım farklıdır. Bir çöp toplayıcısına (GC - garbage collector) sahip olan dillerde, GC artık kullanılmayan belleği takip eder, temizler ve bizim bunu düşünmemize gerek kalmaz. GC’si olmayan çoğu dilde ise, belleğin ne zaman artık kullanılmadığını belirlemek ve tıpkı onu talep ettiğimiz gibi, açıkça serbest bırakacak (free) kodu çağırmak bizim sorumluluğumuzdadır. Bunu doğru yapmak tarihsel olarak zor bir programlama problemi olmuştur. Unutursak, bellek israf ederiz. Çok erken yaparsak, geçersiz bir değişkenimiz olur. İki kez yaparsak, o da bir bug’dır (hata). Tam olarak bir allocate (ayırma) işlemi ile tam olarak bir free (serbest bırakma) işlemini eşleştirmemiz gerekir.

Rust farklı bir yol izler: Sahip olan değişken kapsam dışına çıktığında bellek otomatik olarak iade edilir. İşte Liste 4-1’deki kapsam örneğimizin bir sabit metin yerine String kullanan versiyonu:

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’imizin ihtiyaç duyduğu belleği ayırıcıya iade edebileceğimiz doğal bir an vardır: metin kapsam dışına çıktığında. Bir değişken kapsam dışına çıktığında, Rust bizim için özel bir fonksiyon çağırır. Bu fonksiyona drop denir ve String’in yazarının belleği iade edecek kodu koyabileceği yer burasıdır. Rust, süslü kapanış parantezinde drop’u otomatik olarak çağırır.

Not: C++’ta, bir öğenin ömrünün sonunda kaynakları serbest bırakma (deallocating) pattern’ine bazen Resource Acquisition Is Initialization (RAII) - Kaynak Edinimi Başlatmadır denir. Rust’taki drop fonksiyonu, daha önce RAII kalıplarını kullandıysanız size tanıdık gelecektir.

Bu kalıbın Rust kodunun yazılma şekli üzerinde derin bir etkisi vardır. Şu anda basit gibi görünebilir, ancak heap üzerinde ayırdığımız verileri birden fazla değişkenin kullanmasını istediğimiz daha karmaşık durumlarda kodun davranışı beklenmedik olabilir. Şimdi o durumlardan bazılarını inceleyelim.

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

Rust’ta birden fazla değişken aynı verilerle farklı yollarla etkileşime girebilir. Liste 4-2, bir tamsayı kullanan bir örneği göstermektedir.

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

Bunun ne yaptığını muhtemelen tahmin edebiliriz: “5 değerini x’e bağla; sonra, x’teki değerin bir kopyasını çıkar ve onu y’ye bağla.” Artık x ve y olmak üzere iki değişkenimiz var ve ikisi de 5’e eşit. Gerçekten olan da tam olarak budur, çünkü tamsayılar bilinen, sabit bir boyuta sahip basit değerlerdir ve bu iki 5 değeri stack’e itilir.

Şimdi String versiyonuna bakalım:

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

Bu çok benzer görünüyor, bu yüzden çalışma şeklinin aynı olacağını varsayabiliriz: Yani, ikinci satır metin1’deki değerin bir kopyasını oluşturur ve onu metin2’ye bağlar. Ancak olan şey tam olarak bu değildir.

String’in arka planda neler yaptığına bakmak için Şekil 4-1’e göz atın. Bir String, solda gösterildiği gibi üç bölümden oluşur: stringin içeriğini tutan belleğe yönelik bir işaretçi (pointer), bir uzunluk ve bir kapasite (capacity). Bu veri grubu stack’te saklanır. Sağda ise içerikleri tutan heap üzerindeki bellek yer alır.

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

Uzunluk, String’in içeriğinin şu anda bayt cinsinden ne kadar bellek kullandığıdır. Kapasite (capacity), String’in ayırıcıdan aldığı toplam bellek miktarının bayt cinsinden değeridir. Uzunluk ve kapasite arasındaki fark önemlidir, ancak bu bağlamda değil; o yüzden şimdilik kapasiteyi görmezden gelmek sorun olmaz.

metin1’i metin2’ye atadığımızda, String verileri kopyalanır, yani stack’teki işaretçiyi, uzunluğu ve kapasiteyi kopyalarız. İşaretçinin (pointer) referans verdiği heap üzerindeki verileri kopyalamayız. Başka bir deyişle, bellekteki veri gösterimi Şekil 4-2’deki gibi görünür.

Şekil 4-2: metin1’in işaretçisinin, uzunluğunun ve kapasitesinin bir kopyasına sahip olan metin2 değişkeninin bellekteki gösterimi

Gösterim Şekil 4-3’teki gibi görünmez, ki bu Rust heap verilerini de kopyalasaydı belleğin nasıl görüneceğiydi. Eğer Rust bunu yapsaydı, heap üzerindeki veriler büyük olsaydı metin2 = metin1 işlemi çalışma zamanı performansı açısından çok maliyetli olabilirdi.

Şekil 4-3: Rust heap verilerini de kopyalasaydı metin2 = metin1’in ne yapabileceğine dair başka bir olasılık

Daha önce, bir değişken kapsam dışına çıktığında Rust’ın otomatik olarak drop fonksiyonunu çağırdığını ve o değişkenin heap belleğini temizlediğini söylemiştik. Ancak Şekil 4-2 her iki veri işaretçisinin de aynı konumu gösterdiğini gösteriyor. Bu bir sorundur: metin2 ve metin1 kapsam dışına çıktığında, ikisi de aynı belleği serbest bırakmaya (free) çalışacaktır. Bu, double free (çifte serbest bırakma) hatası olarak bilinir ve daha önce bahsettiğimiz bellek güvenliği (memory safety) hatalarından biridir. Belleği iki kez serbest bırakmak bellek bozulmasına yol açabilir ve bu da potansiyel olarak güvenlik açıklarına neden olabilir.

Bellek güvenliğini sağlamak için, let metin2 = metin1; satırından sonra Rust, metin1’i artık geçerli olarak görmez. Bu nedenle, metin1 kapsam dışına çıktığında Rust’ın hiçbir şeyi serbest bırakması gerekmez. metin2 oluşturulduktan sonra metin1’i kullanmaya çalıştığınızda ne olduğuna bir bakın; çalışmayacaktır:

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

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

Şuna benzer bir hata alırsınız çünkü Rust geçersiz kılınmış (invalidated) referansı kullanmanızı engeller:

$ cargo run
   Compiling ownership v0.1.0 ($PROJE/listings/ch04-understanding-ownership/no-listing-04-cant-use-after-move)
error[E0382]: borrow of moved value: `metin1`
 --> src/main.rs:6:16
  |
3 |     let metin1 = String::from("merhaba");
  |         ------ move occurs because `metin1` has type `String`, which does not implement the `Copy` trait
4 |     let metin2 = metin1;
  |                  ------ value moved here
5 |
6 |     println!("{metin1}, dünya!");
  |                ^^^^^^ value borrowed here after move
  |
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
  |
4 |     let metin2 = metin1.clone();
  |                        ++++++++

warning: unused variable: `metin2`
 --> src/main.rs:4:9
  |
4 |     let metin2 = metin1;
  |         ^^^^^^ help: if this is intentional, prefix it with an underscore: `_metin2`
  |
  = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default

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

Diğer dillerle çalışırken shallow copy (sığ kopya) ve deep copy (derin kopya) terimlerini duyduysanız, verileri kopyalamadan işaretçiyi, uzunluğu ve kapasiteyi kopyalama konsepti muhtemelen sığ bir kopya (shallow copy) yapmak gibi gelebilir. Ancak Rust ilk değişkeni de geçersiz kıldığından, sığ kopya olarak adlandırılmak yerine buna move (taşıma) adı verilir. Bu örnekte, metin1’in metin2’nin içine taşındığını söyleyebiliriz. Yani gerçekte ne olduğu Şekil 4-4’te gösterilmektedir.

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

Bu sorunumuzu çözer! Sadece metin2 geçerli olduğunda, kapsam dışına çıktığında yalnız o belleği serbest bırakacak ve işimiz bitecek.

Ek olarak, bunun ima ettiği bir tasarım tercihi vardır: Rust verilerinizin asla otomatik olarak “derin” (deep) kopyalarını oluşturmaz. Bu nedenle, herhangi bir otomatik kopyalamanın çalışma zamanı performansı açısından ucuz (maliyetsiz) olduğu varsayılabilir.

Kapsam ve Atama (Scope and Assignment)

Bunun tersi, kapsam belirleme (scoping), sahiplik ve belleğin drop fonksiyonu aracılığıyla serbest bırakılması arasındaki ilişki için de geçerlidir. Var olan bir değişkene tamamen yeni bir değer atadığınızda, Rust derhal orijinal değer üzerinde drop’u çağıracak ve onun belleğini serbest bırakacaktır. Örneğin şu kodu inceleyin:

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

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

Başlangıçta bir metin değişkeni tanımlarız ve ona "merhaba" değerine sahip bir String bağlarız. Sonra hemen "selam" değerine sahip yeni bir String oluştururuz ve bunu metin’e atarız. Bu noktada, artık heap’teki orijinal değeri gösteren hiçbir şey (referans) yoktur. Şekil 4-5 stack ve heap verilerinin şu anki halini göstermektedir:

Şekil 4-5: Başlangıç değeri bütünüyle değiştirildikten sonra bellekteki gösterimi

Orijinal string böylece derhal kapsam dışına çıkar. Rust bunun üzerinde drop fonksiyonunu çalıştıracak ve belleği hemen serbest bırakılacaktır. En sonunda değeri ekrana yazdırdığımızda "selam, dünya!" olacaktır.

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

Eğer String’in stack verisiyle yetinmeyip, heap verisini derinlemesine (deep copy) kopyalamak istiyorsak, clone adında yaygın bir metot kullanabiliriz. Metot sözdizimini Bölüm 5’te ele alacağız, ancak metotlar birçok programlama dilinde ortak bir özellik olduğundan muhtemelen onları daha önce görmüşsünüzdür.

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

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

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

Bu, hiçbir sorun çıkarmadan çalışır ve açıkça heap verisinin kopyalandığı Şekil 4-3’te gösterilen davranışı üretir.

clone fonksiyonuna yapılan bir çağrı gördüğünüzde, bazı rastgele kodların çalıştırıldığını ve bu kodun pahalı (yüksek maliyetli) olabileceğini bilirsiniz. Bu, farklı bir şeylerin olup bittiğine dair görsel bir göstergedir.

Sadece Stack Verisi (Stack-Only Data): Copy

Henüz konuşmadığımız bir pürüz (ayrıntı) daha var. Liste 4-2’de gösterilen, tamsayıları kullanan bu kod çalışır ve 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ımız yok, ancak x hala geçerlidir ve y’nin içine taşınmamıştır (move edilmemiştir).

Bunun nedeni, derleme zamanında bilinen bir boyuta sahip olan tamsayı gibi türlerin tamamen stack üzerinde saklanmasıdır, bu nedenle gerçek değerlerin kopyalarını oluşturmak hızlıdır. Bu, y değişkenini oluşturduktan sonra x’in geçerli olmasını engellemek istememiz için hiçbir neden olmadığı anlamına gelir. Başka bir deyişle, burada derin ve sığ kopyalama arasında hiçbir fark yoktur, bu yüzden clone’u çağırmak olağan sığ kopyalamadan farklı bir şey yapmaz ve onu dışarıda bırakabiliriz.

Rust’ın, tamsayılar gibi stack’te depolanan türlere yerleştirebileceğimiz Copy trait’i adında özel bir anotasyonu vardır (trait’ler hakkında Bölüm 10’da daha fazla konuşacağız). Bir tür Copy trait’ini uyguluyorsa, onu kullanan değişkenler move edilmez, bunun yerine kolayca (trivially) kopyalanarak başka bir değişkene atandıktan sonra bile geçerli kalırlar.

Eğer türün kendisi veya parçalarından herhangi biri Drop trait’ini uygulamışsa, Rust bir türü Copy ile işaretlememize izin vermez. Türün değeri kapsam dışına çıktığında özel bir şey olması gerekiyorsa ve o türe Copy anotasyonunu eklersek derleme zamanı hatası (compile-time error) alırız. Türünüze trait’i uygulamak için Copy anotasyonunu nasıl ekleyeceğinizi öğrenmek için Ek C’deki “Türetilebilir Traitler (Derivable Traits)” bölümüne bakın.

Peki, hangi türler Copy trait’ini uygular? Emin olmak için ilgili türün dokümantasyonunu kontrol edebilirsiniz, ancak genel bir kural olarak, herhangi bir basit skaler (tekil) değer grubu Copy’yi uygulayabilir; tahsisat gerektiren veya bir tür kaynak olan hiçbir şey Copy’yi uygulayamaz. İşte Copy’yi uygulayan bazı türler:

• u32 gibi tüm tamsayı türleri.
• true ve false değerlerine sahip Boolean türü, bool.
• f64 gibi tüm kayan noktalı sayı türleri (floating-point types).
• Karakter türü, char.
• Demetler (Tuples), yalnızca Copy uygulayan türleri içeriyorlarsa. Örneğin (i32, i32) Copy’yi uygular, ancak (i32, String) uygulamaz.

Sahiplik ve Fonksiyonlar (Ownership and Functions)

Bir değeri bir fonksiyona geçirmenin mekaniği, bir değişkene bir değer atarken uygulananla benzerdir. Bir değişkeni bir fonksiyona geçirmek, tıpkı atama işleminde olduğu gibi taşıyacak (move) veya kopyalayacaktır (copy). Liste 4-3’te, değişkenlerin ne zaman kapsama girip çıktığını gösteren bazı notlara sahip bir örnek yer almaktadır.

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.

Eğer sahipligi_alir çağrısından sonra metin’i kullanmaya çalışsaydık, Rust bir derleme zamanı hatası fırlatırdı (throw). Bu statik kontroller bizi hatalardan korur. metin ve x’i nerelerde kullanabileceğinizi ve sahiplik kurallarının sizi nerelerde engellediğini görmek için main’e metin ve x kullanan kodlar eklemeyi deneyin.

Dönüş Değerleri ve Kapsam (Return Values and Scope)

Değer döndürmek de sahipliği aktarabilir. Liste 4-4, Liste 4-3’tekine benzer açıklamalarla bazı değerler döndüren bir fonksiyonun örneğini 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 zaman aynı kalıbı (pattern) izler: Başka bir değişkene değer atamak onu taşır (moves). Heap üzerinde veri içeren bir değişken kapsam dışına çıktığında, verinin sahipliği başka bir değişkene taşınmadığı sürece bu değer drop ile temizlenir.

Bu işe yarasa da, sahipliği almak ve ardından her fonksiyonla sahipliği geri döndürmek biraz yorucudur. Peki ya bir fonksiyonun bir değeri kullanmasına izin verip sahipliği almasını istemiyorsak? Bir fonksiyona geçirdiğimiz herhangi bir şeyi, onu tekrar kullanmak istiyorsak geriye döndürmek zorunda olmamız oldukça can sıkıcıdır; buna fonksiyonun gövdesinden kaynaklanan ve döndürmek isteyebileceğimiz diğer veriler de dahildir.

Rust, Liste 4-5’te gösterildiği gibi, bir demet kullanarak birden fazla değeri 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, yaygın olması gereken bir konsept için çok fazla seremoni (angarya) ve epey bir iştir. Neyse ki, Rust’ın sahipliği aktarmadan bir değeri kullanmak için sahip olduğu bir özellik var: referanslar.

Referanslar ve Ödünç Alma

Referanslar ve Ödünç Alma (References and Borrowing)

Liste 4-5’teki demet kodunun sorunu, String’in uzunlugu_hesapla fonksiyonuna taşınmış (moved) olması ve uzunlugu_hesapla çağrısından sonra bu String’i hala kullanabilmek için çağıran fonksiyona geri döndürmek zorunda kalmamızdır. Bunun yerine, String değerine bir referans sağlayabiliriz. Referans, bir işaretçiye (pointer) benzer; yani, o adreste depolanan verilere erişmek için takip edebileceğimiz bir adrestir; ancak o veriler başka bir değişkene aittir. İşaretçiden farklı olarak, bir referansın ömrü boyunca belirli bir türden geçerli bir değere işaret edeceği garanti edilir.

Bir değerin sahipliğini almak yerine nesneye referans olan bir parametreye sahip uzunlugu_hesapla fonksiyonunu nasıl tanımlayacağınız ve kullanacağınız aşağıda açıklanmıştır:

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()
}

İlk olarak, değişken tanımındaki ve fonksiyon dönüş değerindeki tüm demet kodlarının gittiğine dikkat edin. İkinci olarak, uzunlugu_hesapla’ya &metin1 ilettiğimize ve tanımında String yerine &String aldığımıza dikkat edin. Bu ampersanlar (ve işaretleri, &) referansları temsil eder ve bir değerin sahipliğini almadan ona atıfta bulunmanıza olanak tanır. Şekil 4-6 bu konsepti tasvir etmektedir.

Şekil 4-6: String metin1’e işaret eden &String metin diyagramı

Not: & kullanarak referans almanın (referencing) zıttı dereferencing (referansın değerini alma) olarak adlandırılır ve bu, dereference operatörü olan * ile gerçekleştirilir. Dereference operatörünün bazı kullanımlarını Bölüm 8’de göreceğiz ve detaylarını Bölüm 15’te tartışacağız.

Ş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 değerine atıfta bulunan ancak ona sahip olmayan bir referans oluşturmamızı sağlar. Referans ona sahip olmadığı için, referansın kullanımı durduğunda işaret ettiği değer düşürülmeyecektir (drop edilmeyecektir).

Aynı şekilde, fonksiyonun imzası da metin parametresinin türünün bir referans olduğunu belirtmek için & kullanır. Gelin açıklayıcı birkaç not 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 referansın işaret ettiği değer metin kullanımı durduğunda düşürülmez, çünkü metin sahipliğe sahip değildir. Fonksiyonlar, asıl değerler yerine referansları parametre olarak aldıklarında, sahipliği geri vermek için değerleri döndürmemize gerek kalmaz, çünkü sahipliğe hiçbir zaman sahip olmadık.

Bir referans oluşturma eylemine ödünç alma diyoruz. Gerçek hayatta olduğu gibi, bir kişinin sahip olduğu bir şeyi ondan ödünç alabilirsiniz. İşiniz bittiğinde onu geri vermek zorundasınızdır. Ona sahip olmazsınız.

Peki, ödünç aldığımız bir şeyi değiştirmeye çalışırsak ne olur? Liste 4-6’daki kodu deneyin. Sürprizbozan: Çalışmıyor!

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 ($PROJE/listings/ch04-understanding-ownership/listing-04-06)
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

Tıpkı değişkenlerin varsayılan olarak değiştirilemez olduğu gibi, referanslar da öyledir. Referansına sahip olduğumuz bir şeyi değiştirmemize izin verilmez.

Değiştirilebilir Referanslar (Mutable References)

Bunun yerine bir değiştirilebilir referans kullanarak sadece birkaç küçük ayarla ödünç alınan bir değeri değiştirmemize izin vermesi için Liste 4-6’daki kodu 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");
}

Önce, metin’i mut olacak şekilde değiştiririz. Ardından, degistir fonksiyonunu çağırdığımız yerde &mut metin ile değiştirilebilir bir referans oluştururuz ve fonksiyon imzasını bir_metin: &mut String ile değiştirilebilir bir referans kabul edecek şekilde güncelleriz. Bu, degistir fonksiyonunun ödünç aldığı değeri değiştireceğini çok net bir şekilde belirtir.

Değiştirilebilir referansların büyük bir kısıtlaması vardır: Bir değere değiştirilebilir bir referansınız varsa, o değere başka hiçbir referansınız olamaz. metin’e iki tane değiştirilebilir referans oluşturmaya çalışan bu kod başarısız olacaktır:

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 ($PROJE/listings/ch04-understanding-ownership/no-listing-10-multiple-mut-not-allowed)
error[E0499]: cannot borrow `metin` as mutable more than once at a time
 --> src/main.rs:6:14
  |
5 |     let r1 = &mut metin;
  |              ---------- first mutable borrow occurs here
6 |     let r2 = &mut metin;
  |              ^^^^^^^^^^ second mutable borrow occurs here
7 |
8 |     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, kodun geçersiz olduğunu çünkü metin’i aynı anda birden fazla kez değiştirilebilir olarak ödünç alamayacağımızı söylüyor. İlk değiştirilebilir ödünç alma r1’dedir ve println! içinde kullanılana kadar sürmelidir, ancak bu değiştirilebilir referansın oluşturulmasıyla kullanımı arasında, r1 ile aynı veriyi ödünç alan r2’de başka bir değiştirilebilir referans oluşturmaya çalıştık.

Aynı verilere aynı anda birden fazla değiştirilebilir referans yapılmasını engelleyen bu kısıtlama, değişime izin verir ancak bunu çok kontrollü bir şekilde yapar. Çoğu dil istediğiniz zaman değiştirmenize izin verdiği için bu, yeni Rust geliştiricilerinin (Rustaceans) zorlandığı bir konudur. Bu kısıtlamaya sahip olmanın faydası, Rust’ın derleme zamanında veri yarışlarını (data races) önleyebilmesidir. Veri yarışı (data race), yarış koşuluna (race condition) benzer ve şu üç davranış meydana geldiğinde ortaya çıkar:

• İki veya daha fazla işaretçi aynı anda aynı verilere erişir.
• İşaretçilerden en az biri verilere yazmak için kullanılmaktadır.
• Verilere erişimi senkronize etmek için hiçbir mekanizma kullanılmamaktadır.

Veri yarışları tanımsız davranışlara (undefined behavior) neden olur ve bunları çalışma zamanında izlemeye çalışırken teşhis edip düzeltmek zor olabilir; Rust, veri yarışları içeren kodları derlemeyi reddederek bu sorunu baştan engeller!

Her zamanki gibi, yalnızca eşzamanlı (simultaneous) olmayan, birden çok değiştirilebilir referansa izin veren yeni bir kapsam oluşturmak için süslü parantezleri kullanabiliriz:

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ı birleştirmek için de benzer bir kural uygular. Bu kod bir hatayla 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 ($PROJE/listings/ch04-understanding-ownership/no-listing-12-immutable-and-mutable-not-allowed)
error[E0502]: cannot borrow `metin` as mutable because it is also borrowed as immutable
 --> src/main.rs:7:14
  |
5 |     let r1 = &metin; // sorun yok
  |              ------ immutable borrow occurs here
6 |     let r2 = &metin; // sorun yok
7 |     let r3 = &mut metin; // BÜYÜK SORUN
  |              ^^^^^^^^^^ mutable borrow occurs here
8 |
9 |     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

Vay canına! Aynı değere değiştirilemez bir referansımız varken, aynı zamanda değiştirilebilir bir referansımız da olamaz.

Değiştirilemez referans kullananlar, değerin aniden altlarından değişmesini beklemezler! Ancak, birden çok değiştirilemez referansa izin verilir çünkü sadece verileri okuyan hiç kimsenin, başka birinin verileri okumasını etkileme yeteneği yoktur.

Bir referansın kapsamının, tanıtıldığı yerden başladığına ve referansın son kullanıldığı zamana kadar devam ettiğine dikkat edin. Örneğin, değiştirilemez referansların son kullanımı, değiştirilebilir referans tanıtılmadan önce println! içinde olduğundan bu kod derlenecektir:

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 referanslar r1 ve r2’nin kapsamları, en son kullanıldıkları println!’den sonra biter; bu da değiştirilebilir referans r3’ün yaratılmasından öncedir. Bu kapsamlar örtüşmez (overlap), dolayısıyla bu koda izin verilir: Derleyici, referansın kapsamın bitiminden önceki bir noktada artık kullanılmadığını anlayabilir.

Ödünç alma hataları zaman zaman sinir bozucu olsa da, bunun Rust derleyicisinin potansiyel bir bug’ı erkenden (çalışma zamanından ziyade derleme zamanında) göstermesi ve size tam olarak nerede sorun olduğunu bildirmesi olduğunu unutmayın. Böylece verilerinizin neden düşündüğünüz gibi olmadığını bulmak için iz sürmek zorunda kalmazsınız.

Sarkan Referanslar (Dangling References)

İşaretçileri olan dillerde, bazı bellekleri serbest bırakırken o belleğe giden bir işaretçiyi koruyarak yanlışlıkla bir sarkan işaretçi (dangling pointer) (muhtemelen başkasına verilmiş olan bellekteki bir konuma başvuran bir işaretçi) oluşturmak kolaydır. Rust’ta ise bunun aksine, derleyici referansların asla sarkan referanslar olmayacağını garanti eder: Bazı verilere bir referansınız varsa, derleyici verilere olan referansın kapsam dışına çıkmasından önce verilerin kapsam dışına çıkmamasını sağlayacaktır.

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

fn main() {
    let hicbire_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:16
  |
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ği ifade eder: ömürler. Ömürleri Bölüm 10’da ayrıntılı olarak tartışacağız. Ancak, ömürlerle ilgili kısımları göz ardı ederseniz, mesaj gerçekten de bu kodun neden sorun olduğuna dair temel ipucunu içerir:

this function's return type contains a borrowed value, but there is no value
for it to be borrowed from
(bu fonksiyonun dönüş türü ödünç alınan bir değer içeriyor, ancak ödünç alınacağı bir değer yok)

sarkan_isaretci kodumuzun her aşamasında tam olarak ne olduğuna daha yakından bakalım:

fn main() {
    let hicbire_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 içinde oluşturulduğu için, sarkan_isaretci kodu bittiğinde metin’in bellekten tahsisi kaldırılacaktır (deallocated). Ancak ona bir referans döndürmeye çalıştık. Bu, bu referansın geçersiz bir String’e işaret edeceği anlamına gelir. Bu hiç iyi değil! Rust bunu yapmamıza izin vermeyecektir.

Buradaki çözüm doğrudan String’i döndürmektir:

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

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

    metin
}

Bu hiçbir sorun olmadan çalışır. Sahiplik dışarı taşınır ve hiçbir şeyin tahsisi kaldırılmaz.

Referans Kuralları

Referanslar hakkında tartıştıklarımızı özetleyelim:

• Herhangi bir zamanda, ya 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 Türü (The Slice Type)

Dilimler, bir koleksiyondaki bitişik bir eleman dizisine referans vermenizi sağlar. Bir dilim bir tür referanstır, bu nedenle sahipliği yoktur.

İşte küçük bir programlama problemi: Boşluklarla ayrılmış kelimelerden oluşan bir metin (string) alan ve o metinde bulduğu ilk kelimeyi döndüren bir fonksiyon yazın. Eğer fonksiyon metin içinde boşluk bulamazsa, tüm metin tek bir kelime olmalıdır, bu yüzden metnin tamamı döndürülmelidir.

Not: Dilimleri tanıtmak amacıyla, bu bölümde yalnızca ASCII karakterleri olduğunu varsayıyoruz; UTF-8 kullanımı ile ilgili daha kapsamlı bir tartışma Bölüm 8’deki “UTF-8 Kodlanmış Metni Stringler ile Saklamak” bölümünde yer almaktadır.

Dilimlerin çözeceği problemi anlamak için, dilim kullanmadan bu fonksiyonun imzasını nasıl yazacağımız üzerinde çalışalım:

fn ilk_kelime(metin: &String) -> ?

ilk_kelime fonksiyonunun &String türünde bir parametresi var. Sahipliğe ihtiyacımız yok, o yüzden bu gayet uygundur. (İdiyomatik Rust’ta, fonksiyonlar ihtiyaç duymadıkça argümanlarının sahipliğini almazlar ve bunun nedenleri ilerledikçe netleşecektir.) Peki ne döndürmeliyiz? Bir metnin bir kısmından bahsetmenin gerçekten bir yolu yok. Ancak, bir boşlukla belirtilen kelimenin sonunun indeksini döndürebiliriz. Liste 4-7’de gösterildiği gibi bunu 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’i eleman eleman incelememiz ve bir değerin boşluk olup olmadığını kontrol etmemiz gerektiğinden, as_bytes metodunu kullanarak String’imizi bir bayt dizisine dönüştürüyoruz.

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() {}

Daha sonra, iter metodunu kullanarak bayt dizisi üzerinde bir yineleyici oluşturuyoruz:

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() {}

Yineleyicileri Bölüm 13’te daha detaylı tartışacağız. Şimdilik iter’in bir koleksiyondaki her elemanı döndüren bir metot olduğunu ve enumerate’in iter sonucunu sarmaladığını ve bunun yerine her elemanı bir demetin parçası olarak döndürdüğünü bilin. enumerate’ten döndürülen demetin ilk elemanı indekstir ve ikinci eleman elemana bir referanstır. Bu, indeksi kendimiz hesaplamaktan biraz daha uygundur.

enumerate metodu bir demet döndürdüğü için, o demeti ayrıştırmak (destructure) amacıyla desenleri (patterns) kullanabiliriz. Desenler hakkında Bölüm 6’da daha fazla konuşacağız. for döngüsünde, demetteki indeks için i ve demetteki tek bayt için &oge olan bir desen belirtiyoruz. .iter().enumerate()’ten elemanın bir referansını aldığımız için desende & kullanırız.

for döngüsünün içinde, bayt literali (byte literal) sözdizimini kullanarak boşluğu temsil eden baytı ararız. Eğer bir boşluk bulursak, o konumu döndürürüz. Aksi takdirde, metin.len() kullanarak metnin 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 metindeki ilk kelimenin sonunun indeksini bulmanın bir yoluna sahibiz, ancak bir sorun var. Tek başına bir usize döndürüyoruz, ancak bu yalnızca &String bağlamında anlamlı bir sayıdır. Başka bir deyişle, String’den ayrı bir değer olduğu için gelecekte de geçerli kalacağının 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 olmadan derlenir ve metin.clear() çağırdıktan sonra kelime’yi kullansaydık da derlenirdi. kelime metin’in durumuna hiç bağlı olmadığı için, kelime hala 7 (veya "merhaba" kelimesinin uzunluğu) değerini içerir. İlk kelimeyi çıkarmayı denemek için metin değişkeni ile birlikte bu 7 değerini kullanabilirdik, ancak bu bir bug olurdu çünkü kelime’de 7’yi kaydettiğimizden bu yana metin’in içerikleri değişmiştir.

kelime’deki indeksin metin’deki verilerle senkronizasyonunun (uyumunun) bozulması konusunda endişelenmek yorucu ve hataya açıktır! Eğer bir ikinci_kelime fonksiyonu yazarsak bu indeksleri yönetmek daha da kırılgan (brittle) bir hal alır. İmzası şuna benzerdi:

fn ikinci_kelime(metin: &String) -> (usize, usize) {

Artık bir başlangıç ve bir bitiş indeksini izliyoruz; belirli bir durumdaki verilerden hesaplanmış ancak o duruma hiçbir şekilde bağlı olmayan daha da fazla değerimiz var. Etrafta dolaşan ve senkronize tutulması gereken, birbiriyle ilgisiz üç değişkenimiz var.

Neyse ki Rust’ın bu soruna bir çözümü var: string dilimleri.

String Dilimleri (String Slices)

Bir string dilimi, bir String’in elemanlarının bitişik bir dizisine referanstır ve şuna benzer:

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

    let merhaba = &metin[0..7];
    let dunya = &metin[8..13];
}

Tüm String’e referans vermek yerine, merhaba, ekstra [0..7] bölümünde belirtilen String’in bir kısmına referanstır. Dilimleri [başlangıç_indeksi..bitiş_indeksi] belirterek köşeli parantezler içinde bir aralık kullanarak oluştururuz; burada başlangıç_indeksi dilimdeki ilk konumdur ve bitiş_indeksi dilimdeki son konumun bir fazlasıdır. Dahili olarak, dilim veri yapısı dilimin başlangıç konumunu ve uzunluğunu depolar; bu uzunluk bitiş_indeksi eksi başlangıç_indeksi değerine karşılık gelir. Yani, let dunya = &metin[8..13]; durumunda dunya, metin’in 8. indeksindeki bayta bir işaretçi ve 5 uzunluk değeri içeren bir dilim olacaktır.

Şekil 4-7 bunu bir diyagram halinde göstermektedir.

Şekil 4-7: String’in bir parçasına atıfta bulunan bir string dilimi

Rust’ın .. aralık sözdizimi ile, eğer indeks 0’dan başlamak istiyorsanız, iki noktadan önceki değeri bırakabilirsiniz. Başka bir deyişle, bunlar birbirine eşittir:

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

let dilim = &metin[0..2];
let dilim = &metin[..2];
}

Aynı şekilde, diliminiz String’in son baytını içeriyorsa, sondaki sayıyı da bırakabilirsiniz. Bu, şunların eşit olduğu anlamına gelir:

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

let uzunluk = metin.len();

let dilim = &metin[3..uzunluk];
let dilim = &metin[3..];
}

Tüm metnin bir dilimini almak için her iki değeri de bırakabilirsiniz. Dolayısıyla bunlar da eşittir:

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

let uzunluk = metin.len();

let dilim = &metin[0..uzunluk];
let dilim = &metin[..];
}

Not: String dilim aralığı indeksleri geçerli UTF-8 karakter sınırlarında gerçekleşmelidir. Çok baytlı (multibyte) bir karakterin ortasında bir string dilimi oluşturmaya çalışırsanız, programınız bir hatayla çıkış yapacaktır.

Tüm bu bilgileri göz önünde bulundurarak, ilk_kelime’yi bir dilim döndürecek şekilde yeniden yazalım. “String dilimi“ni ifade eden tür &str olarak 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 sonu için indeksi Liste 4-7’de yaptığımız gibi, bir boşluğun ilk geçtiği yeri arayarak elde ederiz. Bir boşluk bulduğumuzda, metnin başlangıcını ve boşluğun indeksini sırasıyla başlangıç ve bitiş indeksleri olarak kullanarak bir string dilimi döndürürüz.

Artık ilk_kelime’yi çağırdığımızda, temel alınan (underlying) verilere bağlı tek bir değer geri alıyoruz. Bu değer, dilimin başlangıç noktasına yönelik bir referans ile dilimdeki eleman sayısından oluşur.

Bir dilim döndürmek ikinci_kelime fonksiyonu için de işe yarayacaktır:

fn ikinci_kelime(metin: &String) -> &str {

Derleyici String içindeki referansların geçerli kalmasını sağlayacağından artık bozması çok daha zor olan basit bir API’ye sahibiz. Liste 4-8’deki programda yer alan ve ilk kelimenin sonunun indeksini aldığımız, ancak daha sonra metni boşalttığımızda indeksimizin geçersiz hale geldiği hatayı hatırlıyor musunuz? O kod mantıksal olarak yanlıştı ancak anında herhangi bir hata göstermemişti. İlk kelime indeksini boşaltılmış bir metinle birlikte kullanmaya devam etseydik, sorunlar daha sonra ortaya çıkacaktı. Dilimler bu hatayı imkansız kılar ve kodumuzla ilgili bir sorunumuz olduğunu çok daha erken bilmemizi sağlar. ilk_kelime’nin dilim sürümünü kullanmak bir derleme zamanı hatası fırlatı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() {
    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 ($PROJE/listings/ch04-understanding-ownership/no-listing-19-slice-error)
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ırlayın: Eğer bir şeye değiştirilemez bir referansımız varsa, ona ayrıca değiştirilebilir bir referans alamayız. clear’ın String’i kesmesi (truncate) gerektiği için değiştirilebilir bir referans alması gerekir. clear çağrısından sonraki println!, kelime’deki referansı kullanır, dolayısıyla o noktada değiştirilemez referansın hala aktif olması gerekir. Rust, clear’daki değiştirilebilir referans ile kelime’deki değiştirilemez referansın aynı anda var olmasına izin vermez ve derleme başarısız olur. Rust yalnızca API’mizi daha kolay kullanılır hale getirmekle kalmadı, aynı zamanda bütün bir hata sınıfını derleme zamanında ortadan kaldırdı!

Dilim Olarak Sabit Metinler (String Literals as Slices)

Sabit metinlerin (string literals) ikili dosya içinde saklandığından bahsettiğimizi hatırlayın. Artık dilimleri bildiğimize göre sabit metinleri uygun bir şekilde anlayabiliriz:

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

Buradaki metin değişkeninin türü &str’dir: İkili dosyanın belirli bir noktasına işaret eden bir dilimdir. Sabit metinlerin değiştirilemez olmasının nedeni de budur; &str değiştirilemez bir referanstır.

Parametre Olarak String Dilimleri

Sabitlerin (literals) ve String değerlerinin dilimlerini alabileceğinizi bilmek, ilk_kelime üzerinde yapacağımız bir iyileştirmeye, yani onun imzasına yönlendirir bizi:

fn ilk_kelime(metin: &String) -> &str {

Daha tecrübeli bir Rust geliştiricisi bunun yerine Liste 4-9’da gösterilen imzayı yazardı, çünkü bu imza aynı fonksiyonu hem &String 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` sabit metinlerin dilimleri (kısmi veya tam) üzerinde çalışır.
    let kelime = ilk_kelime(&sabit_metnim[0..7]);
    let kelime = ilk_kelime(&sabit_metnim[..]);

    // Sabit metinler zaten metin dilimleri (string slices) olduğu için,
    // bu da dilim sözdizimi olmadan çalışır!
    let kelime = ilk_kelime(sabit_metnim);
}

Eğer elimizde bir string dilimi varsa, bunu doğrudan geçirebiliriz. Eğer bir String’imiz varsa, bu String’in bir dilimini veya String’in referansını geçirebiliriz. Bu esneklik, Bölüm 15’teki “Fonksiyonlarda ve Metotlarda Deref Zorlamalarını Kullanma (Using Deref Coercions in Functions and Methods)” bölümünde ele alacağımız deref zorlamaları (deref coercions) özelliğinden yararlanır.

Bir fonksiyonu String referansı yerine bir string dilimi alacak şekilde tanımlamak, API’mizi hiçbir işlevselliğini kaybetmeden daha genel ve kullanışlı hale 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` sabit metinlerin dilimleri (kısmi veya tam) üzerinde çalışır.
    let kelime = ilk_kelime(&sabit_metnim[0..7]);
    let kelime = ilk_kelime(&sabit_metnim[..]);

    // Sabit metinler zaten metin dilimleri (string slices) olduğu için,
    // bu da dilim sözdizimi olmadan çalışır!
    let kelime = ilk_kelime(sabit_metnim);
}

Diğer Dilimler (Other Slices)

String dilimleri tahmin edebileceğiniz gibi stringlere özgüdür. Ancak daha genel bir dilim türü de vardır. Şu diziyi (array) ele alalım:

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

Tıpkı bir stringin bir kısmına başvurmak (referans vermek) isteyebileceğimiz gibi, bir dizinin bir kısmına da başvurmak isteyebiliriz. Bunu şu şekilde yapardık:

#![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 bir referans ve bir uzunluk depolayarak tıpkı string dilimlerinin çalıştığı gibi çalışır. Bu tür dilimleri her türlü diğer koleksiyon için kullanacaksınız. Bu koleksiyonları, Bölüm 8’de vektörler hakkında konuştuğumuzda ayrıntılı olarak tartışacağız.

Özet

Sahiplik, ödünç alma ve dilimler kavramları Rust programlarında bellek güvenliğini (memory safety) derleme zamanında sağlar. Rust dili, tıpkı diğer sistem programlama dilleri gibi bellek kullanımınız üzerinde size kontrol verir. Ancak, veri sahibinin kapsam dışına çıktığında o veriyi otomatik olarak temizlemesi, bu kontrolü elde etmek için ekstra kod yazıp ayıklamak zorunda olmadığınız anlamına gelir.

Sahiplik, Rust’ın diğer pek çok parçasının çalışma şeklini etkiler, bu nedenle kitabın geri kalanında bu kavramlar hakkında daha fazla konuşacağız. Şimdi Bölüm 5’e geçelim ve veri parçalarını bir struct içinde gruplandırmaya bakalım.

İlgili Verileri Yapılandırmak İçin Struct Kullanımı

Bir struct veya yapı, anlamlı bir grup oluşturan birden fazla ilgili değeri bir araya getirip isimlendirmenizi sağlayan özel bir veri türüdür. Nesne yönelimli (object-oriented) bir programlama diline aşinaysanız, struct bir nesnenin veri özelliklerine (data attributes) benzer. Bu bölümde, halihazırda bildiklerinizi geliştirmek için demetleri (tuples) struct’larla karşılaştıracak ve verileri gruplandırmak için struct’ların ne zaman daha iyi bir yol olduğunu göstereceğiz.

Struct’ların nasıl tanımlanacağını ve örnekleneceğini (instantiate) göstereceğiz. Bir struct türüyle ilişkili davranışları belirtmek için ilişkili fonksiyonların (associated functions), özellikle de metot (method) olarak adlandırılan türünün nasıl tanımlanacağını tartışacağız. Struct’lar ve enum’lar (Bölüm 6’da tartışılacaktır), Rust’ın derleme zamanı tür kontrolünden (compile-time type checking) tam anlamıyla yararlanmak üzere programınızın etki alanında (domain) yeni türler oluşturmak için temel yapı taşlarıdır.

Struct Tanımlama ve Örnekleme

Struct’ları Tanımlama ve Örnekleme (Defining and Instantiating Structs)

Struct’lar, “Demet Türü (The Tuple Type)” bölümünde tartışılan demetlere benzerler, her ikisi de birden fazla ilgili değeri bir arada tutar. Demetler gibi, bir struct’ın parçaları da farklı türlerde olabilir. Demetlerden farklı olarak, bir struct’ta her bir veri parçasını isimlendirirsiniz, böylece değerlerin ne anlama geldiği açıkça belli olur. Bu isimleri eklemek, struct’ların demetlerden daha esnek olduğu anlamına gelir: Bir örneğin değerlerini belirtmek veya onlara erişmek için verilerin sırasına güvenmek zorunda kalmazsınız.

Bir struct tanımlamak için struct anahtar kelimesini girer ve tüm struct’a bir isim veririz. Bir struct’ın adı, gruplandırılan veri parçalarının önemini (anlamını) açıklamalıdır. Daha sonra, süslü parantezler içinde, alanlar (fields) olarak adlandırdığımız veri parçalarının isimlerini ve türlerini tanımlarız. Örneğin, Liste 5-1 bir kullanıcı hesabı hakkında bilgi depolayan bir struct’ı göstermektedir.

struct Kullanici {
    aktif: bool,
    kullanici_adi: String,
    eposta: String,
    giris_sayisi: u64,
}

fn main() {}

Tanımladıktan sonra bir struct’ı kullanmak için, alanların her biri için somut değerler belirterek o struct’ın bir örneğini oluştururuz. Bir örnek oluştururken struct’ın adını belirtiriz ve ardından anahtar: değer (key: value) çiftlerini içeren süslü parantezler ekleriz; burada anahtarlar alanların adlarıdır ve değerler o alanlarda saklamak istediğimiz verilerdir. Alanları, struct’ta tanımladığımız sırayla belirtmek zorunda değiliz. Başka bir deyişle, struct tanımı tür için genel bir şablon gibidir ve örnekler, o türün değerlerini oluşturmak için bu şablonu belirli verilerle doldurur. Örneğin, Liste 5-2’de gösterildiği gibi belirli bir kullanıcı bildirebiliriz.

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’tan belirli bir değeri almak için nokta gösterimini (dot notation) kullanırız. Örneğin, bu kullanıcının e-posta adresine erişmek için kullanici1.eposta kullanırız. Örnek değiştirilebilir ise, nokta gösterimini kullanıp belirli bir alana atama yaparak bir değeri değiştirebiliriz. 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");
}

Tüm örneğin değiştirilebilir olması gerektiğine dikkat edin; Rust yalnızca belirli alanları değiştirilebilir olarak işaretlememize izin vermez. Herhangi bir ifadede olduğu gibi, bu yeni örneği örtük olarak (implicitly) döndürmek için fonksiyon gövdesindeki son ifade olarak struct’ın yeni bir örneğini oluşturabiliriz.

Liste 5-4, verilen e-posta ve kullanıcı adıyla bir Kullanici örneği döndüren bir kullanici_olustur fonksiyonunu göstermektedir. aktif alanı true değerini ve giris_sayisi 1 değerini alı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ı adı vermek mantıklıdır, ancak eposta ve kullanici_adi alan adlarını ve değişkenlerini tekrarlamak zorunda kalmak biraz yorucudur. Struct’ın daha fazla alanı olsaydı, her bir adı tekrarlamak daha da sinir bozucu olurdu. Neyse ki, kullanışlı bir kısaltma var!

Alan Başlatma Kısaltmasını Kullanmak (Using the Field Init Shorthand)

Liste 5-4’te parametre adları ve struct alan adları tam olarak aynı olduğundan, kullanici_olustur’u Liste 5-5’te gösterildiği gibi kullanici_adi ve eposta tekrarları olmadan tam olarak aynı davranacak şekilde yeniden yazmak için alan başlatma kısaltması (field init shorthand) sözdizimini kullanabiliriz.

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ı olan Kullanici struct’ının yeni bir örneğini oluşturuyoruz. eposta alanının değerini kullanici_olustur fonksiyonunun eposta parametresindeki değere ayarlamak istiyoruz. eposta alanı ve eposta parametresi aynı ada sahip olduğundan, eposta: eposta yerine sadece eposta yazmamız yeterlidir.

Struct Güncelleme Sözdizimi İle Örnekler Oluşturmak (Creating Instances with Struct Update Syntax)

Aynı türdeki başka bir örneğin değerlerinin çoğunu içeren, ancak bazılarını değiştiren yeni bir struct örneği oluşturmak genellikle yararlıdır. Bunu struct güncelleme sözdizimi (struct update syntax) kullanarak yapabilirsiniz.

İlk olarak, Liste 5-6’da güncelleme sözdizimi olmadan, kullanici2 içinde düzenli bir yolla nasıl yeni bir Kullanici örneği oluşturulacağını gösteriyoruz. eposta için yeni bir değer belirliyoruz ancak bunun dışında Liste 5-2’de oluşturduğumuz kullanici1’deki 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ı etkiyi daha az kodla elde edebiliriz. .. sözdizimi, açıkça ayarlanmayan geri kalan alanların verilen örnekteki alanlarla aynı değere sahip olması gerektiğini belirtir.

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, kullanici2’de eposta için farklı bir değere sahip olan ancak kullanici1’den alınan kullanici_adi, aktif ve giris_sayisi alanları için aynı değerlere sahip bir örnek oluşturur. ..kullanici1, kalan tüm alanların değerlerini kullanici1’deki karşılık gelen alanlardan alması gerektiğini belirtmek için en sona gelmelidir, ancak struct tanımındaki alanların sırasına bakılmaksızın istediğimiz kadar alan için herhangi bir sırada değer belirtebiliriz.

Struct güncelleme sözdiziminin tıpkı bir atama (assignment) işlemi gibi = kullandığına dikkat edin; bunun nedeni, veriyi “Değişkenlerin ve Verilerin Move İle Etkileşimi” bölümünde gördüğümüz gibi taşımasıdır (move). Bu örnekte, kullanici2 oluşturulduktan sonra artık kullanici1’i kullanamayız çünkü kullanici1’in kullanici_adi alanındaki String kullanici2’ye taşınmıştır. Eğer kullanici2’ye hem eposta hem de kullanici_adi için yeni String değerleri verseydik ve dolayısıyla kullanici1’den yalnızca aktif ve giris_sayisi değerlerini kullansaydık, o zaman kullanici2 oluşturulduktan sonra kullanici1 hala geçerli olurdu. Hem aktif hem de giris_sayisi, Copy trait’ini uygulayan türlerdir, bu nedenle “Sadece Stack Verisi: Copy (Stack-Only Data: Copy)” bölümünde tartıştığımız davranış uygulanacaktır. Ayrıca bu örnekte hala kullanici1.eposta kullanabiliriz çünkü değeri kullanici1’den dışarı taşınmamıştır (moved out).

Demet Struct’lar ile Farklı Türler Oluşturmak (Creating Different Types with Tuple Structs)

Rust ayrıca, demet struct’lar (tuple structs) olarak adlandırılan ve demetlere (tuples) benzeyen struct’ları da destekler. Demet struct’lar, struct adının sağladığı ek anlama sahiptir, ancak alanlarıyla ilişkili adları yoktur; bunun yerine, yalnızca alanların türlerine sahiptirler. Demet struct’lar, tüm demete bir isim vermek, demeti diğer demetlerden farklı bir tür yapmak istediğinizde ve her bir alanı normal bir struct’taki gibi isimlendirmenin gereksiz veya fazlalık (verbose) olacağı durumlarda kullanışlıdır.

Bir demet struct’ı tanımlamak için, struct anahtar kelimesiyle başlayın ve ardından struct adına ek olarak demetteki türleri belirtin. Örneğin, burada 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ürlerde olduklarına dikkat edin. Tanımladığınız her struct, kendi içinde yer alan alanlar aynı türlerde olsa bile, kendine has (kendi başına) bir türdür. Örneğin, Renk türünde bir parametre alan bir fonksiyon argüman olarak bir Nokta alamaz, her iki tür de üç i32 değerinden oluşsa bile. Bunun dışında demet struct örnekleri, bireysel parçalarına ayrıştırılabilmeleri (destructure) ve belirli bir değere erişmek için noktadan (.) sonra indeksi kullanılabilmeleri bakımından demetlere benzerler. Demetlerden farklı olarak, demet struct’ları ayrıştırdığınızda (destructure) struct’ın türünü belirtmenizi gerektirir. Örneğin, orijin noktasındaki değerleri x, y ve z adlı değişkenlere ayrıştırmak için let Nokta(x, y, z) = orijin; yazardık.

Birim Benzeri Struct’ları Tanımlamak (Defining Unit-Like Structs)

Hiçbir alanı olmayan struct’lar da tanımlayabilirsiniz! Bunlara “Demet Türü (The Tuple Type)” bölümünde bahsettiğimiz birim türe () benzer şekilde davrandıkları için birim benzeri struct’lar (unit-like structs) denir. Birim benzeri struct’lar, bazı türler üzerinde bir trait uygulamanız gerektiğinde ancak türün kendisinde saklamak istediğiniz herhangi bir veri olmadığında yararlı olabilir. Trait’leri Bölüm 10’da tartışacağız. İşte HerZamanEsit adında bir birim struct tanımlama ve örnekleme (instantiate) örneği:

struct HerZamanEsit;

fn main() {
    let ozne = HerZamanEsit;
}

HerZamanEsit’i tanımlamak için, struct anahtar kelimesini, istediğimiz ismi ve ardından bir noktalı virgül kullanırız. Süslü parantezlere veya normal parantezlere gerek yoktur! Daha sonra, benzer bir yolla (herhangi bir süslü veya normal parantez olmadan tanımladığımız adı kullanarak) ozne değişkeninde HerZamanEsit örneğini alabiliriz. Daha sonra bu tür için bir davranış (behavior) uygulayacağımızı, öyle ki HerZamanEsit’in her örneğinin başka herhangi bir türün her örneğine her zaman eşit olacağını hayal edin, belki de test amacıyla bilinen bir sonuca sahip olmak için. Bu davranışı uygulamak için hiçbir veriye ihtiyacımız olmazdı! Bölüm 10’da trait’leri nasıl tanımlayacağınızı ve bunları birim benzeri struct’lar dahil 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:15
  |
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:12
  |
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 (An Example Program Using Structs)

Struct’ları ne zaman kullanmak isteyebileceğimizi anlamak için bir dikdörtgenin alanını hesaplayan bir program yazalım. Tekil değişkenler kullanarak başlayacağız ve ardından bunun yerine struct kullanana kadar programı yeniden düzenleyeceğiz.

Cargo ile dikdortgenler adında yeni bir ikili proje (binary project) oluşturalım; bu proje, piksel cinsinden belirtilen bir dikdörtgenin genişliğini ve yüksekliğini alıp dikdörtgenin alanını hesaplayacak. Liste 5-8, projemizin src/main.rs dosyasında tam olarak bunu yapmanın bir yolunu içeren kısa bir programı göstermektedir.

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 komutunu kullanarak çalıştırın:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/rectangles`
Dikdörtgenin alanı 1500 kare pikseldir.

Bu kod, her bir boyutu parametre alan alan fonksiyonunu çağırarak dikdörtgenin alanını bulmada başarılıdır, ancak bu kodu net ve okunaklı hale getirmek için daha fazlasını yapabiliriz.

Bu kodun sorunu alan fonksiyonunun imzasında açıktı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 bir dikdörtgenin alanını hesaplaması gerekiyordu, ancak yazdığımız fonksiyonun iki parametresi var ve programımızın hiçbir yerinde parametrelerin birbiriyle ilişkili olduğu açık değil. Genişlik ve yüksekliği gruplandırmak çok daha okunaklı ve daha yönetilebilir olacaktır. Bölüm 3’teki “Demet Türü (The Tuple Type)” kısmında bunu yapmanın bir yolunu (demetleri kullanarak) tartışmıştık.

Demetlerle Yeniden Düzenleme (Refactoring with Tuples)

Liste 5-9 programımızın demet kullanan başka bir sürümünü gösterir.

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 bakıma bu program daha iyidir. Demetler biraz daha fazla yapı eklememize izin verir ve artık sadece tek bir argüman geçiriyoruz. Ancak başka bir açıdan bu sürüm daha az nettir: Demetler öğelerini isimlendirmez, bu nedenle demetin parçalarına indeksle ulaşmamız gerekir, bu da hesaplamamızı daha az açık hale getirir.

Genişlik ve yüksekliği karıştırmak alan hesaplaması için önemli olmaz, ancak dikdörtgeni ekrana çizmek isteseydik önemli olurdu! genislik’in demet indeksi 0 ve yukseklik’in demet indeksi 1 olduğunu akılda tutmamız gerekirdi. Kodu başkası kullansaydı, bunu anlaması ve aklında tutması onun için daha da zor olurdu. Kodumuzda verilerimizin anlamını yansıtmadığımız için artık hata yapmak daha kolaydır.

Struct’larla Yeniden Düzenleme (Refactoring with Structs)

Verileri etiketleyerek anlam katmak için struct’ları kullanırız. Liste 5-10’da gösterildiği gibi, kullandığımız demeti bütünü için bir ad ve parçaları için adlar olan 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ımladık ve ona Dikdortgen adını verdik. Süslü parantezler içinde alanları her ikisi de u32 türünde olan genislik ve yukseklik olarak tanımladık. Daha sonra, main içinde genişliği 30 ve yüksekliği 50 olan özel bir Dikdortgen örneği oluşturduk.

alan fonksiyonumuz artık türü bir Dikdortgen struct örneğinin değiştirilemez ödünç alınmış hali (immutable borrow) olan ve dikdortgen olarak adlandırdığımız tek bir parametreyle tanımlanmıştır. Bölüm 4’te bahsedildiği gibi, struct’ın sahipliğini almak yerine onu ödünç almak istiyoruz. Bu yolla main, dikdortgen1’in sahipliğini korur ve kullanmaya devam edebilir; işte bu yüzden fonksiyon imzasında ve fonksiyonu çağırdığımız yerde & işaretini kullanıyoruz.

alan fonksiyonu, Dikdortgen örneğinin genislik ve yukseklik alanlarına erişir (ödünç alınan bir struct örneğinin alanlarına erişmenin alan değerlerini taşımadığına dikkat edin, bu yüzden struct’ların sık sık ödünç alındığını görürsünüz). alan için fonksiyon imzamız artık tam olarak ne demek istediğimizi ifade eder: genislik ve yukseklik alanlarını kullanarak Dikdortgen’in alanını hesapla. Bu, genişlik ve yüksekliğin birbiriyle ilişkili olduğunu gösterir ve demet indeks değerleri 0 ve 1 kullanmak yerine değerlere açıklayıcı (descriptive) adlar verir. Bu durum, kodun netliği için büyük bir kazanımdır.

Türetilen Traitlerle Yararlı İşlevsellik Ekleme (Adding Functionality with Derived Traits)

Programımızı debug ederken (hata ayıklarken) bir Dikdortgen örneğini ekrana yazdırabilmek ve tüm alanlarının değerlerini görmek faydalı olurdu. Liste 5-11’de önceki bölümlerde kullandığımız gibi println! makrosunu kullanmayı deniyoruz. Ancak bu çalışmayacaktır.

struct Dikdortgen {
    genislik: u32,
    yukseklik: u32,
}

fn main() {
    let dikdortgen1 = Dikdortgen {
        genislik: 30,
        yukseklik: 50,
    };

    println!("dikdortgen1 şöyledir: {dikdortgen1}");
}

Bu kodu derlediğimizde şu ana mesajı içeren bir hata alırız:

error[E0277]: `Dikdortgen` doesn't implement `std::fmt::Display`

println! makrosu birçok çeşit biçimlendirme yapabilir ve varsayılan olarak süslü parantezler, println! makrosuna Display olarak bilinen biçimlendirmeyi (doğrudan son kullanıcı tüketimi için tasarlanmış çıktı) kullanmasını söyler. Şimdiye kadar gördüğümüz ilkel türler varsayılan olarak Display trait’ini uygular çünkü bir kullanıcıya 1’i veya diğer herhangi bir ilkel türü göstermenin yalnızca tek bir yolu vardır. Ancak struct’lar söz konusu olduğunda println! makrosunun çıktıyı biçimlendirme şekli daha az nettir, çünkü daha fazla görüntüleme olasılığı vardır: Virgül istiyor musunuz yoksa istemiyor musunuz? Süslü parantezleri yazdırmak ister misiniz? Tüm alanlar gösterilmeli mi? Bu belirsizlik (ambiguity) nedeniyle Rust ne istediğimizi tahmin etmeye çalışmaz ve struct’lar println! ve {} yer tutucusu (placeholder) ile kullanılacak, hali hazırda sağlanmış bir Display uygulamasına sahip değildir.

Hataları okumaya devam edersek şu yararlı notu (yardımcı notu) buluruz:

   |                                     |`Dikdortgen` cannot be formatted with the default formatter
   |                                     required by this formatting parameter

Hadi deneyelim! println! makro çağrısı artık şu şekilde görünecek: println!("dikdortgen1 şöyledir: {dikdortgen1:?}");. Süslü parantezlerin içine :? belirtecini (specifier) koymak, println!’e Debug adında bir çıktı biçimi kullanmak istediğimizi söyler. Debug trait’i, kodumuzu hata ayıklama sırasında değerini görebilmemiz için struct’ımızı geliştiriciler için yararlı olacak bir şekilde yazdırmamızı sağlar.

Kodu bu değişiklikle derleyin. Olamaz! Hâlâ hata alıyoruz:

error[E0277]: `Dikdortgen` doesn't implement `Debug`

Fakat derleyici bize yine de faydalı bir not veriyor:

   |                                     required by this formatting parameter
   |

Rust hata ayıklama bilgilerini yazdırmak için işlevsellik içerir, ancak bu işlevselliği struct’ımız için kullanılabilir hale getirmek adına bunu (açıkça) kendimiz seçmeliyiz. Bunu yapmak için, Liste 5-12’de gösterildiği gibi struct tanımından hemen önce dış özniteliği (outer attribute) #[derive(Debug)] 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 hiçbir hata almayacağız ve şu çıktıyı göreceğiz:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
dikdortgen1 şöyledir: Dikdortgen { genislik: 30, yukseklik: 50 }

Harika! En güzel çıktı olmayabilir, ancak bu örnekteki tüm alanların değerlerini gösterir, ki bu da hata ayıklama sırasında kesinlikle yardımcı olacaktır. Daha büyük struct’larımız olduğunda, okuması biraz daha kolay bir çıktıya sahip olmak yararlıdır; bu durumlarda, println! dizesinde {:?} yerine {:#?} kullanabiliriz. Bu örnekte {:#?} stilini kullanmak şu çıktıyı üretecektir:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/rectangles`
dikdortgen1 şöyledir: Dikdortgen {
    genislik: 30,
    yukseklik: 50,
}

Debug formatını kullanarak bir değeri yazdırmanın başka bir yolu da, bir ifadenin sahipliğini alan (println! referans alırken) ve kodunuzda söz konusu dbg! makro çağrısının nerede (dosya ve satır numarası olarak) gerçekleştiğini o ifadenin sonucunda elde edilen değerle birlikte ekrana yazdıran ve değerin sahipliğini geri döndüren dbg! makrosunu kullanmaktır.

Not: dbg! makrosunu çağırmak, standart çıktı konsolu akışına (stdout) yazdıran println!’in aksine, standart hata konsolu akışına (stderr) yazdırır. Bölüm 12’deki “Hataları Standart Hata Çıktısına (Standard Error) Yönlendirmek” bölümünde stderr ve stdout hakkında daha fazla konuşacağız.

Burada, tüm dikdortgen1 struct’ının değerinin yanı sıra, genislik alanına atanan değere de ilgi duyduğumuz bir örnek var:

#[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 ifadesinin etrafına dbg! koyabiliriz ve dbg! ifadenin değerinin sahipliğini geri döndürdüğü için, genislik alanı sanki orada dbg! çağrısı yokmuş gibi aynı değeri alacaktır. dbg!’in dikdortgen1’in sahipliğini almasını istemiyoruz, bu yüzden bir sonraki çağrıda dikdortgen1’e bir referans kullanıyoruz. İşte bu örneğin çıktısının nasıl göründüğü:

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.61s
     Running `target/debug/rectangles`
[src/main.rs:10:16] 30 * olcek = 60
[src/main.rs:14:5] &dikdortgen1 = Dikdortgen {
    genislik: 60,
    yukseklik: 50,
}

Çıktının ilk bölümünün, 30 * olcek ifadesinde hata ayıklaması yaptığımız src/main.rs dosyasındaki 10. satırdan geldiğini ve bu ifadenin sonucunun 60 olduğunu görebiliriz (tamsayılar için uygulanan Debug biçimlendirmesi yalnızca değerlerini yazdırmaktır). src/main.rs dosyasının 14. satırındaki dbg! çağrısı, Dikdortgen struct’ı olan &dikdortgen1’in değerini çıkarır. Bu çıktı, Dikdortgen türünün güzel (pretty) Debug biçimlendirmesini kullanır. dbg! makrosu, kodunuzun ne yaptığını anlamaya çalışırken gerçekten yararlı olabilir!

Debug trait’ine ek olarak, Rust, özel türlerimize yararlı davranışlar ekleyebilen, derive niteliğiyle birlikte kullanmamız için bize birkaç trait sağlamıştır. Bu trait’ler ve davranışları Ek C’de listelenmiştir. Özel davranışa sahip bu trait’lerin nasıl uygulanacağının yanı sıra Bölüm 10’da kendi trait’lerinizi nasıl oluşturacağınızı da ele alacağız. Ayrıca derive dışında birçok başka öznitelik de vardır; daha fazla bilgi için Rust Referansındaki “Öznitelikler (Attributes)” bölümüne bakın.

alan fonksiyonumuz çok spesifiktir: Sadece dikdörtgenlerin alanını hesaplar. Bu davranışı Dikdortgen yapımıza (struct) daha yakından bağlamak (tie) faydalı olacaktır çünkü başka hiçbir türle çalışmayacaktır. Şimdi alan fonksiyonunu Dikdortgen türümüzde tanımlanan bir alan metoduna dönüştürerek bu kodu yeniden düzenlemeye nasıl devam edebileceğimize bakalım.

Metotlar

Metotlar (Methods)

Metotlar fonksiyonlara oldukça benzer: Onları da fn anahtar kelimesi ve bir isimle tanımlarız, parametre alabilirler, bir değer döndürebilirler ve başka bir yerden çağrıldıklarında çalıştırılacak bazı kodlar barındırırlar. Ancak fonksiyonlardan farklı olarak metotlar, bir yapının (struct) (veya Bölüm 6 ve Bölüm 18’de göreceğimiz üzere bir enum veya trait nesnesinin) bağlamı içinde tanımlanırlar. Metotların ilk parametresi her zaman self olmalıdır; bu parametre, metodun üzerinde çağrıldığı yapı (struct) örneğini temsil eder.

Metot Sözdizimi (Method Syntax)

Hadi parametre olarak bir Dikdortgen örneği alan eski alan fonksiyonumuzu değiştirelim ve bunun yerine Liste 5-13’te gösterildiği gibi Dikdortgen yapısı (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ı {} metrekaredir.", dikdortgen1.alan());
}

Fonksiyonu Dikdortgen bağlamında tanımlamak için, Dikdortgen adına bir impl (uygulama/implementation) bloğu başlatıyoruz. Bu impl bloğu içindeki her şey Dikdortgen tipiyle ilişkilendirilecektir. Daha sonra alan fonksiyonunu impl süslü parantezlerinin içine taşıyoruz ve imzadaki ilk (ve bu durumda tek) parametreyi hem tanımda hem de gövdede self olacak şekilde değiştiriyoruz. Önceden alan fonksiyonunu çağırıp dikdortgen1’i argüman olarak ilettiğimiz main fonksiyonunun içinde, artık Dikdortgen örneğimiz üzerinde alan metodunu çağırmak için metot sözdizimini (method syntax) kullanabiliriz. Metot sözdizimi doğrudan örneğin adından sonra gelir: Bir nokta ekleriz, ardından metodun adını, parantezleri ve varsa argümanları yazarız.

alan metodunun imzasında dikdortgen: &Dikdortgen yerine &self kullanıyoruz. Buradaki &self, aslında self: &Self ifadesinin kısaltmasıdır. Bir impl bloğu içerisinde Self tipi, o impl bloğunun ait olduğu tipin kısa adıdır. Metotların ilk parametresinin adı self ve tipi Self olmak zorundadır; bu nedenle Rust, ilk parametre alanında bunu sadece self ismiyle kısaltmanıza olanak tanır. Ancak 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 & işareti koymamız gerektiğini unutmayın. Metotlar; aynen diğer parametrelerde olduğu gibi self’in sahipliğini alabilir, burada yaptığımız gibi self’i değiştirilemez şekilde ödünç alabilir veya self’i değiştirilebilir şekilde ödünç alabilirler.

Fonksiyon versiyonunda neden &Dikdortgen kullandıysak, burada da aynı nedenden ötürü &self kullandık: Sahipliği almak istemiyoruz; yalnızca yapıdaki verileri okumak istiyoruz, onlara yazmak istemiyoruz. Eğer metodun, çağrıldığı örneği değiştirmesini isteseydik, ilk parametre olarak &mut self kullanırdık. İlk parametre olarak sadece self kullanarak örneğin sahipliğini tamamen alan bir metot yazmak nadir görülen bir durumdur; bu teknik genellikle metot self’i başka bir şeye dönüştürdüğünde ve dönüşümden sonra çağıran kişinin orijinal örneği kullanmasını engellemek istediğinizde kullanılır.

Metot sözdiziminin sağladığı kolaylıklar ve her metodun imzasında self tipini tekrar etme zorunluluğunun ortadan kalkmasının yanı sıra, fonksiyonlar yerine metotları kullanmanın asıl ana nedeni kod organizasyonudur. Bir tipin örneğiyle yapabileceğimiz her şeyi tek bir impl bloğunda topladık. Böylece kodumuzu kullanacak kişilerin, Dikdortgen’in yeteneklerini kütüphanemizin çeşitli yerlerinde aramak zorunda kalmalarını engellemiş olduk.

Ayrıca, bir metoda yapının (struct) alanlarından (field) biriyle aynı ismi vermeyi de seçebiliriz. Örneğin, Dikdortgen üzerinde aynı zamanda 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 istedik: Kısacası, bir alanı aynı isimli bir metot içinde herhangi bir amaçla kullanabiliriz. main fonksiyonunda, dikdortgen1.genislik ifadesinden sonra parantez kullandığımızda, Rust bizim genislik metodunu kastettiğimizi anlar. Parantez kullanmadığımızda ise Rust bizim genislik alanını (field) kastettiğimizi bilir.

Sıklıkla (ama her zaman değil), bir metoda yapıdaki alanla aynı ismi verdiğimizde, bu metodun yalnızca o alandaki değeri döndürmesini ve başka hiçbir şey yapmamasını isteriz. Bu tür metotlara alıcılar (getters) denir. Bazı diğer dillerin aksine Rust, yapı alanları için alıcıları (getter) otomatik olarak uygulamaz. Alıcılar faydalıdır, çünkü alanı gizli (private), ancak metodu açık yapabilirsiniz. Böylece bu alana sadece okunabilir (read-only) bir erişim sağlayarak onu tipin genel API’sinin bir parçası haline getirebilirsiniz. “Açık” ve “gizli” (private) kavramlarının ne olduğunu ve bir alanın veya metodun nasıl bu şekilde tasarlanacağını Bölüm 7’de tartışacağı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

Şimdi Dikdortgen yapımız üzerinde ikinci bir metot yazarak pratik yapalım. Bu kez, bir Dikdortgen örneğinin başka bir Dikdortgen örneğini parametre olarak almasını istiyoruz. Eğer ikinci Dikdortgen, tamamen self’in (yani birinci Dikdortgen’in) içine sığabiliyorsa true, sığamıyorsa false döndürmeli. Yani, kapsayabilir_mi metodunu tanımladığımızda, 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)
    );
}

Beklenen çıktı aşağıdaki gibi olmalıdır; çünkü dikdortgen2’nin her iki boyutu da dikdortgen1’den küçüktür, ancak dikdortgen3 dikdortgen1’den daha geniştir:

dikdortgen1, dikdortgen2'yi kapsayabilir mi? true
dikdortgen1, dikdortgen3'ü kapsayabilir mi? false

Bir metot tanımlamak istediğimizi biliyoruz, bu yüzden bunu impl Dikdortgen bloğunun içine yazacağız. Metodun adı kapsayabilir_mi olacak ve parametre olarak başka bir Dikdortgen’in değiştirilemez referansını alacak. Parametrenin tipinin ne olması gerektiğini, metodu çağıran koda bakarak da anlayabiliriz: dikdortgen1.kapsayabilir_mi(&dikdortgen2) satırı argüman olarak &dikdortgen2’yi iletiyor, ki bu da bir Dikdortgen örneği olan dikdortgen2’nin değiştirilemez bir ödünç alımıdır. Bu oldukça mantıklı; çünkü sadece dikdortgen2’yi okumaya ihtiyacımız var (eğer yazmaya/değiştirmeye ihtiyacımız olsaydı değiştirilebilir -mutable- bir referans alırdık) ve kapsayabilir_mi metodunu çağırdıktan sonra dikdortgen2’yi tekrar kullanabilmek için main fonksiyonunun onun sahipliğini elinde tutmasını istiyoruz.

kapsayabilir_mi metodunun dönüş değeri bir Boolean (mantıksal değer) olacak ve metodun gövdesinde self’in genişlik ve yüksekliğinin, diğer Dikdortgen’in genişlik ve yüksekliğinden büyük olup olmadığını kontrol edeceğiz. Hadi Liste 5-13’teki impl bloğumuza yeni kapsayabilir_mi metodunu ekleyelim (Liste 5-15).

#[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 fonksiyonu ile birlikte çalıştırdığımızda istediğimiz çıktıyı alacağız. Metotlar, self parametresinden sonra eklediğimiz birden fazla parametreyi alabilirler ve bu parametreler tıpkı standart fonksiyonlardaki parametreler gibi çalışır.

İlişkili Fonksiyonlar (Associated Functions)

Bir impl bloğu içinde tanımlanan tüm fonksiyonlara ilişkili fonksiyonlar (associated functions) denir; çünkü bu fonksiyonlar impl kelimesinden sonra adı yazılan tiple ilişkilendirilmişlerdir. İlk parametresi self olmayan (ve dolayısıyla metot olmayan) ilişkili fonksiyonlar da tanımlayabiliriz. Bunlar metot değildir çünkü çalışmak için ilgili tipin bir örneğine ihtiyaç duymazlar. Biz zaten bu tarz bir fonksiyonu daha önce kullandık: String tipi üzerinde tanımlı olan String::from fonksiyonu.

Metot olmayan ilişkili fonksiyonlar genellikle, yapının yeni bir örneğini döndürecek “kurucular” (constructors) olarak kullanılırlar. Bunlara çoğunlukla new adı verilir, ancak new dilde yerleşik olarak bulunan veya özel bir anlam taşıyan bir kelime değildir. Örneğin, genişlik ve yükseklik için aynı değeri kullanan ve böylece bir kare oluşturmayı kolaylaştıran kare adında bir ilişkili fonksiyon tanımlayabiliriz. Bu sayede aynı değeri iki kez girmek zorunda kalmayı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üş tipindeki ve fonksiyon gövdesindeki Self anahtar kelimesi, impl anahtar kelimesinden sonra görünen tip için bir kısaltmadır; yani bu durumda Dikdortgen’i temsil eder.

Bu ilişkili fonksiyonu çağırmak için yapının (struct) adıyla birlikte :: sözdizimini kullanırız; let kare_obje = Dikdortgen::kare(3); buna güzel bir örnektir. Bu fonksiyon, yapı tarafından isim alanına (namespace) dahil edilmiştir: :: sözdizimi hem ilişkili fonksiyonlar hem de modüllerin oluşturduğu isim alanları (namespaces) için kullanılır. Modülleri Bölüm 7’de detaylıca tartışacağız.

Birden Fazla impl Bloğu

Her yapının (struct) 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 metotları birden fazla impl bloğuna ayırmak için geçerli bir nedenimiz olmasa da, bu tamamen geçerli bir sözdizimidir. Jenerik tipleri ve özellikleri (traits) tartışacağımız Bölüm 10’da, birden fazla impl bloğunun oldukça faydalı olduğu durumları göreceğiz.

Özet

Yapılar (Structs), çalıştığınız problem alanına (domain) uygun ve anlamlı özel tipler oluşturmanızı sağlar. Yapıları kullanarak, birbiriyle ilişkili veri parçalarını birbirine bağlı tutabilir ve kodunuzu netleştirmek için her bir parçaya anlamlı bir isim verebilirsiniz. impl bloklarında ise tipinizle ilişkili fonksiyonları tanımlayabilirsiniz. Metotlar da bir tür ilişkili fonksiyondur ve yapı örneklerinizin sergileyeceği davranışları (behavior) belirlemenize olanak tanır.

Ancak özel tipler (custom types) oluşturmanın tek yolu yapılar (structs) değildir: Şimdi araç çantanıza yeni bir araç daha eklemek için Rust’ın enum özelliğine geçelim.

Enum’lar ve Desen Eşleştirme

Bu bölümde, enum olarak da adlandırılan numaralandırmalara bakacağız.

Enum’lar, olası varyantlarını (seçeneklerini) numaralandırarak bir tür tanımlamanıza olanak tanır. Öncelikle, bir enum’ın verilerle birlikte nasıl bir anlam ifade edebileceğini göstermek için bir enum tanımlayıp kullanacağız. Daha sonra, bir değerin bir şey ya da hiçbir şey (something or nothing) olabileceğini ifade eden Option adlı özellikle yararlı bir enum’ı inceleyeceğiz. Ardından, match ifadesindeki desen eşleştirmenin, bir enum’ın farklı değerleri için farklı kodlar çalıştırmayı nasıl kolaylaştırdığına bakacağız. Son olarak, if let yapısının kodunuzdaki enum’ları işlemek için kullanılabilecek ne kadar uygun ve özlü bir başka ifade (idiom) olduğunu ele alacağız.

Bir Enum Tanımlama

Bir Enum Tanımlama

Struct’ların (yapıların) size ilgili alanları ve verileri birlikte gruplandırmanın bir yolunu sunduğu gibi (örneğin genislik ve yukseklik değerlerine sahip bir Dikdortgen gibi), enum’lar da bir değerin olası değerler kümesinden biri olduğunu söylemenin bir yolunu sunar. Örneğin, Dikdortgen’in Daire ve Ucgen’i de içeren olası şekiller kümesinden biri olduğunu söylemek isteyebiliriz. Bunu yapmak için Rust, bu olasılıkları bir enum olarak kodlamamıza (encode) olanak tanır.

Kodda ifade etmek isteyebileceğimiz bir duruma bakalım ve enum’ların neden yararlı olduğunu ve bu durumda struct’lardan neden daha uygun olduğunu görelim. Diyelim ki IP adresleriyle çalışmamız gerekiyor. Şu anda IP adresleri için iki ana standart kullanılıyor: 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 olasılıklar söz konusu olduğundan, olası tüm varyantları numaralandırabiliriz (enumerate); numaralandırma da adını buradan alır.

Herhangi bir IP adresi sürüm dört veya sürüm altı adres olabilir, ancak aynı anda ikisi birden olamaz. IP adreslerinin bu özelliği enum veri yapısını uygun hale getirir çünkü bir enum değeri varyantlarından yalnızca biri olabilir. Hem sürüm dört hem de sürüm altı adresler temelde hala IP adresleridir, bu nedenle kod herhangi bir IP adresi türüne uygulanan durumları işlerken her ikisine de aynı tür olarak davranılmalıdır.

Bu kavramı, kodda bir IpAdresTuru (IpAddrKind) numaralandırması tanımlayıp bir IP adresinin olabileceği olası türleri olan V4 ve V6’yı 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’nün iki varyantının 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 kendi tanımlayıcısı altında adlandırıldığına ve ikisini ayırmak için çift iki nokta üst üste (::) kullandığımıza dikkat edin. Bu faydalıdır çünkü artık IpAdresTuru::V4 ve IpAdresTuru::V6 değerlerinin her ikisi de aynı türdendir: IpAdresTuru. Daha sonra, örneğin, herhangi bir IpAdresTuru 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) {}

Ve 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 daha da fazla avantajı vardır. IP adresi türümüz hakkında daha fazla düşünürsek, şu anda asıl IP adresi verisini depolamak için bir yolumuz yok; sadece hangi tür olduğunu biliyoruz. Bölüm 5’te struct’ları yeni öğrendiğiniz için, Liste 6-1’de gösterildiği gibi bu sorunu struct’larla çözmek isteyebilirsiniz.

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 (IpAddr) struct’ı tanımladık: IpAdresTuru (daha önce tanımladığımız enum) türünde bir tur (kind) alanı ve String türünde bir adres alanı. Bu struct’ın iki örneği var. İlki ev’dir ve tur değeri olarak IpAdresTuru::V4’e, ilişkili adres verisi olarak da 127.0.0.1 değerine sahiptir. İkinci örnek ise geridongu’dur (loopback). Bu örnek, tur değeri olarak IpAdresTuru’nün diğer varyantı olan V6’ya sahiptir ve bununla ilişkili ::1 adresini barındırır. tur ve adres değerlerini bir araya toplamak için bir struct kullandık, böylece artık varyant değerle ilişkilendirilmiş oldu.

Bununla birlikte, aynı kavramı sadece bir enum kullanarak ifade etmek daha kısa ve özlüdür: Bir struct’ın içine bir enum koymak yerine, verileri 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 ilişkili String değerlerine 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"));
}

Verileri doğrudan enum’ın her bir varyantına ekliyoruz, bu nedenle fazladan bir struct’a gerek kalmaz. Burada, enum’ların nasıl çalıştığına dair başka bir ayrıntıyı görmek de daha kolaydır: Tanımladığımız her enum varyantının adı, aynı zamanda o enum’ın bir örneğini oluşturan bir fonksiyon haline 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ımladığımız için bu kurucu (constructor) fonksiyon otomatik olarak tanımlanmış olarak gelir.

Struct yerine enum kullanmanın başka bir avantajı daha vardır: Her varyant farklı türlerde ve miktarlarda ilişkili verilere sahip olabilir. Sürüm dört IP adresleri her zaman 0 ile 255 arasında değerlere sahip dört sayısal bileşene sahip olacaktır. V4 adreslerini dört u8 değeri olarak depolamak isteyip V6 adreslerini yine de tek bir String değeri olarak ifade etmek isteseydik, bunu bir struct ile yapamazdık. Enum’lar bu durumu kolaylıkla halleder:

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 depolamak üzere veri yapılarını tanımlamanın birkaç farklı yolunu gösterdik. Ancak ortaya çıktığı üzere, IP adreslerini depolamak ve hangi türde olduklarını kodlamak o kadar yaygındır ki, standart kütüphanede kullanabileceğimiz bir tanım vardır! Gelin standart kütüphanenin IpAddr’ı nasıl tanımladığına bakalım. Bizim tanımladığımız ve kullandığımız enum ve varyantların aynısına sahiptir, ancak adres verilerini varyantların içine her varyant için farklı şekilde tanımlanan 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ür veriyi koyabileceğinizi göstermektedir: örneğin string’ler, sayısal türler veya struct’lar. Hatta içine başka bir enum bile ekleyebilirsiniz! Ayrıca, standart kütüphane türleri genellikle sizin bulacağınızdan çok daha karmaşık değildir.

Standart kütüphane IpAddr için bir tanım içerse de, standart kütüphanenin tanımını kapsamımıza dahil etmediğimiz için yine de kendi tanımımızı oluşturup çakışma olmadan kullanabileceğimizi unutmayın. Türleri kapsama getirme konusunu Bölüm 7’de daha ayrıntılı olarak ele alacağız.

Liste 6-2’de başka bir enum örneğine bakalım: Bunun varyantlarına gömülü çok çeşitli türleri vardır.

enum Mesaj {
    Cik,
    Tasi { x: i32, y: i32 },
    Yaz(String),
    RenkDegistir(i32, i32, i32),
}

fn main() {}

Bu enum’ın farklı türlere sahip dört varyantı vardır:

• Cik: Kendisiyle ilişkili hiçbir veriye sahip değildir.
• Tasi: Tıpkı bir struct’ta olduğu 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ı türlerde struct tanımları tanımlamaya benzer, tek fark enum’ın struct anahtar kelimesini kullanmaması ve tüm varyantların Mesaj türü altında birlikte gruplandırılmasıdır. Aşağıdaki struct’lar önceki enum varyantlarının tuttuğu aynı verileri tutabilirdi:

struct CikMesaji; // birim (unit) struct
struct TasiMesaji {
    x: i32,
    y: i32,
}
struct YazMesaji(String); // demet (tuple) struct
struct RenkDegistirMesaji(i32, i32, i32); // demet (tuple) struct

fn main() {}

Ancak her biri kendi türüne sahip olan bu farklı struct’ları kullansaydık, bu mesaj türlerinden herhangi birini alacak 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 ve struct’lar arasında bir benzerlik daha vardır: Tıpkı struct’larda impl kullanarak metotlar tanımlayabildiğimiz gibi, enum’larda da metotlar tanımlayabiliriz. İşte Mesaj enum’ımızda 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, metodu çağırdığımız değeri elde etmek için self kullanacaktı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övdesinde self’in değeri bu olacaktır.

Standart kütüphanede çok yaygın ve kullanışlı olan başka bir enum’a bakalım: Option.

Option Enum’ı

Bu bölüm, standart kütüphane tarafından tanımlanan başka bir enum olan Option için bir örnek olay incelemesi yapmaktadır. Option türü, bir değerin bir şey olabileceği veya hiçbir şey olamayacağı son derece yaygın senaryoyu kodlar.

Örneğin, boş olmayan bir listedeki ilk öğeyi isterseniz, bir değer alırsınız. Boş bir listedeki ilk öğeyi isterseniz, hiçbir şey alamazsınız. Bu kavramı tür sistemi açısından ifade etmek, derleyicinin ele almanız gereken tüm durumları ele alıp almadığınızı kontrol edebileceği anlamına gelir; bu işlevsellik, diğer programlama dillerinde son derece yaygın olan hataları (bug) önleyebilir.

Programlama dili tasarımı genellikle hangi özellikleri dahil ettiğiniz açısından düşünülür, ancak hariç tuttuğunuz özellikler de önemlidir. Rust, diğer birçok dilin sahip olduğu null (boş) özelliğine sahip değildir. Null, orada hiçbir değer olmadığı anlamına gelen bir değerdir. Null içeren dillerde değişkenler her zaman iki durumdan birinde olabilir: null veya null olmayan (not-null).

Null değerinin mucidi Tony Hoare, 2009’daki “Null Referanslar: Milyar Dolarlık Hata” (“Null References: The Billion Dollar Mistake”) adlı sunumunda şunları söylemiştir:

Buna benim milyar dolarlık hatam diyorum. O zamanlar nesne yönelimli (object-oriented) bir dilde referanslar için ilk kapsamlı tür sistemini tasarlıyordum. Amacım, derleyici tarafından otomatik olarak gerçekleştirilen kontrollerle, referansların tüm kullanımlarının kesinlikle güvenli olmasını sağlamaktı. Ancak, uygulaması çok kolay olduğu için null referans ekleme cazibesine karşı koyamadım. Bu, muhtemelen son kırk yılda bir milyar dolarlık acıya ve hasara neden olan sayısız hataya, güvenlik açığına ve sistem çökmesine yol açtı.

Null değerleriyle ilgili sorun, null değerini null olmayan bir değer olarak kullanmaya çalışırsanız, bir tür hata almanızdır. Bu null veya null olmama özelliği yaygın olduğundan (pervasive), bu tür bir hata yapmak son derece kolaydır.

Ancak null’un ifade etmeye çalıştığı kavram hala yararlıdır: Null, şu anda herhangi bir nedenle geçersiz olan veya olmayan (absent) bir değerdir.

Sorun aslında kavramda değil, belirli uygulamadadır. Bu nedenle Rust’ta null yoktur, ancak bir değerin var veya yok olması kavramını kodlayabilen bir enum’a sahiptir. Bu enum Option<T>’dir ve standart kütüphane tarafından şu şekilde tanımlanır:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Option<T> enum’ı o kadar faydalıdır ki prelude (başlangıç) kütüphanesine bile dahil edilmiştir; açıkça (explicitly) kapsama dahil etmenize gerek yoktur. Varyantları da prelude kütüphanesine dahildir: Some ve None’ı Option:: öneki olmadan doğrudan kullanabilirsiniz. Option<T> enum’ı hala sadece normal bir enum’dır ve Some(T) ve None hala Option<T> türünün varyantlarıdır.

<T> sözdizimi, Rust’ın henüz bahsetmediğimiz bir özelliğidir. Bu genel (generic) bir tür parametresidir ve Bölüm 10’da jenerikleri daha ayrıntılı olarak ele alacağız. Şimdilik bilmeniz gereken tek şey, <T>’nin Option enum’ının Some varyantının herhangi bir türden bir veri tutabileceği anlamına geldiği ve T yerine kullanılan her somut (concrete) türün genel Option<T> türünü farklı bir tür haline getirdiğidir. Sayı türlerini ve karakter (char) türlerini tutmak için Option değerlerinin kullanıldığı bazı örnekler:

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 farklı bir tür olan Option<char>’dır. Some varyantının içinde bir değer belirttiğimiz için Rust bu türleri çıkarabilir. olmayan_sayi için Rust bizden genel Option türünü açıklamamızı ister: Derleyici, yalnızca bir None değerine bakarak karşılık gelen Some varyantının tutacağı türü çıkaramaz. Burada, Rust’a olmayan_sayi’nın Option<i32> türünde olmasını kastettiğimizi söyleriz.

Bir Some değerimiz olduğunda, bir değerin mevcut olduğunu ve değerin Some içinde tutulduğunu biliriz. Bir None değerimiz olduğunda ise bu, bazı açılardan null ile aynı anlama gelir: Geçerli bir değerimiz yoktur. Peki, Option<T>’ye sahip olmak null’a sahip olmaktan neden daha iyidir?

Kısaca, Option<T> ve T (burada T herhangi bir tür olabilir) farklı türler olduğundan, derleyici bir Option<T> değerini sanki kesinlikle geçerli bir değermiş gibi kullanmamıza izin vermez. Örneğin, aşağıdaki kod derlenmeyecektir, çünkü bir Option<i8>’e bir i8 eklemeye çalışmaktadır:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let toplam = x + y;
}

Eğer bu kodu çalıştırırsak, şuna benzer bir hata mesajı alırız:

$ cargo run
   Compiling enums v0.1.0 ($PROJE/listings/ch06-enums-and-pattern-matching/no-listing-07-cant-use-option-directly)
error[E0277]: cannot add `Option<i8>` to `i8`
   --> src/main.rs:6:20
    |
  6 |     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>`
   --> $HOME/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/arith.rs:99:9
    |
 99 |         impl const Add for $t {
    |         ^^^^^^^^^^^^^^^^^^^^^ `i8` implements `Add`
...
114 | add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f16 f32 f64 f128 }
    | ---------------------------------------------------------------------------------- in this macro invocation
    |
   ::: $HOME/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/internal_macros.rs:22:9
    |
 22 |         impl const $imp<$u> for &$t {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&i8` implements `Add<i8>`
...
 33 |         impl const $imp<&$u> for $t {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ `i8` implements `Add<&i8>`
...
 44 |         impl const $imp<&$u> for &$t {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `&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

Sert! Aslında bu hata mesajı, Rust’ın farklı türlerde oldukları için bir i8 ile bir Option<i8>’i nasıl toplayacağını anlamadığı anlamına gelir. Rust’ta i8 gibi bir türde değere sahip olduğumuzda, derleyici her zaman geçerli bir değere sahip olduğumuzdan emin olur. Bu değeri kullanmadan önce null olup olmadığını kontrol etmek zorunda kalmadan güvenle devam edebiliriz. Yalnızca bir Option<i8>’e (veya üzerinde çalıştığımız değerin türü her neyse) sahip olduğumuzda bir değere sahip olmama ihtimalinden endişe duymalıyız; derleyici bu değeri kullanmadan önce bu durumu ele aldığımızdan emin olacaktır.

Başka bir deyişle, bir Option<T> ile T işlemleri gerçekleştirebilmeniz için onu bir T’ye dönüştürmeniz gerekir. Genellikle bu, null ile ilgili en yaygın sorunlardan birini yakalamaya yardımcı olur: Bir şeyin aslında null olduğu halde null olmadığını varsaymak.

Null olmayan (not-null) bir değeri yanlış varsayma riskini ortadan kaldırmak, kodunuza daha fazla güvenmenize yardımcı olur. Null olabilme ihtimali olan bir değere sahip olmak için, o değerin türünü Option<T> yaparak bu durumu açıkça (explicitly) belirtmeniz (opt in) gerekir. Daha sonra, o değeri kullandığınızda, değerin null olduğu durumu açıkça ele almanız istenir. Değerin Option<T> olmayan bir türe sahip olduğu her yerde, değerin null olmadığını güvenle varsayabilirsiniz. Bu, Rust’ta null’un yaygınlığını sınırlamak ve Rust kodunun güvenliğini artırmak için bilinçli (deliberate) olarak verilmiş bir tasarım kararıydı.

Peki, bu değeri kullanabilmek için Option<T> türünde bir değere sahip olduğunuzda T değerini bir Some varyantından nasıl çıkarırsınız? Option<T> enum’ı, çeşitli durumlarda yararlı olan çok sayıda metoda sahiptir; bunları belgelerinden inceleyebilirsiniz. Option<T> üzerindeki metotlara aşina olmak, Rust yolculuğunuzda son derece yararlı olacaktır.

Genel olarak, bir Option<T> değerini kullanmak için, her bir varyantı ele alacak bir koda sahip olmak istersiniz. Yalnızca Some(T) değeriniz olduğunda çalışacak bir kod istersiniz ve bu kodun içteki (inner) T’yi kullanmasına izin verilir. Yalnızca None değeriniz varsa çalışacak başka bir kod istersiniz ve bu kodda kullanılabilecek bir T değeri yoktur. match ifadesi, enum’larla kullanıldığında tam olarak bunu yapan bir kontrol akışı yapısıdır: Sahip olduğu enum’ın hangi varyantına bağlı olarak farklı kodlar çalıştıracaktır ve bu kod eşleşen değerin içindeki verileri 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 ardından hangi desenin eşleştiğine bağlı olarak kod yürütmenize olanak tanıyan, match adı verilen son derece güçlü bir kontrol akışı (control flow) yapısına sahiptir. Desenler; sabit değerlerden (literal values), değişken adlarından, joker karakterlerden (wildcards) ve daha birçok şeyden oluşabilir; Bölüm 19 farklı desen türlerinin hepsini ve ne işe yaradıklarını ele almaktadır. match’in gücü, desenlerin ifade gücünden ve derleyicinin olası tüm durumların ele alındığını (handle edildiğini) doğrulamasından gelir.

Bir match ifadesini bozuk para ayırma makinesi gibi düşünün: Madeni paralar, üzerinde çeşitli boyutlarda delikler bulunan bir raydan aşağı kayar ve her bir para, sığdığı karşılaştığı ilk delikten aşağı düşer. Aynı şekilde, değerler de bir match içindeki her bir desenden geçer ve değerin “sığdığı” ilk desende, yürütme sırasında kullanılmak üzere ilişkili kod bloğuna düşer.

Madeni paralardan bahsetmişken, match kullanarak onları bir örnek olarak kullanalım! Liste 6-3’te gösterildiği gibi, bilinmeyen bir ABD madeni parasını alan ve sayma makinesine benzer bir şekilde hangi para olduğunu belirleyip değerini kuruş (cent) 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() {}

kurus_degeri fonksiyonundaki match’i parçalara ayıralım. İlk olarak, match anahtar kelimesini ve ardından bir ifadeyi listeliyoruz; bu durumda ifade para (coin) değeridir. Bu, if ile kullanılan bir koşul ifadesine çok benzer, ancak aralarında büyük bir fark vardır: if kullanıldığında koşulun bir Boolean değer üretmesi gerekirken, burada herhangi bir tür olabilir. Bu örnekteki para’nın türü, ilk satırda tanımladığımız MadeniPara (Coin) enum’ıdır.

Sırada match kolları (arms) var. Bir kol iki bölümden oluşur: bir desen ve bir kod. Buradaki ilk kolun deseni MadeniPara::Kurus (Coin::Penny) değeridir ve ardından desen ile çalıştırılacak kodu ayıran => operatörü gelir. Bu durumdaki kod sadece 1 değeridir. Her kol bir sonrakinden virgülle ayrılır.

match ifadesi yürütüldüğünde, ortaya çıkan değeri sırasıyla her bir kolun deseniyle karşılaştırır. Bir desen değerle eşleşirse, o desenle ilişkili kod yürütülür. Eğer desen değerle eşleşmezse, tıpkı bozuk para ayırma makinesinde olduğu gibi yürütme bir sonraki kola geçer. İhtiyacımız olduğu kadar kola sahip olabiliriz: Liste 6-3’te, match ifademizin dört kolu vardır.

Her kolla ilişkili kod bir ifadedir ve eşleşen koldaki ifadenin ortaya çıkan değeri, tüm match ifadesi için döndürülen (return) değerdir.

Liste 6-3’te olduğu gibi her bir kolun sadece bir değer döndürdüğü durumlarda, match kolu kodu kısaysa genellikle süslü parantezler kullanmayız. Bir match kolunda birden fazla satır kod çalıştırmak istiyorsanız süslü parantez kullanmanız gerekir ve bu durumda kolu takip eden virgül isteğe bağlıdır (opsiyoneldir). Örneğin, aşağıdaki kod metot bir MadeniPara::Kurus ile çağrıldığında her defasında “Şanslı kuruş!” (“Lucky penny!”) yazdırır, ancak yine de bloğun son değeri olan 1’i 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 de, desenle eşleşen değerlerin parçalarına bağlanabilmeleridir. Enum varyantlarından değerleri bu şekilde çıkarabiliriz.

Örnek olarak, enum varyantlarımızdan birini içinde veri tutacak şekilde değiştirelim. 1999’dan 2008’e kadar Amerika Birleşik Devletleri, 50 eyaletin her biri için bir yüzünde farklı tasarımlara sahip çeyreklikler (quarter) bastı. Diğer hiçbir madeni para eyalet tasarımına sahip değildi, dolayısıyla bu ekstra değere sadece çeyreklikler sahiptir. Liste 6-4’te yaptığımız gibi, YirmiBesKurus (Quarter) varyantını içine depolanmış bir Eyalet (UsState) değeri içerecek şekilde değiştirerek bu bilgiyi enum’ı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 tüm 50 eyaletin çeyrekliklerini toplamaya çalıştığını hayal edelim. Bozuk paralarımızı para türüne göre ayırırken, her çeyreklikle ilişkili eyaletin adını da söyleyeceğiz ki arkadaşımızın sahip olmadığı bir eyaletse onu koleksiyonuna ekleyebilsin.

Bu kodun match ifadesinde, MadeniPara::YirmiBesKurus varyantının değerleriyle eşleşen desene eyalet (state) adında bir değişken ekliyoruz. Bir MadeniPara::YirmiBesKurus eşleştiğinde, eyalet değişkeni o çeyrekliğin eyaletinin değerine bağlanacaktır. Daha sonra, bu koldaki kodda eyalet değişkenini şu şekilde 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));
}

Eğer kurus_degeri(MadeniPara::YirmiBesKurus(Eyalet::Alaska)) şeklinde bir çağrı yapsaydık, para’nın değeri MadeniPara::YirmiBesKurus(Eyalet::Alaska) olurdu. Bu değeri her bir match koluyla karşılaştırdığımızda, MadeniPara::YirmiBesKurus(eyalet)’e ulaşana kadar hiçbiri eşleşmez. O noktada, eyalet için bağlama (binding) Eyalet::Alaska değeri olacaktır. Daha sonra bu bağlamayı println! ifadesinde kullanabilir ve böylece YirmiBesKurus için MadeniPara enum varyantının içindeki eyalet değerini elde edebiliriz.

Option<T> match Deseni

Önceki bölümde, Option<T> kullanırken Some durumundan içteki T değerini çıkarmak istemiştik; tıpkı MadeniPara enum’ında yaptığımız gibi, Option<T>’yi de match kullanarak ele alabiliriz! Madeni paraları karşılaştırmak yerine, Option<T> varyantlarını karşılaştıracağız, ancak match ifadesinin çalışma şekli aynı kalır.

Diyelim ki bir Option<i32> alan ve eğer içinde bir değer varsa o değere 1 ekleyen bir fonksiyon yazmak istiyoruz. Eğer içinde bir değer yoksa, fonksiyon None değerini döndürmeli ve herhangi bir işlem gerçekleştirmeye çalışmamalıdır.

match sayesinde bu fonksiyonu yazmak çok kolaydır ve Liste 6-5’teki gibi görünecektir.

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 çalıştırılmasını daha ayrıntılı inceleyelim. bir_ekle(bes) çağrısı yaptığımızda, bir_ekle gövdesindeki x değişkeni Some(5) değerine sahip olacaktır. Daha sonra bunu her bir match koluyla 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 devam ederiz:

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), Some(i) ile eşleşir mi? Evet, eşleşir! Aynı varyanta sahibiz. i, Some içinde bulunan değere bağlanır, böylece i 5 değerini alır. Daha sonra match kolundaki kod çalıştırılır, böylece i’nin değerine 1 ekleriz ve içinde 6 toplamı olan yeni bir Some değeri oluştururuz.

Şimdi Liste 6-5’teki bir_ekle fonksiyonunun ikinci çağrısını inceleyelim; burada x None’dır. match içine giriyoruz ve ilk kolla karşılaştırıyoruz:

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şiyor! Eklenecek hiçbir değer yok, bu yüzden program durur ve => işaretinin sağ tarafındaki None değerini döndürür. İlk kol eşleştiği için diğer kollar karşılaştırılmaz.

match ve enum’ları birleştirmek birçok durumda yararlıdır. Bu kalıbı (pattern) Rust kodlarında çokça göreceksiniz: bir enum ile match (eşleştirme) yapma, içindeki veriye bir değişken bağlama ve ardından buna dayalı olarak kod çalıştırma. Başlangıçta biraz zorlayıcı gelebilir, ancak alıştıktan sonra bunu tüm dillerde arayacaksınız. Tutarlı bir şekilde kullanıcıların favorisidir.

Eşleşmeler Kapsamlıdır (Exhaustive)

match ile ilgili tartışmamız gereken bir diğer yön daha var: Kolların desenleri tüm olasılıkları kapsamalıdır. bir_ekle fonksiyonumuzun bir hata (bug) içeren ve derlenmeyecek olan şu versiyonunu düşünün:

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);
}

None durumunu ele almadık, bu yüzden bu kod bir hataya neden olacaktır. Neyse ki, bu Rust’ın nasıl yakalayacağını bildiği bir hatadır. Bu kodu derlemeye çalışırsak şu hatayı alırız:

$ cargo run
   Compiling enums v0.1.0 ($PROJE/listings/ch06-enums-and-pattern-matching/no-listing-10-non-exhaustive-match)
error[E0004]: non-exhaustive patterns: `None` not covered
   --> src/main.rs:4:15
    |
  4 |         match x {
    |               ^ pattern `None` not covered
    |
note: `Option<i32>` defined here
   --> $HOME/.rustup/toolchains/stable-aarch64-apple-darwin/lib/rustlib/src/rust/library/core/src/option.rs:600:1
    |
600 | pub enum Option<T> {
    | ^^^^^^^^^^^^^^^^^^
...
604 |     None,
    |     ---- 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
    |
  5 ~             Some(i) => Some(i + 1),
  6 ~             None => todo!(),
    |

For more information about this error, try `rustc --explain E0004`.
warning: `enums` (bin "enums") generated 2 warnings
error: could not compile `enums` (bin "enums") due to 1 previous error

Rust, olası her durumu kapsamadığımızı biliyor ve hatta hangi deseni unuttuğumuzu bile biliyor! Rust’ta eşleşmeler kapsamlıdır: Kodun geçerli olabilmesi için her bir olasılığı sonuna kadar tüketmeliyiz (exhaust). Özellikle Option<T> durumunda, Rust None durumunu açıkça ele almayı unutmamızı engellediğinde, aslında null olabilecekken bir değere sahip olduğumuzu varsaymamızdan bizi korur, böylece daha önce tartışılan milyar dolarlık hatayı imkansız hale getirir.

Hepsini Yakalayan (Catch-All) Desenler ve _ Yer Tutucusu

Enum’ları kullanarak, belirli birkaç değer için özel eylemler yapabilir, diğer tüm değerler için ise varsayılan (default) bir eylem alabiliriz. Şöyle bir oyun uyguladığımızı hayal edelim: Eğer zar attığınızda 3 gelirse, oyuncunuz hareket etmez ama bunun yerine süslü yeni bir şapka kazanır. Eğer 7 atarsanız, oyuncunuz süslü şapkasını kaybeder. Diğer tüm değerler için, oyuncunuz oyun tahtasında o sayı kadar kare ilerler. İşte bu mantığı uygulayan bir match; zar atışının sonucu rastgele bir değer olmak yerine koda gömülmüş (hardcoded) ve diğer tüm mantıklar gövdesi olmayan fonksiyonlarla temsil edilmiştir, çünkü bu fonksiyonları gerçekten uygulamak bu örneğin kapsamı dışındadır:

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 kol için desenler 3 ve 7 sabit değerleridir. Diğer olası tüm değerleri kapsayan son kol için desen ise, diger olarak adlandırdığımız değişkendir. diger kolu için çalışan kod, bu değişkeni oyuncuyu_tasi (move_player) fonksiyonuna aktararak kullanır.

Bu kod derlenir, her ne kadar bir u8’in alabileceği olası tüm değerleri listelememiş olsak da, çünkü son desen özel olarak listelenmeyen tüm değerlerle eşleşecektir. Hepsini yakalayan bu desen, match’in kapsamlı olması gerektiği koşulunu karşılar. Desenler sırayla değerlendirildiği için hepsini yakalayan kolu en sona koymamız gerektiğine dikkat edin. Hepsini yakalayan kolu daha önce koysaydık, diğer kollar asla çalışmazdı, bu yüzden eğer hepsini yakalayan bir koldan sonra kollar eklersek Rust bizi uyaracaktır!

Rust ayrıca, hepsini yakalayan bir kol istediğimizde ancak bu yakalanan değeri kullanmak istemediğimizde kullanabileceğimiz bir desene de sahiptir: _, her değerle eşleşen ve o değere bağlanmayan özel bir desendir. Bu, Rust’a değeri kullanmayacağımızı söyler, böylece Rust kullanılmayan bir değişken hakkında bizi uyarmaz.

Oyunun kurallarını değiştirelim: Artık 3 veya 7 dışında bir şey atarsanız, tekrar zar atmalısınız. Artık yakalanan değeri kullanmamıza gerek yok, bu yüzden kodumuzu diger adlı değişken yerine _ kullanacak şekilde değiştirebiliriz:

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() {}
}

Bu örnek de kapsamlılık şartını karşılıyor çünkü son kolda diğer tüm değerleri açıkça görmezden geliyoruz; hiçbir şeyi unutmuş değiliz.

Son olarak, oyunun kurallarını bir kez daha değiştirelim: Eğer 3 veya 7 dışında bir şey atarsanız sıranızda başka hiçbir şey olmaz. Bunu, _ koluyla çalışan kod olarak birim değeri (unit value - “Demet (Tuple) Türü” bölümünde bahsettiğimiz boş demet türü) kullanarak 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 açıkça, önceki kolların desenleriyle eşleşmeyen başka hiçbir değeri kullanmayacağımızı ve bu durumda hiçbir kod çalıştırmak istemediğimizi söylüyoruz.

Desenler ve eşleştirme hakkında Bölüm 19’da ele alacağımız daha çok şey var. Şimdilik, match ifadesinin biraz uzun kaçabildiği durumlarda yararlı olabilecek if let sözdizimine 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, geri kalanları görmezden gelirken yalnızca bir desenle (pattern) eşleşen değerleri ele almak için if ve let’i daha az ayrıntılı bir şekilde birleştirmenize olanak tanır. max_ayari (config_max) değişkenindeki bir Option<u8> değerini eşleştiren ancak yalnızca değer Some varyantıysa kod çalıştırmak isteyen Liste 6-6’daki programı düşünün.

fn main() {
    let max_ayari = Some(3u8);
    match max_ayari {
        Some(max) => println!("Maksimum değer {max} olarak ayarlandı"),
        _ => (),
    }
}

Eğer değer Some ise, değeri desendeki max değişkenine bağlayarak Some varyantının içindeki değeri yazdırırız. None değeriyle hiçbir şey yapmak istemiyoruz. match ifadesini tatmin etmek için, yalnızca bir varyantı işledikten sonra _ => () eklemek zorundayız; bu da eklenmesi can sıkıcı ve gereksiz (boilerplate) bir koddur.

Bunun yerine, bunu if let kullanarak daha kısa bir şekilde yazabilirdik. Aşağıdaki kod Liste 6-6’daki match ile aynı şekilde davranı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, eşittir işaretiyle ayrılmış bir desen ve bir ifade alır. İfadenin match’e verildiği ve desenin onun ilk kolu olduğu bir match ile aynı şekilde çalışır. Bu durumda desen Some(max)’tir ve max, Some içindeki değere bağlanır. Daha sonra max’i, ilgili match kolunda kullandığımız gibi if let bloğunun gövdesinde de kullanabiliriz. if let bloğundaki kod yalnızca değer desenle eşleşirse çalışır.

if let kullanmak daha az kod yazmak, daha az girinti (indentation) yapmak ve daha az tekrarlayan (boilerplate) kod kullanmak anlamına gelir. Ancak, match’in hiçbir durumu ele almayı unutmamanızı sağlayan kapsamlı denetimini kaybedersiniz. match ve if let arasında seçim yapmak, bulunduğunuz durumda ne yaptığınıza ve kısalık kazanmanın kapsamlı kontrolü kaybetmek için uygun bir takas olup olmadığına bağlıdır.

Başka bir deyişle, if let’i değer bir desenle eşleştiğinde kodu çalıştıran ve diğer tüm değerleri yoksayan bir match için pratik bir sözdizimi (syntax sugar) olarak düşünebilirsiniz.

Bir if let ile birlikte bir else de ekleyebiliriz. else ile birlikte giden kod bloğu, if let ve else ile eşdeğer olan match ifadesindeki _ durumunda gidecek olan kod bloğuyla aynıdır. YirmiBesKurus (Quarter) varyantının da bir Eyalet (UsState) değeri tuttuğu Liste 6-4’teki MadeniPara (Coin) enum tanımını hatırlayın. Gördüğümüz çeyreklik olmayan tüm paraları sayarken aynı zamanda çeyrekliklerin eyaletini duyurmak isteseydik, bunu şöyle bir match ifadesi ile yapabilirdik:

#[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,
    }
}

Veya bunun gibi bir if let ve else ifadesi kullanabilirdik:

#[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” (Happy Path) Kalmak

Yaygın bir örüntü, bir değer mevcut olduğunda bazı hesaplamalar yapmak ve aksi takdirde varsayılan bir değer döndürmektir. Eyalet değerine sahip madeni paralar örneğimizle devam edersek, çeyrekliğin üzerindeki eyaletin ne kadar eski olduğuna bağlı olarak komik bir şey söylemek isteseydik, Eyalet üzerinde bir eyaletin yaşını kontrol etmek için şöyle bir metot tanıtabilirdik:

#[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}");
    }
}

Daha sonra, Liste 6-7’de olduğu gibi koşulun gövdesi içinde bir eyalet (state) değişkeni tanıtarak madeni paranın türüyle eşleştirmek için if let kullanabiliriz.

#[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 işi halleder, ancak işi if let ifadesinin gövdesine iter ve yapılacak iş daha karmaşıksa, üst düzey dalların (branches) birbiriyle tam olarak nasıl ilişkili olduğunu takip etmek zor olabilir. İfadelerin bir değer ürettiği gerçeğinden yararlanarak, Liste 6-8’de olduğu gibi if let’ten eyalet’i (state) üretebilir veya erken dönüş (return early) yapabiliriz. (Buna benzer bir şeyi match ile de yapabilirsiniz.)

#[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}");
    }
}

Yine de bunu takip etmek kendine göre biraz can sıkıcı! if let’in bir dalı bir değer üretir ve diğeri fonksiyondan tamamen geri döner.

Bu yaygın kalıbı (pattern) daha güzel ifade etmek için Rust’ta let...else vardır. let...else sözdizimi, if let’e çok benzer şekilde sol tarafta bir desen ve sağ tarafta bir ifade alır, ancak bir if dalı yoktur, yalnızca bir else dalı vardır. Eğer desen eşleşirse, desendeki değeri dış kapsama (outer scope) bağlar. Eğer desen eşleşmezse, program fonksiyondan dönmesi gereken else koluna akacaktır.

Liste 6-9’da, if let yerine let...else kullanıldığında Liste 6-8’in nasıl göründüğünü görebilirsiniz.

#[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}");
    }
}

if let’in yaptığı gibi iki dal için önemli ölçüde farklı kontrol akışlarına sahip olmadan, fonksiyonun ana gövdesindeki “mutlu yolda” (happy path) kaldığına dikkat edin.

Programınızın match kullanarak ifade edilemeyecek kadar uzun veya karmaşık bir mantığa sahip olduğu bir durumla karşılaşırsanız, if let ve let...else yapılarının da Rust alet çantanızda (toolbox) olduğunu unutmayın.

Özet

Şimdi, numaralandırılmış (enumerated) değerler kümesinden biri olabilen özel türler oluşturmak için enum’ların nasıl kullanılacağını ele aldık. Standart kütüphanenin Option<T> türünün, hataları önlemek için tür sistemini kullanmanıza nasıl yardımcı olduğunu gösterdik. Enum değerlerinin içinde veriler olduğunda, ele almanız gereken durumların sayısına bağlı olarak bu değerleri çıkarmak ve kullanmak için match veya if let kullanabilirsiniz.

Rust programlarınız artık alanınızdaki (domain) kavramları struct’lar ve enum’lar kullanarak ifade edebilir. API’nizde kullanmak üzere özel türler (custom types) oluşturmak tip güvenliği (type safety) sağlar: Derleyici, fonksiyonlarınızın yalnızca her fonksiyonun beklediği türde değerler almasını garanti eder.

Kullanıcılarınıza kullanımı kolay ve yalnızca tam olarak ihtiyaç duyacakları şeyleri ortaya çıkaran iyi organize edilmiş bir API sağlamak için şimdi Rust’ın modüllerine (modules) dönelim.

Paketler, Crate’ler ve Modüller

Büyük programlar yazdıkça kodunuzu düzenlemek giderek daha önemli hale gelecektir. Birbiriyle ilgili işlevleri gruplandırarak ve belirli özelliklere sahip kodları birbirinden ayırarak, belirli bir özelliği uygulayan kodun nerede bulunacağını ve bir özelliğin çalışma şeklini değiştirmek için nereye gidilmesi gerektiğini daha net bir şekilde görebilirsiniz.

Şimdiye kadar yazdığımız programlar tek bir dosyadaki tek bir modül içindeydi. Bir proje büyüdükçe, kodu birden çok modüle ve ardından birden çok dosyaya bölerek düzenlemelisiniz. Bir paket birden fazla ikili crate ve isteğe bağlı olarak bir kütüphane (library) crate’i içerebilir. Bir paket büyüdükçe parçaları, dış bağımlılıklar (external dependencies) haline gelen ayrı crate’lere dönüştürebilirsiniz. Bu bölüm tüm bu teknikleri kapsar. Birlikte geliştirilen bir dizi birbiriyle ilişkili paketten oluşan çok büyük projeler için Cargo, Bölüm 14’teki “Cargo Çalışma Alanları” (Cargo Workspaces) kısmında ele alacağımız çalışma alanlarını (workspaces) sunar.

Ayrıca, kodunuzu daha üst düzeyde yeniden kullanmanızı sağlayan uygulama ayrıntılarını kapsülleme konusunu da tartışacağız: Bir işlemi uyguladıktan sonra, diğer kodlar uygulamanın nasıl çalıştığını bilmek zorunda kalmadan kodunuzu kendi açık arayüzü aracılığıyla çağırabilir. Kodunuzu yazma şekliniz, hangi kısımların diğer kodların kullanması için açık olduğunu ve hangi kısımların değiştirme hakkını saklı tuttuğunuz özel uygulama ayrıntıları olduğunu tanımlar. Bu, zihninizde tutmanız gereken detay miktarını sınırlandırmanın başka bir yoludur.

Bununla ilişkili bir diğer kavram da kapsamdır: Kodun içinde yazıldığı iç içe bağlamın (nested context), “kapsam içinde” (in scope) olarak tanımlanan bir dizi adı vardır. Kodu okurken, yazarken ve derlerken, programcıların ve derleyicilerin belirli bir noktadaki belirli bir adın bir değişkene, fonksiyona, struct’a, enum’a, modüle, sabite (constant) veya başka bir öğeye atıfta bulunup bulunmadığını ve bu öğenin ne anlama geldiğini bilmeleri gerekir. Kapsamlar oluşturabilir ve hangi adların kapsam içinde veya dışında olacağını değiştirebilirsiniz. Aynı kapsamda aynı ada sahip iki öğe bulunamaz; isim çakışmalarını (name conflicts) çözmek için kullanılabilecek araçlar mevcuttur.

Rust, hangi ayrıntıların açığa çıkarılacağı, hangi ayrıntıların gizli tutulacağı ve programlarınızdaki her kapsamda hangi adların bulunacağı da dâhil olmak üzere kodunuzun organizasyonunu yönetmenize olanak tanıyan bir dizi özelliğe sahiptir. Bazen topluca modül sistemi (module system) olarak anılan bu özellikler şunlardır:

• Paketler (Packages): Crate’leri derlemenize (build), test etmenize ve paylaşmanıza olanak tanıyan bir Cargo özelliğidir.
• Crate’ler: Kütüphane veya çalıştırılabilir (executable) dosya üreten bir modül ağacıdır.
• Modüller ve use: Yolların (paths) organizasyonunu, kapsamını ve gizliliğini kontrol etmenizi sağlar.
• Yollar (Paths): Bir struct, fonksiyon veya modül gibi bir öğeyi isimlendirmenin bir yoludur.

Bu bölümde, tüm bu özellikleri ele alacak, nasıl etkileşime girdiklerini tartışacak ve bunları kapsamı yönetmek için nasıl kullanacağınızı açıklayacağız. Bölümün sonunda, modül sistemini sağlam bir şekilde anlayacak ve kapsamlarla bir profesyonel gibi çalışabileceksiniz!

Paketler ve Crate'ler

Paketler ve Crate’ler

Modül sisteminin ele alacağımız ilk kısımları paketler (packages) ve crate’lerdir.

Bir crate, Rust derleyicisinin bir kerede ele aldığı en küçük kod miktarıdır. cargo yerine rustc çalıştırsanız ve tek bir kaynak kod dosyası geçirseniz bile (Bölüm 1’deki “Rust Programını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 bölümlerde göreceğimiz gibi bu modüller, crate ile birlikte derlenen başka dosyalarda tanımlanmış olabilir.

Bir crate iki formdan birinde olabilir: ikili crate veya kütüphane (library) crate’i. İkili crate’ler, bir komut satırı programı veya bir sunucu gibi, çalıştırabileceğiniz çalıştırılabilir (executable) bir dosyaya derleyebildiğiniz programlardır. Her birinin, çalıştırılabilir dosya çalıştığında ne olacağını tanımlayan 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 çalıştırılabilir bir dosyaya derlenmezler. Bunun yerine, birden fazla projeyle paylaşılması amaçlanan işlevleri tanımlarlar. Örneğin, Bölüm 2’de kullandığımız rand crate’i, rastgele sayılar üreten işlevsellik sağlar. Rust programcıları (Rustaceans) çoğu zaman “crate” dediklerinde kütüphane crate’ini kastederler ve “crate” kelimesini genel programlama kavramı olan “kütüphane” (library) ile eşanlamlı olarak kullanırlar.

Crate kökü, Rust derleyicisinin başladığı ve crate’inizin kök modülünü (root module) oluşturan kaynak dosyasıdır (modülleri “Modüllerle Kapsam ve Gizliliği Kontrol Etme” bölümünde derinlemesine açıklayacağız).

Bir paket, bir dizi işlevsellik sağlayan bir veya daha fazla crate’in paketlenmiş halidir. Bir paket, bu crate’lerin nasıl derleneceğini (build) açıklayan bir Cargo.toml dosyası içerir. Cargo’nun kendisi aslında, kodunuzu derlemek için kullandığınız komut satırı aracı için bir ikili crate içeren bir pakettir. Cargo paketi ayrıca, ikili crate’in bağlı olduğu (depends on) bir kütüphane crate’i içerir. Diğer projeler, Cargo komut satırı aracının kullandığı aynı mantığı kullanmak için Cargo kütüphane crate’ine bağımlı olabilir.

Bir paket istediğiniz kadar ikili crate içerebilir, ancak en fazla yalnızca bir kütüphane crate’i içerebilir. Bir paket, kütüphane veya ikili crate fark etmeksizin en az bir crate içermek zorundadır.

Bir paket oluşturduğumuzda neler olduğuna bir göz atalım. Önce şu komutu giriyoruz: cargo new benim-projem:

$ 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. benim-projem dizininde, bize bir paket sağlayan bir Cargo.toml dosyası bulunur. Ayrıca main.rs dosyasını içeren bir src dizini de vardır. Metin düzenleyicinizde Cargo.toml dosyasını açın ve src/main.rs’den hiç bahsedilmediğine dikkat edin. Cargo, paketle aynı ada sahip bir ikili crate’in crate kökünün src/main.rs olduğuna dair bir geleneği izler. Aynı şekilde Cargo, eğer paket dizini src/lib.rs içeriyorsa, paketin, paketle aynı isme sahip bir kütüphane crate’i içerdiğini ve bu crate’in kökünün src/lib.rs olduğunu bilir. Cargo, kütüphaneyi veya ikili dosyayı derlemek için crate kök dosyalarını rustc’ye iletir.

Burada, yalnızca src/main.rs içeren bir paketimiz var; yani yalnızca benim-projem adında bir ikili crate içeriyor. Eğer bir paket hem src/main.rs hem de src/lib.rs içeriyorsa, iki crate’i vardır: paketle aynı isme sahip bir ikili ve bir kütüphane crate’i. Bir paket, src/bin dizinine dosyalar yerleştirilerek birden fazla ikili crate’e sahip olabilir: Bu dizindeki her bir dosya ayrı bir ikili crate olacaktır.

Modüllerle Kapsam ve Gizliliği Kontrol Etme

Modüllerle Kapsam ve Gizliliği Kontrol Etme

Bu bölümde modüllerden ve modül sisteminin diğer parçalarından, yani öğeleri isimlendirmenizi sağlayan yollardan (paths), bir yolu kapsama getiren use anahtar kelimesinden ve öğeleri herkese açık hale getiren pub anahtar kelimesinden bahsedeceğiz. Ayrıca as anahtar kelimesini, harici paketleri ve glob operatörünü de ele alacağız.

Modüller Kopya Kağıdı (Cheat Sheet)

Modüllerin ve yolların detaylarına girmeden önce, burada modüllerin, yolların, use anahtar kelimesinin ve pub anahtar kelimesinin derleyicide nasıl çalıştığına ve çoğu geliştiricinin kodlarını nasıl düzenlediğine dair hızlı bir başvuru kılavuzu (quick reference) sunuyoruz. Bu bölüm boyunca bu kuralların her birini örneklerle inceleyeceğiz, ancak modüllerin nasıl çalıştığını hatırlamak için burası harika bir başvuru noktasıdır.

• Crate kökünden başlayın: Bir crate’i derlerken, derleyici önce derlenecek kodu bulmak için crate kök dosyasına (genellikle bir kütüphane crate’i için src/lib.rs ve bir ikili crate için src/main.rs) bakar.
• Modülleri bildirmek (declaring modules): Crate kök dosyasında yeni modüller bildirebilirsiniz; diyelim ki mod bahce; ile bir “bahce” modülü bildirdiniz. Derleyici, bu modülün kodunu şu konumlarda arayacaktır:
  • Satır içi, mod bahce’den sonraki noktalı virgül yerine konulan süslü parantezlerin içinde
  • src/bahce.rs dosyasında
  • src/bahce/mod.rs dosyasında
• Alt modülleri bildirmek (declaring submodules): Crate kökü dışındaki herhangi bir dosyada alt modüller bildirebilirsiniz. Örneğin, src/bahce.rs içinde mod sebzeler; bildirebilirsiniz. Derleyici, alt modülün kodunu ana modülün adını taşıyan dizinde şu konumlarda arayacaktır:
  • Satır içi, doğrudan mod sebzeler’den sonra, noktalı virgül yerine süslü parantezlerin içinde
  • src/bahce/sebzeler.rs dosyasında
  • src/bahce/sebzeler/mod.rs dosyasında
• Modüllerdeki kodların yolları: Bir modül crate’inizin bir parçası olduğunda, gizlilik kuralları izin verdiği sürece, kodun yolunu kullanarak o crate’in başka bir yerinden o modüldeki koda başvurabilirsiniz. Örneğin, bahce sebzeler modülündeki bir Kuskonmaz (Asparagus) türü crate::bahce::sebzeler::Kuskonmaz adresinde (yolunda) bulunacaktır.
• Gizli ve açık: Bir modül içindeki kod varsayılan olarak üst modüllerinden gizlidir. Bir modülü açık hale getirmek için mod yerine pub mod ile bildirin. Açık bir modül içindeki öğeleri de açık hale getirmek için bildirimlerinden (declaration) önce pub kullanın.
• use anahtar kelimesi: Bir kapsam içinde, use anahtar kelimesi uzun yolların tekrarını azaltmak için öğelere kısayollar oluşturur. crate::bahce::sebzeler::Kuskonmaz’a başvurabilen herhangi bir kapsamda, use crate::bahce::sebzeler::Kuskonmaz; ile bir kısayol oluşturabilirsiniz; ve o andan itibaren bu türü o kapsamda kullanmak için yalnızca Kuskonmaz yazmanız yeterlidir.

Burada, bu kuralları gösteren arka_bahce (backyard) adlı bir ikili crate oluşturuyoruz. Crate’in yine arka_bahce adını taşıyan dizini, şu dosyaları ve dizinleri içerir:

arka_bahce
├── Cargo.lock
├── Cargo.toml
└── src
    ├── bahce
    │   └── sebzeler.rs
    ├── bahce.rs
    └── main.rs

Bu durumda crate kök dosyası src/main.rs’dir ve şunları içerir:

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 dahil etmesini söyler:

pub mod sebzeler;

Burada, pub mod sebzeler;, src/bahce/sebzeler.rs dosyasındaki kodun da dahil edildiği anlamına gelir. O kod da şudur:

#[derive(Debug)]
pub struct Kuskonmaz {}

Şimdi bu kuralların detaylarına girelim ve pratikte nasıl uygulandıklarını gösterelim!

İlgili Kodu Modüllerde Gruplama

Modüller, okunabilirlik ve kolay yeniden kullanım için bir crate içindeki kodu düzenlememize olanak tanır. Modüller aynı zamanda öğelerin gizliliğini kontrol etmemizi sağlar çünkü bir modül içindeki kod varsayılan olarak gizlidir. Gizli öğeler, dışarıdan kullanıma açık olmayan dahili (internal) uygulama ayrıntılarıdır. Modülleri ve içlerindeki öğeleri açık hale getirmeyi seçebiliriz, bu da onları açığa çıkararak harici kodların onları kullanmasına ve onlara bağımlı olmasına olanak tanır.

Örnek olarak, bir restoranın işlevselliğini sağlayan bir kütüphane (library) crate’i yazalım. Fonksiyonların imzalarını tanımlayacağız, ancak bir restoranın uygulanmasından ziyade kodun organizasyonuna odaklanmak için gövdelerini boş bırakacağız.

Restoran sektöründe, bir restoranın bazı bölümleri ön kısım (front of house), diğerleri ise arka kısım (back of house) olarak adlandırılır. Ön kısım müşterilerin bulunduğu yerdir; burası karşılamanın (hosts) müşterileri oturttuğu, servis elemanlarının (servers) siparişleri ve ödemeleri aldığı ve barmenlerin içecekleri hazırladığı yeri kapsar. Arka kısım ise şeflerin ve aşçıların mutfakta çalıştığı, bulaşıkçıların temizlik yaptığı ve yöneticilerin idari işleri yürüttüğü yerdir.

Crate’imizi bu şekilde yapılandırmak için, fonksiyonlarını iç içe geçmiş modüller halinde düzenleyebiliriz. 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 girin; bu kod restoranın ön kısmını temsil eder.

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() {}
    }
}

mod anahtar kelimesini ve ardından modülün adını (bu durumda restoran_on_kisim) kullanarak bir modül tanımlarız. Modülün gövdesi daha sonra süslü parantezlerin içine girer. Modüllerin içine, bu durumda karsilama ve servis modüllerinde olduğu gibi başka modüller yerleştirebiliriz. Modüller ayrıca struct’lar, enum’lar, sabitler (constants), trait’ler ve Liste 7-1’de olduğu gibi fonksiyonlar gibi diğer öğeler için tanımlar da barındırabilir.

Modülleri kullanarak, birbiriyle ilişkili tanımları bir arada gruplayabilir ve neden ilişkili olduklarını isimlendirebiliriz. Bu kodu kullanan programcılar, tüm tanımları okumak zorunda kalmadan, gruplara göre kod içinde gezinebilirler ve bu da onlarla alakalı tanımları bulmalarını kolaylaştırır. Bu koda yeni işlevsellik ekleyen programcılar, programın düzenli kalması için kodu nereye yerleştireceklerini bileceklerdir.

Daha önce, src/main.rs ve src/lib.rs dosyalarının crate kökleri (crate roots) olarak adlandırıldığından bahsetmiştik. Bu şekilde adlandırılmalarının nedeni, bu iki dosyadan herhangi birinin içeriğinin, crate’in modül yapısının kökünde (bu yapı modül ağacı - module tree olarak bilinir) 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çine nasıl yuvalandığını (iç içe geçtiğini) gösterir; örneğin, karsilama, restoran_on_kisim’in içine yuvalanmıştır. Ağaç ayrıca bazı modüllerin kardeş (siblings) olduğunu, yani aynı modül içinde tanımlandıklarını gösterir; karsilama ve servis, restoran_on_kisim içinde tanımlanmış kardeş modüllerdir. Eğer A modülü B modülünün içindeyse, A modülünün B modülünün çocuğu ve B modülünün A modülünün ebeveyni olduğunu söyleriz. Tüm modül ağacının, örtük (implicit) crate adlı modülün altında köklendiğine (rooted) dikkat edin.

Modül ağacı, bilgisayarınızdaki dosya sisteminin dizin ağacını hatırlatabilir; bu çok yerinde bir karşılaştırmadır! Tıpkı dosya sistemindeki dizinler gibi, kodunuzu düzenlemek için de modülleri kullanırsınız. Ve bir dizindeki dosyalar gibi, modüllerimizi bulmanın da bir yoluna ihtiyacımız var.

Modül Ağacındaki Bir Öğeye Başvurmak İçin Yollar

Modül Ağacındaki Bir Öğeye Başvurmak İçin Yollar (Paths)

Rust’a modül ağacında bir öğeyi nerede bulacağını göstermek için, dosya sisteminde gezinirken (navigate) bir yol (path) kullandığımız şekilde bir yol kullanırız. Bir fonksiyonu çağırmak için onun yolunu bilmemiz gerekir.

Bir yol iki şekilde olabilir:

• Mutlak yol, crate kökünden başlayan tam yoldur; harici bir crate’den gelen kod için mutlak yol crate adıyla başlar ve mevcut crate’ten gelen kod için değişmez crate kelimesiyle başlar.
• Göreceli yol, geçerli modülden başlar ve mevcut modüldeki self, super veya bir tanımlayıcı kullanır.

Hem mutlak hem de göreceli yollar, birbirinden çift iki nokta üst üste (::) ile ayrılmış bir veya daha fazla tanımlayıcı tarafından takip edilir.

Liste 7-1’e dönecek olursak, bekleme_listesine_ekle (add_to_waitlist) 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, bazı modülleri ve fonksiyonları çıkarılmış halde Liste 7-1’i içermektedir.

Crate kökünde tanımlanan restoranda_yemek_ye (eat_at_restaurant) adındaki 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 başka bir sorun daha vardır. Nedenini birazdan açıklayacağız.

restoranda_yemek_ye fonksiyonu kütüphane (library) crate’imizin herkese açık API’sinin bir parçasıdır, bu yüzden onu pub anahtar kelimesiyle işaretliyoruz. “Yolları pub Anahtar Kelimesiyle Açığa Çıkarmak” (Exposing Paths with the pub Keyword) bölümünde pub hakkında daha fazla detaya gireceğiz.

mod restoran_on_kisim {
    mod karsilama {
        fn bekleme_listesine_ekle() {}
    }
}

pub fn restoranda_yemek_ye() {
    // Mutlak (absolute) yol
    crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();

    // Göreceli (relative) yol
    restoran_on_kisim::karsilama::bekleme_listesine_ekle();
}

restoranda_yemek_ye fonksiyonu içinde bekleme_listesine_ekle fonksiyonunu ilk çağırdığımızda mutlak (absolute) bir yol kullanıyoruz. bekleme_listesine_ekle fonksiyonu restoranda_yemek_ye ile aynı crate içinde tanımlanmıştır, yani mutlak bir yolu başlatmak için crate anahtar kelimesini kullanabiliriz. Daha sonra bekleme_listesine_ekle’ye ulaşana kadar ardışık (successive) modüllerin her birini 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 için crate adını kullanmak, kabuğunuzda dosya sistemi kökünden başlamak için / kullanmaya benzer.

restoranda_yemek_ye fonksiyonu içinde bekleme_listesine_ekle fonksiyonunu ikinci kez çağırdığımızda ise göreceli (relative) bir yol kullanırız. Yol, modül ağacında restoranda_yemek_ye ile aynı seviyede tanımlanmış olan modülün adı restoran_on_kisim ile başlar. Buradaki dosya sistemi karşılığı, restoran_on_kisim/karsilama/bekleme_listesine_ekle yolunu kullanmak olurdu. Bir modül adıyla başlamak, yolun göreceli olduğu anlamına gelir.

Göreceli veya mutlak bir yol kullanıp kullanmama seçimi projenize bağlı olarak vereceğiniz bir karardır ve bu seçim, öğe tanımlama kodunu, öğeyi kullanan koddan ayrı olarak mı yoksa birlikte mi taşıma (move) ihtimalinizin daha yüksek olduğuna bağlıdır. Örneğin, restoran_on_kisim modülünü ve restoranda_yemek_ye fonksiyonunu musteri_deneyimi (customer_experience) adında bir modüle taşırsak, bekleme_listesine_ekle’nin mutlak yolunu güncellememiz gerekir, ancak göreceli yol geçerliliğini korur. Bununla birlikte, eğer restoranda_yemek_ye fonksiyonunu ayrı olarak yemek (dining) adında bir modüle taşırsak, bekleme_listesine_ekle çağrısına giden mutlak yol aynı kalır, ancak göreceli yolun güncellenmesi gerekir. Genel tercihimiz mutlak yolları belirtmektir, çünkü kod tanımlarını ve öğe çağrılarını birbirinden bağımsız olarak taşımak isteme olasılığımız daha yüksektir.

Liste 7-3’ü derlemeye çalışalım ve henüz neden derlenmediğini öğrenelim! Aldığımız hatalar Liste 7-4’te gösterilmektedir.

$ cargo build
Compiling restaurant v0.1.0 ($PROJE/listings/ch07-managing-growing-projects/listing-07-03)
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 `restaurant` (lib) due to 2 previous errors

Hata mesajları karsilama (hosting) modülünün gizli olduğunu söylüyor. Başka bir deyişle, karsilama modülü ve bekleme_listesine_ekle fonksiyonu için doğru yollara sahibiz, ancak Rust gizli bölümlere erişimi olmadığı için bunları kullanmamıza izin vermiyor. Rust’ta tüm öğeler (fonksiyonlar, metotlar, struct’lar, enum’lar, modüller ve sabitler) varsayılan olarak üst modüllere gizlidir. Eğer bir fonksiyon veya struct gibi bir öğeyi gizli yapmak isterseniz, onu bir modülün içine koyarsınız.

Üst bir modüldeki öğeler alt modüllerin içindeki gizli öğeleri kullanamaz, ancak alt modüllerdeki öğeler ata modüllerindeki öğeleri kullanabilir. Bunun nedeni alt modüllerin uygulama ayrıntılarını (implementation details) sarmalaması ve gizlemesidir, ancak alt modüller tanımlandıkları bağlamı görebilirler. Metaforumuzla devam edecek olursak, gizlilik kurallarının bir restoranın arka ofisi (back office) gibi olduğunu düşünün: Orada olup bitenler restoran müşterilerine gizlidir, ancak ofis yöneticileri (managers) işlettikleri restorandaki her şeyi görebilir ve yapabilirler.

Rust modül sisteminin bu şekilde çalışmasını seçti, böylece iç uygulama detaylarını (inner implementation details) gizlemek varsayılan oldu. Bu şekilde, içteki kodun (inner code) hangi kısımlarını dıştaki kodu (outer code) bozmadan değiştirebileceğinizi bilirsiniz. Ancak Rust, bir öğeyi açık hale getirmek için pub anahtar kelimesini kullanarak alt modüllerin kodunun iç kısımlarını dıştaki ata modüllere açma seçeneğini de sunar.

Yolları pub Anahtar Kelimesiyle Açığa Çıkarmak (Exposing)

Liste 7-4’te karsilama modülünün gizli olduğunu söyleyen 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 (absolute) yol
    crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();

    // Göreceli (relative) yol
    restoran_on_kisim::karsilama::bekleme_listesine_ekle();
}

Ne yazık ki, Liste 7-5’teki kod Liste 7-6’da gösterildiği gibi hala derleyici hatalarına neden olur.

$ cargo build
   Compiling restaurant v0.1.0 ($PROJE/listings/ch07-managing-growing-projects/listing-07-05)
error[E0603]: function `bekleme_listesine_ekle` is private
  --> src/lib.rs:12:42
   |
12 |     crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();
   |                                          ^^^^^^^^^^^^^^^^^^^^^^ private function
   |
note: the function `bekleme_listesine_ekle` is defined here
  --> src/lib.rs:4:9
   |
 4 |         fn bekleme_listesine_ekle() {}
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0603]: function `bekleme_listesine_ekle` is private
  --> src/lib.rs:15:35
   |
15 |     restoran_on_kisim::karsilama::bekleme_listesine_ekle();
   |                                   ^^^^^^^^^^^^^^^^^^^^^^ private function
   |
note: the function `bekleme_listesine_ekle` is defined here
  --> src/lib.rs:4:9
   |
 4 |         fn bekleme_listesine_ekle() {}
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `restaurant` (lib) due to 2 previous errors

Ne oldu? mod karsilama’nın önüne pub anahtar kelimesini eklemek modülü açık hale getirir. Bu değişiklikle, eğer restoran_on_kisim modülüne erişebiliyorsak, karsilama modülüne de erişebiliriz. Ancak karsilama modülünün içerikleri hala gizlidir; modülü açık hale getirmek onun içeriğini de açık hale getirmez. Bir modül üzerindeki pub anahtar kelimesi sadece ata modüllerindeki kodların o modüle atıfta bulunmasına (refer to) izin verir, ancak içindeki (inner) kodlara erişmesini sağlamaz. Modüller kapsayıcılar (containers) olduğundan, sadece modülü açık hale getirerek yapabileceğimiz pek bir şey yoktur; daha ileri gitmeli ve modül içindeki öğelerden birini veya birkaçını da açık hale getirmeyi seçmeliyiz.

Liste 7-6’daki hatalar bekleme_listesine_ekle fonksiyonunun gizli olduğunu söylüyor. Gizlilik kuralları, struct’lar, enum’lar, fonksiyonlar ve metotlar ile birlikte modüller için de geçerlidir.

Liste 7-7’de olduğu gibi tanımından önce pub anahtar kelimesini ekleyerek bekleme_listesine_ekle fonksiyonunu da açık hale getirelim.

mod restoran_on_kisim {
    pub mod karsilama {
        pub fn bekleme_listesine_ekle() {}
    }
}

// -- snip --
pub fn restoranda_yemek_ye() {
    // Mutlak (absolute) yol
    crate::restoran_on_kisim::karsilama::bekleme_listesine_ekle();

    // Göreceli (relative) yol
    restoran_on_kisim::karsilama::bekleme_listesine_ekle();
}

Artık kod derlenecek! pub anahtar kelimesini eklemenin gizlilik kurallarına uygun olarak bu yolları restoranda_yemek_ye içinde kullanmamıza neden izin verdiğini görmek için, mutlak ve göreceli yollara (absolute and relative paths) bakalım.

Mutlak yolda, crate’imizin modül ağacının kökü (root) 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 fonksiyonu restoran_on_kisim ile aynı modülde tanımlandığı için (yani, restoranda_yemek_ye ve restoran_on_kisim kardeş modüllerdir), restoranda_yemek_ye içinden restoran_on_kisim modülüne atıfta bulunabiliriz. Sırada pub ile işaretlenmiş karsilama modülü var. karsilama’nın üst modülüne (parent module) erişebiliyoruz, dolayısıyla karsilama’ya erişebiliriz. Son olarak, bekleme_listesine_ekle fonksiyonu pub ile işaretlenmiştir ve bu fonksiyonun üst modülüne erişebiliriz, dolayısıyla bu fonksiyon çağrısı çalışır!

Göreceli (relative) yolda mantık, ilk adım hariç, mutlak yolla 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 fonksiyonu ile aynı modülde tanımlanmıştır, bu nedenle restoranda_yemek_ye fonksiyonunun tanımlı olduğu modülden başlayan göreceli yol çalışır. Ardından, karsilama ve bekleme_listesine_ekle fonksiyonları pub ile işaretlendiği için yolun geri kalanı çalışır ve bu 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 yapacağınız ve kodunuzla nasıl etkileşime girebileceklerini belirleyen sözleşmenizdir (contract). İnsanların crate’inize bağımlı olmasını kolaylaştırmak için açık API’nizde yapılacak değişiklikleri yönetmekle ilgili pek çok husus vardır. Bu hususlar bu kitabın kapsamı dışındadır; eğer bu konuyla ilgileniyorsanız, Rust API Yönergeleri kılavuzuna bakabilirsiniz.

super İle Göreceli (Relative) Yollara Başlamak

Göreceli (relative) yollar oluştururken, yolun (path) başında super kullanarak geçerli modül veya crate kökü yerine üst modülden başlayabiliriz. Bu, dosya sistemindeki yollarda bir üst dizine gitmek anlamına gelen .. sözdizimi ile başlamaya benzer. super kullanmak, üst modülde (parent module) olduğunu bildiğimiz bir öğeye başvurmamızı sağlar; bu da, bir modül üst modülle yakından ilişkiliyken, üst modülün ileride modül ağacında başka bir yere taşınması ihtimaline karşı modül ağacını yeniden düzenlemeyi kolaylaştırabilir.

Liste 7-8’de bir şefin yanlış bir siparişi düzeltip bizzat müşteriye götürdüğü durumu modelleyen kodu düşünün. restoran_arka_kisim modülünde tanımlanan yanlis_siparisi_duzelt (fix_incorrect_order) fonksiyonu, siparisi_teslim_et (deliver_order) fonksiyonunun yolunu belirterek ve super ile başlayarak, üst modülde tanımlı olan 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çindedir, bu yüzden restoran_arka_kisim’in üst modülüne (bu durumda kök (root) olan crate’tir) gitmek için super kullanabiliriz. Oradan itibaren siparisi_teslim_et fonksiyonunu arar ve buluruz. Başarılı! Crate’in modül ağacını yeniden düzenlemeye karar verirsek, restoran_arka_kisim modülünün ve siparisi_teslim_et fonksiyonunun birbirleriyle aynı ilişki içinde kalma ihtimalinin yüksek olduğunu ve birlikte taşınacaklarını düşünüyoruz. Bu nedenle, super kullandık ki bu kod başka bir modüle taşındığında gelecekte kodu güncelleyecek daha az yerimiz olsun.

Struct’ları ve Enum’ları Herkese Açık (Public) Yapmak

Struct’ları ve enum’ları da herkese açık olarak belirtmek için pub anahtar kelimesini kullanabiliriz, ancak struct’lar ve enum’lar ile pub kullanımının birkaç ek detayı vardır. Eğer bir struct tanımının öncesinde pub kullanırsak, struct’ı herkese açık yaparız, ancak struct’ın alanları hala gizli kalacaktır. Her bir alanı (field) duruma göre (case-by-case) herkese açık yapıp yapmamayı seçebiliriz. Liste 7-9’da, herkese açık bir tost alanı (field) ve gizli bir mevsim_meyvesi (seasonal_fruit) alanına sahip, açık bir restoran_arka_kisim::Kahvalti (Breakfast) struct’ı tanımladık. Bu durum, müşterinin yemekle birlikte gelen ekmek türünü seçebildiği, ancak şefin o mevsimde nelerin mevcut olduğuna ve stokta ne olduğuna göre hangi meyvenin eşlik edeceğine karar verdiği bir restorandaki durumu modeller. Mevcut olan meyve hızlı değiştiği için müşteriler meyveyi seçemezler ya da hangi meyveyi alacaklarını dahi göremezler.

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 fonksiyonunda nokta (dot) gösterimini kullanarak tost alanını yazabilir (değiştirebilir) veya okuyabiliriz. Dikkat edin ki mevsim_meyvesi alanı gizli olduğu için, onu restoranda_yemek_ye içinde kullanamayız. Nasıl bir hata aldığınızı görmek için mevsim_meyvesi alanının değerini değiştiren satırın (yorum satırının) yorumunu (uncomment) kaldırmayı deneyin!

Ayrıca, restoran_arka_kisim::Kahvalti struct’ı gizli bir alana sahip olduğu için, bu struct’ın Kahvalti’nın bir örneğini oluşturan herkese açık ilişkili bir fonksiyon sağlaması gerektiğine dikkat edin (burada onu yaz (summer) olarak adlandırdık). Kahvalti struct’ı böyle bir fonksiyona sahip olmasaydı, restoranda_yemek_ye içinde Kahvalti’nın bir örneğini oluşturamazdık, çünkü restoranda_yemek_ye içinde gizli olan mevsim_meyvesi alanının değerini ayarlayamazdık.

Buna karşın, bir enum’ı herkese açık yaparsak, tüm varyantları da açık olur. Liste 7-10’da gösterildiği gibi yalnızca enum anahtar kelimesinden önce pub kullanmamı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 (Appetizer) enum’ını açık hale getirdiğimiz için, restoranda_yemek_ye içinde Corba (Soup) ve Salata (Salad) varyantlarını kullanabiliriz.

Varyantları herkese açık olmadıkça enum’lar pek yararlı olmazlar; her durumda tüm enum varyantlarına pub eklemek can sıkıcı olurdu, bu nedenle enum varyantları için varsayılan (default) durum açık olmalarıdır. Struct’lar alanları açık olmadan da çoğu zaman kullanışlıdır, bu nedenle struct alanları, aksi pub ile belirtilmedikçe her şeyin varsayılan olarak gizli olduğu genel kuralını takip eder.

Henüz ele almadığımız ve pub’ı ilgilendiren bir durum daha vardır; o da son modül sistemi özelliğimiz olan use anahtar kelimesidir. Önce use anahtar kelimesini tek başına ele alacağız ve ardından pub ve use’u birlikte nasıl kullanacağımızı göstereceğiz.

use Anahtar Kelimesi ile Yolları Kapsama Dahil Etme

use Anahtar Kelimesi ile Yolları Kapsama (Scope) Getirmek

Fonksiyonları çağırmak için yolları (paths) uzun uzun yazmak zorunda kalmak kullanışsız ve tekrarlayan bir iş gibi hissettirebilir. Liste 7-7’de, bekleme_listesine_ekle fonksiyonu için mutlak ya da göreceli yolu seçmiş olsak da, bekleme_listesine_ekle’yi her çağırmak istediğimizde restoran_on_kisim ve karsilama’yı da belirtmek zorundaydık. Neyse ki bu süreci basitleştirmenin bir yolu var: use anahtar kelimesiyle bir yolun kısayolunu bir kez oluşturabilir ve ardından daha kısa olan bu adı kapsamın diğer her yerinde kullanabiliriz.

Liste 7-11’de, bekleme_listesine_ekle fonksiyonunu restoranda_yemek_ye içinde çağırmak için yalnızca karsilama::bekleme_listesine_ekle belirtmemiz gerekecek şekilde, crate::restoran_on_kisim::karsilama modülünü restoranda_yemek_ye fonksiyonunun kapsamına 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 ve bir yol eklemek, dosya sisteminde sembolik bir bağlantı (symbolic link) oluşturmaya benzer. Crate köküne use crate::restoran_on_kisim::karsilama ekleyerek, tıpkı karsilama modülü crate kökünde tanımlanmış gibi, karsilama artık o kapsamda geçerli bir isim haline gelir. use ile kapsama getirilen yollar da tıpkı diğer yollar gibi gizliliği kontrol eder.

use’un kısayolu yalnızca kullanıldığı belirli kapsam için oluşturduğuna dikkat edin. Liste 7-12, restoranda_yemek_ye fonksiyonunu musteri adlı yeni bir alt modüle taşır ve bu modül use ifadesinden farklı bir kapsam olduğu için fonksiyon gövdesi derlenmez.

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 artık musteri modülü içinde geçerli olmadığını gösterir:

$ cargo build
   Compiling restaurant v0.1.0 ($PROJE/listings/ch07-managing-growing-projects/listing-07-12)
error[E0433]: failed to resolve: use of unresolved module or unlinked crate `karsilama`
  --> 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: `restaurant` (lib) generated 1 warning
error: could not compile `restaurant` (lib) due to 1 previous error; 1 warning emitted

Ayrıca use ifadesinin kendi kapsamında artık kullanılmadığına dair bir uyarı olduğuna da dikkat edin! Bu sorunu çözmek için use ifadesini de musteri modülünün içine taşıyın veya alt musteri modülünden, üst modüldeki kısayola super::karsilama ile başvurun.

İdiomatik use Yolları Oluşturmak

Liste 7-11’de, neden use crate::restoran_on_kisim::karsilama’yı belirtip ardından restoranda_yemek_ye içinde karsilama::bekleme_listesine_ekle’yi çağırdığımızı merak etmiş olabilirsiniz; Liste 7-13’teki gibi aynı sonucu elde etmek için use yolunu neden ta bekleme_listesine_ekle fonksiyonuna kadar belirtmedik?

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();
}

Liste 7-11 ve Liste 7-13 aynı işi başarsa da, bir fonksiyonu use ile kapsama getirmenin idiomatik (dile özgü doğru kullanım) yolu Liste 7-11’dir. Fonksiyonun ebeveyn modülünü use ile kapsama getirmek, fonksiyonu çağırırken o ebeveyn modülü belirtmemiz gerektiği anlamına gelir. Fonksiyonu çağırırken ebeveyn modülü belirtmek, bir yandan tam yolun tekrarlanmasını en aza indirirken diğer yandan fonksiyonun yerel olarak tanımlanmadığını da açıkça belli eder. Liste 7-13’teki kodda ise bekleme_listesine_ekle fonksiyonunun nerede tanımlandığı belirsizdir.

Öte yandan, struct’ları, enum’ları ve diğer öğeleri use ile içe aktarırken, tam yolu belirtmek idiomatiktir. Liste 7-14, standart kütüphanenin HashMap struct’ını bir ikili crate’in kapsamına almanın idiomatik yolunu gösterir.

use std::collections::HashMap;

fn main() {
    let mut harita = HashMap::new();
    harita.insert(1, 2);
}

Bu idiomatik kullanımın arkasında çok güçlü bir neden yoktur: Yalnızca ortaya çıkmış bir gelenektir ve insanlar Rust kodunu bu şekilde okuyup yazmaya alışmışlardır.

Bu idiomun (geleneğin) istisnası, use ifadeleriyle aynı ada sahip iki öğeyi kapsama getiriyorsak geçerlidir; çünkü Rust buna izin vermez. Liste 7-15, aynı isme fakat farklı üst modüllere sahip iki Result türünün kapsama nasıl getirileceğini ve bunlara nasıl atıfta bulunulacağı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, ebeveyn modülleri kullanmak iki Result türünü birbirinden ayırır. Bunun yerine use std::fmt::Result ve use std::io::Result ifadelerini belirtseydik, aynı kapsamda iki Result türümüz olurdu ve biz Result kelimesini kullandığımızda Rust hangisini kastettiğimizi bilemezdi.

as Anahtar Kelimesiyle Yeni İsimler Sağlamak

Aynı ada sahip iki türü use ile aynı kapsama getirme probleminin başka bir çözümü daha vardır: Yolun ardından, tür için as ve yeni bir yerel ad veya takma ad belirtebiliriz. Liste 7-16, Liste 7-15’teki kodu as kullanarak iki Result türünden birini yeniden adlandırmak suretiyle yazmanın başka bir 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 ifadesinde std::io::Result türü için yeni IoResult adını seçtik; bu ad kapsama dahil ettiğimiz std::fmt içindeki Result ile çakışmayacaktır (conflict). Hem Liste 7-15 hem de Liste 7-16 idiomatik kabul edilir, dolayısıyla seçim size kalmış!

pub use ile İsimleri Yeniden Dışa Aktarmak (Re-exporting)

Bir adı use anahtar kelimesi ile kapsama aldığımızda, bu ad onu içe aktardığımız (import) kapsam için gizli olur. O kapsamın dışındaki kodların bu isme, sanki o kapsamda tanımlanmış gibi atıfta bulunmasını (refer to) sağlamak için pub ve use kelimelerini birleştirebiliriz. Bu tekniğe yeniden dışa aktarma denir çünkü biz bir öğeyi kendi kapsamımıza getirirken aynı zamanda diğerlerinin de o öğeyi kendi kapsamlarına getirebilmesi için onu kullanılabilir kılıyoruz.

Liste 7-17, Liste 7-11’deki kodda kök modüldeki (root module) use ifadesinin pub use olarak değiştirilmiş halini göstermektedir.

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ı gerekiyordu; ki bu da restoran_on_kisim modülünün pub olarak işaretlenmesini gerektirirdi. Şimdi bu pub use, kök modülden (root module) karsilama modülünü yeniden dışa aktardığı için, harici kodlar bunun yerine restoran::karsilama::bekleme_listesine_ekle() yolunu kullanabilir.

Yeniden dışa aktarma işlemi, kodunuzun iç yapısı (internal structure), kodunuzu çağıran programcıların alanı (domain) nasıl düşüneceğinden farklı olduğunda yararlıdır. Örneğin, bu restoran metaforunda, restoranı işleten kişiler “ön kısım” ve “arka kısım” hakkında düşünürler. Ancak bir restoranı ziyaret eden müşteriler büyük olasılıkla restoranın bölümleri hakkında bu terimlerle düşünmeyeceklerdir. pub use ile kodumuzu tek bir yapıyla yazabilir ancak farklı bir yapıyla açığa çıkarabiliriz. Bunu yapmak, kütüphanemizi hem kütüphane üzerinde çalışan programcılar hem de kütüphaneyi çağıran programcılar için iyi organize edilmiş hale getirir. Bölüm 14’teki “Kullanışlı Bir Genel API’yi Dışa Aktarmak” (Exporting a Convenient Public API) başlığında, pub use için başka bir örneğe ve bunun crate’inizin dokümantasyonunu nasıl etkilediğine bakacağız.

Harici (External) Paketleri Kullanmak

Bölüm 2’de, rastgele sayılar elde etmek için rand adlı harici bir paketi kullanan bir tahmin oyunu projesi programladık. rand paketini projemizde kullanmak için, Cargo.toml dosyamıza şu satırı ekledik:

rand = "0.8.5"

Cargo.toml dosyasına rand paketini bir bağımlılık (dependency) olarak eklemek, Cargo’ya rand paketini ve tüm bağımlılıklarını crates.io adresinden indirip projemiz için erişilebilir kılmasını 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 listeledik. Hatırlarsanız Bölüm 2’deki “Rastgele Bir Sayı Üretmek” kısmında Rng trait’ini kapsama almış ve rand::thread_rng fonksiyonunu çağırmıştık:

use std::io;

use rand::Rng;

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

    let gizli_sayi = rand::thread_rng().gen_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 çekmek de aynı adımları gerektirir: Onları paketinizin Cargo.toml dosyasında listelemek ve içerdikleri öğeleri kendi kapsamınıza almak için use kullanmak.

Standart std kütüphanesinin de paketimiz için harici bir crate olduğuna dikkat edin. Standart kütüphane Rust diliyle birlikte geldiğinden (shipped), Cargo.toml dosyamızı std’yi içerecek şekilde değiştirmemize gerek yoktur. Ancak yine de oradaki öğeleri paketimizin kapsamına dahil etmek için ona use ile başvurmamız gerekir. Örneğin, HashMap ile şu satırı kullanırdık:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
}

Bu, standart kütüphane crate’inin adı olan std ile başlayan mutlak (absolute) bir yoldur.

Uzun use Listelerini Temizlemek İçin İç İçe (Nested) Yollar Kullanmak

Eğer aynı crate’te ya da aynı modülde tanımlanmış birden çok öğeyi kullanıyorsak, her bir öğeyi kendi satırında listelemek dosyalarımızda dikey olarak çok yer kaplayabilir. Örneğin, Liste 2-4’teki tahmin oyununda yer alan bu iki use ifadesi, öğeleri std’den kapsama getirmektedir:

use rand::Rng;
// --snip--
use std::cmp::Ordering;
use std::io;
// --snip--

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

    let gizli_sayi = rand::thread_rng().gen_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.to_string()) {
        Ordering::Less => println!("Çok küçük!"),
        Ordering::Greater => println!("Çok büyük!"),
        Ordering::Equal => println!("Kazandınız!"),
    }
}

Bunun yerine, aynı öğeleri tek bir satırda kapsama getirmek 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 iki nokta üst üste işaretini (::) ve yolların farklılaşan kısımlarının bir listesini süslü parantezler içine alarak yaparız.

use rand::Rng;
// --snip--
use std::{cmp::Ordering, io};
// --snip--

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

    let gizli_sayi = rand::thread_rng().gen_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!"),
    }
}

Büyük programlarda, aynı crate’ten ya da modülden birçok öğeyi iç içe yollar (nested paths) kullanarak kapsama getirmek, ihtiyaç duyulan ayrı use ifadelerinin sayısını büyük ölçüde azaltabilir!

Bir yolda herhangi bir seviyede iç içe yol kullanabiliriz; bu, ortak bir alt yolu (subpath) paylaşan iki use ifadesini birleştirirken yararlıdır. Örneğin, Liste 7-19 iki adet use ifadesi göstermektedir: biri std::io’yu kapsama getirirken, diğeri std::io::Write’ı kapsama getirir.

use std::io;
use std::io::Write;

Bu iki yolun ortak noktası std::io’dur ve bu tamamen ilk yola karşılık gelir. Bu iki yolu tek bir use ifadesinde birleştirmek için, Liste 7-20’de gösterildiği gibi iç içe yolda self kullanabiliriz.

use std::io::{self, Write};

Bu satır std::io ve std::io::Write’ı kapsama alır.

Öğeleri Glob Operatörü ile İçe Aktarmak

Eğer bir yolda tanımlı tüm açık öğeleri kapsama almak istiyorsak, o yolu belirtebilir ve ardından * glob operatörünü koyabiliriz:

#![allow(unused)]
fn main() {
use std::collections::*;
}

Bu use ifadesi, std::collections içinde tanımlı tüm açık öğeleri geçerli kapsama getirir. Glob operatörünü kullanırken dikkatli olun! Glob, hangi isimlerin kapsamda olduğunu ve programınızda kullanılan bir ismin nerede tanımlandığını anlamanızı zorlaştırabilir. Ayrıca, bağımlılık (dependency) kendi tanımlarını değiştirirse, içe aktardığınız (imported) şeyler de değişir; bu da örneğin, bağımlılık, aynı kapsamdaki sizin bir tanımınızla aynı isme sahip bir tanım eklerse, bağımlılığı güncellediğinizde derleyici hatalarına yol açabilir.

Glob operatörü, test yazarken test edilecek her şeyi tests modülü içine almak için sıkça kullanılır; bu konuyu Bölüm 11’deki “Nasıl Test Yazılır?” kısmında ele alacağız. Glob operatörü bazen prelude (ön hazırlık/başlangıç) kalıbının (pattern) bir parçası olarak da kullanılır: Bu kalıp hakkında daha fazla bilgi edinmek için standart kütüphane dokümantasyonuna bakabilirsiniz.

Modülleri Farklı Dosyalara Ayırma

Modülleri Farklı Dosyalara Ayırma

Şimdiye kadar bu bölümdeki tüm örnekler birden fazla modülü tek bir dosyada tanımladı. Modüller büyüdüğünde, kod içinde gezinmeyi (navigate) kolaylaştırmak için modül tanımlarını ayrı bir dosyaya taşımak isteyebilirsiniz.

Örneğin, birden çok restoran modülü içeren Liste 7-17’deki koddan başlayalım. Tüm modülleri crate kök dosyasında tanımlamak yerine, modülleri ayrı dosyalara çıkaracağız. Bu durumda crate kök dosyası src/lib.rs’dir, ancak bu prosedür, crate kök dosyası src/main.rs olan ikili crate’lerde de çalışır.

İlk olarak restoran_on_kisim modülünü kendi dosyasına çıkaracağız. restoran_on_kisim modülü için süslü parantezlerin içindeki kodu kaldırın ve src/lib.rs’in Liste 7-21’de gösterilen kodu içermesi için sadece mod restoran_on_kisim; bildirimini (declaration) bırakın. 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();
}

Daha sonra, Liste 7-22’de gösterildiği gibi, süslü parantezlerin içinde bulunan kodu src/restoran_on_kisim.rs adlı yeni bir dosyaya yerleştirin. Derleyici, bu dosyaya bakması gerektiğini bilir çünkü crate kökünde restoran_on_kisim adında bir modül bildirimiyle karşılaşmıştır.

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ğini unutmayın. Derleyici, dosyanın projenin bir parçası olduğunu bildiğinde (ve mod ifadesini nereye koyduğunuzdan dolayı kodun modül ağacının neresinde bulunduğunu anladığında), projenizdeki diğer dosyalar yüklenen dosyanın koduna “Modül Ağacındaki Bir Öğeye Başvurmak İçin Yollar (Paths)” bölümünde anlatıldığı gibi o dosyanın nerede tanımlandığını gösteren bir yol kullanarak atıfta bulunmalıdır. Başka bir deyişle, mod diğer programlama dillerinde görmüş olabileceğiniz bir “include” (dahil etme) işlemi değildir.

Sonraki adımda, karsilama modülünü kendi dosyasına çıkaracağız. Bu süreç biraz farklıdır çünkü karsilama, kök (root) modülünün değil, restoran_on_kisim modülünün bir alt modülüdür. karsilama dosyasını modül ağacındaki ata modüllerine göre adlandırılacak yeni bir dizine, bu durumda 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;

Daha sonra, karsilama modülünde yapılan tanımları içermesi için src/restoran_on_kisim adlı bir dizin ve içinde bir karsilama.rs dosyası oluşturuyoruz:

pub fn bekleme_listesine_ekle() {}

Eğer karsilama.rs dosyasını src dizinine koysaydık derleyici karsilama.rs kodunun, restoran_on_kisim modülünün bir alt modülü olarak değil de doğrudan crate kökünde bildirilen bir karsilama modülünde olmasını beklerdi. Derleyicinin hangi modüllerin kodu için hangi dosyaları kontrol edeceğine dair kuralları, dizinlerin ve dosyaların modül ağacıyla daha yakından eşleştiği anlamına gelir.

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 farklı dosyalarda yaşasa bile herhangi bir değişiklik olmadan çalışacaktır. Bu teknik, modüllerin boyutları 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 ifadesinin de değişmediğine ve use anahtar kelimesinin crate’in bir parçası olarak hangi dosyaların derlendiği üzerinde hiçbir etkisinin olmadığına dikkat edin. mod anahtar kelimesi modülleri tanımlar (declare) ve Rust o modülün içine giren kod için modülle aynı ada sahip bir dosyaya bakar.

Özet

Rust, bir modülde tanımlanan öğelere başka bir modülden atıfta bulunabilmeniz (refer to) için bir paketi birden çok crate’e ve bir crate’i birden çok modüle bölmenizi sağlar. Bunu mutlak veya göreceli yollar (absolute or relative paths) belirterek yapabilirsiniz. Bu yollar, o kapsamda öğenin birden çok kullanımı için daha kısa bir yol kullanabilmeniz adına use ifadesiyle kapsama dahil edilebilir. Modül kodu varsayılan olarak gizlidir, ancak pub anahtar kelimesini ekleyerek tanımları açık hale getirebilirsiniz.

Bir sonraki bölümde, standart kütüphanede (standard library) bulunan ve kendi düzenli organize edilmiş kodunuzda kullanabileceğiniz bazı koleksiyon veri yapılarına (collection data structures) bakacağız.

Yaygın Koleksiyonlar

Rust’ın standart kütüphanesi, koleksiyonlar adı verilen çok kullanışlı bir dizi veri yapısı içerir. Diğer birçok veri türü tek bir spesifik değeri temsil ederken, koleksiyonlar birden fazla değeri barındırabilir. Gömülü dizi ve demet türlerinin aksine, bu koleksiyonların işaret ettiği veriler yığında saklanır; bu da veri miktarının derleme zamanında bilinmesine gerek olmadığı 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 durumunuz için en uygun olanı seçmek zamanla geliştireceğiniz bir yetenektir. Bu bölümde, Rust programlarında çok sık kullanılan üç koleksiyonu ele alacağız:

• Bir vektör, yan yana duran değişken sayıda değeri depolamanızı sağlar.
• Bir string (dizgi), 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 (karma harita), bir değeri belirli bir anahtarla ilişkilendirmenizi sağlar. Bu, harita 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 belgelere göz atabilirsiniz.

Vektörlerin, stringlerin ve hash maplerin nasıl oluşturulup güncelleneceğini ve her birini neyin özel kıldığını tartışacağız.

Vektörlerle Değer Listeleri Saklama

Vektörlerle Değer Listeleri Depolamak

Bakacağımız ilk koleksiyon türü, Vec<T>, diğer adıyla vektördür. Vektörler, birden fazla değeri hafızada (bellekte) yan yana koyan tek bir veri yapısında depolamanızı sağlar. Vektörler sadece aynı türdeki değerleri depolayabilir. Bir dosyadaki metin satırları veya alışveriş sepetindeki ürünlerin fiyatları gibi bir öğe listeniz olduğunda kullanışlıdırlar.

Yeni Bir Vektör Oluşturmak

Yeni, 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 bir tür ek açıklaması eklediğimize dikkat edin. Bu vektöre herhangi bir değer eklemediğimiz için, Rust ne tür elemanları depolamak niyetinde olduğumuzu bilmez. 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üphane tarafından sağlanan Vec<T> türünün herhangi bir türü barındırabileceğini bilin. Belirli bir türü tutması için bir vektör oluşturduğumuzda, bu türü açılı parantezler içinde belirtebiliriz. Liste 8-1’de, Rust’a v içerisindeki Vec<T>’nin i32 türünden elemanlar tutacağını söyledik.

Daha sıklıkla, başlangıç değerleriyle bir Vec<T> oluşturursunuz ve Rust depolamak istediğiniz değerin türünü çıkarsar, bu yüzden bu tür ek açıklamasına nadiren ihtiyaç duyarsınız. Rust, verdiğiniz değerleri tutan yeni bir vektör oluşturacak olan kullanışlı vec! makrosunu sağlar. Liste 8-2, 1, 2 ve 3 değerlerini tutan yeni bir Vec<i32> oluşturur. Tamsayı türü i32’dir, çünkü Bölüm 3’teki “Veri Türleri” bölümünde tartıştığımız gibi, bu varsayılan tamsayı türü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ğu sonucuna varabilir ve tür ek açıklamasına gerek kalmaz. Sırada, bir vektörün nasıl değiştirileceğine bakacağız.

Bir Vektörü Güncellemek

Bir vektör oluşturup ardından ona elemanlar eklemek için, Liste 8-3’te gösterildiği gibi push (it) 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 tartışıldığı gibi, herhangi bir değişkenle ilgili olduğu üzere, eğer değerini değiştirebilmek istiyorsak, onu mut anahtar kelimesini kullanarak değiştirilebilir yapmamız gerekir. İçine yerleştirdiğimiz sayıların hepsi i32 türündedir ve Rust bunu veriden anlar, bu yüzden Vec<i32> ek açıklamasına ihtiyacımız yoktur.

Vektörlerin Elemanlarını Okumak

Bir vektörde depolanan bir değere referans vermenin iki yolu vardır: indeksleme yoluyla veya get (al) metodunu kullanarak. Aşağıdaki örneklerde, ekstra netlik için bu fonksiyonlardan döndürülen değerlerin türlerini ek açıklama ile belirttik.

Liste 8-4, indeksleme sözdizimi ve get metodu ile bir vektördeki bir 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."),
    }
}

Burada birkaç detaya dikkat edin. Üçüncü elemanı almak için 2 indeks değerini kullanırız çünkü vektörler sıfırdan başlayarak sayılarla indekslenir. & ve [] kullanmak, indeks değerindeki elemanın referansını verir. get metodunu indeks bir argüman olarak geçirilmiş şekilde kullandığımızda, match ile kullanabileceğimiz bir Option<&T> elde ederiz.

Rust, mevcut elemanların aralığının dışındaki bir indeks değerini kullanmaya çalıştığınızda programın nasıl davranacağını seçebilmeniz için bir elemana referans vermenin bu iki yolunu sunar. Bir örnek olarak, beş elemanlı bir vektörümüz olduğunda ve ardından Liste 8-5’te gösterildiği gibi her iki teknikle 100. indeksteki bir elemana erişmeye çalıştığımızda ne olduğuna 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 [] metodu programın panik yapmasına neden olacaktır çünkü var olmayan bir elemana referans verir. Bu yöntem, vektörün sonunu geçecek şekilde bir elemana erişilme girişimi olduğunda programınızın çökmesini istiyorsanız en iyi seçenektir.

get metoduna vektörün dışında bir indeks geçirildiğinde, panik yapmadan None döndürür. Normal şartlar altında vektör aralığının ötesindeki bir elemana erişim zaman zaman meydana gelebiliyorsa bu yöntemi kullanırsınız. Daha sonra kodunuz, Bölüm 6’da tartışıldığı gibi, Some(&eleman) veya None olma durumunu yönetecek bir mantığa sahip olacaktır. Örneğin, indeks, bir kullanıcının girdiği bir sayıdan geliyor olabilir. Yanlışlıkla çok büyük bir sayı girerlerse ve program bir None değeri alırsa, kullanıcıya mevcut vektörde kaç tane öğe olduğunu söyleyebilir ve geçerli bir değer girmeleri için bir şans daha verebilirsiniz. Bu, bir yazım hatası nedeniyle programın çökmesinden daha kullanıcı dostu olacaktır!

Programın geçerli bir referansı olduğunda, ödünç alma denetleyicisi bu referansın ve vektörün içeriğine yönelik diğer referansların geçerli kalmasını sağlamak için (Bölüm 4’te kapsanan) sahiplik ve ödünç alma kurallarını zorunlu tutar. Aynı kapsamda değiştirilebilir ve değiştirilemez referanslara sahip olamayacağınızı belirten kuralı hatırlayın. Bu kural, bir vektördeki ilk elemana değiştirilemez bir referans tuttuğumuz ve sonuna bir eleman eklemeye çalıştığımız Liste 8-6’da uygulanır. Eğer daha sonra fonksiyonda o elemana tekrar atıfta bulunmaya çalışırsak bu program çalışmayacaktır.

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    let ilk = &v[0];

    v.push(6);

    println!("İlk eleman: {ilk}");
}

Bu kodun derlenmesi şu hatayla sonuçlanacaktır:

$ cargo run
   Compiling koleksiyonlar v0.1.0 ($PROJE/listings/ch08-common-koleksiyonlar/listing-08-06)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:7:5
  |
5 |     let ilk = &v[0];
  |                - immutable borrow occurs here
6 |
7 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
8 |
9 |     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 çalışması gerekiyormuş gibi görünebilir: İlk elemana olan bir referans, vektörün sonundaki değişiklikleri neden umursasın ki? Bu hata vektörlerin çalışma şeklinden kaynaklanmaktadır: Vektörler değerleri bellekte yan yana yerleştirdiğinden, vektörün sonuna yeni bir eleman eklemek, eğer tüm elemanları vektörün şu anda depolandığı yerde yan yana koyacak kadar alan yoksa, yeni bir bellek ayırmayı ve eski elemanları yeni alana kopyalamayı gerektirebilir. Bu durumda, ilk elemana olan referans, ayrılmamış belleğe işaret ediyor olacaktır. Ödünç alma kuralları programların o duruma düşmesini engeller.

Not: Vec<T> türünün uygulama ayrıntıları hakkında daha fazlası için “The Rustonomicon” kitabına bakın.

Bir Vektördeki Değerlerin Üzerinde Yineleme (Iterating) Yapmak

Bir vektördeki her bir elemana sırayla erişmek için, her defasında birine erişmek adına indeksleri kullanmak yerine, tüm elemanlar boyunca yineleme yapabiliriz. Liste 8-7, i32 değerlerinden oluşan bir vektördeki her bir elemanın değiştirilemez referanslarını almak ve onları yazdırmak için bir 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 için değiştirilebilir bir vektördeki her elemanın değiştirilebilir referansları ü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’deki değere ulaşmak amacıyla * referansı kaldırma operatörünü kullanmalıyız. Referansı kaldırma operatörü hakkında daha fazla bilgiyi Bölüm 15’teki “Referansı Kaldırma Operatörü ile İşaretçiden Değere Ulaşmak” bölümünde konuşacağız.

Bir vektör üzerinde, ister değiştirilemez ister değiştirilebilir şekilde, yineleme yapmak ödünç alma denetleyicisinin kuralları sayesinde güvenlidir. Eğer Liste 8-7 ve Liste 8-8’deki for döngüsü gövdelerinde öğe eklemeye veya çıkarmaya kalkışsaydık, Liste 8-6’daki kodla aldığımıza benzer bir derleyici hatası alırdık. for döngüsünün tuttuğu vektöre olan referans, tüm vektörün eşzamanlı olarak değiştirilmesini engeller.

Birden Fazla Türü Depolamak için Enum Kullanmak

Vektörler sadece aynı türdeki değerleri depolayabilir. Bu rahatsız edici olabilir; farklı türlerdeki öğelerin bir listesini depolamaya kesinlikle ihtiyaç duyduğumuz kullanım durumları vardır. Neyse ki, bir enum’ın varyantları aynı enum türü altında tanımlanır, dolayısıyla farklı türlerdeki elemanları temsil etmek için tek bir türe ihtiyaç duyduğumuzda, bir enum tanımlayabilir ve kullanabiliriz!

Örneğin, bir elektronik tabloda, bir satırdaki bazı sütunların tam sayılar, bazılarının ondalıklı sayılar ve bazılarının da stringler içerdiği bir değer dizisini almak istediğimizi varsayalım. Varyantları farklı değer türlerini tutacak bir enum tanımlayabiliriz ve tüm enum varyantları aynı tür (enum’ın türü) kabul edilir. Ardından, o enum’ı tutacak ve böylece nihayetinde farklı türleri barındıracak bir vektör oluşturabiliriz. 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, her bir elemanı yığında depolamak için tam olarak ne kadar belleğe ihtiyaç duyulacağını bilmesi amacıyla, derleme zamanında vektörde hangi türlerin olacağını bilmek zorundadır. Ayrıca bu vektörde hangi türlere izin verildiği konusunda da açık olmalıyız. Eğer Rust bir vektörün herhangi bir türü barındırmasına izin verseydi, bir veya daha fazla türün vektörün elemanları üzerinde gerçekleştirilen operasyonlarda hatalara neden olma ihtimali olurdu. Bir enum ve match (eşleştirme) ifadesi kullanmak, Bölüm 6’da tartışıldığı gibi, Rust’ın her olası durumun ele alındığından derleme zamanında emin olması anlamına gelir.

Eğer bir programın çalışma zamanında bir vektörde depolamak üzere alacağı türlerin kapsamlı kümesini bilmiyorsanız, enum tekniği işe yaramayacaktır. Bunun yerine, Bölüm 18’de ele alacağımız bir trait nesnesi kullanabilirsiniz.

Vektörleri kullanmanın en yaygın yollarından bazılarını tartıştığımıza göre, standart kütüphane tarafından Vec<T> üzerinde tanımlanmış birçok kullanışlı metodun tamamı için API belgelerini mutlaka inceleyin. Örneğin, push (it) metoduna ek olarak, bir pop (çıkar) metodu son elemanı kaldırır ve döndürür.

Bir Vektörü Düşürmek (Dropping) Elemanlarını Da Düşürür

Diğer herhangi bir struct gibi, bir vektör de Liste 8-10’da belirtildiği gibi kapsam dışına çıktığında 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ığı tamsayılar temizlenecektir. Ö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ı sağlar.

Bir sonraki koleksiyon türüne geçelim: String!

String'lerle UTF-8 Kodlanmış Metin Saklama

Stringlerle UTF-8 Kodlanmış Metin Depolamak

Bölüm 4’te stringlerden (dizgilerden) bahsetmiştik, ancak şimdi onları daha derinlemesine inceleyeceğiz. Yeni Rustacean’lar genellikle üç nedenin birleşimi yüzünden stringlerde takılırlar: Rust’ın olası hataları açığa çıkarma eğilimi, stringlerin birçok programcının sandığından daha karmaşık bir veri yapısı olması ve UTF-8. Bu faktörler, başka programlama dillerinden geldiğinizde zor görünebilecek bir şekilde birleşir.

Stringleri koleksiyonlar bağlamında tartışıyoruz çünkü stringler bir bayt koleksiyonu ve o baytlar metin olarak yorumlandığında yararlı işlevsellik sağlamak için bazı metotlar olarak uygulanmıştır. Bu bölümde, her koleksiyon türünün sahip olduğu oluşturma, güncelleme ve okuma gibi String üzerindeki işlemlerden bahsedeceğiz. Ayrıca String’in diğer koleksiyonlardan farklı olduğu yolları, yani insanların ve bilgisayarların String verilerini yorumlama biçimleri arasındaki farklar nedeniyle bir String’e indeksleme yapmanın ne kadar karmaşık olduğunu da tartışacağız.

Stringleri Tanımlamak

Öncelikle string terimiyle ne kastettiğimizi tanımlayacağız. Rust, çekirdek dilinde yalnızca bir string türüne sahiptir: genellikle ödünç alınmış biçiminde &str olarak görülen string dilimi str. Bölüm 4’te, başka bir yerde depolanan bazı UTF-8 kodlanmış string verilerine referanslar olan string dilimlerinden bahsettik. Örneğin, string sabitleri programın ikili dosyasında saklanır ve bu nedenle string dilimleridirler.

Çekirdek dile kodlanmak yerine Rust’ın standart kütüphanesi tarafından sağlanan String türü, büyütülebilir, değiştirilebilir, sahiplenilmiş, UTF-8 kodlamalı bir string türüdür. Rustacean’lar Rust’ta “stringlerden” bahsettiklerinde, bu türlerden sadece birini değil, String veya string dilimi &str türlerinden herhangi birini kastediyor olabilirler. Bu bölüm büyük ölçüde String ile ilgili olsa da, her iki tür de Rust’ın standart kütüphanesinde yoğun bir şekilde kullanılır ve hem String hem de string dilimleri UTF-8 ile kodlanmıştır.

Yeni Bir String Oluşturmak

Vec<T> ile kullanılabilen aynı işlemlerin birçoğu String ile de mevcuttur, çünkü String aslında bazı ekstra garantiler, kısıtlamalar ve yeteneklerle bir bayt vektörünün etrafında bir sarmalayıcı olarak uygulanmıştır. Vec<T> ve String ile aynı şekilde çalışan bir fonksiyona örnek, Liste 8-11’de gösterildiği gibi, bir örnek oluşturmak için kullanılan new fonksiyonudur.

fn main() {
    let mut s = String::new();
}

Bu satır s adında yeni, boş bir string oluşturur ve daha sonra içine veri yükleyebiliriz. Genellikle string’i başlatmak istediğimiz bazı başlangıç verilerimiz olacaktır. Bunun için, string sabitlerinin yaptığı gibi Display trait’ini uygulayan herhangi bir türde kullanılabilen to_string metodunu kullanırız. Liste 8-12 iki örnek gösterir.

fn main() {
    let veri = "başlangıç içeriği";

    let s = veri.to_string();

    // The method also works on a literal directly:
    let s = "başlangıç içeriği".to_string();
}

Bu kod, başlangıç içeriği içeren bir string oluşturur.

Ayrıca 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 eşdeğerdir.

fn main() {
    let s = String::from("başlangıç içeriği");
}

Stringler pek çok şey için kullanıldığından, stringler için bize birçok seçenek sunan pek çok farklı jenerik API kullanabiliriz. Bazıları gereksiz (redundant) görünebilir, ancak hepsinin yeri vardır! Bu durumda, String::from ve to_string aynı şeyi yapar, bu nedenle hangisini seçeceğiniz bir stil ve okunabilirlik meselesidir.

Unutmayın stringler UTF-8 kodludur, bu yüzden Liste 8-14’te gösterildiği gibi uygun şekilde kodlanmış herhangi bir veriyi onlara dahil edebiliriz.

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 hepsi geçerli String değerleridir.

Bir String’i Güncellemek

Bir String boyutu büyüyebilir ve tıpkı Vec<T> içeriğinde olduğu gibi, içine daha fazla veri iterseniz (push) içeriği değişebilir. Ayrıca, String değerlerini birleştirmek için + operatörünü veya format! makrosunu rahatça kullanabilirsiniz.

push_str veya push ile Ekleme Yapmak

Liste 8-15’te gösterildiği gibi bir string dilimi eklemek için 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 içerecektir. push_str metodu bir string dilimi alır çünkü parametrenin sahipliğini almak istemeyebiliriz. Örneğin, Liste 8-16’daki kodda, s2’nin içeriğini s1’e ekledikten sonra onu 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ı, onun değerini son satırda yazdıramazdık. Ancak, bu kod beklediğimiz gibi çalışır!

push metodu tek bir karakteri parametre olarak alır ve onu String’e ekler. Liste 8-17, push metodu kullanarak bir String’e l harfini ekler.

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}

Sonuç olarak s, lol içerecektir.

+ veya format! ile Birleştirmek

Sıklıkla iki mevcut string’i birleştirmek istersiniz. Bunu yapmanın bir yolu 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! içerecektir. Ekledikten sonra s1’in artık geçerli olmamasının ve s2’ye bir referans kullanmamızın nedeni, + operatörünü kullandığımızda çağrılan metodun imzası ile ilgilidir. + operatörü, imzası şuna benzeyen add metodunu kullanır:

fn add(self, s: &str) -> String {

Standart kütüphanede, add’in jenerikler ve ilişkili türler kullanılarak tanımlandığını göreceksiniz. Burada, somut türleri yerine koyduk ki bu, metodu String değerleriyle çağırdığımızda olan şeydir. Jenerikleri Bölüm 10’da tartışacağız. Bu imza, + operatörünün karmaşık kısımlarını anlamamız için gereken ipuçlarını bize verir.

İlk olarak, s2 bir &’e sahiptir, bu da ikinci string’in bir referansını ilk string’e eklediğimiz anlamına gelir. Bunun nedeni add fonksiyonundaki s parametresidir: Bir String’e sadece bir string dilimi ekleyebiliriz; iki String değerini birbirine ekleyemeyiz. Ama bir dakika, add’in ikinci parametresinde belirtildiği gibi &s2’nin türü &str değil, &String’dir. Öyleyse Liste 8-18 neden derleniyor?

add çağrısında &s2’yi kullanabilmemizin nedeni, derleyicinin &String argümanını bir &str’ye zorlayabilmesidir. add metodunu çağırdığımızda Rust, burada &s2’yi &s2[..] haline getiren bir deref zorlaması kullanır. Deref zorlamasını Bölüm 15’te daha derinlemesine tartışacağız. add fonksiyonu s parametresinin sahipliğini almadığı için, s2 bu operasyondan sonra hala geçerli bir String olacaktır.

İkinci olarak, imzada add fonksiyonunun self’in sahipliğini aldığını görebiliriz, çünkü self bir &’e sahip değildir. Bu, Liste 8-18’deki s1’in add çağrısının içine taşınacağı ve ondan sonra artık geçerli olmayacağı anlamına gelir. Yani, let s3 = s1 + &s2; ifadesi her iki string’i kopyalayıp yeni bir tane oluşturacakmış gibi görünse de, bu ifade aslında s1’in sahipliğini alır, s2’nin içeriğinin bir kopyasını ekler ve ardından sonucun sahipliğini döndürür. Başka bir deyişle, bir sürü kopya yapıyormuş gibi görünür ama yapmaz; bu uygulama kopyalamadan daha verimlidir.

Eğer birden fazla string’i birleştirmemiz gerekirse, + operatörünün davranışı hantal hale gelir:

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, tic-tac-toe olacaktır. Tüm o + ve " karakterleriyle neler olup bittiğini görmek zordur. Stringleri daha karmaşık şekillerde 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’i tic-tac-toe olarak ayarlar. format! makrosu println! gibi çalışır, ancak çıktıyı ekrana yazdırmak yerine içeriklerle birlikte bir String döndürür. format! kullanan kod sürümünün okunması çok daha kolaydır ve format! makrosu tarafından oluşturulan kod referanslar kullandığından, bu çağrı parametrelerinin hiçbirinin sahipliğini almaz.

Stringleri İndekslemek

Diğer birçok programlama dilinde, bir string’deki tekil karakterlere indeksleriyle 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 bir hata 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 ($PROJE/listings/ch08-common-koleksiyonlar/listing-08-19)
error[E0277]: the type `str` cannot be indexed by `{integer}`
   --> src/main.rs:4:16
    |
  4 |     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: the following other types implement trait `SliceIndex<T>`
   --> $HOME/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/slice/index.rs:214:1
    |
214 | unsafe impl<T> const SliceIndex<[T]> for usize {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `usize` implements `SliceIndex<[T]>`
    |
   ::: $HOME/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/bstr/traits.rs:203:1
    |
203 | unsafe impl SliceIndex<ByteStr> for usize {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `usize` implements `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 hikayeyi anlatıyor: Rust stringleri indekslemeyi desteklemiyor. Peki ama neden? Bu soruyu cevaplamak için Rust’ın stringleri bellekte nasıl sakladığını tartışmamız gerekiyor.

İç Temsil (Internal Representation)

Bir String, bir Vec<u8> üzerinde sarmalayıcıdır. Liste 8-14’teki uygun şekilde kodlanmış UTF-8 örnek stringlerimizden bazılarına bakalım. Önce buna:

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 (len) 4 olacaktır, bu da "Hola" stringini saklayan vektörün 4 bayt uzunluğunda olduğu anlamına gelir. 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");
}

Eğer size string’in ne kadar uzun olduğu sorulsaydı, 12 diyebilirdiniz. Aslında Rust’ın cevabı 24’tür: Bu, “Здравствуйте” stringini UTF-8’de kodlamak için gereken bayt sayısıdır, çünkü o string’deki her bir Unicode skaler değeri 2 bayt depolama alanı kaplar. Bu nedenle, string’in baytlarındaki bir indeks her zaman geçerli bir Unicode skaler değeri ile ilişkili olmayacaktır. Bunu göstermek için, şu geçersiz Rust kodunu inceleyin:

let merhaba = "Здравствуйте";
let cevap = &merhaba[0];

cevap değişkeninin ilk harf olan З olmayacağını zaten biliyorsunuz. UTF-8 ile kodlandığında З harfinin ilk baytı 208, ikincisi ise 151’dir, bu yüzden görünüşe göre cevap aslında 208 olmalıdır, ancak 208 tek başına geçerli bir karakter değildir. Bir kullanıcı bu string’in ilk harfini istediğinde muhtemelen 208 döndürülmesini istemeyecektir; ancak Rust’ın bayt indeks 0’da sahip olduğu tek veri budur. String sadece Latin harfleri içerse bile kullanıcılar genellikle bayt değerinin döndürülmesini istemezler: Eğer &"hi"[0] bayt değerini döndüren geçerli bir kod olsaydı, h değil 104 döndürürdü.

O halde cevap, beklenmedik bir değer döndürmekten ve hemen keşfedilemeyecek hatalara neden olmaktan kaçınmak için Rust’ın bu kodu hiç derlememesi ve geliştirme sürecinin başlarında yanlış anlamaları önlemesidir.

Baytlar, Skaler Değerler ve Grafem Kümeleri (Grapheme Clusters)

UTF-8 ile ilgili bir diğer nokta da Rust’ın perspektifinden stringlere bakmanın aslında üç alakalı yolu olmasıdır: baytlar, skaler değerler ve grafem kümeleri (bizim harfler olarak adlandırdığımız şeye en yakın olan şey).

Devanagari alfabesiyle yazılmış Hintçe “नमस्ते” kelimesine bakarsak, şöyle görünen 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 saklama şeklidir. Onlara Rust’ın char türünün karşılığı olan Unicode skaler değerleri olarak bakarsak, bu baytlar şöyle görünür:

['न', 'म', 'स', '्', 'त', 'े']

Burada altı tane char değeri vardır, ancak dördüncü ve altıncı harf değildir: Onlar tek başlarına anlam ifade etmeyen aksan işaretleridir. Son olarak, onlara grafem kümeleri olarak bakarsak, bir insanın Hintçe kelimeyi oluşturan dört harf olarak adlandıracağı şeyi elde ederiz:

["न", "म", "स्", "ते"]

Rust, veri hangi insan dilinde olursa olsun, her programın ihtiyaç duyduğu yorumlamayı seçebilmesi için bilgisayarların sakladığı ham string verilerini yorumlamanın farklı yollarını sunar.

Rust’ın bir karakteri elde etmek için bir String’e indeksleme yapmamıza izin vermemesinin son bir nedeni de, indeksleme işlemlerinin her zaman sabit zaman (constant time, O(1)) almasının beklenmesidir. Ancak bir String ile bu performansı garanti etmek mümkün değildir, çünkü Rust’ın kaç tane geçerli karakter olduğunu belirlemek için içeriğin başından indekse kadar yürümesi gerekir.

Stringleri Dilimlemek (Slicing)

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ığı için bir string içine indeksleme yapmak genellikle kötü bir fikirdir. Bu nedenle, string dilimleri oluşturmak için gerçekten indeksleri kullanmanız gerekiyorsa, Rust sizden daha spesifik olmanızı ister.

[] operatörünü tek bir numarayla kullanarak indeksleme yapmak yerine, belirli baytları içeren bir string dilimi oluşturmak için [] operatörünü bir aralık (range) ile kullanabilirsiniz:

#![allow(unused)]
fn main() {
let merhaba = "Здравствуйте";

let s = &merhaba[0..4];
}

Burada s, stringin ilk 4 baytını barındıran bir &str olacaktır. Daha önce bu karakterlerin her birinin 2 bayt olduğundan bahsetmiştik, yani s, Зд olacaktır.

Eğer bir karakterin baytlarının sadece bir kısmını &merhaba[0..1] gibi bir şeyle dilimlemeye çalışsaydık, tıpkı bir vektörde geçersiz bir indekse erişilmiş gibi Rust çalışma zamanında panik yapardı:

$ cargo run
   Compiling koleksiyonlar v0.1.0 ($PROJE/listings/ch08-common-koleksiyonlar/output-only-01-not-char-boundary)

thread 'main' (34670) panicked at src/main.rs:4:19:
byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Aralıklar kullanarak string dilimleri oluştururken dikkatli olmalısınız çünkü bunu yapmak programınızı çökertebilir.

Stringlerin Üzerinde Yineleme (Iterating) Yapmak

Stringlerin parçaları üzerinde çalışmanın en iyi yolu, karakter mi yoksa bayt mı istediğinizi açıkça belirtmektir. Bireysel Unicode skaler değerleri için chars (karakterler) metodunu kullanın. “Зд” üzerinde chars çağrıldığında char türünde iki değeri ayırır ve döndürür; her bir elemana erişmek için sonucun üzerinde yineleme yapabilirsiniz:

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

Bu kod aşağıdakileri yazdıracaktır:

З
д

Alternatif olarak bytes (baytlar) metodu her bir ham baytı döndürür, ki bu sizin kullanım alanınız için 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 fazlasından oluşabileceğini unutmayın.

Devanagari alfabesinde olduğu gibi stringlerden grafem kümeleri elde etmek karmaşıktır, bu nedenle bu işlev standart kütüphane tarafından sağlanmaz. İhtiyacınız olan işlevsellik buysa crates.io adresinde crateler mevcuttur.

Stringlerin Karmaşıklıklarıyla Başa Çıkmak

Özetlemek gerekirse, stringler karmaşıktır. Farklı programlama dilleri, bu karmaşıklığı programcıya nasıl sunacakları konusunda farklı seçimler yaparlar. Rust, String verilerinin doğru işlenmesini tüm Rust programları için varsayılan davranış haline getirmeyi seçti; bu da programcıların UTF-8 verilerini en başından ele almak için daha fazla kafa yormaları gerektiği anlamına gelir. Bu takas, stringlerin karmaşıklığının diğer programlama dillerinde görünenden daha fazlasını açığa çıkarır, ancak geliştirme yaşam döngünüzün ilerleyen aşamalarında ASCII olmayan karakterlerle ilgili hataları ele almak zorunda kalmanızı önler.

İyi haber şu ki, standart kütüphane bu karmaşık durumları doğru bir şekilde ele almaya yardımcı olmak için String ve &str türleri üzerine inşa edilmiş birçok işlev sunuyor. Bir string’de arama yapmak için contains (içerir) ve bir string’in parçalarını başka bir string ile değiştirmek için replace (değiştir) gibi faydalı metotlar için belgelere göz atmayı unutmayın.

Biraz daha az karmaşık bir şeye geçelim: hash mapler (karma haritalar)!

Hash Map'lerde Anahtarları ve İlişkili Değerleri Saklama

İlişkili Değerlerle Anahtarları Hash Maplerde Saklamak

Yaygın koleksiyonlarımızın sonuncusu hash map’tir (karma harita). HashMap<K, V> türü, K türündeki anahtarları V türündeki değerlerle eşleştirmeyi depolamak için bir karma fonksiyonu kullanır ve bu fonksiyon, bu anahtar ve değerleri belleğe nasıl yerleştireceğini belirler. Birçok programlama dili bu tür bir veri yapısını destekler, ancak genellikle hash, map (harita), object (nesne), hash table (karma tablosu), dictionary (sözlük) veya associative array (ilişkisel dizi) gibi birkaç farklı isim kullanırlar.

Hash mapler, verileri vektörlerde olduğu gibi bir indeks kullanarak değil de herhangi bir türde olabilen bir anahtar kullanarak aramak istediğinizde kullanışlıdır. Örneğin bir oyunda, her takımın skorunu bir hash mapte tutabilirsiniz; burada her anahtar bir takımın adıdır ve değerler her takımın skorudur. Bir takımın adı verildiğinde, skorunu alabilirsiniz.

Bu bölümde hash maplerin temel API’sini inceleyeceğiz, ancak standart kütüphane tarafından HashMap<K, V> üzerinde tanımlanan fonksiyonlarda daha birçok güzel şey saklıdır. Her zaman olduğu gibi, daha fazla bilgi için standart kütüphane belgelerini kontrol edin.

Yeni Bir Hash Map Oluşturmak

Boş bir hash map oluşturmanın bir yolu new kullanmak ve insert (ekle) ile eleman eklemektir. Liste 8-20’de isimleri Mavi ve Sarı olan iki takımın skorlarını takip ediyoruz. Mavi takım 10 puanla, Sarı takım ise 50 puanla başlar.

fn main() {
    use std::collections::HashMap;

    let mut skorlar = HashMap::new();

    skorlar.insert(String::from("Mavi"), 10);
    skorlar.insert(String::from("Sarı"), 50);
}

Önce standart kütüphanenin koleksiyonlar kısmından HashMap’i use ile kullanıma dahil etmemiz gerektiğine dikkat edin. Üç yaygın koleksiyonumuzdan bu, en az sıklıkla kullanılanıdır, bu nedenle otomatik olarak kapsama dahil edilen özellikler arasında yer almaz. Hash mapler ayrıca standart kütüphaneden daha az destek alır; örneğin, bunları oluşturmak için yerleşik bir makro yoktur.

Tıpkı vektörler gibi, hash mapler de verilerini yığında depolar. Bu HashMap, String türünde anahtarlara ve i32 türünde değerlere sahiptir. Vektörler gibi, hash mapler de homojendir: Tüm anahtarlar aynı türde olmalı ve tüm değerler aynı türde olmalıdır.

Bir Hash Mapteki Değerlere Erişmek

Liste 8-21’de gösterildiği gibi anahtarını get (al) metoduna sağlayarak hash map’ten bir değer alabiliriz.

fn main() {
    use std::collections::HashMap;

    let mut skorlar = HashMap::new();

    skorlar.insert(String::from("Mavi"), 10);
    skorlar.insert(String::from("Sarı"), 50);

    let takim_adi = String::from("Mavi");
    let skor = skorlar.get(&takim_adi).copied().unwrap_or(0);
}

Burada skor, Mavi takımla ilişkili değere sahip olacak ve sonuç 10 olacaktır. get metodu bir Option<&V> döndürür; hash mapte o anahtar için bir değer yoksa get, None döndürecektir. Bu program Option’ı, Option<&i32> yerine Option<i32> almak için copied (kopyalanmış) çağrısı yaparak ve ardından eğer skorlar bu anahtar için bir girdiye sahip değilse skor’u sıfıra ayarlamak için unwrap_or çağrısı yaparak ele alır.

Bir for döngüsü kullanarak, vektörlerde yaptığımıza benzer bir şekilde bir hash map’teki her anahtar-değer çifti üzerinde yineleme yapabiliriz:

fn main() {
    use std::collections::HashMap;

    let mut skorlar = HashMap::new();

    skorlar.insert(String::from("Mavi"), 10);
    skorlar.insert(String::from("Sarı"), 50);

    for (anahtar, deger) in &skorlar {
        println!("{anahtar}: {deger}");
    }
}

Bu kod her bir çifti rastgele bir sırada yazdıracaktır:

Sarı: 50
Mavi: 10

Hash Maplerde Sahipliği Yönetmek

i32 gibi Copy (kopyalama) trait’ini uygulayan türler için değerler hash map’e kopyalanır. String gibi sahiplenilmiş değerler için değerler taşınacak ve Liste 8-22’de gösterildiği gibi hash map bu değerlerin sahibi olacaktır.

fn main() {
    use std::collections::HashMap;

    let alan_adi = String::from("Favori renk");
    let alan_degeri = String::from("Mavi");

    let mut map = HashMap::new();
    map.insert(alan_adi, alan_degeri);
    // alan_adi ve alan_degeri bu noktada geçersizdir, bunları kullanmayı deneyin ve
    // hangi derleyici hatasını aldığınızı görün!
}

alan_adi ve alan_degeri değişkenlerini, insert çağrısıyla hash map’e taşındıktan sonra artık kullanamayız.

Eğer hash map’e değerlere ait referansları eklersek, değerler hash map’e taşınmaz. Referansların işaret ettiği değerler, en az hash map geçerli olduğu sürece geçerli olmalıdır. Bu konular hakkında Bölüm 10’da “Referansları Ömürlerle Doğrulamak (Validating References with Lifetimes)” kısmında daha fazla konuşacağız.

Bir Hash Mapi Güncellemek

Anahtar ve değer çiftlerinin sayısı artabilir olsa da her benzersiz anahtarın aynı anda yalnızca bir değerle ilişkisi olabilir (ancak tersi geçerli değildir: Örneğin hem Mavi takım hem de Sarı takım, skorlar hash map’inde 10 değerini depolayabilir).

Bir hash mapteki veriyi değiştirmek istediğinizde, bir anahtara halihazırda bir değer atanmışsa bu durumu nasıl ele alacağınıza karar vermelisiniz. Eski değeri tamamen göz ardı edip yerine yeni değeri koyabilirsiniz. Eski değeri koruyup yeni değeri yok sayabilir ve yalnızca anahtarın zaten bir değeri yoksa yeni değeri ekleyebilirsiniz. Veya eski değer ile yeni değeri birleştirebilirsiniz. Her birini nasıl yapacağımıza bakalım!

Bir Değerin Üzerine Yazmak (Overwriting)

Eğer bir hash map’e bir anahtar ve bir değer ekler ve daha sonra aynı anahtarı farklı bir değerle eklerseniz, o anahtarla ilişkili değer değiştirilir. Liste 8-23’teki kod insert fonksiyonunu iki kez çağırsa bile, hash map yalnızca bir anahtar-değer çifti barındıracaktır çünkü her ikisinde de Mavi takımın anahtarı için değer ekliyoruz.

fn main() {
    use std::collections::HashMap;

    let mut skorlar = HashMap::new();

    skorlar.insert(String::from("Mavi"), 10);
    skorlar.insert(String::from("Mavi"), 25);

    println!("{skorlar:?}");
}

Bu kod {"Mavi": 25} yazdıracaktır. 10 olan orijinal değerin üzerine yazılmıştır.

Yalnızca Bir Anahtarın Değeri Yoksa Bir Anahtar ve Değer Eklemek

Belirli bir anahtarın bir değer ile hash mapte halihazırda var olup olmadığını kontrol etmek ve ardından şu eylemleri gerçekleştirmek yaygındır: Eğer anahtar hash mapte varsa mevcut değer olduğu gibi kalmalıdır; eğer anahtar yoksa onu ve onun için bir değer ekleyin.

Hash maplerin bunun için kontrol etmek istediğiniz anahtarı parametre olarak alan entry (giriş) adında özel bir API’si vardır. entry metodunun dönüş değeri, var olabilecek veya olmayabilecek bir değeri temsil eden Entry adlı bir enum’dır. Diyelim ki Sarı takımın anahtarının onunla ilişkili bir değeri olup olmadığını kontrol etmek istiyoruz. Eğer yoksa 50 değerini eklemek istiyoruz ve aynısını Mavi takım için de yapmak istiyoruz. entry API’si kullanılarak kod, Liste 8-24’teki gibi görünür.

fn main() {
    use std::collections::HashMap;

    let mut skorlar = HashMap::new();
    skorlar.insert(String::from("Mavi"), 10);

    skorlar.entry(String::from("Sarı")).or_insert(50);
    skorlar.entry(String::from("Mavi")).or_insert(50);

    println!("{skorlar:?}");
}

Entry üzerindeki or_insert metodu, karşılık gelen Entry anahtarı varsa o değere değiştirilebilir bir referans (mutable reference) döndürmek üzere tanımlanmıştır ve eğer yoksa, parametreyi bu anahtar için yeni bir değer olarak ekler ve yeni değere değiştirilebilir bir referans döndürür. Bu teknik, mantığı kendi başımıza yazmaktan çok daha temizdir ve ek olarak ödünç alma denetleyicisi ile daha uyumlu çalışır.

Liste 8-24’teki kodun çalıştırılması {"Sarı": 50, "Mavi": 10} yazdıracaktır. İlk entry çağrısı, Sarı takım için 50 değeri ile birlikte anahtarı ekleyecektir çünkü Sarı takımın halihazırda bir değeri yoktur. İkinci entry çağrısı hash map’i değiştirmeyecektir çünkü Mavi takım halihazırda 10 değerine sahiptir.

Eski Değere Dayalı Olarak Bir Değeri Güncellemek

Hash mapler için başka bir yaygın kullanım durumu, bir anahtarın değerini aramak ve sonra eski değere dayanarak onu güncellemektir. Örneğin Liste 8-25, bazı metinlerdeki her bir kelimenin kaç kez geçtiğini sayan bir kod gösterir. Anahtarlar olarak kelimeleri içeren bir hash map kullanıyoruz ve o kelimeyi kaç kez gördüğümüzü takip etmek için değeri artırıyoruz. Eğer bir kelimeyi ilk kez görüyorsak ilk olarak 0 değerini ekleyeceğiz.

fn main() {
    use std::collections::HashMap;

    let metin = "merhaba dünya harika dünya";

    let mut map = HashMap::new();

    for kelime in metin.split_whitespace() {
        let sayac = map.entry(kelime).or_insert(0);
        *sayac += 1;
    }

    println!("{map:?}");
}

Bu kod {"dünya": 2, "merhaba": 1, "harika": 1} yazdıracaktır. Aynı anahtar-değer çiftlerinin farklı bir sırada yazdırıldığını görebilirsiniz: “Bir Hash Mapteki Değerlere Erişmek” bölümünden bir hash map üzerinde yineleme yapmanın rastgele bir düzende gerçekleştiğini hatırlayın.

split_whitespace (boşluklardan_ayır) metodu, metin içindeki değerin boşluklarla ayrılmış alt dilimleri üzerinde bir yineleyici döndürür. or_insert metodu belirtilen anahtar için değere değiştirilebilir bir referans (&mut V) döndürür. Burada, bu değiştirilebilir referansı sayac değişkeninde depoluyoruz, bu nedenle bu değere atama yapmak için öncelikle yıldız imi (*) kullanarak sayac’ı referanstan kaldırmalıyız. Değiştirilebilir referans for döngüsünün sonunda kapsamın dışına çıkar, bu nedenle tüm bu değişiklikler güvenlidir ve ödünç alma kuralları tarafından izin verilir.

Karma (Hashing) Fonksiyonları

Varsayılan olarak HashMap, karma tablolarını barındıran hizmet reddi (denial-of-service, DoS) saldırılarına karşı direnç sağlayabilen SipHash adlı bir karma fonksiyonu kullanır¹. Bu mevcut en hızlı karma algoritması değildir, ancak performanstaki düşüşle birlikte gelen daha iyi güvenlik için yapılan takasa değer. Eğer kodunuzun profilini çıkarır ve varsayılan karma fonksiyonunun amaçlarınız için çok yavaş olduğunu fark ederseniz, farklı bir karma oluşturucu belirterek başka bir fonksiyona geçiş yapabilirsiniz. Bir hasher (karma oluşturucu), BuildHasher trait’ini uygulayan bir türdür. Trait’ler ve bunların nasıl uygulanacağı hakkında Bölüm 10’da konuşacağız. Kendi karma oluşturucunuzu baştan uygulamak zorunda değilsiniz; crates.io, diğer Rust kullanıcıları tarafından paylaşılan, birçok yaygın karma algoritmasını uygulayan karma oluşturucular sağlayan kütüphanelere sahiptir.

Özet

Vektörler, stringler ve hash mapler verileri depolamanız, bunlara erişmeniz ve bunları değiştirmeniz gerektiğinde programlarda gereken büyük miktarda işlevselliği sağlayacaktır. İşte artık çözmek için donanımlı olmanız gereken bazı egzersizler:

1. Bir tam sayı listesi verildiğinde bir vektör kullanın ve listenin medyanını (sıralandığında, orta konumdaki değer) ve modunu (en sık oluşan değer; burada bir hash map yardımcı olacaktır) döndürün.
2. Stringleri Pig Latin’e (Domuz Latincesi) dönüştürün. Her kelimenin ilk sessiz harfi kelimenin sonuna taşınır ve ay eklenir, böylece ilk ilkay-f (irst-fay) olur. Sesli harfle başlayan kelimelerin sonuna bunun yerine hay eklenir (elma (apple), elma-hay (apple-hay) olur). UTF-8 kodlamasıyla ilgili detayları aklınızda bulundurun!
3. Bir hash map ve vektörler kullanarak bir kullanıcının bir şirketteki bir departmana çalışan isimleri eklemesini sağlamak için bir metin arayüzü oluşturun; örneğin, “Sally’yi Mühendisliğe Ekle (Add Sally to Engineering)” veya “Amir’i Satışa Ekle (Add Amir to Sales)”. Ardından kullanıcının bir departmandaki tüm kişilerin veya şirketteki tüm kişilerin departmana göre alfabetik olarak sıralanmış bir listesini almasına izin verin.

Standart kütüphane API belgeleri, bu egzersizler için yararlı olacak vektörlerin, stringlerin ve hash maplerin sahip olduğu metotları açıklar!

İşlemlerin başarısız olabileceği daha karmaşık programlara giriyoruz, bu yüzden hata yönetimi hakkında tartışmak için mükemmel bir zaman. Sırada bunu yapacağız!

1. https://en.wikipedia.org/wiki/SipHash ↩

Hata Yönetimi

Hatalar, yazılımda hayatın bir gerçeğidir; bu nedenle Rust’ın, bir şeylerin yanlış gittiği durumları ele almak için bir dizi özelliği vardır. Çoğu durumda Rust, kodunuzun derlenmesinden önce bir hata olasılığını kabul etmenizi ve bazı eylemlerde bulunmanızı gerektirir. Bu gereklilik, kodunuzu üretime (production) dağıtmadan önce hataları keşfetmenizi ve uygun şekilde ele almanızı sağlayarak programınızı daha sağlam hale getirir!

Rust, hataları iki ana kategoriye ayırır: kurtarılabilir (recoverable) ve kurtarılamaz hatalar. Örneğin bir dosya bulunamadı hatası gibi kurtarılabilir bir hata için büyük olasılıkla sadece sorunu kullanıcıya bildirmek ve işlemi yeniden denemek isteriz. Kurtarılamaz hatalar ise her zaman bir dizinin sonunun ötesindeki bir konuma erişmeye çalışmak gibi hataların belirtileridir ve bu yüzden programı derhal durdurmak isteriz.

Çoğu dil bu iki tür hata arasında ayrım yapmaz ve istisnalar (exceptions) gibi mekanizmalar kullanarak her ikisini de aynı şekilde ele alır. Rust’ta istisnalar (exceptions) yoktur. Bunun yerine, kurtarılabilir hatalar için Result<T, E> türüne ve program kurtarılamaz bir hatayla karşılaştığında yürütmeyi durduran panic! makrosuna sahiptir. Bu bölüm önce panic! çağırmayı ele alıyor ve ardından Result<T, E> değerleri döndürmek hakkında konuşuyor. Ek olarak, bir hatadan kurtulmaya çalışıp çalışmamaya veya yürütmeyi durdurup durdurmamaya karar verirken dikkat edilmesi gerekenleri inceleyeceğiz.

panic! ile Kurtarılamayan Hatalar

panic! ile Kurtarılamayan Hatalar

Bazen kodunuzda kötü şeyler olur ve bu konuda yapabileceğiniz hiçbir şey yoktur. Bu durumlar için Rust’ın panic! makrosu vardır. Uygulamada paniğe neden olmanın iki yolu vardır: kodumuzun panik yapmasına neden olacak bir eylemde bulunmak (bir dizinin sonunu geçerek erişmek gibi) veya açıkça panic! makrosunu çağırmak. Her iki durumda da programımızda bir paniğe neden oluruz. Varsayılan olarak bu panikler bir hata mesajı yazdıracak, yığını geri saracak (unwind), temizleyecek ve çıkacaktır. Bir çevre değişkeni aracılığıyla, bir panik meydana geldiğinde paniğin kaynağının izini sürmeyi kolaylaştırmak için Rust’ın çağrı yığınını (call stack) görüntülemesini de sağlayabilirsiniz.

[profile.release]
panic = 'abort'

Basit bir programda panic! çağırmayı deneyelim:

fn main() {
    panic!("çök ve yan");
}

Programı çalıştırdığınızda şuna benzer bir şey göreceksiniz:

$ cargo run
   Compiling panik v0.1.0 ($PROJE/listings/ch09-error-handling/no-listing-01-panik)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.09s
     Running `target/debug/panik`

thread 'main' (44082) panikked at src/main.rs:2:5:
çök ve yan
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

panic! çağrısı, son iki satırda bulunan hata mesajına neden olur. İlk satır, panik mesajımızı ve kaynak kodumuzda paniğin oluştuğu yeri gösterir: src/main.rs:2:5 bunun, src/main.rs dosyamızın ikinci satırı, beşinci karakteri olduğunu belirtir.

Bu durumda, belirtilen satır bizim kodumuzun bir parçasıdır ve o satıra gidersek panic! makro çağrısını görürüz. Diğer durumlarda, panic! çağrısı kodumuzun çağırdığı bir kodda olabilir ve hata mesajı tarafından bildirilen dosya adı ve satır numarası, nihayetinde panic! çağrısına yol açan bizim kodumuzun satırı değil, panic! makrosunun çağrıldığı başka birinin kodundaki satır olacaktır.

Probleme neden olan kodumuzun bölümünü bulmak için, panic! çağrısının geldiği fonksiyonların geri izlemesini (backtrace) kullanabiliriz. Bir panic! geri izlemesini nasıl kullanacağımızı anlamak için başka bir örneğe bakalım ve bir panic! çağrısı makroyu doğrudan çağıran bizim kodumuzdan ziyade, kodumuzdaki bir hata nedeniyle bir kütüphaneden geldiğinde neye benzediğini görelim. Liste 9-1, bir vektörde geçerli indeks aralığının ötesindeki bir indekse erişmeye çalışan bir koda sahiptir.

fn main() {
    let v = vec![1, 2, 3];

    v[99];
}

Burada vektörümüzün 100. elemanına (indeksleme sıfırdan başladığı için 99. indekstedir) erişmeye çalışıyoruz ancak vektörün sadece üç elemanı var. Bu durumda Rust panik yapacaktır. [] kullanımının bir eleman döndürmesi varsayılır, ancak geçersiz bir indeks geçerseniz Rust’ın burada döndürebileceği doğru olan bir eleman yoktur.

C’de bir veri yapısının sonunun ötesinde okuma yapmaya çalışmak tanımsız davranıştır (undefined behavior). Bellek o yapıya ait olmasa bile, veri yapısındaki o elemana karşılık gelecek olan bellekteki konumda ne varsa onu alabilirsiniz. Buna arabellek aşımı (buffer overread) denir ve eğer bir saldırgan indeksi veri yapısından sonra depolanan ve izin verilmemesi gereken verileri okuyacak şekilde manipüle edebiliyorsa güvenlik açıklarına (security vulnerabilities) yol açabilir.

Programınızı bu tür güvenlik açıklarından korumak için, eğer var olmayan bir indeksteki bir elemanı okumaya çalışırsanız, Rust yürütmeyi durduracak ve devam etmeyi reddedecektir. Deneyelim ve görelim:

$ cargo run
   Compiling panik v0.1.0 ($PROJE/listings/ch09-hata-yonetimi/listing-09-01)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.11s
     Running `target/debug/panik`

thread 'main' (42022) panikked at src/main.rs:4:6:
index out of bounds: the len is 3 but the index is 99
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Bu hata, main.rs dosyamızın 4. satırına işaret ediyor; burada v vektörünün 99. indeksine erişmeye çalışıyoruz.

note: satırı, hataya neden olan şeyin tam olarak ne olduğunun bir geri izlemesini (backtrace) almak için RUST_BACKTRACE çevre değişkenini ayarlayabileceğimizi söyler. Bir geri izleme (backtrace), bu noktaya gelmek için çağrılan tüm fonksiyonların bir listesidir. Rust’taki geri izlemeler diğer dillerdeki gibi çalışır: Geri izlemeyi okumanın anahtarı, en üstten başlayıp kendi yazdığınız dosyaları görene kadar okumaktır. Sorunun ortaya çıktığı nokta orasıdır. O noktanın üstündeki satırlar sizin kodunuzun çağırdığı koddur; altındaki satırlar ise sizin kodunuzu çağıran koddur. Bu önceki ve sonraki satırlar, çekirdek Rust kodunu, standart kütüphane kodunu veya kullanmakta olduğunuz crateleri içerebilir. RUST_BACKTRACE çevre değişkenini 0 hariç herhangi bir değere ayarlayarak bir geri izleme almayı deneyelim. Liste 9-2, göreceğinize benzer bir çıktı gösterir.

$ RUST_BACKTRACE=1 cargo run
thread 'main' panicked at src/main.rs:4:6:
index out of bounds: the len is 3 but the index is 99
stack backtrace:
   0: rust_begin_unwind
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/std/src/panicking.rs:692:5
   1: core::panicking::panic_fmt
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/core/src/panicking.rs:75:14
   2: core::panicking::panic_bounds_check
             at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/core/src/panicking.rs:273:5
   3: <usize as core::slice::index::SliceIndex<[T]>>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/slice/index.rs:274:10
   4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/slice/index.rs:16:9
   5: <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:3361:9
   6: panic::main
             at ./src/main.rs:4:6
   7: core::ops::function::FnOnce::call_once
             at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

Bu epey bir çıktı! Göreceğiniz kesin çıktı, işletim sisteminize ve Rust sürümünüze bağlı olarak farklı olabilir. Bu bilgileri içeren geri izlemeleri almak için hata ayıklama sembollerinin etkinleştirilmiş olması gerekir. Hata ayıklama sembolleri, burada yaptığımız gibi, --release bayrağı olmadan cargo build veya cargo run kullanıldığında varsayılan olarak etkinleştirilir.

Liste 9-2’deki çıktıda, geri izlemenin 6. satırı projemizde soruna neden olan satıra işaret eder: src/main.rs dosyasının 4. satırı. Eğer programımızın panik yapmasını istemiyorsak, incelememize kendi yazdığımız bir dosyadan bahseden ilk satırın işaret ettiği konumdan başlamalıyız. Bilerek panik yapacak kod yazdığımız Liste 9-1’de, paniği düzeltmenin yolu vektör indeks aralığının ötesinde bir eleman istememektir. Kodunuz gelecekte paniklediğinde, kodun paniğe neden olmak için hangi değerlerle nasıl bir eylemde bulunduğunu ve bunun yerine kodun ne yapması gerektiğini bulmanız gerekecektir.

Daha sonra bu bölümdeki “panic! Yapmalı mı Yapmamalı mı?” kısmında panic!’e ve hata durumlarını ele almak için panic!’i ne zaman kullanıp ne zaman kullanmamamız gerektiğine geri döneceğiz. Sırada, Result kullanarak bir hatadan nasıl kurtulacağımıza bakacağız.

Result ile Kurtarılabilir Hatalar

Result ile Kurtarılabilir Hatalar

Çoğu hata, programın tamamen durmasını gerektirecek kadar ciddi değildir. Bazen bir fonksiyon başarısız olduğunda, bunun nedeni kolayca yorumlayıp yanıt verebileceğiniz bir nedendir. Örneğin, bir dosyayı açmaya çalışırsanız ve bu işlem dosya mevcut olmadığı için başarısız olursa, süreci sonlandırmak yerine dosyayı oluşturmak isteyebilirsiniz.

Bölüm 2’deki “Potansiyel Başarısızlığı Result ile Ele Almak” kısmından hatırlayın, Result enum’ı Ok ve Err olmak üzere iki varyanta (seçeneğe) sahip olarak aşağıdaki gibi tanımlanır:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

T ve E jenerik tür parametreleridir: Jenerikleri Bölüm 10’da daha ayrıntılı olarak tartışacağız. Şu anda bilmeniz gereken şey, T’nin Ok varyantı içindeki bir başarı durumunda döndürülecek değerin türünü, E’nin ise Err varyantı içindeki bir başarısızlık durumunda döndürülecek hatanın türünü temsil ettiğidir. Result bu jenerik tür parametrelerine sahip olduğu için, döndürmek istediğimiz başarı değeri ve hata değerinin farklı olabileceği birçok farklı durumda Result türünü ve üzerinde tanımlanan fonksiyonları kullanabiliriz.

Başarısız olabileceği için Result değeri döndüren bir fonksiyon çağıralım. Liste 9-3’te bir dosya açmaya çalışıyoruz.

use std::fs::File;

fn main() {
    let karsilama_dosyasi_sonucu = File::open("merhaba.txt");
}

File::open’ın dönüş türü bir Result<T, E>’dir. Jenerik T parametresi File::open uygulaması tarafından, bir dosya tutucusu (file handle) olan std::fs::File başarı değeri türü ile doldurulmuştur. Hata değerinde kullanılan E’nin türü std::io::Error’dır. Bu dönüş türü, File::open çağrısının başarılı olabileceği ve okuyabileceğimiz veya yazabileceğimiz bir dosya tutucusu döndürebileceği anlamına gelir. Fonksiyon çağrısı başarısız da olabilir: Örneğin dosya mevcut olmayabilir veya dosyaya erişim iznimiz olmayabilir. File::open fonksiyonunun, başarılı mı yoksa başarısız mı olduğunu bize bildirmenin ve aynı zamanda bize dosya tutucusunu veya hata bilgisini vermenin bir yoluna sahip olması gerekir. Bu bilgi tam olarak Result enum’ının ilettiği şeydir.

File::open’ın başarılı olması durumunda, karsilama_dosyasi_sonucu değişkenindeki değer, bir dosya tutucusu barındıran bir Ok örneği olacaktır. Başarısız olması durumunda ise karsilama_dosyasi_sonucu içindeki değer, meydana gelen hatanın türü hakkında daha fazla bilgi barındıran bir Err örneği olacaktır.

File::open’ın döndürdüğü değere bağlı olarak farklı eylemler gerçekleştirmek için Liste 9-3’teki koda ekleme yapmamız gerekir. Liste 9-4, temel bir araç olan ve Bölüm 6’da tartıştığımız match ifadesini kullanarak Result’ı ele almanın bir yolunu gösterir.

use std::fs::File;

fn main() {
    let karsilama_dosyasi_sonucu = File::open("merhaba.txt");

    let karsilama_dosyasi = match karsilama_dosyasi_sonucu {
        Ok(dosya) => dosya,
        Err(hata) => panic!("Dosyayı açarken problem oluştu: {hata:?}"),
    };
}

Option enum’ı gibi, Result enum’ının ve varyantlarının (seçeneklerinin) prelude (önsöz/başlangıç) tarafından kapsama dahil edildiğini (brought into scope), bu nedenle match kollarındaki (arms) Ok ve Err varyantlarından önce Result:: belirtmemize gerek olmadığını unutmayın.

Sonuç Ok olduğunda, bu kod iç dosya değerini Ok varyantından döndürecek ve biz de o dosya tutucusu değerini karsilama_dosyasi değişkenine atayacağız. match sonrasında, okuma veya yazma işlemleri için dosya tutucusunu kullanabiliriz.

match’in diğer kolu (arm), File::open’dan bir Err değeri aldığımız durumu ele alır. Bu örnekte panic! makrosunu çağırmayı seçtik. Geçerli dizinimizde (directory) merhaba.txt adında bir dosya yoksa ve bu kodu çalıştırırsak, panic! makrosundan aşağıdaki çıktıyı görürüz:

$ cargo run
   Compiling hata-yonetimi v0.1.0 (file:///projects/hata-yonetimi)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.73s
     Running `target/debug/hata-yonetimi`

thread 'main' panicked at src/main.rs:8:23:
Dosyayı açarken problem oluştu: Os { code: 2, kind: NotFound, message: "No such file or directory" }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Her zamanki gibi, bu çıktı bize tam olarak neyin yanlış gittiğini söylüyor.

Farklı Hatalar Üzerinde Eşleştirme (Matching) Yapmak

Liste 9-4’teki kod, File::open neden başarısız olursa olsun panic! yapacaktır. Ancak biz farklı başarısızlık nedenleri için farklı eylemler yapmak istiyoruz. Eğer File::open dosya mevcut olmadığı için başarısız olursa, dosyayı oluşturmak ve yeni dosyanın tutucusunu döndürmek istiyoruz. Eğer File::open başka bir nedenden dolayı (örneğin dosyayı açma iznimiz olmadığı için) başarısız olursa, kodun yine Liste 9-4’te olduğu gibi panic! yapmasını istiyoruz. Bunun için, Liste 9-5’te gösterilen bir iç match ifadesi ekliyoruz.

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let karsilama_dosyasi_sonucu = File::open("merhaba.txt");

    let karsilama_dosyasi = match karsilama_dosyasi_sonucu {
        Ok(dosya) => dosya,
        Err(hata) => match hata.kind() {
            ErrorKind::NotFound => match File::create("merhaba.txt") {
                Ok(olusturulan_dosya) => olusturulan_dosya,
                Err(e) => panic!("Dosyayı oluştururken problem oluştu: {e:?}"),
            },
            _ => {
                panic!("Dosyayı açarken problem oluştu: {hata:?}");
            }
        },
    };
}

File::open’ın Err varyantı içinde döndürdüğü değerin türü, standart kütüphane tarafından sağlanan bir yapı (struct) olan io::Error’dır. Bu yapının, bir io::ErrorKind değeri almak için çağırabileceğimiz kind (tür) adında bir metodu vardır. io::ErrorKind enum’ı standart kütüphane tarafından sağlanır ve bir io işleminden kaynaklanabilecek farklı hata türlerini temsil eden varyantlara sahiptir. Kullanmak istediğimiz varyant, açmaya çalıştığımız dosyanın henüz mevcut olmadığını belirten ErrorKind::NotFound (Bulunamadı) varyantıdır. Bu yüzden karsilama_dosyasi_sonucu üzerinde bir eşleştirme yapıyoruz, ancak ayrıca hata.kind() üzerinde de bir iç eşleştirme yapıyoruz.

İç eşleştirmede kontrol etmek istediğimiz koşul, hata.kind() tarafından döndürülen değerin ErrorKind enum’ının NotFound varyantı olup olmadığıdır. Eğer öyleyse, File::create ile dosyayı oluşturmaya çalışıyoruz. Ancak File::create de başarısız olabileceği için iç match ifadesinde ikinci bir kola ihtiyacımız var. Dosya oluşturulamadığında farklı bir hata mesajı yazdırılır. Dış match’in ikinci kolu aynı kalır, böylece program eksik dosya hatası dışındaki tüm hatalarda panik yapar.

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let karsilama_dosyasi = File::open("merhaba.txt").unwrap_or_else(|hata| {
        if hata.kind() == ErrorKind::NotFound {
            File::create("merhaba.txt").unwrap_or_else(|hata| {
                panic!("Dosyayı oluştururken problem oluştu: {hata:?}");
            })
        } else {
            panic!("Dosyayı açarken problem oluştu: {hata:?}");
        }
    });
}

Hata Durumunda Panik İçin Kısayollar: unwrap ve expect

match kullanmak yeterince iyi çalışır, ancak biraz ayrıntılı/uzun olabilir ve niyeti her zaman iyi aktarmayabilir. Result<T, E> türü üzerinde çeşitli ve daha spesifik görevleri yerine getirmek için tanımlanmış birçok yardımcı (helper) metod vardır. unwrap metodu, tıpkı Liste 9-4’te yazdığımız match ifadesi gibi uygulanan bir kısayol metodudur. Eğer Result değeri Ok varyantıysa, unwrap Ok içindeki değeri döndürecektir. Eğer Result Err varyantıysa, unwrap bizim için panic! makrosunu çağıracaktır. İşte unwrap kullanımına bir örnek:

use std::fs::File;

fn main() {
    let karsilama_dosyasi = File::open("merhaba.txt").unwrap();
}

Eğer bu kodu merhaba.txt dosyası olmadan çalıştırırsak, unwrap metodunun yaptığı panic! çağrısından bir hata mesajı görürüz:

thread 'main' panicked at src/main.rs:4:49:
called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }

Benzer şekilde, expect metodu panic! hata mesajını seçmemize de izin verir. unwrap yerine expect kullanmak ve iyi hata mesajları sağlamak, niyetinizi iletebilir ve paniğin kaynağının izini sürmeyi kolaylaştırabilir. expect sözdizimi şuna benzer:

use std::fs::File;

fn main() {
    let karsilama_dosyasi = File::open("merhaba.txt")
        .expect("merhaba.txt bu projeye dahil edilmelidir");
}

expect’i de unwrap ile aynı şekilde kullanırız: dosya tutucusunu döndürmek veya panic! makrosunu çağırmak için. expect tarafından panic! çağrısında kullanılan hata mesajı, unwrap’in kullandığı varsayılan panic! mesajı yerine bizim expect’e ilettiğimiz parametre olacaktır. İşte şuna benzer:

thread 'main' panicked at src/main.rs:5:10:
merhaba.txt bu projeye dahil edilmelidir: Os { code: 2, kind: NotFound, message: "No such file or directory" }

Üretime hazır (production-quality) kodlarda çoğu Rustacean unwrap yerine expect’i seçer ve işlemin neden her zaman başarılı olmasının beklendiği hakkında daha fazla bağlam (context) verir. Bu şekilde, varsayımlarınızın yanlış olduğu kanıtlanırsa (hata alırsanız), hata ayıklamada kullanabileceğiniz daha fazla bilginiz olur.

Hataları Yaymak (Propagating Errors)

Bir fonksiyonun uygulaması başarısız olabilecek bir şey çağırdığında, hatayı fonksiyonun içinde ele almak yerine ne yapılacağına karar verebilmesi için hatayı çağıran koda döndürebilirsiniz. Bu hatayı yaymak/iletmek (propagating) olarak bilinir ve kodunuzun bağlamında elinizde olandan ziyade hatanın nasıl ele alınacağını belirleyen daha fazla bilginin veya mantığın olabileceği çağıran koda daha fazla kontrol verir.

Örneğin Liste 9-6, bir dosyadan bir kullanıcı adını okuyan bir fonksiyonu gösterir. Dosya mevcut değilse veya okunamıyorsa, bu fonksiyon o hataları, kendisini çağıran koda geri döndürecektir.

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn dosyadan_kullanici_adini_oku() -> Result<String, io::Error> {
    let kullanici_adi_dosyasi_sonucu = File::open("merhaba.txt");

    let mut kullanici_adi_dosyasi = match kullanici_adi_dosyasi_sonucu {
        Ok(dosya) => dosya,
        Err(e) => return Err(e),
    };

    let mut kullanici_adi = String::new();

    match kullanici_adi_dosyasi.read_to_string(&mut kullanici_adi) {
        Ok(_) => Ok(kullanici_adi),
        Err(e) => Err(e),
    }
}
}

Bu fonksiyon çok daha kısa bir şekilde yazılabilir, ancak hata yönetimini keşfetmek için ilk başta çoğunu manuel olarak yaparak başlayacağız; sonunda daha kısa olan yolu göstereceğiz. Önce fonksiyonun dönüş türüne bakalım: Result<String, io::Error>. Bu, fonksiyonun Result<T, E> türünde bir değer döndürdüğü, burada jenerik T parametresinin somut String türüyle doldurulduğu ve jenerik E türünün somut io::Error türüyle doldurulduğu anlamına gelir.

Eğer bu fonksiyon hiçbir problem yaşamadan başarılı olursa, bu fonksiyonu çağıran kod, bu fonksiyonun dosyadan okuduğu kullanici_adi String’ini barındıran bir Ok değeri alacaktır. Eğer bu fonksiyon herhangi bir problemle karşılaşırsa, çağıran kod problemlerin ne olduğuna dair daha fazla bilgi barındıran bir io::Error örneği içeren bir Err değeri alacaktır. Bu fonksiyonun dönüş türü olarak io::Error’ı seçtik çünkü bu, bu fonksiyonun gövdesinde çağırdığımız ve başarısız olabilecek işlemlerin her ikisinden ( File::open fonksiyonu ve read_to_string metodu) dönen hata değerinin türüdür.

Fonksiyonun gövdesi File::open fonksiyonunu çağırarak başlar. Ardından Result değerini Liste 9-4’teki match’e benzeyen bir match ile ele alırız. Eğer File::open başarılı olursa, desen (pattern) değişkeni olan dosya içindeki dosya tutucusu kullanici_adi_dosyasi adlı değiştirilebilir değişkendeki değer olur ve fonksiyon devam eder. Err durumunda, panic! çağırmak yerine fonksiyondan tamamen ve erkenden (early) çıkmak ve File::open’dan gelen, artık desen değişkeni e’de bulunan hata değerini bu fonksiyonun hata değeri olarak çağıran koda geri iletmek için return anahtar kelimesini kullanırız.

Yani, eğer kullanici_adi_dosyasi’nda bir dosya tutucumuz varsa, fonksiyon daha sonra kullanici_adi değişkeninde yeni bir String oluşturur ve dosyanın içeriğini kullanici_adi’na okumak için kullanici_adi_dosyasi’ndaki dosya tutucusu üzerinde read_to_string metodunu çağırır. File::open başarılı olmuş olsa bile read_to_string metodu da başarısız olabileceği için bir Result döndürür. Bu yüzden o Result’ı ele almak için başka bir match’e ihtiyacımız var: Eğer read_to_string başarılı olursa fonksiyonumuz da başarılı olmuş olur ve dosyadan alınan, şu an kullanici_adi değişkeninde bulunan kullanıcı adını bir Ok içine sararak döndürürüz. Eğer read_to_string başarısız olursa, File::open’ın dönüş değerini işleyen match’te hata değerini döndürdüğümüz gibi hata değerini döndürürüz. Ancak açıkça return dememize gerek yoktur, çünkü bu fonksiyondaki son ifadedir.

Bu kodu çağıran kod daha sonra bir kullanıcı adı içeren bir Ok değeri ya da bir io::Error içeren bir Err değeri almayı yönetecek hale gelecektir. Bu değerlerle ne yapılacağına karar vermek çağıran koda bağlıdır. Çağıran kod bir Err değeri alırsa, panic! çağırıp programı çökertebilir, varsayılan (default) bir kullanıcı adı kullanabilir veya kullanıcı adını dosya dışındaki başka bir yerden (örneğin) bulabilir. Çağıran kodun gerçekte ne yapmaya çalıştığı hakkında yeterli bilgiye sahip değiliz, bu yüzden tüm başarı veya hata bilgilerini uygun bir şekilde ele alınması için yukarı doğru iletiriz (propagate).

Hataları yayma (propagating errors) deseni Rust’ta o kadar yaygındır ki Rust bunu kolaylaştırmak için soru işareti (?) operatörünü sağlar.

? Operatörü Kısayolu

Liste 9-7, Liste 9-6’daki ile aynı işlevselliğe sahip olan ancak ? operatörünü kullanan bir dosyadan_kullanici_adini_oku uygulamasını gösterir.

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn dosyadan_kullanici_adini_oku() -> Result<String, io::Error> {
    let mut kullanici_adi_dosyasi = File::open("merhaba.txt")?;
    let mut kullanici_adi = String::new();
    kullanici_adi_dosyasi.read_to_string(&mut kullanici_adi)?;
    Ok(kullanici_adi)
}
}

Bir Result değerinin sonuna konan ?, Liste 9-6’daki Result değerlerini ele almak için tanımladığımız match ifadeleriyle neredeyse aynı şekilde çalışmak üzere tanımlanmıştır. Eğer Result değeri Ok ise, Ok içindeki değer bu ifadeden geri dönecek (get returned) ve program devam edecektir. Eğer değer bir Err ise, hata değerinin çağıran koda iletilmesi için return anahtar kelimesini kullanmışız gibi tüm fonksiyondan Err döndürülecektir.

Liste 9-6’daki match ifadesinin yaptığı ile ? operatörünün yaptığı arasında bir fark vardır: Üzerinde ? operatörü çağrılan hata değerleri, değerleri bir türden diğerine dönüştürmek için kullanılan ve standart kütüphanedeki From trait’inde tanımlı olan from fonksiyonundan geçer. ? operatörü from fonksiyonunu çağırdığında, alınan hata türü geçerli fonksiyonun dönüş türünde tanımlanan hata türüne dönüştürülür. Bu, kısımlar birçok farklı nedenle başarısız olabilse bile, bir fonksiyonun başarısız olabileceği tüm yolları temsil etmek üzere tek bir hata türü döndürdüğünde kullanışlıdır.

Örneğin, Liste 9-7’deki dosyadan_kullanici_adini_oku fonksiyonunu değiştirebilir ve kendi tanımladığımız OurError (BizimHatamiz) adında özel bir hata türünü döndürebiliriz. Eğer io::Error’dan bir OurError örneği oluşturmak için impl From<io::Error> for OurError tanımlarsak, o zaman dosyadan_kullanici_adini_oku fonksiyonunun gövdesindeki ? operatörü çağrıları, fonksiyona başka bir kod eklemeye gerek kalmadan from çağırıp hata türlerini dönüştürecektir.

Liste 9-7 bağlamında, File::open çağrısının sonundaki ?, Ok içindeki değeri kullanici_adi_dosyasi değişkenine döndürecektir. Eğer bir hata meydana gelirse, ? operatörü tüm fonksiyondan erken dönecek ve herhangi bir Err değerini çağıran koda verecektir. Aynı şey read_to_string çağrısının sonundaki ? için de geçerlidir.

? operatörü pek çok tekrarlayan (boilerplate) kodu ortadan kaldırır ve bu fonksiyonun uygulamasını daha basit hale getirir. Liste 9-8’de gösterildiği gibi metod çağrılarını hemen ? sonrasına zincirleyerek (chaining) bu kodu daha da kısaltabiliriz.

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn dosyadan_kullanici_adini_oku() -> Result<String, io::Error> {
    let mut kullanici_adi = String::new();

    File::open("merhaba.txt")?.read_to_string(&mut kullanici_adi)?;

    Ok(kullanici_adi)
}
}

kullanici_adi değişkenindeki yeni String’in oluşturulmasını fonksiyonun başına taşıdık; o kısım değişmedi. Bir kullanici_adi_dosyasi değişkeni oluşturmak yerine read_to_string çağrısını doğrudan File::open("merhaba.txt")? sonucuna zincirledik. read_to_string çağrısının sonunda hala bir ? var ve hem File::open hem de read_to_string başarılı olduğunda hataları döndürmek yerine hala kullanici_adi içeren bir Ok değeri döndürüyoruz. İşlevsellik Liste 9-6 ve Liste 9-7’deki ile yine aynıdır; bu sadece onu yazmanın farklı, daha ergonomik (ergonomic) bir yoludur.

Liste 9-9, fs::read_to_string kullanarak bunu daha da kısa yapmanın bir yolunu gösterir.

#![allow(unused)]
fn main() {
use std::fs;
use std::io;

fn dosyadan_kullanici_adini_oku() -> Result<String, io::Error> {
    fs::read_to_string("merhaba.txt")
}
}

Bir dosyayı bir string’in içine okumak oldukça yaygın bir işlem olduğundan, standart kütüphane dosyayı açan, yeni bir String oluşturan, dosyanın içeriğini okuyan, içerikleri o String içine koyan ve onu döndüren kullanışlı fs::read_to_string fonksiyonunu sağlar. Elbette fs::read_to_string kullanmak bize tüm hata yönetimini açıklama fırsatı vermez, bu yüzden ilk olarak uzun yolu tercih ettik.

? Operatörünün Nerelerde Kullanılabileceği

? operatörü yalnızca, dönüş türü ?’nin üzerinde kullanıldığı değer ile uyumlu (compatible) olan fonksiyonlarda kullanılabilir. Bunun nedeni, ? operatörünün Liste 9-6’da tanımladığımız match ifadesi ile aynı şekilde fonksiyondan değerin erken bir dönüşünü (early return) gerçekleştirecek şekilde tanımlanmış olmasıdır. Liste 9-6’da, match bir Result değeri kullanıyordu ve erken dönen kol bir Err(e) değeri döndürüyordu. Bu return ile uyumlu olması için fonksiyonun dönüş türünün bir Result olması gerekir.

Liste 9-10’da, ? operatörünü, ? kullandığımız değerin türüyle uyumsuz bir dönüş türüne sahip olan bir main fonksiyonunda kullandığımızda alacağımız hataya bakalım.

use std::fs::File;

fn main() {
    let karsilama_dosyasi = File::open("merhaba.txt")?;
}

Bu kod bir dosyayı açar ki bu da başarısız olabilir. ? operatörü, File::open tarafından döndürülen Result değerini takip eder, ancak bu main fonksiyonu Result değil () dönüş türüne sahiptir. Bu kodu derlediğimizde şu hata mesajını alırız:

$ cargo run
   Compiling hata-yonetimi v0.1.0 ($PROJE/listings/ch09-error-handling/listing-09-10)
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
 --> src/main.rs:4:54
  |
3 | fn main() {
  | --------- this function should return `Result` or `Option` to accept `?`
4 |     let karsilama_dosyasi = File::open("merhaba.txt")?;
  |                                                      ^ cannot use the `?` operator in a function that returns `()`
  |
help: consider adding return type
  |
3 ~ fn main() -> Result<(), Box<dyn std::error::Error>> {
4 |     let karsilama_dosyasi = File::open("merhaba.txt")?;
5 +     Ok(())
  |

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

Bu hata bize ? operatörünü yalnızca Result, Option veya FromResidual’ı uygulayan başka bir tür döndüren bir fonksiyonda kullanmaya iznimiz olduğuna işaret etmektedir.

Hatayı düzeltmek için iki seçeneğiniz var. Birincisi, sizi engelleyen bir kısıtlamanız olmadığı sürece, fonksiyonunuzun dönüş türünü ? operatörünü üzerinde kullandığınız değerle uyumlu olacak şekilde değiştirmektir. Diğer bir seçenek de, Result<T, E>’yi uygun olan herhangi bir şekilde ele almak için bir match veya Result<T, E> metodlarından birini kullanmaktır.

Hata mesajı ayrıca ?’nin Option<T> değerleri ile de kullanılabileceğinden bahsetmiştir. Tıpkı ?’yi Result’ta kullanırken olduğu gibi, ?’yi Option üzerinde yalnızca bir Option döndüren bir fonksiyonda kullanabilirsiniz. Bir Option<T> üzerinde çağrıldığında ? operatörünün davranışı, bir Result<T, E> üzerinde çağrıldığındaki davranışına benzerdir: Eğer değer None ise, None o noktada fonksiyondan erken döndürülecektir. Değer Some ise, Some içindeki değer ifadenin sonuç değeri olur ve fonksiyon devam eder. Liste 9-11’de verilen metindeki ilk satırın son karakterini bulan bir fonksiyona ait örnek bulunmaktadır.

fn ilk_satirin_son_karakteri(metin: &str) -> Option<char> {
    metin.lines().next()?.chars().last()
}

fn main() {
    assert_eq!(
        ilk_satirin_son_karakteri("Merhaba, dünya\nBugün nasılsın?"),
        Some('a')
    );

    assert_eq!(ilk_satirin_son_karakteri(""), None);
    assert_eq!(ilk_satirin_son_karakteri("\nmerhaba"), None);
}

Bu fonksiyon Option<char> döndürür, çünkü orada bir karakter olması da olmaması da mümkündür. Bu kod metin string dilimi argümanını alır ve üzerinde lines (satırlar) metodunu çağırır; bu da string içindeki satırlar üzerinde bir yineleyici döndürür. Bu fonksiyon ilk satırı incelemek istediği için yineleyiciden ilk değeri almak amacıyla yineleyici üzerinde next (sonraki) metodunu çağırır. metin boş bir string ise, bu next çağrısı None döndürecek ve bu durumda durdurup ilk_satirin_son_karakteri fonksiyonundan None dönmek için ? kullanırız. Eğer metin boş string değilse, next, metin içindeki ilk satırın bir string dilimini barındıran bir Some değeri döndürecektir.

? string dilimini dışarı çıkarır (extracts) ve o string diliminin karakterlerinin yineleyicisini almak için üzerinde chars (karakterler) çağırabiliriz. Bu ilk satırdaki son karakterle ilgileniyoruz, bu nedenle yineleyicideki son öğeyi döndürmesi için last (son) çağırıyoruz. Bu bir Option’dır, çünkü ilk satırın boş bir string olması mümkündür; örneğin "\nmerhaba" örneğinde olduğu gibi metin boş bir satırla başlayıp diğer satırlarda karakterlere sahipse. Ancak, eğer ilk satırda bir son karakter varsa bu Some varyantında döndürülecektir. Ortadaki ? operatörü, bu mantığı ifade etmenin özlü bir yolunu vererek fonksiyonu tek bir satırda uygulamamızı sağlar. Eğer ? operatörünü Option üzerinde kullanamasaydık, bu mantığı daha fazla metod çağrısı veya bir match ifadesi kullanarak uygulamak zorunda kalırdık.

? operatörünü Result döndüren bir fonksiyonda Result üzerinde, Option döndüren bir fonksiyonda ise Option üzerinde kullanabileceğinizi, ancak ikisini birbirine karıştırıp eşleştiremeyeceğinizi unutmayın. ? operatörü bir Result’ı otomatik olarak bir Option’a ya da tam tersine dönüştürmez; bu durumlarda, dönüştürme işlemini açıkça yapmak için Result üzerindeki ok metodu ya da Option üzerindeki ok_or metodu gibi metodları kullanabilirsiniz.

Şimdiye kadar kullandığımız tüm main fonksiyonları () döndürdü. main fonksiyonu, yürütülebilir (executable) bir programın giriş (entry) ve çıkış noktası olması nedeniyle özeldir ve programın beklendiği gibi davranabilmesi için dönüş türünün ne olabileceğine dair kısıtlamalar vardır.

Neyse ki, main aynı zamanda bir Result<(), E> de döndürebilir. Liste 9-12, Liste 9-10’daki kodu barındırır, ancak main fonksiyonunun dönüş türünü Result<(), Box<dyn Error>> olarak değiştirdik ve sonuna Ok(()) dönüş değeri ekledik. Bu kod artık derlenecektir.

use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
    let karsilama_dosyasi = File::open("merhaba.txt")?;

    Ok(())
}

Box<dyn Error> türü bir trait nesnesidir, bu konudan Bölüm 18’deki “Paylaşılan Davranış Üzerinden Soyutlama Yapmak İçin Trait Nesneleri Kullanmak” kısmında bahsedeceğiz. Şimdilik, Box<dyn Error> türünü “herhangi bir hata türü” anlamında okuyabilirsiniz. Box<dyn Error> hata türüne sahip bir main fonksiyonunda Result değeri üzerinde ? kullanımına izin verilir, çünkü herhangi bir Err değerinin erken döndürülmesini mümkün kılar. Bu main fonksiyonunun gövdesi sadece std::io::Error türünde hatalar döndürecek olsa da, Box<dyn Error> belirtmek suretiyle bu imza main gövdesine diğer hataları döndüren başka kodlar eklense dahi doğru kalmaya devam edecektir.

Bir main fonksiyonu Result<(), E> döndürdüğünde yürütülebilir dosya (executable), main Ok(()) döndürürse 0 değeriyle çıkış yapar, main bir Err değeri döndürürse sıfır olmayan bir değerle çıkış yapar. C ile yazılmış yürütülebilir dosyalar çıkarken tamsayılar döndürürler: Başarıyla çıkan programlar 0 tamsayısını, hatalı olanlar ise 0’dan farklı bir tamsayıyı döndürür. Rust da bu kuralla uyumlu olması adına yürütülebilir dosyalardan tamsayılar döndürür.

main fonksiyonu bir ExitCode döndüren report (rapor) fonksiyonunu içeren std::process::Termination trait’ini uygulayan tüm türleri döndürebilir. Kendi türleriniz için Termination trait’ini uygulamak hakkında daha fazla bilgi edinmek için standart kütüphane dokümanlarına başvurun.

Artık panic! çağırmanın veya Result döndürmenin detaylarını tartışmış olduğumuza göre, hangi durumlarda hangisinin uygun olduğuna nasıl karar vereceğimiz konusuna geri dönelim.

panic! Yapmalı mı Yapmamalı mı?

panic! Yapmalı mı Yapmamalı mı?

Peki ne zaman panic! çağırmanız ve ne zaman Result döndürmeniz gerektiğine nasıl karar verirsiniz? Kod panik yaptığında kurtarmanın bir yolu yoktur. Kurtarmanın mümkün bir yolu olsun ya da olmasın, herhangi bir hata durumu için panic! çağırabilirsiniz, ancak bu durumda çağıran kod adına bir durumun kurtarılamaz olduğuna karar vermiş olursunuz. Bir Result değeri döndürmeyi seçtiğinizde, çağıran koda seçenekler sunarsınız. Çağıran kod kendi durumuna uygun bir şekilde kurtarmaya çalışmayı seçebilir veya bu durumda bir Err değerinin kurtarılamaz olduğuna karar verebilir, böylece o da panic! çağırarak kurtarılabilir hatanızı kurtarılamaz bir hataya dönüştürebilir. Bu nedenle, başarısız olabilecek bir fonksiyon tanımlarken varsayılan olarak Result döndürmek iyi bir seçimdir.

Örnekler, prototip kodları ve testler gibi durumlarda, Result döndürmek yerine panik yapan kodlar yazmak daha uygundur. Gelin bunun nedenini inceleyelim ve daha sonra derleyicinin başarısızlığın imkansız olduğunu anlayamadığı ama bir insan olarak sizin anlayabildiğiniz durumları tartışalım. Bu bölüm, kütüphane kodlarında (library code) panik yapıp yapmamaya nasıl karar verileceğine dair bazı genel yönergeler ile sona erecektir.

Örnekler, Prototip Kodu ve Testler

Bazı kavramları açıklamak için bir örnek yazarken sağlam bir hata yönetimi kodunu (hata-yonetimi code) da dahil etmek örneği daha az anlaşılır hale getirebilir. Örneklerde, unwrap gibi panikleyebilen bir metoda yapılan çağrının, kodunuzun geri kalanının ne yaptığına bağlı olarak değişebilecek şekilde uygulamanızın hataları ele alma biçimi için bir yer tutucu olduğu anlaşılır.

Benzer şekilde, prototip oluştururken ve hataları nasıl ele alacağınıza karar vermeye henüz hazır olmadığınızda unwrap ve expect metodları çok kullanışlıdır. Programınızı daha sağlam hale getirmeye hazır olduğunuz zamanlar için kodunuzda net işaretler bırakırlar.

Eğer bir testte bir metot çağrısı başarısız olursa, test edilen işlevsellik o metod olmasa bile tüm testin başarısız olmasını istersiniz. Bir testin başarısızlık olarak işaretlenmesinin yolu panic! olduğundan, unwrap veya expect çağırmak tam olarak gerçekleşmesi gereken şeydir.

Derleyiciden Daha Fazla Bilgiye Sahip Olduğunuz Durumlar

Result’ın bir Ok değerine sahip olmasını sağlayan başka bir mantığınız olduğunda, ancak bu mantık derleyicinin anlayabileceği bir şey olmadığında da expect çağırmak uygun olacaktır. Yine de ele almanız gereken bir Result değerine sahip olursunuz: Çağırdığınız işlem, sizin özel durumunuzda mantıksal olarak imkansız olsa bile genel olarak başarısız olma olasılığını hala taşır. Kodu manuel olarak inceleyerek hiçbir zaman bir Err varyantına sahip olmayacağınızdan emin olabiliyorsanız, expect çağırmak ve argüman metninde hiçbir zaman bir Err varyantına sahip olmayacağınızı düşünme nedeninizi belgelemek son derece kabul edilebilirdir. İşte bir örnek:

fn main() {
    use std::net::IpAddr;

    let ev: IpAddr = "127.0.0.1"
        .parse()
        .expect("Sabit kodlanmış IP adresi geçerli olmalıdır");
}

Sabit kodlanmış bir string’i ayrıştırarak bir IpAddr örneği oluşturuyoruz. 127.0.0.1’in geçerli bir IP adresi olduğunu görebiliriz, bu yüzden burada expect kullanmak kabul edilebilirdir. Ancak, sabit kodlanmış, geçerli bir string’e sahip olmak parse metodunun dönüş türünü değiştirmez: Yine de bir Result değeri alırız ve derleyici bu string’in her zaman geçerli bir IP adresi olduğunu görecek kadar akıllı olmadığı için, Err varyantı bir olasılıkmış gibi derleyici bizi yine de Result’ı ele almaya zorlayacaktır. Eğer IP adresi string’i programa sabit kodlanmış olmak yerine bir kullanıcıdan gelseydi ve dolayısıyla başarısız olma ihtimali olsaydı, Result’ı kesinlikle daha sağlam bir şekilde ele almak isterdik. Bu IP adresinin sabit kodlanmış olduğu varsayımından bahsetmek, gelecekte IP adresini başka bir kaynaktan almamız gerekirse expect’i daha iyi bir hata yönetimi (hata-yonetimi) koduyla değiştirmemizi sağlayacaktır.

Hata Yönetimi Yönergeleri

Kodunuzun kötü bir duruma düşmesi muhtemelse kodunuzun panik yapması tavsiye edilir. Bu bağlamda kötü durum, kodunuza geçersiz değerler, çelişkili değerler veya eksik değerler geçildiğinde olduğu gibi bazı varsayımların, garantilerin, sözleşmelerin veya değişmezlerin ihlal edilmesidir; ayrıca bunlara ek olarak aşağıdakilerden biri veya daha fazlasıdır:

• Kötü durum, bir kullanıcının verileri yanlış formatta girmesi gibi zaman zaman gerçekleşmesi muhtemel olan bir şeyin aksine beklenmeyen bir şeydir.
• Bu noktadan sonraki kodunuz, sorunu her adımda kontrol etmek yerine bu kötü durumda olmamaya güvenmek zorundadır.
• Bu bilgiyi kullandığınız türlerde kodlamanın iyi bir yolu yoktur. Ne demek istediğimize dair bir örneği Bölüm 18’deki “Durumları ve Davranışları Türler Olarak Kodlamak” kısmında işleyeceğiz.

Eğer biri kodunuzu çağırır ve mantıklı olmayan değerler verirse, yapabiliyorsanız bir hata döndürmek en iyisidir, böylece kütüphane kullanıcısı bu durumda ne yapmak istediğine karar verebilir. Ancak, devam etmenin güvensiz veya zararlı olabileceği durumlarda, en iyi seçenek panic! çağırmak ve kütüphanenizi kullanan kişiyi kodundaki hata konusunda uyararak geliştirme sırasında düzeltmelerini sağlamak olabilir. Benzer şekilde, kontrolünüz dışında olan ve düzeltmenin hiçbir yolu olmayan geçersiz bir durum döndüren dış bir kodu çağırıyorsanız genellikle panic! uygundur.

Bununla birlikte, başarısızlık bekleniyorsa, Result döndürmek bir panic! çağrısı yapmaktan daha uygundur. Örnekler arasında bir ayrıştırıcıya hatalı biçimlendirilmiş veriler verilmesi veya bir HTTP isteğinin hız sınırına ulaştığınızı belirten bir durum döndürmesi yer alır. Bu durumlarda Result döndürmek, başarısızlığın, çağıran kodun nasıl ele alacağına karar vermesi gereken beklenen bir olasılık olduğunu gösterir.

Kodunuz, geçersiz değerler kullanılarak çağrıldığında kullanıcıyı riske atabilecek bir işlem gerçekleştirdiğinde, kodunuz önce değerlerin geçerli olduğunu doğrulamalı ve değerler geçerli değilse panik yapmalıdır. Bu çoğunlukla güvenlik nedeniyledir: Geçersiz veriler üzerinde çalışmaya kalkışmak, kodunuzu güvenlik açıklarına maruz bırakabilir. Bir sınırların dışında bellek erişimi girişiminde bulunursanız standart kütüphanenin panic! çağırmasının ana nedeni budur: Mevcut veri yapısına ait olmayan bir belleğe erişmeye çalışmak yaygın bir güvenlik problemidir. Fonksiyonların genellikle sözleşmeleri vardır: Davranışları yalnızca girdiler belirli gereksinimleri karşıladığında garanti edilir. Sözleşme ihlal edildiğinde panik yapmak mantıklıdır, çünkü bir sözleşme ihlali her zaman çağıran taraftaki bir hatayı gösterir ve bu çağıran kodun açıkça ele almasını isteyeceğiniz bir hata türü değildir. Aslında, çağıran kodun kurtulması için mantıklı bir yol yoktur; çağıran programcıların kodu düzeltmesi gerekir. Bir fonksiyona ait sözleşmeler, özellikle de bir ihlalin paniğe neden olacağı durumlarda, fonksiyonun API dokümantasyonunda açıklanmalıdır.

Ancak, tüm fonksiyonlarınızda çok sayıda hata kontrolüne sahip olmak uzun, ayrıntılı ve can sıkıcı olacaktır. Neyse ki kontrollerin birçoğunu sizin yerinize yapması için Rust’ın tür sistemini ve dolayısıyla derleyici tarafından yapılan tür denetimini kullanabilirsiniz. Eğer fonksiyonunuz parametre olarak belirli bir türe sahipse, derleyicinin zaten geçerli bir değere sahip olduğunuzdan emin olduğunu bilerek kodunuzun mantığıyla ilerleyebilirsiniz. Örneğin, Option yerine bir türünüz varsa, programınız hiçbir şey yerine bir şeye sahip olmayı bekler. Bu durumda kodunuzun Some ve None varyantları için iki durumu ele alması gerekmez: Sadece kesinlikle bir değere sahip olmak için tek bir durumu olacaktır. Fonksiyonunuza hiçbir şey iletmeye çalışan kod derlenmeyecektir bile, bu nedenle fonksiyonunuzun çalışma zamanında bu durumu kontrol etmesi gerekmez. Başka bir örnek, parametrenin asla negatif olmadığından emin olmak için u32 gibi işaretsiz bir tamsayı türü kullanmaktır.

Doğrulama (Validation) İçin Özel Türler (Custom Types)

Geçerli bir değere sahip olduğumuzdan emin olmak için Rust’ın tür sistemini kullanma fikrini bir adım öteye taşıyalım ve doğrulama için özel bir tür oluşturmaya bakalım. Bölüm 2’deki, kodumuzun kullanıcıdan 1 ile 100 arasında bir sayıyı tahmin etmesini istediği tahmin oyununu hatırlayın. Kullanıcının tahminini gizli sayımızla karşılaştırmadan önce bu sayılar arasında olduğunu hiçbir zaman doğrulamadık; sadece tahminin pozitif olduğunu doğruladık. Bu durumda sonuçlar çok vahim değildi: “Çok büyük” veya “Çok küçük” şeklindeki çıktılarımız hala doğru olurdu. Ancak kullanıcıyı geçerli tahminlere yönlendirmek ve kullanıcının aralık dışında bir sayı tahmin etmesi ile (örneğin) harf yazması durumlarında farklı davranışlara sahip olmak kullanışlı bir geliştirme olurdu.

Bunu yapmanın bir yolu, potansiyel olarak negatif sayılara izin vermek için tahmini sadece u32 yerine i32 olarak ayrıştırmak ve ardından sayının aralıkta olması için şöyle bir kontrol eklemek olabilir:

use rand::Rng;
use std::cmp::Ordering;
use std::io;

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

    let gizli_sayi = rand::thread_rng().gen_range(1..=100);

    loop {
        // --snip--

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

        let mut tahmin = String::new();

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

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

        if tahmin < 1 || tahmin > 100 {
            println!("Gizli sayı 1 ile 100 arasında olacak.");
            continue;
        }

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

if ifadesi değerimizin aralığın dışında olup olmadığını kontrol eder, kullanıcıya sorunu bildirir ve döngünün bir sonraki yinelemesini başlatmak ve başka bir tahmin istemek için continue çağırır. if ifadesinden sonra, tahmin’in 1 ile 100 arasında olduğunu bilerek tahmin ve gizli sayı arasındaki karşılaştırmalara devam edebiliriz.

Ancak bu ideal bir çözüm değildir: Eğer programın sadece 1 ile 100 arasındaki değerler üzerinde çalışması kesinlikle kritikse ve bu gerekliliğe sahip birçok fonksiyonu varsa, her fonksiyonda böyle bir kontrole sahip olmak sıkıcı olur (ve performansı etkileyebilir).

Bunun yerine, doğrulamaları her yerde tekrarlamak yerine tahsis edilmiş bir modülde yeni bir tür yapabilir ve türün bir örneğini oluşturmak için doğrulamaları bir fonksiyona koyabiliriz. Bu sayede, fonksiyonların imzalarında yeni türü kullanmaları ve aldıkları değerleri güvenle kullanmaları güvenli olur. Liste 9-13, yalnızca new (yeni) fonksiyonu 1 ile 100 arasında bir değer alırsa bir Tahmin (Guess) örneği oluşturacak bir Tahmin türünü tanımlamanın bir yolunu gösterir.

#![allow(unused)]
fn main() {
pub struct Tahmin {
    deger: i32,
}

impl Tahmin {
    pub fn new(deger: i32) -> Tahmin {
        if deger < 1 || deger > 100 {
            panic!(
                "Tahmin değeri 1 ile 100 arasında olmalıdır, {deger} alındı."
            );
        }

        Tahmin { deger }
    }

    pub fn deger(&self) -> i32 {
        self.deger
    }
}
}

src/tahmin_oyunu.rs dosyasındaki bu kodun, src/lib.rs dosyasına (burada göstermediğimiz) mod tahmin_oyunu; modül beyanının eklenmesine bağlı olduğunu unutmayın. Bu yeni modülün dosyası içinde, i32 tutan deger (value) adında bir alana sahip Tahmin adında bir struct (yapı) tanımlıyoruz. Sayının depolanacağı yer burasıdır.

Daha sonra, Tahmin üzerinde Tahmin değerlerinin örneklerini oluşturan new (yeni) adında ilişkili bir fonksiyon (associated function) uygularız. new fonksiyonu, i32 türünde deger (value) adında bir parametreye sahip olacak ve bir Tahmin döndürecek şekilde tanımlanmıştır. new fonksiyonunun gövdesindeki kod, deger’in 1 ile 100 arasında olduğundan emin olmak için onu test eder. Eğer deger bu testten geçemezse, bir panic! çağrısı yaparız ki bu da çağıran kodu yazan programcıyı düzeltmesi gereken bir hata olduğu konusunda uyarır, çünkü bu aralığın dışında bir deger ile bir Tahmin oluşturmak, Tahmin::new’in güvendiği sözleşmeyi ihlal edecektir. Tahmin::new’in panikleyebileceği koşullar herkese açık (public-facing) API dokümantasyonunda tartışılmalıdır; oluşturduğunuz API dokümantasyonunda panic! olasılığını belirten belgeleme kurallarını (documentation conventions) Bölüm 14’te ele alacağız. Eğer deger testi geçerse, deger alanı deger parametresine ayarlanmış yeni bir Tahmin yaratırız ve Tahmin’i döndürürüz.

Ardından, self’i ödünç alan, başka parametresi olmayan ve bir i32 döndüren deger (value) adında bir metot uygularız. Bu tür metotlara bazen alıcı denir çünkü amacı alanlarından (fields) bazı verileri almak ve onu döndürmektir. Bu açık metod gereklidir çünkü Tahmin yapısının (struct) deger alanı gizlidir. Tahmin yapısını kullanan kodun doğrudan deger’i ayarlamasına izin verilmemesi için deger alanının gizli olması önemlidir: tahmin_oyunu modülü dışındaki kod, bir Tahmin örneği oluşturmak için Tahmin::new fonksiyonunu kullanmak zorundadır, böylece bir Tahmin’in, Tahmin::new fonksiyonundaki koşullar tarafından kontrol edilmemiş bir deger’e sahip olmasının hiçbir yolu olmadığından emin olunur.

Böylece yalnızca 1 ile 100 arasındaki sayıları parametre alan veya döndüren bir fonksiyon, imzasında bir i32 yerine bir Tahmin aldığını veya döndürdüğünü bildirebilir ve gövdesinde herhangi bir ek doğrulama yapmasına gerek kalmaz.

Özet

Rust’ın hata yönetimi (hata-yonetimi) özellikleri daha sağlam kodlar yazmanıza yardımcı olmak için tasarlanmıştır. panic! makrosu, programınızın başa çıkamayacağı bir durumda olduğunu belirtir ve geçersiz veya yanlış değerlerle ilerlemeye çalışmak yerine sürece durmasını söylemenize olanak tanır. Result enum’ı, işlemlerin kodunuzun kurtarabileceği bir şekilde başarısız olabileceğini belirtmek için Rust’ın tür sistemini kullanır. Sizin kodunuzu çağıran koda, potansiyel başarıyı ya da başarısızlığı ele alması gerektiğini bildirmek için Result’ı kullanabilirsiniz. panic! ve Result’ı uygun durumlarda kullanmak kodunuzu kaçınılmaz problemler karşısında daha güvenilir hale getirecektir.

Artık standart kütüphanenin jenerikleri Option ve Result enum’larıyla kullanmasının kullanışlı yollarını gördüğünüze göre, jeneriklerin nasıl çalıştığı ve onları kodunuzda nasıl kullanabileceğiniz hakkında konuşacağız.

Jenerik Türler, Traitler ve Ömürler

Her programlama dili, kavramların tekrarını etkin bir şekilde ele almak için araçlara sahiptir. Rust’ta bu araçlardan biri jeneriklerdir: somut türler veya diğer özellikler için soyut yedeklerdir. Kod derlenip çalıştırılırken yerlerinde ne olacağını bilmeden jeneriklerin davranışını veya diğer jeneriklerle nasıl ilişki kurduklarını ifade edebiliriz.

Fonksiyonlar, i32 veya String gibi somut bir tür yerine bir tür jenerik türe ait parametreler alabilir; tıpkı aynı kodu birden fazla somut değer üzerinde çalıştırmak için bilinmeyen değerlere sahip parametreler aldıkları gibi. Aslında, Bölüm 6’da Option<T> ile, Bölüm 8’de Vec<T> ve HashMap<K, V> ile ve Bölüm 9’da Result<T, E> ile jenerikleri zaten kullandık. Bu bölümde, kendi türlerinizi, fonksiyonlarınızı ve metotlarınızı jeneriklerle nasıl tanımlayacağınızı keşfedeceksiniz!

Önce kod tekrarını azaltmak için bir fonksiyonun nasıl çıkarılacağını gözden geçireceğiz. Ardından, yalnızca parametrelerinin türleri bakımından farklılık gösteren iki fonksiyondan jenerik bir fonksiyon oluşturmak için aynı tekniği kullanacağız. Ayrıca struct ve enum tanımlarında jenerik türlerin nasıl kullanılacağını açıklayacağız.

Daha sonra, davranışı jenerik bir şekilde tanımlamak için traitleri nasıl kullanacağınızı öğreneceksiniz. Herhangi bir tür yerine, yalnızca belirli bir davranışa sahip türleri kabul etmesi adına bir jenerik türü kısıtlamak için traitleri jenerik türlerle birleştirebilirsiniz.

Son olarak, derleyiciye referansların birbiriyle nasıl ilişki kurduğu hakkında bilgi veren bir çeşit jenerik olan ömürleri tartışacağız. Ömürler, ödünç alınan değerler hakkında derleyiciye yeterli bilgi vermemizi sağlar, böylece referansların bizim yardımımız olmadan olabileceğinden daha fazla durumda geçerli kalacağından emin olabilir.

Bir Fonksiyonu Çıkararak Tekrarlamayı Kaldırmak

Jenerikler, kod tekrarını kaldırmak için belirli türleri birden fazla türü temsil eden bir yer tutucuyla değiştirmemizi sağlar. Jenerik sözdizimine dalmadan önce, belirli değerleri birden fazla değeri temsil eden bir yer tutucuyla değiştiren bir fonksiyon çıkararak jenerik türleri içermeyen bir şekilde tekrarı nasıl kaldıracağımıza bakalım. Sonra, jenerik bir fonksiyonu çıkarmak için aynı tekniği uygulayacağız! Bir fonksiyona çıkarabileceğiniz tekrarlayan kodu nasıl tanıyacağınızı görerek, jenerikleri kullanabilecek tekrarlayan kodları tanımaya başlayacaksınız.

Bir listedeki en büyük sayıyı bulan, Liste 10-1’deki kısa programla başlayacağız.

fn main() {
    let sayi_listesi = vec![34, 50, 25, 100, 65];

    let mut en_buyuk = &sayi_listesi[0];

    for sayi in &sayi_listesi {
        if sayi > en_buyuk {
            en_buyuk = sayi;
        }
    }

    println!("En büyük sayı: {en_buyuk}");
    assert_eq!(*en_buyuk, 100);
}

sayi_listesi değişkeninde bir tamsayı listesi saklıyoruz ve listedeki ilk sayının referansını en_buyuk adlı bir değişkene yerleştiriyoruz. Ardından listedeki tüm sayılar üzerinde yineleme yapıyoruz ve eğer o anki sayı en_buyuk içinde depolanan sayıdan daha büyükse o değişkendeki referansı değiştiriyoruz. Ancak, o anki sayı şimdiye kadar görülen en büyük sayıdan küçük veya ona eşitse değişken değişmez ve kod listedeki bir sonraki sayıya geçer. Listedeki tüm sayıları değerlendirdikten sonra, en_buyuk en büyük sayıya referans vermelidir, bu örnekte o da 100’dür.

Şimdi iki farklı sayı listesindeki en büyük sayıyı bulmakla görevlendirildik. Bunu yapmak için, Liste 10-2’de gösterildiği gibi Liste 10-1’deki kodu kopyalamayı ve aynı mantığı programın iki farklı yerinde kullanmayı seçebiliriz.

fn main() {
    let sayi_listesi = vec![34, 50, 25, 100, 65];

    let mut en_buyuk = &sayi_listesi[0];

    for sayi in &sayi_listesi {
        if sayi > en_buyuk {
            en_buyuk = sayi;
        }
    }

    println!("En büyük sayı: {en_buyuk}");

    let sayi_listesi = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let mut en_buyuk = &sayi_listesi[0];

    for sayi in &sayi_listesi {
        if sayi > en_buyuk {
            en_buyuk = sayi;
        }
    }

    println!("En büyük sayı: {en_buyuk}");
}

Bu kod çalışmasına rağmen, kodu kopyalamak yorucu ve hataya açıktır. Ayrıca, kodu değiştirmek istediğimizde birden fazla yerde güncellemeyi de unutmamalıyız.

Bu tekrarı ortadan kaldırmak için, parametre olarak aktarılan herhangi bir tamsayı listesi üzerinde çalışan bir fonksiyon tanımlayarak bir soyutlama oluşturacağız. Bu çözüm kodumuzu daha açık hale getirir ve bir listedeki en büyük sayıyı bulma kavramını soyut bir şekilde ifade etmemizi sağlar.

Liste 10-3’te, en büyük sayıyı bulan kodu en_buyuk_bul adlı bir fonksiyona çıkarıyoruz. Ardından Liste 10-2’deki iki listedeki en büyük sayıyı bulmak için fonksiyonu çağırıyoruz. Bu fonksiyonu gelecekte sahip olabileceğimiz diğer herhangi bir i32 değer listesinde de kullanabiliriz.

fn en_buyuk_bul(liste: &[i32]) -> &i32 {
    let mut en_buyuk = &liste[0];

    for oge in liste {
        if oge > en_buyuk {
            en_buyuk = oge;
        }
    }

    en_buyuk
}

fn main() {
    let sayi_listesi = vec![34, 50, 25, 100, 65];

    let sonuc = en_buyuk_bul(&sayi_listesi);
    println!("En büyük sayı: {sonuc}");
    assert_eq!(*sonuc, 100);

    let sayi_listesi = vec![102, 34, 6000, 89, 54, 2, 43, 8];

    let sonuc = en_buyuk_bul(&sayi_listesi);
    println!("En büyük sayı: {sonuc}");
    assert_eq!(*sonuc, 6000);
}

en_buyuk_bul fonksiyonu, fonksiyona aktarabileceğimiz herhangi bir somut i32 değer dilimini temsil eden liste adında bir parametreye sahiptir. Sonuç olarak, fonksiyonu çağırdığımızda, kod aktardığımız belirli değerler üzerinde çalışır.

Özetle, Liste 10-2’deki kodu Liste 10-3’e dönüştürmek için attığımız adımlar şunlardır:

1. Tekrarlanan kodu belirleyin.
2. Tekrarlanan kodu fonksiyonun gövdesine çıkarın ve o kodun girdilerini ve dönüş değerlerini fonksiyon imzasında belirtin.
3. Bunun yerine fonksiyonu çağırmak için tekrarlanan kodun iki örneğini güncelleyin.

Sırada, kod tekrarını azaltmak için aynı adımları jeneriklerle kullanacağız. Fonksiyon gövdesinin belirli değerler yerine soyut bir liste üzerinde çalışabilmesi gibi, jenerikler de kodun soyut türler üzerinde çalışmasına izin verir.

Örneğin, iki fonksiyonumuz olduğunu varsayalım: biri i32 değerlerinden oluşan bir dilimdeki en büyük öğeyi, diğeri ise char değerlerinden oluşan bir dilimdeki en büyük öğeyi bulan bir fonksiyon. Bu tekrarı nasıl ortadan kaldırırdık? Hadi öğrenelim!

Jenerik Veri Türleri

Jenerik Veri Türleri

Fonksiyon imzaları veya struct’lar (yapılar) gibi öğeler için tanımlamalar oluşturmak amacıyla jenerikleri kullanırız, bunları daha sonra birçok farklı somut veri türüyle kullanabiliriz. İlk olarak jenerikleri kullanarak fonksiyonları, struct’ları, enum’ları ve metotları nasıl tanımlayacağımıza bakalım. Sonra jeneriklerin kod performansını nasıl etkilediğini tartışacağız.

Fonksiyon Tanımlarında

Jenerik kullanan bir fonksiyon tanımlarken, jenerikleri genellikle parametrelerin ve dönüş değerinin veri türlerini belirteceğimiz yere, yani fonksiyonun imzasına yerleştiririz. Bunu yapmak kodumuzu daha esnek hale getirir ve kod tekrarını engellerken fonksiyonumuzu çağıranlara daha fazla işlevsellik sağlar.

en_buyuk fonksiyonumuza devam edersek, Liste 10-4 her ikisi de bir dilimdeki en büyük değeri bulan iki fonksiyon göstermektedir. Daha sonra bunları jenerik kullanan tek bir fonksiyonda birleştireceğiz.

fn en_buyuk_i32(liste: &[i32]) -> &i32 {
    let mut en_buyuk = &liste[0];

    for oge in liste {
        if oge > en_buyuk {
            en_buyuk = oge;
        }
    }

    en_buyuk
}

fn en_buyuk_char(liste: &[char]) -> &char {
    let mut en_buyuk = &liste[0];

    for oge in liste {
        if oge > en_buyuk {
            en_buyuk = oge;
        }
    }

    en_buyuk
}

fn main() {
    let sayi_listesi = vec![34, 50, 25, 100, 65];

    let sonuc = en_buyuk_i32(&sayi_listesi);
    println!("En büyük sayı: {sonuc}");
    assert_eq!(*sonuc, 100);

    let karakter_listesi = vec!['y', 'm', 'a', 'q'];

    let sonuc = en_buyuk_char(&karakter_listesi);
    println!("En büyük karakter: {sonuc}");
    assert_eq!(*sonuc, 'y');
}

en_buyuk_i32 fonksiyonu Liste 10-3’te çıkardığımız ve bir dilimdeki en büyük i32’yi bulan fonksiyondur. en_buyuk_char fonksiyonu ise bir dilimdeki en büyük char değerini bulur. Fonksiyon gövdeleri aynı koda sahiptir, bu yüzden tek bir fonksiyona jenerik bir tür parametresi dahil ederek bu tekrarı ortadan kaldıralım.

Yeni, tek bir fonksiyondaki türleri parametre haline getirmek için tıpkı bir fonksiyona geçirilen değer parametrelerinde yaptığımız gibi tür parametresini isimlendirmemiz gerekir. Bir tür parametresi adı olarak herhangi bir tanımlayıcı kullanabilirsiniz. Ancak biz T kullanacağız çünkü kural olarak, Rust’taki tür parametresi adları kısadır (genellikle tek bir harf) ve Rust’ın tür adlandırma kuralı UpperCamelCase (BüyükDeveHali) şeklindedir. Türün (Type) kısaltması olan T, çoğu Rust programcısının varsayılan seçimidir.

Fonksiyonun gövdesinde bir parametre kullandığımızda, derleyicinin bu adın ne anlama geldiğini bilmesi için imzaya parametre adını bildirmemiz gerekir. Benzer şekilde, bir fonksiyon imzasında bir tür parametresi adı kullandığımızda, kullanmadan önce tür parametresi adını bildirmemiz gerekir. Jenerik en_buyuk fonksiyonunu tanımlamak için tür adı tanımlarını fonksiyon adı ve parametre listesi arasına açılı ayraçlar (angle brackets, <>) içine yerleştiririz, tıpkı bunun gibi:

fn en_buyuk_bul<T>(liste: &[T]) -> &T {

Bu tanımı “en_buyuk_bul fonksiyonu T türü üzerinde jeneriktir” olarak okuruz. Bu fonksiyonun, T türündeki değerlerden oluşan bir dilim olan liste adında bir parametresi vardır. en_buyuk_bul fonksiyonu aynı T türünde bir değere referans döndürecektir.

Liste 10-5, imzasında jenerik veri türünü kullanan birleştirilmiş en_buyuk_bul fonksiyon tanımını gösterir. Liste ayrıca fonksiyonu bir i32 değer dilimiyle veya char değer dilimiyle nasıl çağırabileceğimizi de gösterir. Bu kodun henüz derlenmeyeceğini unutmayın.

fn en_buyuk_bul<T>(liste: &[T]) -> &T {
    let mut en_buyuk = &liste[0];

    for oge in liste {
        if oge > en_buyuk {
            en_buyuk = oge;
        }
    }

    en_buyuk
}

fn main() {
    let sayi_listesi = vec![34, 50, 25, 100, 65];

    let sonuc = en_buyuk_bul(&sayi_listesi);
    println!("En büyük sayı: {sonuc}");

    let karakter_listesi = vec!['y', 'm', 'a', 'q'];

    let sonuc = en_buyuk_bul(&karakter_listesi);
    println!("En büyük karakter: {sonuc}");
}

Bu kodu şu anda derlersek şu hatayı alırız:

$ cargo run
   Compiling bolum10 v0.1.0 ($PROJE/listings/ch10-generic-types-traits-and-lifetimes/listing-10-05)
error[E0369]: binary operation `>` cannot be applied to type `&T`
 --> src/main.rs:5:16
  |
5 |         if oge > en_buyuk {
  |            --- ^ -------- &T
  |            |
  |            &T
  |
help: consider restricting type parameter `T` with trait `PartialOrd`
  |
1 | fn en_buyuk_bul<T: std::cmp::PartialOrd>(liste: &[T]) -> &T {
  |                  ++++++++++++++++++++++

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

Yardım metni bir trait olan std::cmp::PartialOrd’dan bahsediyor ve bir sonraki bölümde traitler hakkında konuşacağız. Şimdilik bu hatanın, en_buyuk_bul gövdesinin T’nin olabileceği olası tüm türler için çalışmayacağını ifade ettiğini bilin. Gövdede T türündeki değerleri karşılaştırmak istediğimizden, yalnızca değerleri sıralanabilen türleri kullanabiliriz. Karşılaştırmaları mümkün kılmak için standart kütüphane, türler üzerine uygulayabileceğiniz std::cmp::PartialOrd trait’ine sahiptir (bu trait hakkında daha fazla bilgi için Ek C’ye bakın). Liste 10-5’i düzeltmek için yardım metninin önerisini izleyebilir ve T için geçerli olan türleri yalnızca PartialOrd uygulayanlarla kısıtlayabiliriz. Standart kütüphane hem i32 hem de char üzerinde PartialOrd uyguladığı için liste o zaman derlenecektir.

Struct (Yapı) Tanımlarında

Ayrıca bir veya daha fazla alanda <> sözdizimini kullanarak jenerik tür parametresi kullanmak için struct’lar tanımlayabiliriz. Liste 10-6 herhangi bir türden x ve y koordinat değerlerini tutmak için bir Nokta<T> struct’ı tanımlar.

struct Nokta<T> {
    x: T,
    y: T,
}

fn main() {
    let tamsayi = Nokta { x: 5, y: 10 };
    let ondalikli = Nokta { x: 1.0, y: 4.0 };
}

Struct tanımlarında jenerik kullanma sözdizimi, fonksiyon tanımlarında kullanılana benzer. İlk olarak struct isminin hemen arkasında açılı ayraçlar içinde tür parametresinin ismini tanımlıyoruz. Daha sonra struct tanımında normalde somut veri türlerini belirteceğimiz yerlerde jenerik türü kullanıyoruz.

Nokta<T>’yi tanımlamak için sadece bir jenerik tür kullandığımızdan, bu tanımın Nokta<T> yapısının bir T türü üzerinde jenerik olduğunu ve x ve y alanlarının ikisinin de aynı türden olduğunu söylediğine dikkat edin (bu tür ne olursa olsun). Liste 10-7’deki gibi farklı türlerde değerleri olan bir Nokta<T> örneği oluşturursak kodumuz derlenmeyecektir.

struct Nokta<T> {
    x: T,
    y: T,
}

fn main() {
    let calismayacak = Nokta { x: 5, y: 4.0 };
}

Bu örnekte x’e tamsayı olan 5 değerini atadığımızda derleyiciye Nokta<T>’nin bu örneği için T jenerik türünün bir tamsayı olacağını bildiririz. Daha sonra, x ile aynı türde olmasını tanımladığımız y için 4.0 belirttiğimizde, bunun gibi bir tür uyuşmazlığı hatası alırız:

$ cargo run
   Compiling bolum10 v0.1.0 ($PROJE/listings/ch10-generic-types-traits-and-lifetimes/listing-10-07)
error[E0308]: mismatched types
 --> src/main.rs:7:41
  |
7 |     let calismayacak = Nokta { x: 5, y: 4.0 };
  |                                         ^^^ expected integer, found floating-point number

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

x ve y’nin her ikisinin de jenerik olduğu ancak farklı türlere sahip olabildiği bir Nokta struct’ı tanımlamak için birden fazla jenerik tür parametresi kullanabiliriz. Örneğin, Liste 10-8’de x’in T türünde ve y’nin U türünde olduğu, T ve U türleri üzerinde jenerik olması için Nokta’nın tanımını değiştiriyoruz.

struct Nokta<T, U> {
    x: T,
    y: U,
}

fn main() {
    let ikisi_de_tamsayi = Nokta { x: 5, y: 10 };
    let ikisi_de_ondalikli = Nokta { x: 1.0, y: 4.0 };
    let tamsayi_ve_ondalikli = Nokta { x: 5, y: 4.0 };
}

Artık gösterilen tüm Nokta örneklerine izin veriliyor! Bir tanımda istediğiniz kadar çok jenerik tür parametresi kullanabilirsiniz ancak birkaça taneden fazlasını kullanmak kodunuzun okunmasını zorlaştırır. Kodunuzda çok sayıda jenerik türe ihtiyaç duyduğunuzu fark ederseniz, bu durum kodunuzun daha küçük parçalara bölünerek yeniden yapılandırılması gerektiğine işaret edebilir.

Enum Tanımlarında

Struct’larda yaptığımız gibi enum’ları da varyantlarında (seçeneklerinde) jenerik veri türlerini barındıracak şekilde tanımlayabiliriz. Standart kütüphanenin sağladığı ve Bölüm 6’da kullandığımız Option<T> enum’ına bir kez daha bakalım:

#![allow(unused)]
fn main() {
enum Option<T> {
    Some(T),
    None,
}
}

Bu tanım artık size daha mantıklı gelmelidir. Gördüğünüz gibi Option<T> enum’ı T türü üzerinde jeneriktir ve iki varyantı vardır: T türünden bir değer tutan Some ve hiçbir değer tutmayan bir None varyantı. Option<T> enum’ını kullanarak isteğe bağlı bir değerin soyut kavramını ifade edebiliriz ve Option<T> jenerik olduğu için bu isteğe bağlı değerin türü ne olursa olsun bu soyutlamayı kullanabiliriz.

Enum’lar birden fazla jenerik türü de kullanabilir. Bölüm 9’da kullandığımız Result enum’ının tanımı buna bir örnektir:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

Result enum’ı T ve E olmak üzere iki tür üzerinde jeneriktir ve iki varyantı vardır: T türünden bir değer tutan Ok ve E türünden bir değer tutan Err. Bu tanım, başarılı olabilecek (bir tür T değeri döndüren) veya başarısız olabilecek (bir tür E hatası döndüren) bir operasyonumuzun olduğu her yerde Result enum’ını kullanmayı elverişli hale getirir. Aslında, Liste 9-3’te dosya başarıyla açıldığında T’nin std::fs::File türüyle doldurulduğu ve dosya açılırken sorunlar olduğunda E’nin std::io::Error türüyle doldurulduğu bir dosyayı açmak için kullandığımız şey budur.

Kodunuzda sadece tuttukları değerlerin türleri açısından farklılık gösteren çoklu struct veya enum tanımlarına sahip olduğunuz durumları fark ettiğinizde, bunun yerine jenerik türler kullanarak tekrarlardan kaçınabilirsiniz.

Metot Tanımlarında

Struct ve enum’lar üzerinde metotlar uygulayabilir (Bölüm 5’te yaptığımız gibi) ve jenerik türleri bunların tanımlarında da kullanabiliriz. Liste 10-9, Liste 10-6’da tanımladığımız Nokta<T> struct’ı üzerinde uygulanan x adlı metodu gösterir.

struct Nokta<T> {
    x: T,
    y: T,
}

impl<T> Nokta<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Nokta { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

Burada Nokta<T> üzerinde x alanındaki veriye bir referans döndüren x adında bir metot tanımladık.

Metotları Nokta<T> türü üzerinde uyguladığımızı belirtmek için T’yi kullanabilmek adına impl’den hemen sonra T bildirmemiz gerektiğine dikkat edin. T’yi impl’den sonra jenerik bir tür olarak bildirerek Rust, Nokta içindeki açılı parantezlerdeki türün somut bir türden ziyade jenerik bir tür olduğunu belirleyebilir. Bu jenerik parametre için struct tanımında bildirilen jenerik parametreden farklı bir ad seçebilirdik ancak aynı adı kullanmak kuraldır. Jenerik bir tür bildiren bir impl içerisinde bir metot yazarsanız, jenerik türün yerine hangi somut tür (concrete type) gelirse gelsin, o metot türün herhangi bir örneğinde tanımlanacaktır.

Bir tür üzerinde metotları tanımlarken jenerik türler üzerindeki kısıtlamaları da belirtebiliriz. Örneğin herhangi bir jenerik türdeki Nokta<T> örnekleri yerine yalnızca Nokta<f32> örnekleri üzerinde metotlar uygulayabilirdik. Liste 10-10’da somut tür f32’yi kullanıyoruz, bu da impl’den sonra herhangi bir tür bildirmediğimiz anlamına geliyor.

struct Nokta<T> {
    x: T,
    y: T,
}

impl<T> Nokta<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

impl Nokta<f32> {
    fn orijinden_uzaklik(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Nokta { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

Bu kod Nokta<f32> türünün orijinden_uzaklik adlı bir metoda sahip olacağı anlamına gelir; T’nin f32 türünde olmadığı diğer Nokta<T> örneklerinde bu metot tanımlı olmayacaktır. Bu metot, noktamızın (0.0, 0.0) koordinatlarındaki noktadan ne kadar uzakta olduğunu ölçer ve yalnızca ondalıklı türler için mevcut olan matematiksel işlemleri kullanır.

Bir struct tanımındaki jenerik tür parametreleri, aynı struct’ın metot imzalarında kullandıklarınızla her zaman aynı değildir. Liste 10-11, örneği daha açık hale getirmek için Nokta struct’ı için X1 ve Y1 jenerik türlerini ve karistir metodunun imzası için X2 ve Y2 jenerik türlerini kullanır. Bu metot, ( X1 türünde olan) self’teki (kendisindeki) Nokta değerinin x değerinden ve ( Y2 türünde olan) parametre olarak geçilen Nokta değerinin y değerinden yeni bir Nokta örneği yaratır.

struct Nokta<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Nokta<X1, Y1> {
    fn karistir<X2, Y2>(self, diger: Nokta<X2, Y2>) -> Nokta<X1, Y2> {
        Nokta {
            x: self.x,
            y: diger.y,
        }
    }
}

fn main() {
    let p1 = Nokta { x: 5, y: 10.4 };
    let p2 = Nokta {
        x: "Merhaba",
        y: 'c',
    };

    let p3 = p1.karistir(p2);

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

main fonksiyonunda, x için i32 (değeri 5) ve y için f64 (değeri 10.4) olan bir Nokta tanımladık. p2 değişkeni x için string dilimine (değeri "Merhaba") ve y için bir char türüne (değeri 'c') sahip bir Nokta yapısıdır. p2 argümanıyla p1 üzerinde karistir çağrısı yapmak bize p3’ü verir, ki bu da x için bir i32’ye sahip olacaktır çünkü x p1’den gelmiştir. p3 değişkeninin y değeri char olacaktır çünkü y p2’den gelmiştir. println! makrosunun çağrılması p3.x = 5, p3.y = c yazdıracaktır.

Bu örneğin amacı, bazı jenerik parametrelerin impl ile bazı jenerik parametrelerin ise metot tanımıyla bildirildiği bir durumu göstermektir. Burada X1 ve Y1 jenerik parametreleri impl sonrasında bildirilir çünkü onlar struct tanımıyla birlikte giderler. X2 ve Y2 jenerik parametreleri fn karistir’dan (fn mixup) sonra bildirilir çünkü sadece metotla ilgilidirler.

Jenerikleri Kullanan Kodların Performansı

Jenerik tür parametrelerini kullanırken bir çalışma zamanı maliyeti olup olmadığını merak ediyor olabilirsiniz. İyi haber şu ki, jenerik türler kullanmak programınızı somut türler kullandığınızdan daha yavaş çalıştırmayacaktır.

Rust derleme zamanında jenerikleri kullanarak kodun monomorfizasyonunu (monomorphization - tektipleştirme) gerçekleştirerek bunu başarır. Monomorfizasyon, derlendiğinde kullanılan somut türleri doldurarak jenerik kodu özel/spesifik koda dönüştürme işlemidir. Bu süreçte derleyici, Liste 10-5’te jenerik fonksiyonu yaratmak için kullandığımız adımların tersini yapar: Derleyici jenerik kodun çağrıldığı tüm yerlere bakar ve jenerik kodun birlikte çağrıldığı somut türler için kod üretir.

Standart kütüphanenin jenerik Option<T> enum’ını kullanarak bunun nasıl çalıştığına bakalım:

#![allow(unused)]
fn main() {
let tamsayi = Some(5);
let ondalikli = Some(5.0);
}

Rust bu kodu derlediğinde monomorfizasyon uygular. Bu süreç sırasında derleyici Option<T> örneklerinde kullanılmış olan değerleri okur ve iki tür Option<T> tespit eder: Biri i32 diğeri ise f64. Bu şekilde, Option<T>’nin jenerik tanımını i32 ve f64’e özel iki tanıma genişletir ve böylece jenerik tanımı belirli olanlarla değiştirir.

Kodun monomorfize edilmiş (tektipleştirilmiş) hali aşağıdakine benzer (derleyici burada örnek olarak kullandıklarımızdan farklı isimler kullanır):

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let tamsayi = Option_i32::Some(5);
    let ondalikli = Option_f64::Some(5.0);
}

Jenerik Option<T>, derleyici tarafından oluşturulan belirli tanımlarla değiştirilir. Rust jenerik kodu her bir örnekte türü belirten bir koda derlediğinden, jenerikleri kullanmak için hiçbir çalışma zamanı maliyeti ödemeyiz. Kod çalıştığında, tıpkı her tanımı elle kopyalamışız gibi performans gösterir. Monomorfizasyon süreci, Rust’ın jeneriklerini çalışma zamanında son derece verimli hale getirir.

Trait'lerle Ortak Davranış Tanımlama

Traitler ile Paylaşılan Davranışı Tanımlamak

Bir trait, belirli bir türün sahip olduğu ve diğer türlerle paylaşabileceği işlevselliği tanımlar. Paylaşılan davranışı soyut bir şekilde tanımlamak için traitleri kullanabiliriz. Jenerik bir türün belirli bir davranışa sahip herhangi bir tür olabileceğini belirtmek için trait sınırlarını kullanabiliriz.

Not: Traitler, bazı farklılıkları olsa da, diğer dillerde genellikle arayüzler olarak adlandırılan bir özelliğe benzerdir.

Bir Trait Tanımlamak

Bir türün davranışı, o tür üzerinde çağırabileceğimiz metotlardan oluşur. Tüm bu türlerde aynı metotları çağırabiliyorsak farklı türler aynı davranışı paylaşır. Trait tanımları, bazı amaçları gerçekleştirmek için gerekli bir dizi davranışı tanımlamak amacıyla metot imzalarını gruplamanın bir yoludur.

Örneğin, çeşitli türlerde ve miktarlarda metin tutan birden fazla struct’ımız (yapımız) olduğunu varsayalım: Belirli bir konumda dosyalanmış bir haber hikayesini tutan HaberMakalesi struct’ı ve yeni bir gönderi mi, yeniden paylaşım mı yoksa başka bir gönderiye yanıt mı olduğunu belirten meta verilerle birlikte en fazla 280 karaktere sahip olabilen SosyalGonderi struct’ı.

Bir HaberMakalesi veya SosyalGonderi örneğinde depolanabilecek verilerin özetlerini görüntüleyebilen aggregator (toplayıcı) adında bir medya toplayıcı kütüphane crate’i yapmak istiyoruz. Bunu yapmak için, her bir türden bir özete ihtiyacımız var ve bir örnek üzerinde ozetle metodu çağırarak bu özeti isteyeceğiz. Liste 10-12 bu davranışı ifade eden açık bir Ozet trait’inin tanımını gösterir.

pub trait Ozet {
    fn ozetle(&self) -> String;
}

Burada, trait anahtar kelimesini ve ardından bu durumda Ozet olan trait adını kullanarak bir trait bildiriyoruz. Ayrıca, birkaç örnekte göreceğimiz gibi, bu crate’e bağlı olan cratelerin de bu trait’ten yararlanabilmesi için trait’i pub olarak bildiriyoruz. Süslü parantezlerin (curly brackets) içinde, bu trait’i uygulayan türlerin davranışlarını tanımlayan metot imzalarını bildiririz, bu durumda fn ozetle(&self) -> String’dir.

Metot imzasından sonra süslü parantezler içinde bir uygulama sağlamak yerine noktalı virgül kullanırız. Bu trait’i uygulayan her tür, metodun gövdesi için kendi özel davranışını sağlamalıdır. Derleyici, Ozet trait’ine sahip olan her türün tam olarak bu imzayla tanımlanmış ozetle metoduna sahip olmasını zorunlu kılacaktır.

Bir trait gövdesinde birden fazla metoda sahip olabilir: Metot imzaları her satıra bir tane olacak şekilde listelenir ve her satır noktalı virgülle biter.

Bir Tür Üzerinde Trait Uygulamak (Implementing)

Ozet trait’inin metotlarının istenen imzalarını tanımladığımıza göre, artık onu medya toplayıcımızdaki türler üzerinde uygulayabiliriz. Liste 10-13, ozetle metodunun dönüş değerini oluşturmak için manşeti, yazarı ve konumu kullanan HaberMakalesi struct’ı üzerinde Ozet trait’inin bir uygulamasını gösterir. SosyalGonderi struct’ı için, gönderi içeriğinin halihazırda 280 karakterle sınırlı olduğunu varsayarak ozetle metodunu kullanıcı adı ve ardından gönderinin tüm metni olarak tanımlıyoruz.

pub trait Ozet {
    fn ozetle(&self) -> String;
}

pub struct HaberMakalesi {
    pub manset: String,
    pub konum: String,
    pub yazar: String,
    pub icerik: String,
}

impl Ozet for HaberMakalesi {
    fn ozetle(&self) -> String {
        format!("{}, {} ({})", self.manset, self.yazar, self.konum)
    }
}

pub struct SosyalGonderi {
    pub kullanici_adi: String,
    pub icerik: String,
    pub yanit: bool,
    pub yeniden_paylasim: bool,
}

impl Ozet for SosyalGonderi {
    fn ozetle(&self) -> String {
        format!("{}: {}", self.kullanici_adi, self.icerik)
    }
}

Bir tür üzerinde bir trait uygulamak, normal metotları uygulamaya benzer. Aradaki fark, impl kelimesinden sonra uygulamak istediğimiz trait adını koymamız, ardından for anahtar kelimesini kullanmamız ve sonra trait’i uygulamak istediğimiz türün adını belirtmemizdir. impl bloğunun içine, trait tanımında belirtilen metot imzalarını koyarız. Her imzanın sonuna noktalı virgül eklemek yerine süslü parantezler kullanırız ve trait’in metotlarının o belirli tür için sahip olmasını istediğimiz belirli davranışla metot gövdesini doldururuz.

Kütüphane HaberMakalesi ve SosyalGonderi üzerinde Ozet trait’ini uyguladığına göre, crate kullanıcıları normal metotları çağırdığımız şekilde HaberMakalesi ve SosyalGonderi örneklerinde trait metotlarını çağırabilir. Tek fark, kullanıcının türlerin yanı sıra trait’i de kapsama dahil etmesi gerektiğidir. İşte bir ikili crate’in aggregator kütüphane crate’imizi nasıl kullanabileceğine dair bir örnek:

use aggregator::{Ozet, SosyalGonderi};

fn main() {
    let gonderi = SosyalGonderi {
        kullanici_adi: String::from("horse_ebooks"),
        icerik: String::from(
            "elbette, muhtemelen zaten bildiğiniz gibi, insanlar",
        ),
        yanit: false,
        yeniden_paylasim: false,
    };

    println!("1 yeni gönderi: {}", gonderi.ozetle());
}

Bu kod 1 yeni gönderi: horse_ebooks: elbette, muhtemelen zaten bildiğiniz gibi, insanlar yazdırır.

aggregator crate’ine bağlı olan diğer crateler de Ozet trait’ini kendi türleri üzerinde uygulamak için Ozet trait’ini kapsama dahil edebilirler. Dikkat edilmesi gereken bir kısıtlama, bir tür üzerinde bir trait’i ancak trait veya türden biri ya da her ikisi bizim crate’imiz için yerel ise uygulayabilmemizdir. Örneğin, SosyalGonderi türü bizim aggregator crate’imiz için yerel olduğundan, aggregator crate işlevselliğimizin bir parçası olarak SosyalGonderi gibi özel bir tür üzerinde Display (Göster) gibi standart kütüphane traitlerini uygulayabiliriz. Ayrıca, Ozet trait’i aggregator crate’imiz için yerel olduğundan, aggregator crate’imizde Vec<T> üzerinde Ozet uygulayabiliriz.

Ancak harici traitleri harici türler üzerinde uygulayamayız. Örneğin, aggregator crate’imiz içerisinde Vec<T> üzerinde Display trait’ini uygulayamayız, çünkü hem Display hem de Vec<T> standart kütüphanede tanımlanmıştır ve aggregator crate’imiz için yerel değildir. Bu kısıtlama, tutarlılık adı verilen bir özelliğin ve daha spesifik olarak ebeveyn türün mevcut olmaması nedeniyle bu adı alan yetim kuralının bir parçasıdır. Bu kural, başkalarının kodunun sizin kodunuzu, sizin kodunuzun da başkalarının kodunu bozamamasını sağlar. Kural olmasaydı, iki crate aynı tür için aynı trait’i uygulayabilirdi ve Rust hangi uygulamayı kullanacağını bilemezdi.

Varsayılan Uygulamaları (Default Implementations) Kullanmak

Bazen her türdeki tüm metotlar için uygulama gerektirmek yerine bir trait’teki metotların bazılarında veya tümünde varsayılan bir davranışa sahip olmak yararlıdır. Böylece, trait’i belirli bir tür üzerinde uygularken, her metodun varsayılan davranışını koruyabilir veya geçersiz kılabiliriz.

Liste 10-14’te, Liste 10-12’de yaptığımız gibi yalnızca metot imzasını tanımlamak yerine Ozet trait’inin ozetle metodu için varsayılan bir string (dizgi) belirliyoruz.

pub trait Ozet {
    fn ozetle(&self) -> String {
        String::from("(Devamını oku...)")
    }
}

pub struct HaberMakalesi {
    pub manset: String,
    pub konum: String,
    pub yazar: String,
    pub icerik: String,
}

impl Ozet for HaberMakalesi {}

pub struct SosyalGonderi {
    pub kullanici_adi: String,
    pub icerik: String,
    pub yanit: bool,
    pub yeniden_paylasim: bool,
}

impl Ozet for SosyalGonderi {
    fn ozetle(&self) -> String {
        format!("{}: {}", self.kullanici_adi, self.icerik)
    }
}

HaberMakalesi örneklerini özetlerken varsayılan bir uygulama kullanmak için impl Ozet for HaberMakalesi {} şeklinde boş bir impl bloğu belirtiriz.

Artık doğrudan HaberMakalesi üzerinde ozetle metodunu tanımlamıyor olsak da, varsayılan bir uygulama sağladık ve HaberMakalesi’nin Ozet trait’ini uyguladığını belirttik. Sonuç olarak, HaberMakalesi örneğinde ozetle metodunu hala şu şekilde çağırabiliriz:

use aggregator::{self, HaberMakalesi, Ozet};

fn main() {
    let makale = HaberMakalesi {
        manset: String::from("Penguenler Stanley Cup Şampiyonluğunu kazandı!"),
        konum: String::from("Pittsburgh, PA, ABD"),
        yazar: String::from("Iceburgh"),
        icerik: String::from(
            "Pittsburgh Penguenleri bir kez daha NHL'deki en iyi \
             hokey takımı.",
        ),
    };

    println!("Yeni makale mevcut! {}", makale.ozetle());
}

Bu kod Yeni makale mevcut! (Devamını oku...) yazdırır.

Varsayılan bir uygulama oluşturmak, Liste 10-13’teki SosyalGonderi üzerindeki Ozet uygulamasında herhangi bir şeyi değiştirmemizi gerektirmez. Bunun nedeni, varsayılan bir uygulamayı geçersiz kılma sözdiziminin, varsayılan bir uygulaması olmayan bir trait metodunu uygulama sözdizimiyle aynı olmasıdır.

Varsayılan uygulamalar, diğer metotların varsayılan bir uygulaması olmasa bile aynı trait’teki diğer metotları çağırabilir. Bu şekilde, bir trait çok fazla faydalı işlevsellik sağlayabilir ve uygulayıcılardan sadece küçük bir kısmını belirtmelerini isteyebilir. Örneğin, uygulamasının gerekli olduğu yazari_ozetle metodu olan bir Ozet trait’i tanımlayabiliriz ve ardından yazari_ozetle metodunu çağıran varsayılan bir uygulamaya sahip ozetle metodu tanımlayabiliriz:

pub trait Ozet {
    fn yazari_ozetle(&self) -> String;

    fn ozetle(&self) -> String {
        format!(
            "({} yazarından daha fazlasını okuyun...)",
            self.yazari_ozetle()
        )
    }
}

pub struct SosyalGonderi {
    pub kullanici_adi: String,
    pub icerik: String,
    pub yanit: bool,
    pub yeniden_paylasim: bool,
}

impl Ozet for SosyalGonderi {
    fn yazari_ozetle(&self) -> String {
        format!("@{}", self.kullanici_adi)
    }
}

Bu Ozet sürümünü kullanmak için, trait’i bir tür üzerinde uygularken sadece yazari_ozetle metodunu tanımlamamız gerekir:

pub trait Ozet {
    fn yazari_ozetle(&self) -> String;

    fn ozetle(&self) -> String {
        format!(
            "({} yazarından daha fazlasını okuyun...)",
            self.yazari_ozetle()
        )
    }
}

pub struct SosyalGonderi {
    pub kullanici_adi: String,
    pub icerik: String,
    pub yanit: bool,
    pub yeniden_paylasim: bool,
}

impl Ozet for SosyalGonderi {
    fn yazari_ozetle(&self) -> String {
        format!("@{}", self.kullanici_adi)
    }
}

yazari_ozetle’yi tanımladıktan sonra, SosyalGonderi struct’ının örnekleri üzerinde ozetle’yi çağırabiliriz ve ozetle’nin varsayılan uygulaması, sağladığımız yazari_ozetle tanımını çağıracaktır. yazari_ozetle uygulamasını gerçekleştirdiğimiz için Ozet trait’i bize daha fazla kod yazmamıza gerek kalmadan ozetle metodunun davranışını verdi. İşte şöyle görünür:

use aggregator::{self, SosyalGonderi, Ozet};

fn main() {
    let gonderi = SosyalGonderi {
        kullanici_adi: String::from("horse_ebooks"),
        icerik: String::from(
            "elbette, muhtemelen zaten bildiğiniz gibi, insanlar",
        ),
        yanit: false,
        yeniden_paylasim: false,
    };

    println!("1 yeni gönderi: {}", gonderi.ozetle());
}

Bu kod 1 yeni gönderi: (@horse_ebooks yazarından daha fazlasını okuyun...) yazdırır.

Aynı metodun geçersiz kılınan bir uygulamasından varsayılan uygulamayı çağırmanın mümkün olmadığını unutmayın.

Traitleri Parametre Olarak Kullanmak

Artık traitlerin nasıl tanımlanacağını ve uygulanacağını bildiğinize göre, birçok farklı türü kabul eden fonksiyonları tanımlamak için traitleri nasıl kullanacağınızı keşfedebiliriz. Ozet trait’ini uygulayan bir türde olan oge parametresi üzerinde ozetle metodunu çağıran bildir fonksiyonunu tanımlamak için Liste 10-13’te HaberMakalesi ve SosyalGonderi türleri üzerinde uyguladığımız Ozet trait’ini kullanacağız. Bunu yapmak için, impl Trait sözdizimini şu şekilde kullanırız:

pub trait Ozet {
    fn ozetle(&self) -> String;
}

pub struct HaberMakalesi {
    pub manset: String,
    pub konum: String,
    pub yazar: String,
    pub icerik: String,
}

impl Ozet for HaberMakalesi {
    fn ozetle(&self) -> String {
        format!("{}, {} ({})", self.manset, self.yazar, self.konum)
    }
}

pub struct SosyalGonderi {
    pub kullanici_adi: String,
    pub icerik: String,
    pub yanit: bool,
    pub yeniden_paylasim: bool,
}

impl Ozet for SosyalGonderi {
    fn ozetle(&self) -> String {
        format!("{}: {}", self.kullanici_adi, self.icerik)
    }
}

pub fn bildir(oge: &impl Ozet) {
    println!("Son dakika haberi! {}", oge.ozetle());
}

oge parametresi için somut bir tür (concrete type) yerine impl anahtar kelimesini ve trait adını belirtiyoruz. Bu parametre, belirtilen trait’i uygulayan herhangi bir türü kabul eder. bildir’in gövdesinde, oge üzerinde Ozet trait’inden gelen ozetle gibi metotları çağırabiliriz. bildir çağırabiliriz ve herhangi bir HaberMakalesi veya SosyalGonderi örneği geçebiliriz. Fonksiyonu String veya i32 gibi herhangi bir türle çağıran kod derlenmeyecektir çünkü bu türler Ozet trait’ini uygulamazlar.

Trait Sınırı (Trait Bound) Sözdizimi

impl Trait sözdizimi basit durumlar için işe yarar ancak aslında trait sınırı (trait bound) olarak bilinen daha uzun bir formun sözdizimsel şekeri gibidir; şu şekilde görünür:

pub fn bildir<T: Ozet>(oge: &T) {
    println!("Son dakika haberi! {}", oge.ozetle());
}

Bu uzun form, önceki bölümdeki örneğe eşdeğerdir ancak daha uzundur. Jenerik tür parametresinin bildirimi ile birlikte iki nokta üst üsteden sonra ve açılı parantezlerin içine trait sınırlarını yerleştiririz.

impl Trait sözdizimi kullanışlıdır ve basit durumlarda kodu daha özlü hale getirirken, daha tam olan (fuller) trait sınırı sözdizimi diğer durumlarda daha fazla karmaşıklığı ifade edebilir. Örneğin, Ozet uygulayan iki parametremiz olabilir. Bunu impl Trait sözdizimi ile yapmak şuna benzer:

pub fn bildir(oge1: &impl Ozet, oge2: &impl Ozet) {

Eğer bu fonksiyonun oge1 ve oge2’nin farklı türlere sahip olmasına izin vermesini istiyorsak (her iki tür de Ozet uyguladığı sürece) impl Trait kullanmak uygundur. Ancak her iki parametreyi de aynı türe sahip olmaya zorlamak istersek, şu şekilde bir trait sınırı kullanmalıyız:

pub fn bildir<T: Ozet>(oge1: &T, oge2: &T) {

oge1 ve oge2 parametrelerinin türü olarak belirtilen jenerik tür T, fonksiyonu öyle bir kısıtlar ki, oge1 ve oge2 için argüman olarak iletilen değerin somut türü (concrete type) aynı olmalıdır.

+ Sözdizimi ile Birden Fazla Trait Sınırı

Birden fazla trait sınırı da belirtebiliriz. Diyelim ki bildir’in oge üzerinde ozetle ile birlikte ekran biçimlendirmesini de kullanmasını istiyoruz: bildir tanımında oge’nin hem Display hem de Ozet trait’lerini uygulaması gerektiğini belirtiyoruz. Bunu + sözdizimini kullanarak yapabiliriz:

pub fn bildir(oge: &(impl Ozet + Display)) {

+ sözdizimi jenerik türler üzerindeki trait sınırlarıyla da geçerlidir:

pub fn bildir<T: Ozet + Display>(oge: &T) {

Belirtilen iki trait sınırı ile bildir’in gövdesi ozetle’yi çağırabilir ve oge’yi formatlamak için {} kullanabilir.

where Cümlecikleriyle Daha Açık Trait Sınırları

Çok fazla trait sınırı kullanmanın dezavantajları vardır. Her jeneriğin kendi trait sınırları vardır, bu nedenle birden fazla jenerik tür parametresine sahip fonksiyonlar, fonksiyonun adı ve parametre listesi arasında çok fazla trait sınırı bilgisi içerebilir, bu da fonksiyon imzasının okunmasını zorlaştırır. Bu nedenle, Rust fonksiyon imzasından sonra bir where (nerede/şartıyla) cümleciği içinde trait sınırlarını belirtmek için alternatif bir sözdizimine sahiptir. Yani bunu yazmak yerine:

fn bazi_fonksiyonlar<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {

Şu şekilde bir where cümleciği kullanabiliriz:

fn bazi_fonksiyonlar<T, U>(t: &T, u: &U) -> i32
where
    T: Display + Clone,
    U: Clone + Debug,
{
    unimplemented!()
}

Bu fonksiyonun imzası daha az karmaşıktır: Fonksiyon adı, parametre listesi ve dönüş türü birbirine yakındır, tıpkı çok fazla trait sınırı olmayan bir fonksiyona benzer şekilde.

Traitleri Uygulayan (Implement) Türler Döndürmek

impl Trait sözdizimini, burada gösterildiği gibi bir trait uygulayan bazı türlerden bir değer döndürmek için dönüş pozisyonunda da kullanabiliriz:

pub trait Ozet {
    fn ozetle(&self) -> String;
}

pub struct HaberMakalesi {
    pub manset: String,
    pub konum: String,
    pub yazar: String,
    pub icerik: String,
}

impl Ozet for HaberMakalesi {
    fn ozetle(&self) -> String {
        format!("{}, {} ({})", self.manset, self.yazar, self.konum)
    }
}

pub struct SosyalGonderi {
    pub kullanici_adi: String,
    pub icerik: String,
    pub yanit: bool,
    pub yeniden_paylasim: bool,
}

impl Ozet for SosyalGonderi {
    fn ozetle(&self) -> String {
        format!("{}: {}", self.kullanici_adi, self.icerik)
    }
}

fn ozetlenebilir_dondur() -> impl Ozet {
    SosyalGonderi {
        kullanici_adi: String::from("horse_ebooks"),
        icerik: String::from(
            "elbette, muhtemelen zaten bildiğiniz gibi, insanlar",
        ),
        yanit: false,
        yeniden_paylasim: false,
    }
}

Dönüş türü olarak impl Ozet kullanarak, ozetlenebilir_dondur fonksiyonunun somut türün adını vermeden Ozet trait’ini uygulayan bir tür döndürdüğünü belirtiyoruz. Bu durumda, ozetlenebilir_dondur bir SosyalGonderi döndürür ancak bu fonksiyonu çağıran kodun bunu bilmesi gerekmez.

Dönüş türünü sadece uyguladığı trait ile belirtebilme yeteneği, özellikle Bölüm 13’te ele aldığımız kapanışlar ve yineleyiciler bağlamında faydalıdır. Kapanışlar ve yineleyiciler, yalnızca derleyicinin bildiği türler veya belirtilmesi çok uzun olan türler yaratır. impl Trait sözdizimi, bir fonksiyonun çok uzun bir tür yazmaya gerek kalmadan Iterator trait’ini uygulayan bir tür döndürdüğünü özlü bir şekilde belirtmenizi sağlar.

Ancak, impl Trait’i yalnızca tek bir tür döndürüyorsanız kullanabilirsiniz. Örneğin, dönüş türü impl Ozet olarak belirtilen ve bir HaberMakalesi ya da bir SosyalGonderi döndüren bu kod işe yaramayacaktır:

pub trait Ozet {
    fn ozetle(&self) -> String;
}

pub struct HaberMakalesi {
    pub manset: String,
    pub konum: String,
    pub yazar: String,
    pub icerik: String,
}

impl Ozet for HaberMakalesi {
    fn ozetle(&self) -> String {
        format!("{}, {} ({})", self.manset, self.yazar, self.konum)
    }
}

pub struct SosyalGonderi {
    pub kullanici_adi: String,
    pub icerik: String,
    pub yanit: bool,
    pub yeniden_paylasim: bool,
}

impl Ozet for SosyalGonderi {
    fn ozetle(&self) -> String {
        format!("{}: {}", self.kullanici_adi, self.icerik)
    }
}

fn ozetlenebilir_dondur(degistir: bool) -> impl Ozet {
    if degistir {
        HaberMakalesi {
            manset: String::from(
                "Penguenler Stanley Cup Şampiyonluğunu kazandı!",
            ),
            konum: String::from("Pittsburgh, PA, ABD"),
            yazar: String::from("Iceburgh"),
            icerik: String::from(
                "Pittsburgh Penguenleri bir kez daha NHL'deki en iyi \
                 hokey takımı.",
            ),
        }
    } else {
        SosyalGonderi {
            kullanici_adi: String::from("horse_ebooks"),
            icerik: String::from(
                "elbette, muhtemelen zaten bildiğiniz gibi, insanlar",
            ),
            yanit: false,
            yeniden_paylasim: false,
        }
    }
}

Derleyicide impl Trait sözdiziminin nasıl uygulandığına ilişkin kısıtlamalar nedeniyle HaberMakalesi veya SosyalGonderi döndürülmesine izin verilmez. Bu davranışa sahip bir fonksiyonun nasıl yazılacağını Bölüm 18’in “Paylaşılan Davranış Üzerinden Soyutlama Yapmak İçin Trait Nesneleri Kullanmak” bölümünde ele alacağız.

Metotları Koşullu (Conditionally) Uygulamak İçin Trait Sınırlarını Kullanmak

Jenerik tür parametreleri kullanan bir impl bloğu ile birlikte bir trait sınırı kullanarak, belirtilen traitleri uygulayan türler için koşullu olarak metotlar uygulayabiliriz. Örneğin, Liste 10-15’teki Cift<T> türü her zaman yeni bir Cift<T> örneği döndüren new fonksiyonunu uygular (Bölüm 5’in “Metot Sözdizimi” kısmından hatırlayın, Self, bu durumda Cift<T> olan impl bloğunun türü için bir tür takma adıdır). Fakat bir sonraki impl bloğunda, Cift<T> yalnızca kendi içindeki T türü karşılaştırmayı sağlayan PartialOrd trait’ini ve yazdırmayı sağlayan Display trait’ini uyguluyorsa karsilastir_goster metodunu uygular.

use std::fmt::Display;

struct Cift<T> {
    x: T,
    y: T,
}

impl<T> Cift<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: Display + PartialOrd> Cift<T> {
    fn karsilastir_goster(&self) {
        if self.x >= self.y {
            println!("En büyük üye x = {}", self.x);
        } else {
            println!("En büyük üye y = {}", self.y);
        }
    }
}

Ayrıca, başka bir trait’i uygulayan herhangi bir tür için koşullu olarak bir trait de uygulayabiliriz. Trait sınırlarını karşılayan herhangi bir tür üzerindeki trait uygulamalarına kapsayıcı uygulamalar denir ve Rust standart kütüphanesinde yaygın olarak kullanılırlar. Örneğin, standart kütüphane Display trait’ini uygulayan her tür için ToString trait’ini uygular. Standart kütüphanedeki impl bloğu bu koda benzemektedir:

impl<T: Display> ToString for T {
    // --snip--
}

Standart kütüphanede bu kapsayıcı uygulama (blanket implementation) bulunduğundan dolayı, Display trait’ini uygulayan herhangi bir tür üzerinde ToString trait’i tarafından tanımlanan to_string metodunu çağırabiliriz. Örneğin tamsayılar Display uyguladığından tamsayıları bu şekilde karşılık gelen String değerlerine dönüştürebiliriz:

#![allow(unused)]
fn main() {
let s = 3.to_string();
}

Kapsayıcı uygulamalar, trait’in dokümantasyonunda “Uygulayıcılar” (Implementors) bölümünde yer alır.

Traitler ve trait sınırları, kod tekrarını azaltmak için jenerik tür parametrelerini kullanan kod yazmamızı sağlarken aynı zamanda derleyiciye jenerik türün belirli bir davranışa sahip olmasını istediğimizi belirtmemize de olanak tanır. Derleyici daha sonra trait sınırı bilgisini, kodumuzla birlikte kullanılan tüm somut türlerin doğru davranışı sağladığını kontrol etmek için kullanabilir. Dinamik olarak yazılmış dillerde, bir metodu tanımlamayan bir tür üzerinde metodu çağırsaydık çalışma zamanında bir hata alırdık. Ancak Rust bu hataları derleme zamanına taşır, böylece kodumuz çalışmadan önce sorunları düzeltmeye zorlanırız. Ek olarak, çalışma zamanında davranış için kontrol yapan bir kod yazmamıza gerek kalmaz, çünkü zaten derleme zamanında kontrol etmişizdir. Bunu yapmak jeneriklerin esnekliğinden vazgeçmek zorunda kalmadan performansı artırır.

Ömürlerle Referansları Doğrulama

Referansları Ömürlerle (Lifetimes) Doğrulamak

Ömürler, daha önce kullandığımız başka bir jenerik türüdür. Ömürler, bir türün istediğimiz davranışa sahip olduğundan emin olmak yerine, referansların onlara ihtiyacımız olduğu sürece geçerli kalmasını sağlar.

Bölüm 4’teki “Referanslar ve Ödünç Alma (Borrowing)” kısmında bahsetmediğimiz bir detay, Rust’taki her referansın bir ömrü (lifetime) olduğudur; bu, o referansın geçerli olduğu kapsamdır. Tıpkı çoğu zaman türlerin çıkarsanması gibi, çoğu zaman ömürler de örtüktür ve çıkarsanırlar. Yalnızca birden fazla türün mümkün olduğu durumlarda türleri açıklamamız gerekir. Benzer bir şekilde, referansların ömürlerinin birkaç farklı şekilde ilişkili olabileceği durumlarda da ömürleri açıklamamız gerekir. Rust, çalışma zamanında kullanılan gerçek referansların kesinlikle geçerli olacağından emin olmak için jenerik ömür parametrelerini kullanarak bu ilişkileri açıklamayı zorunlu tutar.

Ömürleri açıklamak, diğer çoğu programlama dilinde var olan bir kavram bile değildir, bu yüzden bu size yabancı gelecektir. Bu bölümde ömürleri bütünüyle ele almayacak olsak da, bu kavrama alışabilmeniz için ömür sözdizimiyle karşılaşabileceğiniz yaygın durumları tartışacağız.

Sarkan Referanslar (Dangling References)

Ömürlerin temel amacı, sarkan referansları önlemektir. Eğer bunların var olmasına izin verilseydi, bir programın başvurmayı amaçladığı veriler dışındaki verilere referans vermesine neden olurdu. Bir dış kapsama ve bir iç kapsama sahip olan Liste 10-16’daki programı düşünün.

fn main() {
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {r}");
}

Not: Liste 10-16, 10-17 ve 10-23’teki örnekler, değişkenlere ilk değer vermeden onları bildirir, bu nedenle değişken adı dış kapsamda mevcuttur. İlk bakışta bu, Rust’ın null (boş) değerlere sahip olmamasıyla çelişiyor gibi görünebilir. Ancak, bir değişkene değer vermeden onu kullanmaya çalışırsak, derleme zamanı hatası alırız; bu da Rust’ın gerçekten null değerlere izin vermediğini gösterir.

Dış kapsam, ilk değeri olmayan r adında bir değişken tanımlar ve iç kapsam, ilk değeri 5 olan x adında bir değişken tanımlar. İç kapsamın içinde, r’nin değerini x’e bir referans olarak ayarlamaya çalışırız. Sonra iç kapsam sona erer ve r’deki değeri yazdırmaya çalışırız. Bu kod derlenmeyecektir, çünkü biz onu kullanmaya çalışmadan önce r’nin atıfta bulunduğu değer kapsam dışına çıkmıştır. İşte hata mesajı:

$ cargo run
   Compiling bolum10 v0.1.0 (file:///projects/bolum10)
error[E0597]: `x` does not live long enough
 --> src/main.rs:6:13
  |
5 |         let x = 5;
  |             - binding `x` declared here
6 |         r = &x;
  |             ^^ borrowed value does not live long enough
7 |     }
  |     - `x` dropped here while still borrowed
8 |
9 |     println!("r: {r}");
  |                   - borrow later used here

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

Hata mesajı, x değişkeninin “yeterince uzun yaşamadığını (does not live long enough)” söyler. Bunun nedeni, iç kapsam 7. satırda sona erdiğinde x’in kapsam dışına çıkacak olmasıdır. Ancak r dış kapsam için hala geçerlidir; kapsamı daha geniş olduğu için onun “daha uzun yaşadığını” söylüyoruz. Rust bu kodun çalışmasına izin verseydi, r x kapsam dışına çıktığında ayrılması iptal edilen belleğe atıfta bulunuyor olurdu ve r ile yapmaya çalıştığımız hiçbir şey doğru çalışmazdı. Peki, Rust bu kodun geçersiz olduğunu nasıl belirliyor? Bir ödünç alma denetleyicisi kullanır.