I would move all struct members from Foo<false> into a “new” Foo<true> and return that?

Yes… if you don’t define Drop for Foo.

If you do, then you will have to either use mem::take()/mem::replace() with each field, or if you don’t mind unsafe {}, you can just do a trivial transmute. Justunsafe { transmute(self) } should work.

I’m stating the obvious here, but if you have ownership at the time of conversion, then you can just change the type, you don’t have to use dyn (a la impl Foo<false> { fn into_debug(self) -> Foo<true> {} }). That may require some code restructuring of course.

I’m getting Hans Reiser vibes from Overstreet

You would do good on a CoC board.

Friendly Advice: If you hang out in microblog platforms, especially mastodon, do it less. The echo chamber discourse there is not good for your sanity. This is general advice, not just for you, really.

Yeah, I got that.

I’m asking what would be the benefit of not using a single error enum for all failure reasons?

use-case?

It’s quite simple. Just remove the permalink field! If you are calculating it then no need to store it in the struct.

This is inefficient. It should be the other way around. Remove base_url and rel_permalink, and store permalink and the rel_permalink offset.

That way, you can get a zero cost &str for any of the three.

This is neither news*, nor majorly relevant. Having rustc_codegen_gcc as a rustup component is going to be way more relevant, and is much closer to delivery, just to give an example.

* The post itself (not the content of it) appearing on the official blog was sort of pleasantly surprising (brought tears to my eyes, i tell ya). Hopefully that was a result of maturity, rather than external pressure.

unrecoverable errors in the form of panic

ahem

Correct link without /edit/: https://github.com/Nutomic/ibis/releases/0.1.2

you’re not supposed to immediately reach for macros

correct

for small things you don’t quite like about the language.

incorrect

Excessive macro use makes it impossible for others (including your future self) to read your code

N/A. the macro above is trivial.

impossible for others to read your code and there’s often good reasons why it’s designed like it is.

fiction

There is a general mechanism in Rust that allows language users to add their own sugar. It’s called macros 😉

macro_rules! keep {
    (let $id:ident = $expr:expr => $($tt:tt)+) => {
        let $id = $expr;
        let $id = $id$($tt)+;
    }
}

fn main() {
    keep!{ let path = std::env::current_dir().unwrap() => .as_path() };
    println!("{path:?}");
}

You can remove let from the macro’s fragment specifier and invocation.

mastering_rust

Maybe wait until you’re actually good at it.

Rebinding with and without mut is a known and encouraged pattern in rust. Leaving things as mut longer than necessary is not.

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.

If you’re not into tiling, install openbox and a panel of your choosing. You will quickly find that you don’t need a DE at all.

The maintenance is too high.

acquired knowledge spotted

I will let you on a little secret.

The best “support” you can get is support from upstreams directly (I’m involved in both sides of that equation). But upstreams will often only “support” you when you 1. run the latest stable version 2. the upstream source code wasn’t patched willy-nilly by the packager (your distro).

So the best desktop linux experience comes with using rolling distro that gives you such packages, with Arch being the most prominent example.

The acquired knowledge that argues stability and tells you otherwise is a meme.

Never set foot in AU.
I was under the impression that Tasmania doesn’t get that cold.
Also, apparently some would rather describe Perth as Mediterranean-SouthAfrican, rather than Mediterranean-Californian 😉

Monthly Reminder: High or low, all Linux usage stats are fake.

Good.

Can you formulate your question better, with a minimal example and properly formatted code?