Rust'ta "Cannot borrow immutable twice" Hatasını Anlamak ve Çözmek

Rust, belki de güvenliği en ön planda tutan programlama dillerinden biri. Ancak bu güvenlik, bazen geliştiricilerin başını derde sokabilir. Çünkü Rust, hafıza yönetimi konusunda oldukça katı kurallara sahip ve bu kurallar, dilin başlıca özelliklerinden biri olan *ownership* (sahiplik) modelinin bir parçasıdır. İşte bu yazıda, Rust’ta karşınıza çıkabilecek yaygın hatalardan biri olan “Cannot borrow immutable twice” hatasını derinlemesine inceleyeceğiz.

Rust’ta Borrowing ve İmmutability Nedir?

Rust'ta veri, "borrow" adı verilen bir işlemle paylaşılır. Bu işlemde, bir veriye sadece bir yerden erişilebilir ve ya sadece okuma, ya da yazma izni verilir. Okuma izni *immutable* (değiştirilemez) iken, yazma izni *mutable* (değiştirilebilir) olarak tanımlanır. Ama işte burada dikkat etmeniz gereken önemli bir şey var: Rust, aynı anda hem mutable hem de immutable borrows’a izin vermez. Bunun anlamı, aynı veriyi iki farklı yerde okuma izniyle (immutable borrow) almak yasaktır.

Cannot Borrow Immutable Twice Hatasının Sebebi Nedir?

Bu hatayı genellikle şu şekilde görürsünüz:

kopyala
let x = 5;
let y = &x; // x'in immutable borrows'u
let z = &x; // Aynı şekilde bir başka immutable borrow
PHP

Rust burada, x'in iki kez *immutable* olarak borçlanılmasına izin vermez. Bu da hataya sebep olur. Peki neden? Çünkü Rust'un sahiplik modeli, aynı veriye birden fazla okuma işlemi yapılırken veri tutarsızlıklarını önlemek için bu kısıtlamayı getirir. Aynı anda birden fazla *immutable borrow* yapmaya çalıştığınızda, bu bellekle ilgili potansiyel sorunlara yol açabilir.

Hata Nasıl Çözülür?

Bu hatayı çözmek için birkaç farklı yol izleyebilirsiniz. İşte bu yollardan bazıları:

1. Borrow’a Tekrar Erişim Sağlamadan Önce İlk Borrows’u Kapatın
Rust, her borrow'un bir "yaşama süresine" sahiptir. Eğer bir borrows’un sonlandığından emin olursanız, aynı veriye ikinci kez borçlanabilirsiniz. Aşağıdaki gibi bir kod örneğiyle bu hatayı çözebilirsiniz:

kopyala
let x = 5;
let y = &x; // x'in immutable borrows'u
println!("{}", y); // y'yi kullanıyoruz
// İlk borrow bitiyor, şimdi yeni bir borrow alabiliriz.
let z = &x; // x'in başka bir immutable borrows'u
println!("{}", z);
PHP

Bu şekilde, bir borrow bitmeden yeni bir borrow başlatılmamış olur, dolayısıyla hata ortadan kalkar.

2. Veri Kopyalama veya Klonlama
Eğer veriyi değiştirmenize gerek yoksa, basit bir kopyalama veya klonlama işlemi yaparak bu sorunu aşabilirsiniz. Örneğin, bir tam sayı (`i32`) gibi temel türler, `Copy` özelliğine sahip olduğundan, bu tür verileri kopyalayabilirsiniz.

kopyala
let x = 5;
let y = x; // x, y'ye kopyalanır
let z = x; // x'in bir kopyası olduğu için sorun yok
PHP

Burada, `x` bir referans yerine kopyalandığı için, aynı veriye iki kez *borrow* yapmamış oluruz.

3. Mutable Borrow Kullanmak
Eğer veriye yalnızca tek bir yazma izni (mutable borrow) vermeniz gerekiyorsa, aynı anda okuma işlemi yapmamanız gerekir. İşte bu çözüm de şu şekilde olabilir:

kopyala
let mut x = 5;
let y = &mut x; // x'in mutable borrows'u
*y += 1; // x’i değiştiriyoruz
println!("{}", y); // x'in son hali
PHP

Burada, bir *mutable borrow* ile x’i değiştirebiliriz ve bu, yalnızca bir kez yapılabilir.

Sonuç

Rust’un katı sahiplik kuralları, programın güvenliğini artırmak için harika bir sistem sunar. Ancak bazen, bu katı kurallar hatalarla karşılaşmanıza sebep olabilir. “Cannot borrow immutable twice” hatası da bu hatalardan biridir. Rust’un borrows ve sahiplik modeline aşina oldukça, bu tür hataları kolayca aşabilirsiniz. Bu hatanın çözümü basit görünebilir, ama dilin tasarımıyla ilgili temel anlayışınızı geliştirmenize yardımcı olur. Unutmayın, Rust'ta her şeyin bir sırası var!