• thejevans@lemmy.ml
    link
    fedilink
    arrow-up
    1
    ·
    1 year ago

    I definitely use that syntax whenever I can. One of the situations where I get stuck with the nested syntax that I shared is when the result of the function call in the for loop affects the inputs for that function call for the next item in the loop. Another is when I am using a heuristic to sort the iterator that I’m looping over such that most of the time I can break from the loop early, which is helpful if the function in the loop is heavy.

    • DWin@sh.itjust.works
      link
      fedilink
      arrow-up
      2
      ·
      edit-2
      1 year ago

      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.