Donated with HOFs

Author: buraksenyurt

fops/src/file_io_ops.rs

@@ -32,7 +32,7 @@ pub fn write_games_to_file(games: &[Game]) -> io::Result<()> {
     let mut contents = String::new();
     for g in games {
         contents.push_str(&g.to_string());
-        contents.push_str("\n");
+        contents.push('\n');
     }
     let mut f = File::create("games.dat")?;
     f.write_all(contents.as_bytes())?;
@@ -145,3 +145,52 @@ pub fn append_game_to_file(path: &str, game: &Game) -> io::Result<()> {
     writeln!(file, "{}", game)?;
     Ok(())
 }
+
+/*
+    Aşğıdaki fonksiyon games.dat dosyasında okuma ve Game türünden vektöre dönüştürm işini
+    iterasyon fonksiyonlarını kullanarak gerçekleştirir. Iterasyon fonksiyonları Higher- Order Functions
+    olarak da ifade edilebilir. Rust'ın bu yetkinliği Zero Cost Abstraction da sağlar. Yani normal for döngüleri ile
+    icra edilenler gibi herhangi bir çalışma zamanı performans kaybı söz konusu değildir.
+
+    Higher-Order Function'lar parametre olarak fonksiyon alan veya fonksiyon döndüren enstrümanlardır.
+    Fonksiyonel dillerde yer alan önemli özelliklerden birisidir.
+*/
+pub fn read_games_to_vec_with_hof() -> io::Result<Vec<Game>> {
+    read_games_from_file()?
+        .into_iter()
+        .map(|line| {
+            let cols: Vec<&str> = line.split('|').collect();
+            if cols.len() != 3 {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    format!("Beklenmeyen sütun sayısı: `{}`", line),
+                ));
+            }
+
+            let title = cols[0].to_string();
+            let year = cols[1]
+                .parse::<u16>()
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+            let popularity = cols[2]
+                .parse::<f32>()
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+            Ok(Game {
+                title,
+                year,
+                popularity,
+            })
+        })
+        .collect()
+}
+
+pub fn write_games_buffered_with_hof(path: &str, games: &[Game]) -> io::Result<()> {
+    let file = File::create(path)?;
+    let mut writer = BufWriter::new(file);
+
+    games
+        .iter()
+        .try_for_each(|game| writeln!(writer, "{}", game))?;
+
+    writer.flush()
+}

fops/src/main.rs

@@ -27,7 +27,7 @@ fn main() -> std::io::Result<()> {
         println!("{}", game);
     }
 
-    println!("\n\n");
+    println!("\nOyunları Vector İçerisine Okuma Sonuçları\n");
     let games = read_games_to_vec()?;
     for game in games {
         println!("{}", game);
@@ -40,12 +40,25 @@ fn main() -> std::io::Result<()> {
         println!("{}", game);
     }
 
-    println!("\n\n");
+    let games = load_games();
+    write_games_buffered_with_hof("newGames.dat", &games)?;
+    let games = read_games_from_file()?;
+    for game in games {
+        println!("{}", game);
+    }
+
+    println!("\nBufReader ile Okuma Sonuçları\n");
     let games = read_games_buffered_into_vec("newGames.dat")?;
     for game in games {
         println!("{}", game);
     }
 
+    println!("\nHOF Tekniği ile Okuma Sonuçları\n");
+    let games = read_games_to_vec_with_hof()?;
+    for game in games {
+        println!("{}", game);
+    }
+
     let shogun = Game {
         title: "Shogun Shawdown".to_string(),
         year: 2024,

io.md

@@ -391,4 +391,61 @@ pub fn append_game_to_file(path: &str, game: &Game) -> io::Result<()> {
     writeln!(file, "{}", game)?;
     Ok(())
 }
+```
+
+### Iterator Fonksiyonlarını Kullanmak
+
+Rust'ın güçlü özelliklerinden birisi de Zero Cost Abstraction sağlayan Higher-Order Function setidir. Genellikle
+fonksiyonel dillerde fonksiyonları parametre olarak alan veya döndüren fonksiyonlar yaygın olarak kullanılır. Rust'ın
+iterasyon metotları sonrasında gelen birçok fonksiyon bu tanıma uyar. Dolayısıyla Rust'ın da Higher-Order Function
+desteği sağladığını söyleyebiliriz.
+
+Aşğıdaki fonksiyon games.dat dosyasından okuma ve Game türünden vektöre dönüştürme işlevini iterasyon fonksiyonlarını
+kullanarak gerçekleştirir. Örnekte bunlar map ve collect çağrılarıdır. Bu metotların çalışma zamanı maliyetleri yoktur.
+
+```rust
+pub fn read_games_to_vec_with_hof() -> io::Result<Vec<Game>> {
+    read_games_from_file()?
+        .into_iter()
+        .map(|line| {
+            let cols: Vec<&str> = line.split('|').collect();
+            if cols.len() != 3 {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    format!("Beklenmeyen sütun sayısı: `{}`", line),
+                ));
+            }
+
+            let title = cols[0].to_string();
+            let year = cols[1]
+                .parse::<u16>()
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+            let popularity = cols[2]
+                .parse::<f32>()
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+            Ok(Game {
+                title,
+                year,
+                popularity,
+            })
+        })
+        .collect()
+}
+```
+
+Bu örnekten hareketle file_io_ops modülündeki diğer metotlarda da benzer kullanımlar icra edilebilir. Örneğin yazma
+işlemini ele aldığımız fonksiyonu aşağıdaki gibi değiştirebiliriz.
+
+```rust
+pub fn write_games_buffered_with_hof(path: &str, games: &[Game]) -> io::Result<()> {
+    let file = File::create(path)?;
+    let mut writer = BufWriter::new(file);
+
+    games
+        .iter()
+        .try_for_each(|game| writeln!(writer, "{}", game))?;
+
+    writer.flush()
+}
 ```