Rust enum, impl, std::fmt, option, debug,

// ana programda kullanılmayan kod parçaları için rust bizi uyarıyor.// Uyarıları görmek istemiyorsak.#![allow(dead_code)]
enum yonler_basit{    yukari,    asagi,    sag,    sol,}enum yonler_tip{    yukari(u32), // tip verebilrim.    asagi {x: i32, y: f64},    sag,    sol,}enum yonler_tuple{    yukari(u32,u32),    asagi(u32,u32),    sag(u32,u32),    sol(u32,u32),}
















// bir oyun yapıyoruz farz edin.// asıl yapı burada. koordinat sistemindeki en küçük parça noktadır.struct Point{    x:i32,    y:i32,}use std::fmt; // fonksyion için gerekli.impl fmt::Debug for Point {    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {        write!(f, "x: {}, y:{}", self.x, self.y)    }}#[derive(Debug)] // debug sembolleri için gerekli. ana programı etkilemez.enum yonler{    yukari(Point),    asagi(Point),    sag(Point),    sol(Point),}#[derive(Debug)]enum Tuslar{    yukariTus(String),    asagiTus(String),    sagTus(String),    solTus(String),}impl yonler{    fn yon_eslesmesi(&self) -> Tuslar{        match *self { // "pointer dereferance" veriyi kullanmak için gerekli            // yönler önemli değil. tuşlar yakalansın.            yonler::yukari(_) => Tuslar::yukariTus(String::from("w basıldı")),            yonler::asagi(_) => Tuslar::asagiTus(String::from("s basıldı")),            yonler::sag(_) => Tuslar::sagTus(String::from("d basıldı")),            yonler::sol(_) => Tuslar::solTus(String::from("a basıldı")),        }    }}impl Tuslar{    /// yon_eslesmesi fonksiyonundan gelen "yukariTus("w basıldı")" sonucunu "w basıldı"    /// sonucunna çevirmek üzere kullanılır.    /// "ref s" ile string referans olarak alınır.    ///    ///  ref ve '&' işareti aynı şeyi ifade ediyor. c# benzeri ;)    /// let a = 5;    /// let b= &a;    /// let ref R=u;    fn yok_et(&self) -> &String{        match *self { // "pointer dereferance" veriyi kullanmak için gerekli            // yönler önemli değil. tuşlar yakalansın.            Tuslar::yukariTus(ref s) => s,            Tuslar::asagiTus(ref s) => s,            Tuslar::sagTus(ref s) => s,            Tuslar::solTus(ref s) => s,        }    }}fn enum_yon_fonksiyon(){    let u= yonler::yukari(Point {x:0, y:1});    let k = u.yon_eslesmesi();    let x=k.yok_et();
    println!("{:?}", k); // :? ve :#? için "#[derive(Debug)]" kullanmak gerek.    println!("{}", x);}


enum sekil{    Dikdortgen {genislik: u32, uzunluk: u32},    Kare(u32),    Cember(f64),}impl sekil{    fn alan(&self) -> f64{        match *self{            // tür dönüşümü "as" ile olur. "<değişken>= >veri> as i64" diye uygulanır.            sekil::Dikdortgen {genislik, uzunluk} => (genislik * uzunluk) as f64,            sekil::Kare(ref s) => (s*s) as f64,            sekil::Cember(ref r) => 3.142 * (r*r), // zaten f64        }    }}
fn sekil_fonksiyon(){    let r=sekil::Dikdortgen{genislik: 10, uzunluk: 48};    let s=sekil::Kare(7);    let c=sekil::Cember(8.9);
    let ar = r.alan();    println!("{}", ar);
    let a_s = s.alan();    println!("{}", a_s);
    let ac = c.alan();    println!("{}", ac);}

fn main() {    enum_yon_fonksiyon();    sekil_fonksiyon();
    bolum();
}
fn bolum(){    fn bolum_option(x: f64, y:f64) -> Option<f64> {        if y==0.0{            None // "null safety"        }else {            Some(x/y)        }    }
    let res = bolum_option(4.0,13.0);    match res {        Some(x) => println!("{:.5}",x), // virgülden sonra kaç basamak yazdıracak.        None => println!("0 ile bölünemez.")    }
}