logoalt Hacker News

sgarland • yesterday at 8:22 PM • 2 replies • view on HN

From TFA, on combinators vs. loops:

    items.iter().enumerate().filter(|(_, i)| cond(i)).map(|(idx, i)| Pointer::idx(i, path, idx)).collect()

    while (i < cursors.len) {
        if (actual_index < arr.items.len) { cursors[i] = .{...}; i += 1; }
        else iteration.remove(i);
    }
I’ve been slowly learning Rust, and this style is my main gripe against it, because I feel like I’m being gaslit. Its proponents praise its readability and ease of use, and just… no. It looks deranged. A simple loop is immediately obvious to anyone who’s programmed in any language. Even Python’s list comprehensions are loop-ish.

Replies

matja • yesterday at 9:04 PM

.len doesn't work on a list (because it might mislead you about the efficiency of the operation if it did exist), so it's better to use iterators - so then you can change the underlying type without changing your code.

But then, saying while "let Some(item) = iter.next()" everytime is tedious, so they give you .iter() - for any type that is efficiently iterable.

Nothing stopping you using a manual loop that you need to update if you change the container type.

himata4113 • yesterday at 8:24 PM

  items.filter(|(i)| cond(i)).map(Pointer::idx).collect()
you can probably get away with this if you implement a Trait, not sure how but I know for a fact this is possible, idk why there's an enumerate there when you aren't even using it.

items is already an iteratible so you can do direct .filter on it as well

tl;dr if the code looks ugly you're probably not taking advantage of a language feature that allows it to look pretty.

➕ show 1 reply