Which code style to initialize structs?
fedilink
14
Which code style to initialize structs?
fedilink

Which of these code styles do you find preferable?

First option using mut with constructor in the beginning:

  let mut post_form = PostInsertForm::new(
    data.name.trim().to_string(),
    local_user_view.person.id,
    data.community_id,
  );
  post_form.url = url.map(Into::into);
  post_form.body = body;
  post_form.alt_text = data.alt_text.clone();
  post_form.nsfw = data.nsfw;
  post_form.language_id = language_id;

Second option without mut and constructor at the end:

  let post_form = PostInsertForm {
    url: url.map(Into::into),
    body,
    alt_text: data.alt_text.clone(),
    nsfw: data.nsfw,
    language_id,
    ..PostInsertForm::new(
      data.name.trim().to_string(),
      local_user_view.person.id,
      data.community_id,
    )
  };

You can see the full PR here: https://github.com/LemmyNet/lemmy/pull/5037/files

@al4s@feddit.org
link
fedilink
13•3M

Definitely the second one.

  1. It avoids Mut
  2. It makes clear that the initialization is over at the end of of the statement. The first option invites people to change some more properties hundreds of lines down where you won’t see them.
Deebster
link
fedilink
10•3M

100% the second one. It’s the idiomatic way to do this in Rust, and it leaves you with an immutable object.

I personally like to move the short declarations together (i.e. body down with language_id (or both at the top)) but that’s a minor quibble.

@BB_C@programming.dev
link
fedilink
9•3M

Neither.

  • make new() give you a fully valid and usable struct value.
  • or use a builder (you can call it something else like Partial/Incomplete/whatever) struct so you can’t accidentally do anything without a fully initialized value.

Maybe you should also use substructs that hold some of the info.

Dessalines
link
fedilink
1•
edit-2
3M

We recently used TypedBuilder (which is builder pattern), but switched to DeriveNew, as its a bit cleaner, and requires less generated code.

@DemocratPostingSucks@lemm.ee
link
fedilink
8•3M

Defo the second one, the first is weird imo

asudox
link
fedilink
6•
edit-2
3M

Second one if a constructor or a builder is not an option. 1 is out of the question.

Why are the Lemmy devs asking for this though?

@nutomic@lemmy.ml
mod
creator
link
fedilink
4•3M

@DemocratPostingSucks@lemm.ee @Deebster@programming.dev @al4s@feddit.org Thanks for the feedback! Personally I prefer the first option, but based on your comments I will merge the PR with the second option.

@al4s@feddit.org
link
fedilink
7•3M

If you’re ever forced to do something the second way, you can also wrap it in braces, that way you end up with an immutable value again:

let app = {
  let mut app = ...
  ...
  app
};
@taladar@sh.itjust.works
link
fedilink
1•3M

Why not just a let app = app; line after the let mut app = ...; one?

@nutomic@lemmy.ml
mod
creator
link
fedilink
1•3M

Thats even more verbose so the second option is better.

@al4s@feddit.org
link
fedilink
3•3M

Yeah if you have the second option, use it, but if the struct has private fields it won’t work.

@taladar@sh.itjust.works
link
fedilink
2•3M

The first one won’t work either for private fields.

@al4s@feddit.org
link
fedilink
1•3M

You can have setters that set private fields, there are also sometimes structs with mixed private and public fields

Nothing4You
link
fedilink
3•3M

also adding my vote for the second one

Rust Programming
!rust@lemmy.ml
    Subscribe
    • 0 users online
    • 2 users / day
    • 9 users / week
    • 32 users / month
    • 71 users / 6 months
    • 1 subscriber
    • 287 Posts
    • 836 Comments
    • Modlog