2
Which code style to initialize structs? (lemmy.ml)
submitted 10 months ago by nutomic@lemmy.ml to c/rust@lemmy.ml
4 comments fedilink hide all child comments

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

top 4 comments
sorted by: hot top controversial new old
[-] livingcoder@programming.dev 1 points 9 months ago* (last edited 9 months ago)

I prefer to encapsulate a mutable reference to the instance in a scope.

let post_form = {
    let mut post_form = PostInsertForm::new(
        // your constructor arguments
    );
    post_form.some_mutating_method(
        // mutation arguments
    );
    post_form
};

This way you're left with an immutable instance and you encapsulate all of the logic needed to setup the instance in one place.

[-] al4s@feddit.org 1 points 10 months ago

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.
[-] BB_C@programming.dev 1 points 10 months ago

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.

[-] Deebster@programming.dev 1 points 10 months ago

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.

this post was submitted on 23 Sep 2024
2 points (100.0% liked)

Rust Programming

8888 readers
2 users here now

founded 6 years ago
MODERATORS
nutomic@lemmy.ml
Joe@lemmy.ml