Rust "Borrow Checker Error" ile Tanışmak: Başarısız Olmaktan Başarıya Giden Yol

Rust diline yeni başlayanlar için, en büyük düşmanlardan biri hiç şüphesiz *"Borrow Checker"* hatasıdır. Rust’un sahip olduğu bu özellik, bellek güvenliğini sağlamak amacıyla önemli bir rol oynar. Ancak, ilk kez bu hata ile karşılaşan bir yazılımcı, bir yanda hüsrana uğrarken diğer yanda Rust'un gerçekten ne kadar güçlü bir dil olduğunu fark edebilir.

Hayal edin, her şey yolunda gidiyor. Rust’ta yazdığınız kod, size kararlı bir şekilde başını sallayarak “Evet, işte buradayım. Beni yaz, çalıştır ve harika sonuçlar al.” diyor. Ancak sonra bir hata alırsınız. Gözlerinizin önünde beliriveren hata mesajını okurken derin bir nefes alırsınız: *“Eyvah, Borrow Checker Error!”* Kafanızda bir dizi soru işareti belirir: “Bu ne demek? Ne oldu? Nereye yanlış yazdım?”

Hadi gelin, bu hatanın ne olduğunu, neden ortaya çıktığını ve nasıl çözüleceğini birlikte keşfedelim.

Rust, bellek güvenliği sağlamak için *ownership* (sahiplik), *borrowing* (ödünç alma) ve *lifetimes* (yaşam süreleri) kavramlarını kullanır. Bunlar, özellikle çoklu iş parçacıklı (multi-threaded) programlama ve düşük seviyeli bellek işlemleri açısından çok önemlidir. Peki ya *borrow checker*? Bu, Rust’un en büyük silahıdır. Kodunuzun bellek hatalarını en başta engellemek için çalışır. Başka bir deyişle, kodunuzun çalışma zamanında bellek sızıntısı veya çökmesi riski olmadan doğru şekilde çalışmasını sağlar.

Fakat işler bazen karmaşıklaşabilir. İşte burada *borrow checker* devreye girer. Eğer borç alırken (ya da sahipliği paylaşıyorken) bir hata yaparsanız, bu kuralı ihlal edersiniz. Rust, bunu anlamanızı sağlayacak şekilde bir hata mesajı gösterir.

Rust'ta bir referans oluşturduğunuzda, *borrow* ettiğiniz veriyle ne yapacağınızı söylemelisiniz. Bu işlemde iki ana kural vardır:
1. Bir veri yalnızca bir kez *mutable* (değiştirilebilir) olmalıdır.
2. Aynı veriye aynı anda yalnızca birden fazla *immutable* (değiştirilemez) referans olabilir, ya da bir *mutable* referans olabilir.

Eğer bu kurallardan birini ihlal ederseniz, *borrow checker* hemen devreye girer ve bir hata mesajı gösterir. İşte size basit bir örnek:

fn main() {
    let mut x = 5;
    let y = &x;  // Immutable borrow
    let z = &mut x;  // Mutable borrow (hata!)
}

Yukarıdaki örnekte, ilk satırda bir *mutable* değişken olan `x` tanımlanıyor. Ardından, `x`'in *immutable* bir referansı olan `y` oluşturuluyor. Ancak sonrasında `x`'in *mutable* referansı olan `z` tanımlanıyor. Bu, Rust’un sahiplik ve borç verme kurallarına aykırıdır. Çünkü bir veri aynı anda hem *immutable* hem de *mutable* olarak borç verilemez. Bu yüzden *borrow checker* bu hatayı yakalar ve aşağıdaki gibi bir hata mesajı alırsınız:

```
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
```

Bu hata, Rust’un güvenlik özelliklerinden yalnızca birine örnektir ve bellek hatalarını önlemenin ne kadar güçlü bir yoludur.

Elbette, bu hatayı düzeltmek mümkündür. Ancak önce, hatanın ne olduğunu tam anlamalısınız. Yukarıdaki örnekte, `y` değişkeni `x`'i borç alırken, `z` değişkeni aynı anda `x`'i değiştirmeye çalıştı. Bu iki referans türü çakıştı ve hata oluştu.

Burada çözüm, *mutable* referansı sadece bir kez kullanmaktır. Örneğin, şöyle düzeltebilirsiniz:

fn main() {
    let mut x = 5;
    let y = &x;  // Immutable borrow
    // `x`'i mutable olarak değiştirmeden önce `y`'i kullanmalısınız
    println!("y: {}", y); 
    let z = &mut x;  // Mutable borrow (şimdi geçerli!)
    *z += 1;
    println!("z: {}", z);
}

Bu düzeltme, ilk referansın kullanımını bitirdikten sonra `x` üzerinde *mutable* işlem yapmanıza olanak tanır. Artık `borrow checker` tarafından hata almazsınız çünkü kurallar doğru bir şekilde izlenmiştir.

Rust’ta kod yazarken, *borrow checker* gibi hatalarla karşılaşmak, aslında öğrenme sürecinin bir parçasıdır. Bu hataları görmek, Rust dilinin sunduğu bellek güvenliğini daha iyi anlamanızı sağlar. Ve ne zaman bir hata ile karşılaşsanız, bu yalnızca dilin ne kadar katı ve güvenli olduğunu gösteren bir işarettir. Rust'un katı kuralları bazen başta sıkıcı gibi görünse de, aslında güçlü ve sağlam kodlar yazmanızı sağlar.

İlk başta bu hatalar sizi boğabilir, ancak onlarla yüzleşmek, sonunda Rust dilinde ustalaşmanıza yardımcı olur. Bu yazıyı okuduktan sonra, *borrow checker* hatalarını daha iyi anlamanızı umarım. Rust’un sağladığı bu güvenlik katmanı sayesinde daha sağlam, güvenli ve hatasız yazılımlar yazmaya devam edebilirsiniz.