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.

[–] anton@lemmy.blahaj.zone 7 points 2 days ago (1 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 ()
}

[–] syklemil@discuss.tchncs.de 1 points 2 days ago* (last edited 2 days ago) (1 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()

[–] anton@lemmy.blahaj.zone 1 points 2 days ago (1 children)

I assumed the rect is a method on something like a graphics context or physics engine, but yeah.

[–] syklemil@discuss.tchncs.de 1 points 2 days ago

Yeah, decent assumption, I'll tone down my comment a bit.

[–] deadcream@sopuli.xyz 1 points 1 day 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.