26
Arguing about arguments (steveklabnik.com)
submitted 1 month ago by to c/rust@programming.dev
19 comments fedilink hide all child comments
you are viewing a single comment's thread
view the rest of the comments
[–] 7 points 1 month ago (5 children)

I'm used to named arguments from other languages, and that makes me fairly partial to them. Having to tool around with builders feels a lot more complex and clunky.

That said, I do wonder at how many of the usecases aren't workarounds for long argument lists that are either stringly typed, or something similar. As in, with a signature of (i32,i32,i32,i32) -> whatever, named arguments seem like a way of getting the compiler to catch errors in confusing {x,y}_{position,length}; but if the signature were newtypes like Rect(Origin(i32,i32), Size(i32, i32)) -> whatever, then the felt need for named arguments drops considerably.

  • permalink
  • fedilink
  • source
  • hideshow 5 child comments
    •
  • [–] 6 points 1 month ago (3 children)

    With newtypes you can also emulate named args with a single struct. This also allows them to be passed on together.

    struct RectArgs{
    x:i32,
    y:32,
    w:32,
    h:32,
}
impl Default for RectArgs{...}

    Then the call site looks like this:

    rect(RectArgs{
    x:0,
    y:0,
    w:30,
    h:20,
}
// with default arguments
rect(RectArgs{
    w:30,
    h:20,
    .. RectArgs::default ()
}
  • permalink
  • fedilink
  • source
  • parent
  • hideshow 3 child comments
    •
  • [–] 1 point 1 month ago* (last edited 1 month ago) (2 children)

    Yeah, though in those cases you might get an extra question about why rect is a function and not a method, e.g.

    Rect {
     w: 30,
     h: 20,
     .. RectArgs::default()
}.do_the_thing()
  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 1 point 1 month ago

    Newtypes have their uses, but as a replacement for named arguments they are an overkill in many cases. They solve different problems.

    Newtypes are beneficial when some domain-specific value with an invariant is used extensively throughout the codebase. You would use them to store and pass around that value without fear that something goes wrong.

    However if we start to create a type for each parameter of every function (which may not be related at all), it would only result in a lot of unnecessary boilerplate. Named arguments is a simple and elegant solution for calling a function in a more explicit way, nothing more.

  • permalink
  • fedilink
  • source
  • parent