Rust Package Yapısı

Rust dilinde de diğer dillerde olan package yapısı genellikle “crate” adı verilen birimlerle oluşturulur. Bir crate, bir Rust projesindeki kodun bir parçasıdır ve genellikle birden fazla modül içerir. Modüller, kodun organize edilmesine ve yeniden kullanılabilirliğine yardımcı olan birimlerdir. Bir crate’in içinde birden fazla modül bulunabilir ve bu modüller birbirleriyle ilişkilendirilebilir.

Rust’ta, bir crate oluşturmak için aşağıdaki adımlar izlenir:

1. Konsolda cargo new <paket-adi> komutu kullanılarak yeni bir Rust projesi oluşturulur. Bu komut, varsayılan olarak src klasörü içinde main.rs dosyasıyla birlikte yeni bir paket oluşturur.
2. Crate’in yapısını oluşturmak için, src klasörü içinde yeni bir Rust dosyası oluşturulur ve modüller bu dosyalar içinde tanımlanır.
3. Crate içindeki modüller, “mod” anahtar kelimesiyle tanımlanır. Örneğin:

mod module1 {
    // module1 kodu burada yer alır
}

mod module2 {
    // module2 kodu burada yer alır
}

4. Modüllerin birbirleriyle ilişkilendirilmesi için, “use” anahtar kelimesi kullanılır. Örneğin

mod module1 {
    pub fn function1() {}
}

mod module2 {
    use crate::module1::function1;
    fn function2() {
        function1();
    }
}

Yukarıdaki örnekte, “module1” adlı bir modülde “function1” adlı bir fonksiyon tanımlanır. Bu fonksiyon, “module2” adlı bir modülde kullanılır. “use” anahtar kelimesi, “module1” modülündeki “function1” fonksiyonunun “module2” modülünde kullanılacağını belirtir.

1. Crate içindeki diğer Rust dosyaları da modüller halinde tanımlanabilir. Örneğin, “mod module3” şeklinde yeni bir Rust dosyası oluşturulabilir ve bu dosya da src klasörü içindeki diğer Rust dosyaları gibi aynı yapıda modüller içerebilir.
2. Crate’in bağımlılıkları, “Cargo.toml” dosyası aracılığıyla yönetilir. Bu dosya, crate’in adını, sürümünü ve bağımlılıklarını içerir. Bağımlılıklar, diğer crate’lerin adları ve sürümleri olarak tanımlanır.

Rust dilinde, crate’lerin yapısı ve modüller arasındaki ilişkilerin düzenlenmesi, kodun daha okunaklı ve yeniden kullanılabilir olmasını sağlar. Crate’lerin bağımlılıkları, “Cargo.toml” dosyası aracılığıyla yönetildiği için, crate’lerle ”bağımlılık zincirleri” oluşturulabilir. Bu sayede, bir crate’in diğer crate’ler tarafından kullanılabilmesi için gereken tüm bağımlılıkların otomatik olarak yüklenmesi ve yönetilmesi mümkün hale gelir. Böylece, Rust dilinde kod yazarken, kullanılacak olan kütüphaneler için ekstra bir çaba harcamak yerine, Cargo.toml dosyasında belirtilen bağımlılıkların yüklenmesi yeterlidir. Bu da, kodun daha hızlı ve kolay bir şekilde geliştirilmesine olanak sağlar. Ayrıca, crate’lerin modüller arasındaki ilişkilerinin düzenlenmesi sayesinde, kodun daha okunaklı ve anlaşılır olması sağlanır. Bu, hem kodun bakımını hem de yeniden kullanılabilirliğini artırır.

Rust dilinde crate’lerin özellikleri aşağıdaki gibi özetlenebilir:

• Kendi isim ve sürüm numarasına sahiptirler.
• Bağımsız olarak derlenebilirler.
• Birden fazla Rust dosyası içerebilirler.
• Modüller, Rust kodunu organize etmek ve yeniden kullanılabilirliğini artırmak için kullanılır.
• Crate’lerin bağımlılıkları, “Cargo.toml” dosyası aracılığıyla yönetilir.
• Cargo, crate’leri derlemek, test etmek, belgelemek ve yayınlamak için kullanılabilir.

Rust topluluğu, geniş bir crate deposu olan “crates.io” üzerinde birçok farklı amaç için kullanılabilecek binlerce crate sunmaktadır. Bu crate’ler, Rust geliştiricilerinin işlerini kolaylaştırmak ve Rust dilinin benimsenmesini artırmak için önemli bir role sahiptir.

Rust dilinde “module”, kodu organize etmek, yeniden kullanılabilirliği artırmak ve kod karmaşıklığını azaltmak için kullanılan bir kavramdır. Modüller, Rust’ta kodun bir bölümünü tanımlayan ve aynı dosyada veya farklı dosyalarda bulunabilen bloklardır.

Modüller, “mod” anahtar kelimesi ile tanımlanır ve bir dosya hiyerarşisi içinde yer alabilirler. Modüller, kodu bir veya daha fazla alt modüle bölerek daha fazla karmaşıklığı önler ve modülerliği sağlar.

Modüller, birbirleriyle ilişkili kodu bir arada tutarak, Rust kodlarının daha okunaklı ve yönetilebilir hale gelmesine yardımcı olur. Modüller, Rust kodlarının yeniden kullanılabilirliğini de artırır, çünkü aynı kod parçası farklı modüllerde kullanılabilir ve yeniden kullanılabilirliği artırır.

Örneğin, “my_project” adlı bir projede “main.rs” adlı bir dosya ve “utils.rs” adlı bir dosya olsun. “utils.rs” dosyasında tanımlanan fonksiyonların “main.rs” dosyasında kullanılabilmesi için “mod utils” ifadesi “main.rs” dosyasına eklenmelidir. Bu şekilde, “utils.rs” dosyasındaki kod, “utils” adlı bir modül olarak “main.rs” dosyasında kullanılabilir hale gelir.

Modüllerin faydaları şunlardır:

• Kod organizasyonu sağlar: Modüller, Rust kodlarını daha kolay okunabilir ve yönetilebilir hale getirir.
• Yeniden kullanılabilirliği artırır: Modüller, Rust kodunun yeniden kullanılabilirliğini artırarak, kodun tekrar yazılmasını önler.
• Farklı dosyalarda kodu kullanmayı sağlar: Modüller, farklı dosyalarda tanımlanan kodu bir arada tutarak, daha fazla karmaşıklığı önler.
• Kod kapsamını sınırlar: Modüller, kodun bir kısmını diğer kod parçalarından ayırmak için kullanılabilir. Bu, hataları ve kod çakışmalarını önlemeye yardımcı olabilir.

Sosyal medya hesaplarım: Twitter | Linkedin | Github | Youtube