Rust'ta "Cannot Borrow Immutable Twice" Hatası ve Çözümü: Geliştiriciler İçin Rehber

Rust programlama dilinde, bellek güvenliği sağlamak amacıyla borç verme (borrowing) sistemi kullanılır. Bu sistem sayesinde, bir veri üzerinde aynı anda sadece bir "mutable" borçlanma (değiştirilebilir) işlemi veya birden fazla "immutable" borçlanma (değiştirilemez) işlemi yapılabilir. Ancak bu kurallar bazen kafa karıştırıcı olabilir ve geliştiriciler, "Cannot borrow immutable twice" hatasıyla karşılaşabilir. Peki, bu hata ne anlama geliyor ve nasıl çözülebilir?

Rust, bellek hatalarını önlemeye odaklanırken, verilerin borçlanmasını kontrol etmek için çok katı kurallar uygular. Bu kurallardan biri, bir veriyi aynı anda birden fazla kez değiştirilemez olarak borçlanmanıza izin vermez. Yani, eğer bir veriyi iki kez değiştirilemez olarak borçlamaya çalışırsanız, Rust bunu engeller ve "Cannot borrow immutable twice" hatasını fırlatır. Gelin, bu durumu bir örnek üzerinden inceleyelim.

Diyelim ki, bir fonksiyonda bir veriye iki kez değiştirilemez olarak erişmeye çalışıyorsunuz. Rust, bu tür bir borçlanma yapmanıza izin vermez. Aşağıda bir örnek kod bulabilirsiniz:

fn main() {
    let x = 10;
    
    let y = &x;  // İlk immutable borçlanma
    let z = &x;  // İkinci immutable borçlanma
    
    println!("y: {}, z: {}", y, z);
}

Bu kodu çalıştırmaya çalıştığınızda, Rust şu hatayı verecektir:

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

Hata mesajı, `x`'in iki kez değiştirilemez olarak borçlanamayacağını belirtiyor. Ama neden? Çünkü Rust, verilerin aynı anda iki farklı yere erişilmesini istemiyor. Bu, veri tutarlılığını garanti etmek ve olası hataları engellemek için yapılan bir tasarım kararıdır.

Bu hatayı düzeltmenin birkaç yolu vardır. İlk yöntem, borçlanmanın yalnızca bir yerde yapılmasını sağlamaktır. Eğer aynı veriye birden fazla kez erişmek istiyorsanız, birini mutable (değiştirilebilir) yaparak çözüm bulabilirsiniz.

Aşağıda hatayı düzeltmek için bir örnek kod verilmektedir:

fn main() {
    let mut x = 10;
    
    let y = &x;    // İlk immutable borçlanma
    let z = &mut x; // Mutable borçlanma (değiştirilebilir)
    
    println!("y: {}, z: {}", y, z);
}

Burada, `x`'i mutable olarak borçladık ve `y` değişkenine de immutable olarak erişim sağladık. Ancak, dikkat edilmesi gereken bir şey var: `y` ile `x` aynı anda değiştirilemez olarak borçlanıyordu, ancak Rust sadece bir tane mutable borçlanmaya izin verir.

Rust'taki borçlanma kuralları başta karmaşık görünebilir, ancak aslında çok güçlüdürler. Bu kurallar sayesinde, veri yarışları ve bellek hataları gibi sorunların önüne geçilir. İşte bazı önemli borçlanma kuralları:

- Bir veri bir kez mutable olarak borçlanabilir. Yani, aynı anda yalnızca bir değişken veriyi değiştirebilir.
- Bir veri birden fazla kez immutable olarak borçlanabilir. Ancak, bir veri mutable olarak borçlanmışsa, başka hiçbir yerden immutable erişime izin verilmez.
- Veriyi mutlak bir şekilde "iade" etmeden borçlanamazsınız. Yani, bir borçlanmayı kullanmadan önce, verinin sahipliği bir yere verilmelidir.

Rust programlama dilinde, "Cannot borrow immutable twice" hatası, genellikle iki farklı değişkenin aynı veriye aynı anda değiştirilemez erişim sağlamaya çalıştığı durumlarda ortaya çıkar. Bu hatayı çözmek için, borçlanmayı düzenlemek ve sadece bir kez borçlanmaya izin veren kuralları takip etmek önemlidir.

Eğer Rust'a yeni başlıyorsanız, bu tür hatalar başlangıçta zorlayıcı olabilir, ancak zamanla bu kuralların neden böyle olduğunu anlayacak ve daha sağlam, hatasız kodlar yazmaya başlayacaksınız. Her hatayı bir öğrenme fırsatı olarak görün ve hatalarla büyümekten korkmayın!