this post was submitted on 24 Sep 2023
214 points (93.1% liked)

Programmer Humor

32568 readers
733 users here now

Post funny things about programming here! (Or just rant about your favourite programming language.)

Rules:

founded 5 years ago
MODERATORS
AgreeableLandscape@lemmy.ml
cat_programmer@lemmy.ml
214
LISP is ugly (lemmy.ml)
submitted 1 year ago by yogthos@lemmy.ml to c/programmerhumor@lemmy.ml
40 comments fedilink hide all child comments
 

source https://rakhim.org/honestly-undefined/10/

you are viewing a single comment's thread
view the rest of the comments
[–] thejevans@lemmy.ml 25 points 1 year ago (2 children)

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

[–] DWin@sh.itjust.works 1 points 1 year ago* (last edited 1 year ago) (1 children)

Just use this syntax

let myResultObject = getResult() 
let item = match myResultObject {
	Ok(item) => item, 
	Err(error) => {
		return;
	} 
};
[–] thejevans@lemmy.ml 2 points 1 year ago (1 children)

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 1 points 1 year ago (1 children)

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 1 points 1 year ago (1 children)

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 2 points 1 year ago* (last edited 1 year ago) (1 children)

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.

[–] thejevans@lemmy.ml 2 points 1 year ago

Thanks for this! I'll see if I can work something like this in.

[–] darcy@sh.itjust.works 1 points 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