Rust programlama dili

use std::io; //User input kabul etmek için bir library
use rand::Rng; //Rng özelliği random number generatorların kullandığı metodlardır
use std::cmp::Ordering; //Bir çeşit enum. (Less, Greater ve Equal değişkenleri)

//Programda her zaman ilk çalıştırılacak kod main fonksiyonudur
fn main() {

//Programı sonsuz döngüye sokar
    loop {

/*"println" yazı çıktısı alır
"!" işareti çıktının fonksiyon olmadığını belirtir*/
        println!("*******************************");
        println!("*                             *");
        println!("*                             *");
        println!("*       Bir sayi girin        *");
        println!("*                             *");
        println!("*                             *");
        println!("*******************************");

/*"let" ile yeni değişken yaratılır.
Rust dilinde değişkenler default olarak immutable(sabit)dır.
Değişkeni değişebilir yapmak için "mut" eklenir
"="" işareti bu değişkene bir şey bağlayacağımızı söyler
"="in sağ tarafında, guess değişkenini neye bağlayacağımız yazar.
Burada guess değişkeni "String::new" çağrısının sonucudur.
"String::new" yeni bir String sonucu veren fonksiyondur. UTF-8 encodingli texttir.
"::", "new"in "String" veri tipine bağlı bir fonksiyon olduğunu söyler.
"new" fonksiyonu veri tiplerine bağlanabilir, bir çeşit yeni değer yapmaya yarar.
Yani "let mut guess = String::new();" tam olarak
Yeni ve şimdilik boş bir mutable String değişkeni yaratır*/
        let mut guess = String::new();

/*Belgenin başında çağırdığımız io modülünden stdin fonksiyonunu çağırır
stdin fonksiyonu user input işlemeye yarar
belgenin başında io modülünü çağırmasaydık bile "std::io::stdin" ile fonksiyonu kullanabilirdik.*/
        io::stdin()

/*bu metod user'dan input almak için
"&mut guess" argümanı user inputu hangi string'e depolaması gerektiğini söyler
"read_line"ın tam işi user inputu, mevcut içeriğinin üzerine yazmadan stringe eklemektir
"&" işaretinin görevi argümanın bir referans olduğunu söyler, farklı kodların aynı veriye erişebilmesi
için kolaylık sağlar. Bu sayede veri memory'e çok kez yazılmaz.
Tıpkı değişkenler gibi referanslar da default olarak immutable'dır.
Bu yüzden "&guess" yerine "&mut guess" yazdık*/
            .read_line(&mut guess)

/*Yukarıdaki kodda ";" olmadığı için aşağıdaki kod teknik olarak hala yukarıdaki satırın devamıdır.
bu kodu "io::stdin().read_line(&mut guess).expect("Girdiniz okunamadı!");" olarak da yazabilirdik
ancak bu okunaklı olmazdı.
.expect bir çeşit io::Result metodudur. burada bir err değeridir. Bir sebeple program girdiyi
okuyamazsa, programı çökertip hata verdirir*/
            .expect("Girdiniz okunamadı!");

/*Guess adında bir değişken oluşturduk, ama zaten böyle bir değişken vardı?
Rust, önceki değişkeni yenisiyle gölgelemeye izin verir.
Gölgelemeyle, iki farklı değişken yaratmak yerine tek değişkeni yeniden kullanırsınız
Bu özellik genellikle bir veri tipini bir başka tipe dönüştürürken kullanılır
trim metodu orijinal veriden, yeni veride olmayan her şeyi çıkarır
yani burada String'den, u32 içinde olmayan her şeyi çıkarır
parse metodu ise string'i bir tür sayıya ayrıştırır çünkü trim tek başına u32'yi karşılamaz
değişken let guess'i yazdıktan sonra ":" ile tam olarak ne tip bir sayı istediğimizi beliritiriz */
        let guess: u32 = match guess.trim().parse() {

            //Parse bir result type döndürür. Eğer girdi sayı değilse tekrar aynı ekranı verir
            //"_" her şey demek, yani user ne girerse girsin err içine al
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("*******************************");
        println!("*                             *");
        println!("*                             *");
        println!("*         Tahmininiz          *");
        println!("*                             *");
        println!("*                             *");
        println!("*******************************");

//{} bir placeholderdır. Birden fazla değer yazdırılabilir.
//Örnek:
/*
let x = 5;
let y = 10;

println!("x = {} and y = {}", x, y);
*/
        println!("{}", guess);

/*"rand::thread_rng" kullanacağımız random number generator fonksiyonu
bu fonksiyonun içinde gen_range mtodunu çağırdık, bu belirtilen aralık içinde random numara seçer
alt değer inclusive ama üst değer exclusive'dir*/
        let secret_number = rand::thread_rng().gen_range(1..4);
        println!("Gizli numara: {}", secret_number);

/*guess ile secret number'ı karşılaştırır, sonra Ordering enum'unun bir çeşidini döndürür.
Örneğin secret_number 38 olsun, user 50 girdisi versin. cmp metodu Ordering::Greater döndürecektir
match ise bu Ordering::Greater'ı aşağıdaki kollarla kıyaslayacak
Ordering::Greater, Ordering::Less ile uyuşmuyor, o zaman bu kodu okumadan es geçecek
Ordering::Greater, Ordering::Greater ile uyuuyor, o zaman bu kodu okuyacak
Ordering::Equal'ı hiç okumayacak çünkü doğru değer zaten döndü. */
        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Çok küçük!"),
            Ordering::Greater => println!("Çok büyük!"),
            Ordering::Equal => {
                println!("KAZANDINIZ!");
                //kazanınca looptan çık
                break;
            }
        }
    }
}