515

You can pry pattern matching from my cold dead hands (sopuli.xyz)

submitted 8 months ago by flamingo_pinyata@sopuli.xyz to c/programmer_humor@programming.dev

195 comments fedilink hide all child comments

you are viewing a single comment's thread
view the rest of the comments

[-] asdfasdfasdf@lemmy.world 52 points 8 months ago

Hard disagree. Super beautiful.

[-] 30p87@feddit.org 14 points 8 months ago

Average Rust code:

macro_rules! sum {
    ( $initial:expr $(, $expr:expr )* $(,)? ) => {
        $initial $(+ $expr)*
    }
}

fn remove_prefix<'a>(mut original: &'a str, prefix: &str) -> &'a str

let mut up = 1;
    'outer: loop {

Hell I don't want to know what you define as ugly then.

[-] asdfasdfasdf@lemmy.world 26 points 8 months ago* (last edited 8 months ago)

Macro syntax technically isn't even Rust
This is definitely not average Rust code.

[-] tatterdemalion@programming.dev 2 points 8 months ago

Sorry, I love Rust but I can't really agree with you here. They only showed a macro_rules! definition, which is definitely rust syntax. Lifetime annotations are relatively common.

I will concede that loop labels are incredibly rare though.

[-] fruitcantfly@programming.dev 4 points 8 months ago

Loop labels are rare, but they lead to much simpler/clearer code when you need them. Consider how you would implement this kind of loop in a language without loop variables:

'outer: while (...) {
    'inner: while (...) {
        if (...) {
            // this breaks out of the outer loop, not just the inner loop
            break 'outer;
        }
    }

    // some code here
}

In C/C++ you'd need to do something like

bool condition = false;
while (...) {
    while (...) {
        if (...) {
            condition = true;
            break;
        }
    }
    if (condition) {
        break;
    }

    // some code here
}

Personally, I wouldn't call it ugly, either, but that's mostly a matter of taste

[-] Ephera@lemmy.ml 1 points 8 months ago

Well, you'd typically put the loops into a function and then do an explicit return to jump out of there. I believe, there's some use-cases where this isn't possible, which is why I'm cool with loop labels existing, but I've been coding Rust for seven years and have not needed them once...

[-] asdfasdfasdf@lemmy.world 1 points 8 months ago

https://fprijate.github.io/tlborm/mbe-macro-rules.html#%3A%7E%3Atext=macro_rules%21+With%2Cfollowing+form%3A

[-] tatterdemalion@programming.dev 1 points 8 months ago

I guess I see what you mean if we want to get very technical about what a syntax extension is. But I think for the purpose of this discussion, it's reasonable to think of macro_rules! as a part of the Rust language. Practically speaking, it is syntax provided by the language team, not just users of the language who are free to extend the syntax by using macro_rules! to do so.

[-] wewbull@feddit.uk 1 points 8 months ago

What language are they then? They're not Python, JS,

[-] flamingo_pinyata@sopuli.xyz 19 points 8 months ago

I don't know if anyone would argue Rust macros are beautiful. If someone does they should be checked out by a doctor.
Speaking as a fan of Rust.

[-] fuck_u_spez_in_particular@lemmy.world 7 points 8 months ago

Definitely not your average Rust code, more like a very ugly example of it.

Also, as the syntax first put me off as well, I gave it a chance years afterwards, and have now (or rather years ago) officially joined the church of Rust evangelism.

A lot of the syntax you define as ugly makes sense when you learn it, it's just so much more explicit than a more dynamic language, but that exactly saves your ass a lot (it did for me at the very least) (I don't mean macros, macros are ugly and should be avoided if possible)