Rust eğitimi: derlenebilir ayrıntılı açıklamalı ve konulara ayrılmış halde

rust_ogren.rs

// Bu bir satırlık yorumdur. Bir satırlık yorum böyle görünür

/*
ÇOK SATIRLI YORUM
Rust Mozilla Research tarafından geliştirilmesi desteklenen bir dildir.
Alt Seviye dil kontrolleri üzerine üst seviyenin kolaylığını ve veri 
güvenliğini ekler
*/

/// Dökümantasyon yorumu böyle yazılr. Markdown notasyonları desteklenir.
/// # Örnekler Başlığı
/// ```
/// fn main() {
/// 	println!("Hello world!");	
/// }
/// ```

//////////////////////
// Dilin Temelleri //
////////////////////

// Fonksiyonlar
// i32: 32 bit işaretli (+ / -) tamsayı
// i8, i16, i64 de var
// u işaretsizler (u8, u16, u32, u64)
// Değişken büyüklükler için isize, usize
// Tür kendiliğinden algınalabilir
// Deklare etmek istersek değişken adı : boşluk tür şeklinde
// Örnek: let tamsayi: i32 = 35;
// Örnek2: let tamsayi2 = 40;

fn ikisini_topla(x: i32, y: i32) -> i32 {
	// Ruby, perl gibi son satır özellikle belirtmeksizin return edilir.
	// return eden fonksonlarda -> bulunur ve onu tür bilgisi izler
	x + y
}

// Her Rust programı muhakkak bir main fonksiyonu içerir
fn main() {
	// Sayılar üzerine //

	// Immutable(Değiştirilemez) Binding (Bağlama/Bağlantı) oluşturma
	let x: i32 = 214;

	// float ve integer için son ek biçiminde tanımlama
	let y = 42i32;
	let f = 3.14f64;

	// Tür çıkarımı
	// Çoğunlukla rust derleyicisi bir değişkenin türünü belirleyebilir.
	// Yani görülebilir biçimde açık bir belirtim şekline mecbur değilsiniz.
	// ama öğretici boyunca açık belirtme şekli daha sık kullanılacak.

	let implicit_x = 1453;

	let implicit_f = 1.37;

	println!("{} ve {}", implicit_x, implicit_f);

	// Aritmetik bir işlemi değişkene Bağlama
	
	println!("İkisini topla fonksiyonunun döndüğü değer: {}", ikisini_topla(5, 4));
	
	let sum = x + y + 19;
	
	println!("sum değişkeninin değeri: {}", sum);

	// Değiştirlebilir Binding
	let mut mutable = 1;
	mutable += 2;
	
	println!("mutable değişkeninin değeri: {}", mutable);

	// Karakter Dizileri yani String //

	// Birebir string binding oluşturma
	let xs: &str = "merhaba genç!";

	// Yazdırma
	println!("Float değerimiz: {}, String Değerimiz: {}", f, xs);

	// Heap üzerinde bellek alanı ayrılmış string
	let s: String = "merhaba dünya.".to_string();

	// Bir string dilimi(string slice) string değişkeninin değiştirilemez görüntüsüdür.
	// Aşağıdaki temel olarak bir değiştirilemez ve stringi işaret eden işaretçi grubudur,
	// yani aslında string içeriğini barındırmaz, sabit olarak ayrılmış ya da bir nesne taşıyan
	// string önbelliğinnin başlangıcından bitimine kadar kısmına  işaret eden işaretçidir.
	let s_slice: &str = &s;

	println!("{} {}", s, s_slice);

	// Vektörler ve Diziler //

	// Sabit Büyüklükte Bir Dizi
	let four_ints: [i32; 4] = [1, 2, 3, 4];
	println!("İlk dizimiz: {:?}", four_ints);

	// Değiştirlebilir büyüklükte bir dizi yani Vektör
	let mut vector: Vec<i32> = vec![1, 2, 3, 4];
	vector.push(5);

	println!("Öge eklenmiş vektörümüz: {:?}", vector);

	// Bir dilim (slice) bir vektör ya da dizinin değiştirilemez görüntüsüdür.
	// String dilimlerine benzer bir mantıktadır.
	// Belli bir aralığı almak için: let dizi_dilim = &dizi[1..4] gibi
	let slice: &[i32] = &vector;

	// bir şeyi debug biçimlendirmesinde ekrana yazdırmak için: {:?}
	println!("Slice: {:?}", slice);

	// Tuple Değiken Tipi //

	// Bir tuple sabit büyüklükteki bir dizidir anca farklı türde değerler içerebilir.

	let tuple: (i32, &str, f64) = (1881, "samsun", 3.14);

	// Tanımlama şablonu örneği
	let (a, b, c) = tuple;

	println!("{} {} {}", a, b, c);

	// İndeks
	println!("tuple değişkeninin ilk itemi: {}", tuple.0);
	println!("tuple değişkeninin ikinci itemi: {}", tuple.1);
	println!("tuple değişkeninin içüncü itemi: {}", tuple.2);

    /////////////
    // Türler //
    ////////////

    // Struct ve Evet! Rust dilinde class yok :O
    // Koordinat bizim oluşturduğumuz bir struct
    // Tanımlamalar main fonksiyonu bitiminde başlıyor
    
    let origin: Koordinat = Koordinat { x: 0, y: 0};

    println!("origin değişkeni: x {} noktasında ve y {} noktasında.", origin.x, origin.y);

    let recipe: Cikolata = Cikolata(12.4, 3.14);

    println!("Çikolata: Kakao miktar: {} gr & Süt miktar {} gr", recipe.0, recipe.1);

    // Enumaratör
    // Alıştığımız C usulü

    enum Yonler {
			Sol,
			Sag,
			Yukari,
			Asagi,
		}

    let _up    = Yonler::Yukari; // bir değişkeni tanımlar kullanmazsak başında _ olmalı yoksa derlenmez
    let _down  = Yonler::Asagi;
    let _left  = Yonler::Sol;
    let _right = Yonler::Sag;

    //Alan ile Enumaratör

    enum OptionalInteger {
    	BirInteger(i32),
    	Nothing,
    }

    let _four    = OptionalInteger::BirInteger(4);
    let _nothing = OptionalInteger::Nothing;

    // ve Generics //

    let bir_foo = Foo { bar: 1923 };

    println!("bir_foo değişkenindeki bar değeri: {}", bir_foo.get_bar());

    let baska_bir_foo = Foo { bar: 1919 };

    println!("{:?}", baska_bir_foo.frobnicate());

    // Detaylı Olarak Şablon Eşleşmesi (Pattern Matching)
    let bar = FooBar {x: 23, y: OptionalI32::AnI32(1920) };

    match bar {
        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
            println!("Sayılar 0!"),

        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
            println!("Sayılar aynı"),
        FooBar { x: n, y: OptionalI32::AnI32(m) } =>
            println!("Farklı sayılar: {} {}", n, m),
        FooBar { x: _, y: OptionalI32::Nothing } =>
            println!("İkinci sayı Nothing!"),
    }

    // Akış Denetimi //

    // Döngü ve iterasyon
    let dizi = [3, 5, 8];
    for i in dizi.iter() {
    	println!("{}", i);
    }

    // Range
    for i in 0..40 {
    	print!("{}", i);
	print!(" ");
    }

    println!("\n");

    // if / else 
    if 5 > 0 {
    	println!("Mantıklı");
    }else {
    	println!("Yok artık!");
    }

    let deger = 1914;

    // bir ifadeymişçesine if
    let degisken = if deger == 1914 {"birinci"} else {"ikinci"};
    println!("{}: {}", degisken, deger);

    // while döngüsü
    let mut sayac = 0;
    
    while sayac < 10 {
    	println!("{}", sayac);
    	sayac += 1;
    }

    // sonsuz döngü
    let enfazla = 10;
    let mut digersayac = 0;

    loop {
    	println!("Biri break ile durdurmadıkça döner durur!");

    	if digersayac == enfazla {
    		break;
    	}

    	digersayac += 1;
    }

    /////////////////////////////////////////////
    // Bellek Güvenliği & İşaretçiler(pointer) //
    ////////////////////////////////////////////

    // Sahiplenme: Bir işaretçiyi(pointer) bir seferde sadece BIR TEK nesne sahiplenir
    let mut benim: Box<i32> = Box::new(1914);
    *benim = 1916; // bu bir dereference örneğidir
    // Burada, `simdi_benim` `benim` değişkeninin sahipliğini alır. Başka bir ifadeyle, `benim` taşındı.
    let mut simdi_benim = benim;
    *simdi_benim += 3;

    println!("{}", simdi_benim); // 1919 dönecek

    // println!("{}", benim); // bu kesinlikle derlenmez çünkü artık işaretçiye `simdi_benim` sahip
    // Reference(referans :) ) başka bir dataya referans eden değiştirilemez bir işaretçidir
    // Bir referans değer aldığında bir bunu ödünç alındı(barrowed) olarak adlandırırız
    // Değer değiştirilemez biçimde ödünç alındığında Değiştirilemez ve Taşınamaz
    // Bir ödünç alma bulunduğu scope sona erdiğinde sona erer

    let mut _oylebirdegisken = 2017;
    _oylebirdegisken = 2013;
    let referans_degisken: &i32 = &_oylebirdegisken;

    println!("{}", _oylebirdegisken); // İlkel tiplerde ayrı bir referans pointer olmadığından oylebirdegisken kullanılabilir

    println!("{}", *referans_degisken);

    // Artık oylebirdegisken = 15; // derlenmez çünkü oylebirdegisken ödünç alındı
    // *referans_degisken = 666; // bu da derlenmeyecektir çünkü referans_değişken değiştirlemez bir referans

    // Değiştirilebilir Referans
     // Değer değiştirilebilir olarak ödünç alındığında (borrowed) tümüyle erişilmezdir.
     let mut oylebirdegisken2 = 1945;
     let referans_degisken2: &mut i32 = &mut oylebirdegisken2;

     *referans_degisken2 += 2; // '*' işareti ile değiştirilebilir olarak ödünç alınmış oylebirdegisken2 işaret edilir

     println!("{}", *referans_degisken2); // 1947, // eğer yerinde oylebirdegisken2 olursa derlenmeyecek

     // referans_degisken2 &mut i32 tipinde, öyle bir i32 yi referans gösterir değeri değil
     // oylebirdegisken2 = 2023; // derlenmez çünkü oylebirdegisken2 ödünç alındı.


}		

// Aynı enum farklı adla public erişiminde BURADA (OptionalInteger)
pub enum OptionalI32 {
	AnI32(i32),
	Nothing,
}

// STRUCT TANIMLARI BURADA //
struct Koordinat {
	x: i32,
	y: i32,
}

struct Cikolata(f64, f64); // Bir tuple struct örneği

struct Foo<T> {
	bar: T,
}

// Method
impl<T> Foo<T> {
	// Methodlar belirtilmesi gereken bir self parametresi alırlar.
	// mesela bir getter gibi düşünelim
	fn get_bar(self) -> T {
		self.bar
	}
}

// Trait | Diğer dillerdeki Interface gibi düşünebilirsiniz
trait  Frobnicate<T> {
	fn frobnicate(self) -> Option<T>;
}

impl<T> Frobnicate<T> for Foo<T> {
	fn frobnicate(self) -> Option<T> {
		Some(self.bar)
	}
}

// Şablon Eşleşmesi Yeni bir Struct
struct FooBar {
	x: i32,
	y: OptionalI32,
}

// STRUCT TANIMLARI BURADA BİTTİ //