• 0 Posts
  • 7 Comments
Joined 1 year ago
cake
Cake day: July 20th, 2023

help-circle


  • It feels like maybe this could be a code structure issue, but within your example what about something like this?

    fn main(){
        let mut counter = 0;
        let output_array = array.into_iter()
            .map(|single_item| {
                // breaks the map if the array when trying to access an item past 5
                if single_item > 5 {
                    break;
                }
            })
            .collect()
            .map(|single_item| {
                // increment a variable outside of this scope that's mutable that can be changed by the previous run
                counter += 1;
                single_item.function(counter);
            })
            .collect();
    }
    

    Does that kinda syntax work for your workflow? Maybe it’ll require you to either pollute a single map (or similar) with a bunch of checks that you can use to trigger a break though.

    Most of the time I’ve been able to find ways to re-write them in this syntax, but I also think that rusts borrowing system although fantastic for confidence in your code makes refactoring an absolute nightmare so often it’s too much of a hassle to rewrite my code with a better syntax.


  • Oh sorry, I misread what you typed and went on a tangent and just idly typed that in.

    One thing you could do for your situation if you’re planning on iterating over some array or vector of items is to use the inbuilt iterators and the chaining syntax. It could look like this

    let output_array = array.into_iter()
        .map(|single_item| {
            // match here if you want to handle exceptions
        })
        .collect();
    

    The collect also only collects results that are Ok(()) leaving you to match errors specifically within the map.

    This chaining syntax also allows you to write code that transverses downwards as you perform each operation, rather than transversing to the right via indentation.

    It’s not perfect and sometimes it’s felt a bit confusing to know exactly what’s happening at each stage, particularly if you’re trying to debug with something mid way through a chain, but it’s prettier than having say 10 levels of nesting due to iterators, matching results, matching options, ect.