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

    I know it’s not nearly as nested as this, but nesting in Rust annoys the hell out of me.

    impl {
        fn {
            for {
                match {
                    case => {
                    }
                }
            }
        }
    }
    

    is something I’ve run into a few times

    • darcy@sh.itjust.works
      link
      fedilink
      arrow-up
      1
      ·
      1 year ago

      the loop or match statement could possibly be extracted to another function, depending on the situation. rustc will most likely inline it so its zero cost

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

      Just use this syntax

      let myResultObject = getResult() 
      let item = match myResultObject {
      	Ok(item) => item, 
      	Err(error) => {
      		return;
      	} 
      };
      
      • thejevans@lemmy.ml
        link
        fedilink
        arrow-up
        2
        ·
        1 year ago

        How does that change anything? Sorry if it wasn’t clear, this was assuming a function call in the for loop that returns either a Result or enum.

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

          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.

          • 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.