Leap seconds are already a problem for minutes and hours, which is probably why they weren’t added until now.

But you’re also missing one use of the impl keyword: fn func() -> impl Trait.

[…] So dropping the impl in [return position] might not be completely impossible like the other uses of impl.

But the impl markes that it is a trait to the programmers.
Take the following functions:

func1()->A{...}
func2()->A{...}

Does the following snippet compile?

let mut thing = func1();
thing = func2();

Under the current rules we know it will. But if A could be a trait, the functions could return different types. We currently mark that with the impl.

Why? What value does -> () provide? Why not elide that?

What value is provided by keeping it?

What value does cluttering up your code with -> () provide?

Why a syntactic special-case for exactly that type and not any other random type?

Because the unit type is special, just like the never ! type. () also has the special importance of being the return value of an empty statement and some other stuff.

languages w/o [semicolons] feel awkward since you’re generally limited to one statement per line

Then fixing that might make sense. :-)

It’s fixed with semicolons ;-)

If the spec contains default values why not make a constructor with all the missing fields or implement Default when all fields are covered?

Also lol:

#[test]
fn test_config_load() {
    todo!();
}

You can already :

res_res??;

I think it’s more for cases where you don’t want to return, like

let new_res = old_res.map(func).flatten();

You are supposed to run sudoedit.
This command creates a temporary copy, opens it in you editor of choice and overwrites the protected file when the temp file changes.
That way the editor doesn’t run as root.
You can see the difference if you run shell command, like whoami, in vim.

The format seems to be some glue to chose between different compression algorithms for the same file format and compress in chunks to be able to decompress only the parts you need.

I’m wondering if there’s a way [to] combine their computational power.

Only if your problem can be be split up reasonably, otherwise you will spend more time waiting for data to move.
Where it can work: video encoding, CI pipelines, data analysis
Where it won’t work: interactive stuff, most single file operations

I want to get into server hosting […]

Then you don’t need another reason to do it.

[If] I can connect them all to one display [or] make them all accessible in one place.

You can either get a hardware switch or chose a primary computer and connect to the others. For that you can use remote desktop software or be a try hard and use ssh.

I think both gcc and clang are roughly build around the C memory model.
If you want to interface with hardware you probably do volatile reads and writes to specific memory addresses.
You should be able to compile for most gcc supported platforms.

Impressive, but the performance paragraph has to be a joke right?

One 500ns query is not a good benchmark.

I was a bit apprehensive because rust has like a gazillion different function types but here it seems to work like just any other language with a HM type system.

The fn(T)->R syntax works for functions without associated data, it discards details of the implementation and works like function pointers in C. This allows them to be copy and 'static.

The other function types can have data with them and have more type information at compile time which allows them to be inlined.
These functions each have their own unwritable type that implements the function traits (Fn(T)->R, FnMut(T)->R and FnOnce(T)->R) depending on their enclosed data.

I hope I remembered everything right from this video by Jon Gjengset.

I agree with the sentiment but …

then nothing can be bricked because on paper you can desolder the rom chip and put another one in place.

Companies already put serial numbers in components and configure them so only specific ones work together, requiring OEM tools to pair them.
It’s imaginable that someone makes something similar with e-fuzes instead.

The new version seems to fix that since your comment was written, but it will stil panics if less than 2 samples are provided, unless the crate it wraps panics at an earlier point.

let peak = buf
            .iter()
            .copied()
            .enumerate()
            .take(self.sample_count / 2)
            .max_by_key(|(_, s)| (s.abs() * 1000.0) as u32)
            .expect("to have at least 1 sample");

Aviation, Health, Space and Car industry have only 3 certified languages that they use. Ada, C and C++.

Rust is automotive certified since over half a year. https://ferrous-systems.com/blog/officially-qualified-ferrocene