516
You can pry pattern matching from my cold dead hands (sopuli.xyz)
submitted 8 months ago by to c/programmer_humor@programming.dev
222 comments fedilink hide all child comments
 
you are viewing a single comment's thread
view the rest of the comments
[–] 5 points 8 months ago (1 child)

So that's why people like C-style return types. That actually makes a lot of sense. I do too now.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 6 points 8 months ago (1 child)

    To be honest, I think, they both have their place. In Rust, you typically wouldn't return just a bool, but rather the element that you removed, so like this:

    fn getofmylawn(lawn: Lawn) -> Option<Teenager> {
    lawn.remove()
}

    And then with such a more complex return-type, C-style means that you can't see the function name right away:

    Option<Teenager> getofmylawn(Lawn lawn) {
    return lawn.remove();
}

    I also really don't think, it's a big deal to move your eyes to the ->...

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 2 points 8 months ago (1 child)

    Amusingly, modern C++ allows you to copy the rust signature nearly 1:1:

    auto getofmylawn(Lawn lawn) -> Option<Teenager> {
    return lawn.remove();
}
  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 8 months ago (1 child)

    Huh, did that emerge out of unrelated design decisions or did they just figure
    why not both?

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 2 points 8 months ago (1 child)

    I believe that it is useful in a few places. cppreference.com mentions templates as one case:

    Trailing return type, useful if the return type depends on argument names, such as template<class T, class U> auto add(T t, U u) -> decltype(t + u); or is complicated, such as in auto fpif(int)->int(*)(int)

    The syntax also matches that of lambdas, though I'm not sure that adding another way of specifying regular functions actually makes the language more consistent, since most code still uses the old style.

    Additionally, the scope of the return type matches the function meaning that you can do

    auto my_class::my_function() -> iterator { /* code */ }

    instead of

    my_class::iterator my_class::my_function() { /* code */ }

    which is kinda nice

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •