Hacker News Reader

Comment by curious145454 | Hacker News Reader

> This takes a bit more code to implement, but provides a simpler API for users.

I fail to see how hiding self.send() inside of IntoFuture makes anything simpler.

StorageRequest::new().set_debug(true).send().await?;

StorageRequest::new().set_debug(true).await?;

Just reading the later variant makes me wonder "What are we (a)waiting for here? For set_debug to succeed?". I'd definitely stick to the former variant.

Perhaps, it's just not the best example and there are better usages than the one chosen to illustrate it.

View on HN

It’s sad that Rust has decided to settle with the builder pattern instead of implementing named arguments.

Can’t you pass “argument” structs as parameters to kinda emulate the feel of named arguments (along with using the Default trait)? I use this in C++ a lot, and it seems that some Rust devs are doing this too.

You can, but it is a mouthful. Especially if you want optional arguments.

    foo::some_func(foo::SomeFuncArgs{
      a: 8,
      b: Some(false),
      ..Default::default()
    })

Personally I would be really happy if `..` could default to `..Default::default()` which would make this a lot cleaner. But even then needing to name a type for the argument struct is noisy. Language-integrated keyword arguments would make this a lot cleaner:

    foo::some_func(
        a=8,
        b=Some(false))

Indeed, it's basically the same as in JS/TS where you just pass an object of key/values rather than have named arguments.

Yes, but it is a lot cleaner there because you don't need to specify the name of the type and you don't need to do anything special for optional arguments.

I wouldn't mind if it worked this way "under the hood" but syntax sugar for passing that last argument as keyword arguments would be a fantastic quality of life improvement.

By the way, C++20 designated initializers works like a charm for this.

  foo::some_func({
    .a = 8, 
    .b = false
  });

(I view this and std::span as the only two usable features in C++20, and pretty much everything else can go to the dustbin or the drawing board.)

I'm waiting to getting some spare time to propose (not quite but very close) that in an RFC. A lot of conversation about it from a while back is available at https://internals.rust-lang.org/t/pre-pre-rfc-syntactic-suga...

Why? The builder pattern is great.

Having both approaches available would be better IMHO. Builder pattern is very nice but I frequently miss having named arguments too. Even if macros can partially fullfill that need, it's not the same and introduces more quirks and complexity...

Fair enough.

Problem with named parameters is that they make renaming function params a breaking change.

Unless the IDE doesn’t support this refactoring? It’s ridiculously easy in C# and VS or VSC.

A (public) library doesn't have access to all codebases depending on it.

Even there changing the method param will invalidate semver specification.

It gets awkward really fast when you may need to set a value.

    let mut foo = build_foo()
        .with_a(8);

    if need_to_set_b {
        foo = foo.with_b(false);
    }

    let foo = foo.build();

Would look very similar with named arguments, no?

Maybe. It depends a bit on how they are implemented. If there is a good way to pass "default" then you can just have a condition for that one argument. But if there is no way to pass "default" then it can get hairy.

For sure. I would like to see that in Rust as well, that would be nice. I am willing to put up with the lack of variadic & named arguments for the goodness the borrow checker brings me, but I can see how that would improve the ergonomics substantially.

Not if you do what Dart did: https://medium.com/dartlang/making-dart-a-better-language-fo...

I'm pretty sure that there's no objection to including named arguments in Rust as of yet. It's just that no one has wanted it badly enough to write an RFC for, and implement, named arguments.

Please note the programmer needs to implement "IntoFuture" and has full control on what and how it would be translated into a future. The example is implemented like this, but it does not have to be.

And yes, the example is not the best.

Aah, yeah that felt a bit off at the time of reading, nice note. I barely had time to keep up with this update and the changes... :p

I think the concept is that you are awaiting the "request type". And getting back a "response type". The example is somewhat confusing since set_debug() returns a StorageRequest.

With tooling this would make your resulting type be a StorageResponse. The whole point is that you can have that "request type" be awaitable.

Apparently, there's another meaning to word "simpler", of which I'm unaware :D

You may be thinking of "primitive", "simplistic" or "spartan". Things that are simple to use are not necessarily primitive.

It's simpler for library users, because they don't need to know which particular method finalizes a builder to obtain a future from it, and `.await` just works in more situations.

That's not quite the best example as someone else noted, you could better of write an API where converting to Future can be a shore of in places where await may work in the Future.

Say, `for await x in connection.item {}` not real syntax but something similar might be in Rust's future.

Reply on news.ycombinator.com