Rust ekibi, Rust'ın yeni bir sürümü olan 1.65.0'ı duyurmaktan mutluluk duyar. Rust, herkesin güvenilir ve verimli yazılım oluşturmasını sağlayan bir programlama dilidir.

Rust'ın önceki bir sürümünü rustup aracılığıyla yüklediyseniz, 1.65.0'ı şu şekilde edinebilirsiniz:

--> rustup update stable

Gelecekteki sürümleri test ederek bize yardımcı olmak isterseniz, beta kanalını (rustup default beta) veya gece kanalını (rustup default nightly) kullanmak için yerel olarak güncelleme yapmayı düşünebilirsiniz. Lütfen karşılaşabileceğiniz hataları bildirin!

1.65.0 kararlı sürümünde neler var?

Genel ilişkili türler - Generic associated types (GATs)

Lifetime, type ve const jenerikleri artık ilişkili türlerde şu şekilde tanımlanabilir:

trait Foo {
    type Bar<'x>;
}

Bunların ne kadar yararlı olabileceğini birkaç kelimeyle anlatmak zor, bu yüzden güçlerini anlamak için işte birkaç örnek özellik:

/// "Kendinden(Self)" ödünç alınabilen "Yineleyici(Iterator)" benzeri bir özellik
trait LendingIterator {
    type Item<'a> where Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
}

/// İşaretçi türü üzerinde jenerik olmaya izin vermek için
/// `Rc` veya `Arc` gibi akıllı işaretçiler üzerinden uygulanabilir.
trait PointerFamily {
    type Pointer<T>: Deref<Target = T>;

    fn new<T>(value: T) -> Self::Pointer<T>;
}

/// Bir dizi öğenin ödünç alınmasına izin verir.
/// Verileri bitişik olarak depolaması gerekmeyen
/// "NdArray" benzeri türler için kullanışlıdır.
trait BorrowArray<T> {
    type Array<'x, const N: usize> where Self: 'x;

    fn borrow_array<'a, const N: usize>(&'a self) -> Self::Array<'a, N>;
}

Gördüğünüz gibi, GAT'ler oldukça çok yönlüdür ve şu anda yazılamayan bir dizi kalıbı mümkün kılar. Daha fazla bilgi için, geçen yıl yayınlanan istikrar duyurusunu duyuran gönderiye veya geçen hafta yayınlanan stabilizasyon duyurusu gönderisine göz atın. İlki, yukarıdaki birkaç örneğin biraz daha derinine inerken, ikincisi bu stabilizasyonun bilinen bazı sınırlamalarından bahsediyor.

Gece(Nightly) referansının ilgili türler bölümünde veya orijinal RFC'de (6,5 yıl önce açılmıştı!) daha derinlemesine okumalar bulunabilir.

`let`- `else` deyimleri

Bu, reddedilebilir bir modele sahip yeni bir tür let ifadesi ve bu model eşleşmediğinde yürütülen bir ıraksayan else bloğu sunar.

let PATTERN: TYPE = EXPRESSION else {
    DIVERGING_CODE;
};

Normal let ifadeleri yalnızca, statik olarak her zaman eşleştiği bilinen reddedilemez kalıpları kullanabilir. Bu model genellikle yalnızca tek bir değişken bağlamadır, ancak yapılar, demetler ve diziler gibi bileşik türleri de açabilir. Ancak bu, şimdiye kadar bir enum varyantını çıkarmak gibi koşullu eşleşmeler için kullanılamıyordu! let-else ile reddedilebilir bir model, normal bir let gibi çevreleyen kapsamdaki değişkenleri eşleştirebilir ve bağlayabilir veya model eşleşmediğinde farklılaşabilir (örneğin,break, return, panic!).


fn get_count_item(s: &str) -> (u64, &str) {
    let mut it = s.split(' ');
    let (Some(count_str), Some(item)) = (it.next(), it.next()) else {
        panic!("Can't segment count item pair: '{s}'");
    };
    let Ok(count) = u64::from_str(count_str) else {
        panic!("Can't parse integer: '{count_str}'");
    };
    (count, item)
}
assert_eq!(get_count_item("3 chairs"), (3, "chairs"));

Ad bağlamalarının kapsamı, bunu match veya if let-else ifadelerinden farklı kılan ana şeydir. Daha önce bu kalıpları talihsiz bir tekrarlama ve bir dış let ile tahmin edebilirdiniz:


let (count_str, item) = match (it.next(), it.next()) {
    (Some(count_str), Some(item)) => (count_str, item),
    _ => panic!("Can't segment count item pair: '{s}'"),
};
let count = if let Ok(count) = u64::from_str(count_str) {
    count
} else {
    panic!("Can't parse integer: '{count_str}'");
};

1.65.0 kararlı sürümünde neler var?

Genel ilişkili türler - Generic associated types (GATs)

let- else deyimleri

`let`- `else` deyimleri