{"id":9558,"date":"2025-06-08T21:28:03","date_gmt":"2025-06-08T20:28:03","guid":{"rendered":"https:\/\/solidt.eu\/site\/?p=9558"},"modified":"2025-12-30T12:25:37","modified_gmt":"2025-12-30T11:25:37","slug":"rust-mutable-iterator-example","status":"publish","type":"post","link":"https:\/\/solidt.eu\/site\/rust-mutable-iterator-example\/","title":{"rendered":"Rust Mutable Iterator example"},"content":{"rendered":"\n
pub trait Explainable {\n    fn do_explain(&self)-> String;\n}\n\npub trait HasAccount {\n    fn get_account(&self)-> String;\n    fn change_account(&mut self, new_value: &str);\n}\n\npub struct Person {\n    name: String,\n    account: String\n}\n\nimpl Explainable for Person {\n    fn do_explain(&self)-> String {\n        return self.name.clone() + \" \" + self.account.as_str()\n    }\n}\n\nimpl HasAccount for Person {\n    fn change_account(&mut self, new_value: &str) {\n        self.account = new_value.to_string();\n    }\n    \n    fn get_account(&self)-> String {\n        return self.account.clone();\n    }\n}\n\nfn change_accounts<'a>(persons: impl Iterator<Item = &'a mut Person>) {\n    for p in persons {\n        println!(\"Changing person: {}\", p.name);\n        let mut new_str= String::with_capacity(100);\n        new_str.push_str(&p.account);\n        new_str.push_str(\"_020\");\n        p.change_account(&new_str);\n    }\n}\n\nfn change_accounts2<'a>(persons: impl Iterator<Item = &'a mut dyn HasAccount>) {\n    for p in persons {\n        let mut new_str = String::with_capacity(100);\n        new_str.push_str(&p.get_account());\n        new_str.push_str(\"_020\");\n        p.change_account(&new_str);\n    }\n}\n\nfn change_accounts3<'a, I>(persons: I)\nwhere\n    I: IntoIterator<Item = &'a mut dyn HasAccount>,\n{\n    for p in persons {\n        let mut new_str = String::with_capacity(100);\n        new_str.push_str(&p.get_account());\n        new_str.push_str(\"_020\");\n        p.change_account(&new_str);\n    }\n}\n\nfn change_accounts4<'a, I>(persons: I)\nwhere\n    I: IntoIterator<Item = &'a mut Box<dyn HasAccount>>,\n{\n    for p in persons {\n        let mut new_str = String::with_capacity(100);\n        new_str.push_str(&p.get_account());\n        new_str.push_str(\"_020\");\n        p.change_account(&new_str);\n    }\n}\n\n\/\/ Trait with both traits\ntrait Entity: Explainable + HasAccount {}\nimpl<T: Explainable + HasAccount> Entity for T {}\n\n\nfn explain_all<'a>(items: impl IntoIterator<Item = &'a Box<dyn Entity>>) {\n    for item in items {\n        println!(\"{}\", item.do_explain());\n    }\n}\n\nfn change_all<'a>(items: impl IntoIterator<Item = &'a mut Box<dyn Entity>>) {\n    for item in items {\n        let mut new_str = item.get_account();\n        new_str.push_str(\"_mod\");\n        item.change_account(&new_str);\n    }\n}\n\n\nfn get_boxed_entities1() -> Vec<Box<dyn Entity>> {\n    vec![\n        Box::new(Person { name: \"Piet\".into(), account: \"abc\".into() }),\n        Box::new(Person { name: \"Klaas\".into(), account: \"xyz\".into() }),\n    ]\n}\n\n\/\/ return an iterator\nfn get_boxed_entities2() -> impl Iterator<Item = Box<dyn Entity>> {\n    return vec![\n        Box::new(Person { name: \"Piet\".into(), account: \"abc\".into() }),\n        Box::new(Person { name: \"Klaas\".into(), account: \"xyz\".into() }),\n    ]\n    .into_iter()\n    .map(|p| p as Box<dyn Entity>)\n}\n\n\n\nfn main() {\n    println!(\"Hello, world!\");\n\n    let mut persons = vec![\n        Person { name: \"Jan\".into(), account: \"2345234\".into() },\n        Person { name: \"Kees\".into(), account: \"342523\".into() }\n    ];\n\n    for p in persons.iter() { \/\/ <- using .iter() here to allow multiple loops\n        let s = p.do_explain();\n        println!(\"{}\", s);\n    }\n\n    for p in persons.iter_mut() {\n        let new_str= p.account.clone() + \"_010\";\n        p.change_account(&new_str);\n    }\n\n    change_accounts(persons.iter_mut());\n    change_accounts(persons.iter_mut());\n\n    change_accounts2(persons.iter_mut().map(|p| p as &mut dyn HasAccount));\n\n    change_accounts3(persons.iter_mut().map(|p| p as &mut dyn HasAccount));\n\n\n    for p in persons.iter() {\n        let s = p.do_explain();\n        println!(\"{}\", s);\n    }\n\n    \/\/ step 2\n    \n    let mut boxed: Vec<Box<dyn HasAccount>> = vec![\n        Box::new(Person { name: \"Piet\".into(), account: \"abc\".into() }),\n        Box::new(Person { name: \"Klaas\".into(), account: \"xyz\".into() }),\n    ];\n\n    change_accounts4(boxed.iter_mut()); \/\/boxed.iter_mut().map(|p| p.as_mut())\n\n    \/\/ step 3\n\n    let mut list: Vec<Box<dyn Entity>> = vec![\n        Box::new(Person { name: \"Jan\".into(), account: \"123\".into() }),\n        Box::new(Person { name: \"Kees\".into(), account: \"456\".into() }),\n    ];\n\n    \/\/ read\n    explain_all(list.iter()); \/\/.map(|x| x.as_ref())\n\n    \/\/ write\n    let iter = list.iter_mut(); \/\/.map(|x| x.as_mut())\n    change_all(iter);\n\n    \/\/ read again\n    explain_all(list.iter()); \/\/.map(|x| x.as_ref())\n\n\n    let mut list2 = get_boxed_entities1();\n    explain_all(list2.iter()); \n    let iter = list2.iter_mut();\n    change_all(iter);\n    explain_all(list2.iter());\n\n\n    let mut list3: Vec<Box<dyn Entity>> = get_boxed_entities2().collect();\n    explain_all(list3.iter()); \n    change_all(list3.iter_mut());\n    explain_all(list3.iter());\n\n    println!(\"Finished\");\n}<\/pre>\n\n\n\n
trait IntoBoxedA<'a>: IntoIterator<Item = &'a Box<dyn A>> {}\nimpl<'a, T> IntoBoxedA<'a> for T where T: IntoIterator<Item = &'a Box<dyn A>> {}\n\n\n\/\/ 3 variants with the same behaviour:\n\nfn process1<'a, T: IntoBoxedA<'a>>(items: T) {\n    ...\n}\n\nfn process1<'a, T>(items: T)\nwhere\n    T: IntoBoxedA<'a>\n{\n    ...\n}\n\nfn process1<'a>(items: impl IntoBoxedA<'a>) {\n    ...\n}\n\n\n\n\ud83d\udc49 Kies impl Trait voor korte functies, en de T: Trait-vorm als je meerdere trait bounds of het concrete generieke type nodig hebt.\n<\/pre>\n\n\n\n
Per trait a concrete alias<\/p>\n\n\n\n
trait IntoBoxedA<'a>: IntoIterator<Item = &'a Box<dyn A>> {}\nimpl<'a, T> IntoBoxedA<'a> for T where T: IntoIterator<Item = &'a Box<dyn A>> {}\n\ntrait IntoBoxedB<'a>: IntoIterator<Item = &'a Box<dyn B>> {}\nimpl<'a, T> IntoBoxedB<'a> for T where T: IntoIterator<Item = &'a Box<dyn B>> {}\n\ntrait IntoBoxedC<'a>: IntoIterator<Item = &'a Box<dyn C>> {}\nimpl<'a, T> IntoBoxedC<'a> for T where T: IntoIterator<Item = &'a Box<dyn C>> {}\n\n\nfn process1<'a, T: IntoBoxedA<'a>>(items: T) {\n    ...\n}\n\nfn process2<'a, T: IntoBoxedB<'a>>(items: T) {\n    ...\n}\n\n\nmacro_rules! define_into_boxed {\n    ($name:ident, $trait:path) => {\n        pub trait $name<'a>: IntoIterator<Item = &'a Box<dyn $trait>> {}\n        impl<'a, T> $name<'a> for T\n        where\n            T: IntoIterator<Item = &'a Box<dyn $trait>>,\n        {}\n    };\n}\n\ntrait A {\n    fn do_a(&self);\n}\n\ntrait B {\n    fn do_b(&self);\n}\n\ntrait C {\n    fn do_c(&self);\n}\n\ndefine_into_boxed!(IntoBoxedA, A);\ndefine_into_boxed!(IntoBoxedB, B);\ndefine_into_boxed!(IntoBoxedC, C);\n\nfn process1<'a>(items: impl IntoBoxedA<'a>) {\n    for a in items {\n        a.do_a();\n    }\n}\n\nfn process2<'a>(items: impl IntoBoxedB<'a>) {\n    for b in items {\n        b.do_b();\n    }\n}\n\n\n<\/pre>\n\n\n\n
Limetime errors<\/p>\n\n\n\n
\/\/ error[E0597]: `boxed` does not live long enough\n\/\/ error[E0759]: `boxed` captured by a closure, but it is dropped before the closure is called\n\n\nlet mut boxed: Vec<Box<dyn HasAccount>> = vec![\n    Box::new(Person { name: \"Piet\".into(), account: \"abc\".into() }),\n    Box::new(Person { name: \"Klaas\".into(), account: \"xyz\".into() }),\n];\n\nedit_accounts(boxed.iter_mut().map(|p| p.as_mut()));\n\n\/\/ solution: collect into a Vec, this causes the iterator to be used\n\nlet mut boxed: Vec<Box<dyn HasAccount>> = vec![\n    Box::new(Person { name: \"Piet\".into(), account: \"abc\".into() }),\n    Box::new(Person { name: \"Klaas\".into(), account: \"xyz\".into() }),\n];\n\nlet mapped: Vec<_> = boxed.iter_mut().map(|p| p.as_mut()).collect();\nedit_accounts(mapped);\n\n\/\/ link original variable lifetime to iterator:\nfn make_iter<'a>(\n    boxed: &'a mut [Box<dyn HasAccount>]\n) -> impl Iterator<Item = &'a mut dyn HasAccount> {\n    boxed.iter_mut().map(|b| b.as_mut())\n}\n\n\n\/\/ Full example:\n\ntrait HasAccount {\n    fn set_account(&mut self, account: &str);\n}\n\nstruct Person {\n    name: String,\n    account: String,\n}\n\nimpl HasAccount for Person {\n    fn set_account(&mut self, account: &str) {\n        self.account = account.to_string();\n    }\n}\n\nfn make_iter<'a>(\n    boxed: &'a mut [Box<dyn HasAccount>]\n) -> impl Iterator<Item = &'a mut dyn HasAccount> {\n    boxed.iter_mut().map(|b| b.as_mut())\n}\n\nfn edit_accounts<'a, I>(accounts: I)\nwhere\n    I: Iterator<Item = &'a mut dyn HasAccount>,\n{\n    for a in accounts {\n        a.set_account(\"updated\");\n    }\n}\n\nfn main() {\n    let mut boxed: Vec<Box<dyn HasAccount>> = vec![\n        Box::new(Person { name: \"Piet\".into(), account: \"abc\".into() }),\n        Box::new(Person { name: \"Klaas\".into(), account: \"xyz\".into() }),\n    ];\n\n    let iter = make_iter(&mut boxed);\n    edit_accounts(iter);\n}\n\n\n\n\n<\/pre>\n\n\n\n
Service returning array\/vec<\/p>\n\n\n\n
Goede vraag \u2014 dit raakt precies de ownership-filosofie van Rust<\/strong> \ud83d\udc4d
Het korte antwoord is: nee, je hoeft meestal g\u00e9\u00e9n lijst mee te geven om te vullen<\/strong>.
De meest idiomatische<\/em> manier is dat je functie zelf de data maakt en deze teruggeeft<\/strong>, zodat de caller automatisch owner wordt.<\/p>\n\n\n\n
Hieronder zet ik de patronen op een rij, van meest aanbevolen<\/em> \u2192 meer uitzonderlijk<\/em>.<\/p>\n\n\n\n
\n\n\n\n
\u2705 1. Functie retourneert een Vec<T><\/code> (aanbevolen)<\/strong><\/h2>\n\n\n\n
Dit is veruit het meest gebruikte en duidelijke patroon.<\/p>\n\n\n\n
struct Item {\n    id: i32,\n    name: String,\n}\n\nfn load_items() -> Vec<Item> {\n    let mut items = Vec::new();\n\n    items.push(Item { id: 1, name: \"A\".into() });\n    items.push(Item { id: 2, name: \"B\".into() });\n\n    items\n}\n<\/pre>\n\n\n\n
Gebruik:<\/p>\n\n\n\n
fn main() {\n    let items = load_items(); \/\/ main is owner\n    println!(\"{}\", items.len());\n}\n<\/pre>\n\n\n\n
Waarom dit goed is<\/h3>\n\n\n\n
    \n
  • Ownership is glashelder<\/strong><\/li>\n\n\n\n
  • Geen lifetimes nodig<\/li>\n\n\n\n
  • Compiler kan optimaliseren (NRVO \/ move elision)<\/li>\n\n\n\n
  • Sluit perfect aan bij Rust-idiomen<\/li>\n<\/ul>\n\n\n\n
    \ud83d\udc49 In 90% van de gevallen is dit wat je wilt<\/strong><\/p>\n\n\n\n
    \n\n\n\n
    \u2705 2. Result + ownership (bij fouten \/ IO \/ services)<\/h2>\n\n\n\n
    Voor services is dit vaak n\u00f3g realistischer:<\/p>\n\n\n\n
    fn load_items() -> Result<Vec<Item>, Box<dyn std::error::Error>> {\n    Ok(vec![\n        Item { id: 1, name: \"A\".into() },\n        Item { id: 2, name: \"B\".into() },\n    ])\n}\n<\/pre>\n\n\n\n
    Gebruik:<\/p>\n\n\n\n
    let items = load_items()?; \/\/ caller is owner\n<\/pre>\n\n\n\n
    \n\n\n\n
    \u26a0\ufe0f 3. Caller geeft een &mut Vec<T><\/code> mee (meestal niet nodig)<\/h2>\n\n\n\n
    Dit kan<\/em>, maar is alleen zinvol als je expliciet wilt toevoegen aan bestaande data<\/strong>.<\/p>\n\n\n\n
    fn load_items_into(items: &mut Vec<Item>) {\n    items.push(Item { id: 1, name: \"A\".into() });\n}\n<\/pre>\n\n\n\n
    Gebruik:<\/p>\n\n\n\n
    let mut items = Vec::new();\nload_items_into(&mut items);\n<\/pre>\n\n\n\n
    Nadelen<\/h3>\n\n\n\n
      \n
    • Minder duidelijk ownership<\/li>\n\n\n\n
    • Minder ergonomisch<\/li>\n\n\n\n
    • Sneller borrow-complexiteit<\/li>\n<\/ul>\n\n\n\n
      \ud83d\udc49 Gebruik dit alleen als:<\/p>\n\n\n\n
        \n
      • je wilt append\u2019en<\/em><\/li>\n\n\n\n
      • performancekritisch bent<\/li>\n\n\n\n
      • of API-compatibiliteit nodig hebt<\/li>\n<\/ul>\n\n\n\n
        \n\n\n\n
        \u2705 4. Iterator teruggeven (lazy \/ streaming)<\/h2>\n\n\n\n
        Als je service potentieel veel data<\/em> heeft of lazy wil zijn:<\/p>\n\n\n\n
        fn load_items() -> impl Iterator<Item = Item> {\n    vec![\n        Item { id: 1, name: \"A\".into() },\n        Item { id: 2, name: \"B\".into() },\n    ].into_iter()\n}\n<\/pre>\n\n\n\n
        Gebruik:<\/p>\n\n\n\n
        let items: Vec<Item> = load_items().collect();\n<\/pre>\n\n\n\n
        Caller is alsnog owner.<\/p>\n\n\n\n
        \n\n\n\n
        \ud83e\udde0 5. Service-struct met methode (typisch voor \u201cservices\u201d)<\/h2>\n\n\n\n
        In jouw \u201cservice\u201d-context waarschijnlijk het mooist:<\/p>\n\n\n\n
        struct ItemService;\n\nimpl ItemService {\n    fn get_items(&self) -> Vec<Item> {\n        vec![\n            Item { id: 1, name: \"A\".into() },\n            Item { id: 2, name: \"B\".into() },\n        ]\n    }\n}\n<\/pre>\n\n\n\n
        Gebruik:<\/p>\n\n\n\n
        let service = ItemService;\nlet items = service.get_items(); \/\/ ownership hier\n<\/pre>\n\n\n\n
        \n\n\n\n
        \u274c Wat je meestal niet<\/strong> wilt<\/h2>\n\n\n\n
        fn get_items<'a>() -> &'a Vec<Item> { ... }\n<\/pre>\n\n\n\n
        \u274c Probleem:<\/p>\n\n\n\n
          \n
        • Wie is owner?<\/li>\n\n\n\n
        • Lifetime hell<\/li>\n\n\n\n
        • Vaak onmogelijk zonder static<\/code> of interne opslag<\/li>\n<\/ul>\n\n\n\n
          \n\n\n\n
          \ud83e\udded Beslisboom<\/h2>\n\n\n\n
          Situatie<\/th>Beste keuze<\/th><\/tr><\/thead>
          Caller moet owner zijn<\/td>fn -> Vec<T><\/code><\/td><\/tr>
          Kan falen<\/td>fn -> Result<Vec<T>, E><\/code><\/td><\/tr>
          Grote\/lazy data<\/td>fn -> impl Iterator<Item = T><\/code><\/td><\/tr>
          Append aan bestaande data<\/td>fn(&mut Vec<T>)<\/code><\/td><\/tr>
          Service-achtig<\/td>impl Service { fn -> Vec<T> }<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
          \n\n\n\n
          \ud83c\udfaf Samenvatting<\/h2>\n\n\n\n
          \n
          Rust wil dat ownership expliciet is \u2014 en retourneren is de schoonste vorm daarvan.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
          \u2714\ufe0f Laat je functie gewoon een Vec<T><\/code> teruggeven<\/strong>
          \u274c Niet vullen via parameters tenzij je daar echt een reden voor hebt<\/p>\n\n\n\n
          Als je wilt, kan ik dit ook laten zien met:<\/p>\n\n\n\n
            \n
          • async services<\/li>\n\n\n\n
          • database calls<\/li>\n\n\n\n
          • trait-based services<\/li>\n\n\n\n
          • Arc<Vec<T>><\/code> \/ shared ownership<\/li>\n<\/ul>\n\n\n\n
            Zeg maar \ud83d\udc4d<\/p>\n\n\n\n
            Zeker \ud83d\udc4d Hieronder laat ik drie veelgebruikte manieren<\/strong> zien om deze functie aan te roepen, m\u00e9t nette error handling. Ik bouw het voorbeeld stap voor stap op.<\/p>\n\n\n\n
            Voor de volledigheid eerst een minimale Item<\/code>:<\/p>\n\n\n\n
            #[derive(Debug)]\nstruct Item {\n    id: i32,\n    name: String,\n}\n<\/pre>\n\n\n\n
            En jouw functie:<\/p>\n\n\n\n
            fn load_items() -> Result<Vec<Item>, Box<dyn std::error::Error>> {\n    Ok(vec![\n        Item { id: 1, name: \"A\".into() },\n        Item { id: 2, name: \"B\".into() },\n    ])\n}\n<\/pre>\n\n\n\n
            \n\n\n\n
            \u2705 1. Idiomatic: ?<\/code> gebruiken (meest aanbevolen)<\/strong><\/h2>\n\n\n\n
            Dit is wat je in bijna alle Rust-services en binaries ziet.<\/p>\n\n\n\n
            fn main() -> Result<(), Box<dyn std::error::Error>> {\n    let items = load_items()?; \/\/ fout? \u2192 automatisch terug uit main\n\n    for item in items {\n        println!(\"{:?}\", item);\n    }\n\n    Ok(())\n}\n<\/pre>\n\n\n\n
            Wat gebeurt hier?<\/h3>\n\n\n\n
              \n
            • load_items()<\/code> geeft Result<Vec<Item>, E><\/code><\/li>\n\n\n\n
            • ?<\/code>:\n
                \n
              • bij Ok<\/code> \u2192 unwrapt de Vec<Item><\/code><\/li>\n\n\n\n
              • bij Err<\/code> \u2192 returned direct uit main<\/code><\/li>\n<\/ul>\n<\/li>\n\n\n\n
              • main<\/code> mag<\/strong> Result<\/code> teruggeven \u2192 Rust print automatisch de fout<\/li>\n<\/ul>\n\n\n\n
                \u2714\ufe0f Simpel, leesbaar, idiomatisch<\/strong><\/p>\n\n\n\n
                \n\n\n\n
                \u2705 2. Expliciet matchen (als je zelf wilt reageren)<\/strong><\/h2>\n\n\n\n
                Handig als je logging of alternatieve flow wilt.<\/p>\n\n\n\n
                fn main() {\n    match load_items() {\n        Ok(items) => {\n            println!(\"Items geladen:\");\n            for item in items {\n                println!(\"{:?}\", item);\n            }\n        }\n        Err(err) => {\n            eprintln!(\"\u274c Fout bij laden van items: {}\", err);\n        }\n    }\n}\n<\/pre>\n\n\n\n
                \u2714\ufe0f Volledige controle
                \u274c Meer boilerplate<\/p>\n\n\n\n
                \n\n\n\n
                \u2705 3. if let Err<\/code> + early return<\/strong><\/h2>\n\n\n\n
                Fijn als je snel wilt stoppen:<\/p>\n\n\n\n
                fn main() {\n    let items = match load_items() {\n        Ok(items) => items,\n        Err(e) => {\n            eprintln!(\"\u274c Kan items niet laden: {}\", e);\n            return;\n        }\n    };\n\n    println!(\"{} items geladen\", items.len());\n}\n<\/pre>\n\n\n\n
                \n\n\n\n
                \ud83e\uddea 4. Met eigen fouttype (iets geavanceerder)<\/h2>\n\n\n\n
                Als je service groter wordt, is dit vaak beter dan Box<dyn Error><\/code>:<\/p>\n\n\n\n
                use std::fmt;\n\n#[derive(Debug)]\nenum LoadError {\n    DatabaseDown,\n}\n\nimpl fmt::Display for LoadError {\n    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n        write!(f, \"Database is niet bereikbaar\")\n    }\n}\n\nimpl std::error::Error for LoadError {}\n\nfn load_items() -> Result<Vec<Item>, LoadError> {\n    Err(LoadError::DatabaseDown)\n}\n<\/pre>\n\n\n\n
                Gebruik:<\/p>\n\n\n\n
                fn main() -> Result<(), LoadError> {\n    let items = load_items()?;\n    println!(\"{:?}\", items);\n    Ok(())\n}\n<\/pre>\n\n\n\n
                \n\n\n\n
                \ud83e\udde0 Samenvatting<\/h2>\n\n\n\n
                Situatie<\/th>Aanpak<\/th><\/tr><\/thead>
                CLI \/ service<\/td>main() -> Result<()><\/code> + ?<\/code><\/td><\/tr>
                UI \/ API<\/td>match<\/code> of map_err<\/code><\/td><\/tr>
                Library code<\/td>Eigen error type<\/td><\/tr>
                Snel stoppen<\/td>match<\/code> + return<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                \ud83d\udc49 Aanrader voor jouw voorbeeld<\/strong>:
                Gebruik variant #1 (?<\/code> in main<\/code>)<\/strong> \u2014 schoon en Rust-idiomatisch.<\/p>\n\n\n\n
                Als je wilt, kan ik dit ook laten zien in:<\/p>\n\n\n\n
                  \n
                • async context (tokio<\/code>)<\/li>\n\n\n\n
                • Web API handler<\/li>\n\n\n\n
                • unit tests (assert!(load_items().is_ok())<\/code>)<\/li>\n\n\n\n
                • service trait met meerdere implementaties<\/li>\n<\/ul>\n\n\n\n
                  Mooi voorbeeld \ud83d\udc4d Dit leent zich perfect<\/em> om te laten zien hoe je in Rust iteratoren<\/strong> maakt die hetzelfde doen als JS function*<\/code>.<\/p>\n\n\n\n
                  Rust heeft geen generators zoals JS, maar je bereikt hetzelfde met:<\/p>\n\n\n\n
                    \n
                  • structs + Iterator<\/code> trait<\/li>\n\n\n\n
                  • of iterator-adapters (map<\/code>, flat_map<\/code>)<\/li>\n\n\n\n
                  • zero-copy waar mogelijk (&str<\/code> slices)<\/li>\n<\/ul>\n\n\n\n
                    Ik laat hieronder een bewust eenvoudige CSV-parser<\/strong> zien, vergelijkbaar met jouw JS-code (dus geen volledige RFC4180).<\/p>\n\n\n\n
                    \n\n\n\n
                    \ud83c\udfaf Doel (1-op-1 met jouw JS)<\/h2>\n\n\n\n
                      \n
                    • String \u2192 regels iterator<\/strong><\/li>\n\n\n\n
                    • Regel \u2192 CSV-waarden iterator<\/strong><\/li>\n\n\n\n
                    • Waarden \u2192 decode \/ trim<\/li>\n<\/ul>\n\n\n\n
                      \n\n\n\n
                      1\ufe0f\u20e3 Iterator: regels uit een string<\/h1>\n\n\n\n
                      In Rust is dit verrassend simpel: lines()<\/code> is al een iterator<\/strong>.<\/p>\n\n\n\n
                      fn get_lines_from_string(source: &str) -> impl Iterator<Item = &str> {\n    source.lines()\n}\n<\/pre>\n\n\n\n
                      Gebruik:<\/p>\n\n\n\n
                      for line in get_lines_from_string(csv) {\n    println!(\"line: {}\", line);\n}\n<\/pre>\n\n\n\n
                      \n\n\n\n
                      2\ufe0f\u20e3 Iterator: CSV-waarden uit \u00e9\u00e9n regel<\/h1>\n\n\n\n
                      Hier maken we zelf een iterator<\/strong> (vergelijkbaar met function*<\/code>).<\/p>\n\n\n\n
                      CSV-iterator struct<\/h3>\n\n\n\n
                      struct CsvValues<'a> {\n    line: &'a str,\n    separator: char,\n    pos: usize,\n    in_string: bool,\n}\n<\/pre>\n\n\n\n
                      Constructor<\/h3>\n\n\n\n
                      fn get_csv_values_from_line<'a>(\n    line: &'a str,\n    separator: char,\n) -> CsvValues<'a> {\n    CsvValues {\n        line,\n        separator,\n        pos: 0,\n        in_string: false,\n    }\n}\n<\/pre>\n\n\n\n
                      Iterator-implementatie<\/h3>\n\n\n\n
                      impl<'a> Iterator for CsvValues<'a> {\n    type Item = &'a str;\n\n    fn next(&mut self) -> Option<Self::Item> {\n        let bytes = self.line.as_bytes();\n        let start = self.pos;\n\n        while self.pos < bytes.len() {\n            let c = bytes[self.pos] as char;\n\n            if c == '\"' {\n                self.in_string = !self.in_string;\n            } else if !self.in_string && c == self.separator {\n                let value = &self.line[start..self.pos];\n                self.pos += 1; \/\/ separator overslaan\n                return Some(value);\n            }\n\n            self.pos += 1;\n        }\n\n        if start < self.line.len() {\n            return Some(&self.line[start..]);\n        }\n\n        None\n    }\n}\n<\/pre>\n\n\n\n
                      \u2714\ufe0f Dit werkt lazy<\/strong>
                      \u2714\ufe0f Geen allocaties
                      \u2714\ufe0f Net als JS yield<\/code><\/p>\n\n\n\n
                      \n\n\n\n
                      3\ufe0f\u20e3 Waarde decoderen (zoals JS decodeValue<\/code>)<\/h1>\n\n\n\n
                      fn decode_value(value: &str) -> String {\n    value\n        .trim()\n        .trim_matches('\"')\n        .replace(\"\\\"\\\"\", \"\\\"\")\n}\n<\/pre>\n\n\n\n
                      \n\n\n\n
                      4\ufe0f\u20e3 Alles samen (zoals jouw JS for..of<\/code>)<\/h1>\n\n\n\n
                      fn main() {\n    let csv = r#\"value1,\"value,with,comma\",\"value \"\"with quotes\"\" inside\",value4\"#;\n\n    for line in get_lines_from_string(csv) {\n        println!(\"======================\");\n\n        for raw in get_csv_values_from_line(line, ',') {\n            let value = decode_value(raw);\n            println!(\"value: {}\", value);\n        }\n    }\n}\n<\/pre>\n\n\n\n
                      \n\n\n\n
                      \ud83d\udda8\ufe0f Output<\/h2>\n\n\n\n
                      ======================\nvalue: value1\nvalue: value,with,comma\nvalue: value \"with quotes\" inside\nvalue: value4\n<\/pre>\n\n\n\n
                      \n\n\n\n
                      \ud83e\udde0 Vergelijking JS vs Rust<\/h2>\n\n\n\n
                      JS<\/th>Rust<\/th><\/tr><\/thead>
                      function*<\/code><\/td>struct + impl Iterator<\/code><\/td><\/tr>
                      yield<\/code><\/td>Some(value)<\/code> in next()<\/code><\/td><\/tr>
                      Lazy<\/td>Lazy<\/td><\/tr>
                      String copies<\/td>Zero-copy (&str<\/code>)<\/td><\/tr>
                      Runtime checks<\/td>Compile-time safety<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                      \n\n\n\n
                      \ud83d\ude80 Bonus: iterator chaining (erg Rust-achtig)<\/h2>\n\n\n\n
                      Je kunt dit ook combineren<\/em>:<\/p>\n\n\n\n
                      let values: Vec<String> =\n    get_lines_from_string(csv)\n        .flat_map(|l| get_csv_values_from_line(l, ','))\n        .map(decode_value)\n        .collect();\n<\/pre>\n\n\n\n
                      \n\n\n\n
                      \ud83d\udccc Wanneer dit patroon gebruiken?<\/h2>\n\n\n\n
                        \n
                      • streaming parsing<\/li>\n\n\n\n
                      • grote bestanden<\/li>\n\n\n\n
                      • zero-copy verwerking<\/li>\n\n\n\n
                      • pipeline-achtige logica (net als JS generators)<\/li>\n<\/ul>\n\n\n\n
                        Als je wilt, kan ik ook:<\/p>\n\n\n\n
                          \n
                        • async iterators laten zien<\/li>\n\n\n\n
                        • een CsvParser<\/code> service maken<\/li>\n\n\n\n
                        • of laten zien hoe dit eruit ziet met BufRead<\/code> (file streaming)<\/li>\n<\/ul>\n\n\n\n
                          Zeg maar \ud83d\udc4d<\/p>\n\n\n\n
                          Ja \u2014 dit is precies het punt waar veel mensen uit JS\/Python tegenaan lopen in Rust<\/strong> \ud83d\ude42
                          Het korte, eerlijke antwoord is:<\/p>\n\n\n\n
                          \n
                          \u274c Rust heeft geen yield return<\/code>-syntax zoals JS of C#<\/strong>
                          \u2705 Maar je kunt bijna hetzelfde ergonomische resultaat<\/strong> krijgen met een paar idiomatische patronen.<\/p>\n<\/blockquote>\n\n\n\n
                          Ik laat ze oplopend zien, beginnend bij wat het dichtst bij yield<\/code> komt<\/em>.<\/p>\n\n\n\n
                          \n\n\n\n
                          \u2705 Optie 1: std::iter::from_fn<\/code> (het dichtst bij yield return<\/code>)<\/h2>\n\n\n\n
                          Dit is conceptueel bijna 1-op-1 yield<\/code><\/strong>.<\/p>\n\n\n\n
                          Definitie zoals jij vroeg<\/h3>\n\n\n\n
                          fn get_csv_values_from_line<'a>(\n    line: &'a str,\n    separator: char,\n) -> impl Iterator<Item = &'a str> {\n    let mut pos = 0usize;\n    let mut in_string = false;\n\n    std::iter::from_fn(move || {\n        let bytes = line.as_bytes();\n        let start = pos;\n\n        while pos < bytes.len() {\n            let c = bytes[pos] as char;\n\n            if c == '\"' {\n                in_string = !in_string;\n            } else if !in_string && c == separator {\n                let value = &line[start..pos];\n                pos += 1;\n                return Some(value); \/\/ \u2b05\ufe0f yield\n            }\n\n            pos += 1;\n        }\n\n        if start < line.len() {\n            pos = line.len();\n            return Some(&line[start..]); \/\/ \u2b05\ufe0f final yield\n        }\n\n        None\n    })\n}\n<\/pre>\n\n\n\n
                          Gebruik<\/h3>\n\n\n\n
                          for v in get_csv_values_from_line(line, ',') {\n    println!(\"value: {}\", v);\n}\n<\/pre>\n\n\n\n
                          Waarom dit zo goed is<\/h3>\n\n\n\n
                            \n
                          • Geen extra struct nodig<\/li>\n\n\n\n
                          • Geen impl Iterator for ...<\/code><\/li>\n\n\n\n
                          • State zit netjes in de closure<\/li>\n\n\n\n
                          • Some(...)<\/code> \u2248 yield<\/code><\/strong><\/li>\n<\/ul>\n\n\n\n
                            \ud83d\udc49 Dit is meestal wat je zoekt als je \u201cyield return\u201d denkt<\/strong><\/p>\n\n\n\n
                            \n\n\n\n
                            \ud83d\udfe1 Optie 2: Custom struct + impl Iterator<\/code> (meest expliciet)<\/h2>\n\n\n\n
                            Dit had je al gezien \u2014 dit is meer boilerplate<\/strong>, maar wel het fundament.<\/p>\n\n\n\n
                            Gebruik dit als:<\/p>\n\n\n\n
                              \n
                            • je iterator herbruikbaar is<\/li>\n\n\n\n
                            • je state wilt exposen<\/li>\n\n\n\n
                            • je performance-maximalisme wilt<\/li>\n<\/ul>\n\n\n\n
                              \n\n\n\n
                              \ud83d\udfe1 Optie 3: Vec<\/code> bouwen en into_iter()<\/code> (geen echte yield)<\/h2>\n\n\n\n
                              fn get_csv_values_from_line<'a>(\n    line: &'a str,\n    separator: char,\n) -> impl Iterator<Item = &'a str> {\n    let mut values = Vec::new();\n    let mut start = 0;\n    let mut in_string = false;\n\n    for (i, c) in line.char_indices() {\n        if c == '\"' {\n            in_string = !in_string;\n        } else if !in_string && c == separator {\n            values.push(&line[start..i]);\n            start = i + 1;\n        }\n    }\n\n    values.push(&line[start..]);\n    values.into_iter()\n}\n<\/pre>\n\n\n\n
                              \u274c Niet lazy
                              \u274c Extra allocaties
                              \u2714\ufe0f Simpel<\/p>\n\n\n\n
                              \n\n\n\n
                              \ud83d\ude80 Optie 4: Nightly Rust (#![feature(generators)]<\/code>) \u274c<\/h2>\n\n\n\n
                              Er bestaan<\/strong> generators in nightly Rust, maar:<\/p>\n\n\n\n
                                \n
                              • niet stabiel<\/li>\n\n\n\n
                              • syntax is anders<\/li>\n\n\n\n
                              • niet aanbevolen voor productie<\/strong><\/li>\n<\/ul>\n\n\n\n
                                \n\n\n\n
                                \ud83e\udde0 Vergelijking met C#\/JS<\/h2>\n\n\n\n
                                Concept<\/th>JS \/ C#<\/th>Rust<\/th><\/tr><\/thead>
                                yield<\/code><\/td>yield value<\/code><\/td>Some(value)<\/code><\/td><\/tr>
                                Generator state<\/td>impliciet<\/td>closure \/ struct<\/td><\/tr>
                                Lazy<\/td>ja<\/td>ja<\/td><\/tr>
                                Syntax sugar<\/td>ja<\/td>nee (bewust)<\/td><\/tr>
                                Zero-cost<\/td>\u274c<\/td>\u2705<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                                \n\n\n\n
                                \ud83c\udfaf Conclusie (belangrijk)<\/h2>\n\n\n\n
                                \n
                                Als je in Rust denkt:
                                \u201cIk wil gewoon een yield-return-achtig ding\u201d<\/strong>
                                \ud83d\udc49 gebruik std::iter::from_fn<\/code><\/strong><\/p>\n<\/blockquote>\n\n\n\n
                                Het is:<\/p>\n\n\n\n
                                  \n
                                • compact<\/li>\n\n\n\n
                                • leesbaar<\/li>\n\n\n\n
                                • idiomatisch<\/li>\n\n\n\n
                                • exact jouw gevraagde signature<\/li>\n<\/ul>\n\n\n\n
                                  Als je wilt, kan ik:<\/p>\n\n\n\n
                                    \n
                                  • async yield<\/code>-achtige voorbeelden geven<\/li>\n\n\n\n
                                  • laten zien hoe dit eruitziet bij file streaming<\/li>\n\n\n\n
                                  • of dit ombouwen naar een echte CSV-service<\/li>\n<\/ul>\n\n\n\n
                                    Zeg maar \ud83d\udc4d<\/p>\n","protected":false},"excerpt":{"rendered":"
                                    Per trait a concrete alias Limetime errors Service returning array\/vec Goede vraag \u2014 dit raakt precies de ownership-filosofie van Rust \ud83d\udc4dHet korte antwoord is: nee, je hoeft meestal g\u00e9\u00e9n lijst mee te geven om te vullen.De meest idiomatische manier is dat je functie zelf de data maakt en deze teruggeeft, zodat de caller automatisch owner […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-9558","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/posts\/9558","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/comments?post=9558"}],"version-history":[{"count":14,"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/posts\/9558\/revisions"}],"predecessor-version":[{"id":10016,"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/posts\/9558\/revisions\/10016"}],"wp:attachment":[{"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/media?parent=9558"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/categories?post=9558"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/solidt.eu\/site\/wp-json\/wp\/v2\/tags?post=9558"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}