The most important part of curl is the library, not the CLI tool. And the TLS backend is very much relevant due to varying features supported, different licenses involved, and varying levels of ease when it comes to building and distribution.

That’s when you’re providing binaries. Otherwise, you would have to be wary of potential compatibility issues with libcurl packages provided by different Linux distributions for example.

See CURLOPT_ECH for a recent and still evolving example of this.

Another huh from me. Or maybe I’m missing something, because this should all be obvious.

The source of the standard library is a rustup component that everyone should have installed. As for crates, you don’t have to manually download any sources. Just add the crate as a dependency, and jump around definitions as much as you like. You can remove the dependency later if you decide to not use it.

this wasn’t easy for me to find

Huh! This is the internal ExitCode, and it’s two jump-to-definition calls away. The first to get to the public type definition, and the second from the public type’s struct field to the private type.

ExitCode is a struct, therefore it behaves like a type with many fields which define the types contained in the struct.

That’s a bit too off. structs in rust are product types. A struct may define zero or more fields. And fields can be named or not. if not, such structs are called tuple structs.

In the doc page, if you clicked on source, it would have taken you to the definition.

pub struct ExitCode(imp::ExitCode);

That’s a public struct with one unnamed private field. The type of the private field also happens to be private/internal.

As for why, usually the purpose is providing type safety, a unified interface,… etc. Notice how for example a windows-only extension trait is implemented that allows converting raw u32 exit codes into ExitCode.

So now you have exit codes possibly sourced from u8 or u32 values depending on the platform. And you need a safe unified interface to represent them.

I hope that’s an enough starting point.

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.

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.

Good.

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

If you’re using an LLM to “learn”, stop. Otherwise, I don’t understand what lazy_static has to do with anything.

It’s hard to tell what you’re asking. But maybe you’re confused because println! (it’s a macro btw) expands to code that involves format_args! which is a compiler built-in that doesn’t take ownership of the token expressions that get passed to it. Notice how the bottom of the format_args! page has this to say:

Lifetime limitation

Except when no formatting arguments are used, the produced fmt::Arguments value borrows temporary values, which means it can only be used within the same expression and cannot be stored for later use. This is a known limitation, see #92698.

So, it’s kind of a feature and a limitation at the same time.

sublemmy

Lemmy communities. Mbin/kbin magazines.