I assumed the rect is a method on something like a graphics context or physics engine, but yeah.

With newtypes you can also emulate named args with a single struct. This also allows them to be passed on together.

struct RectArgs{
    x:i32,
    y:32,
    w:32,
    h:32,
}
impl Default for RectArgs{...}

Then the call site looks like this:

rect(RectArgs{
    x:0,
    y:0,
    w:30,
    h:20,
}
// with default arguments
rect(RectArgs{
    w:30,
    h:20,
    .. RectArgs::default ()
}

Weird. I threw it in compiler explorer and the assembly got longer (as expected).

I’m happy the new ranges got stabilized. It feels weird to use old stuff when you know there is something in the pipeline to replace it.

wrong layer

I misread the comment a bit, I thought they meant tax like a person. I wouldn’t put it past the owners to have their agents apply for small business grants or some other exemption.

The owners can just divide the income among enough agents that they fall into the lowest tax bracket. The real solution is to properly tax excessive profits and unrealized gains.

I don’t know about well documented, but if you use a standardized argument parser, you can even generate a gui from that.

https://github.com/chriskiehl/Gooey

I thought that goes without saying.

Ignore the reasonable comments that say you are more than ready.

The next step is obviously learning Haskell, specifically sum types (like rusts enums), lists (lazy, like rusts iterators) and classes (like rusts traits).
Then you will think, “if only there was a language that was a mix of C and Haskell” and that’s rust.

You can design a language where you don’t need to generate code to accomplish this.

Other people have python scripts generate C, so having on in the same codebase and language is certainly an improvement.

My question isn’t why this is necessary in Rust. My question is why Rust was designed such that this was necessary.

Because otherwise the compiler team either also needs to maintain a huge amount libraries or cut corners and move things to runtime that really should happen at compile time.

Someone mentioned elsewhere that this allows for compile-time type safety. I’m still trying to wrap my head around how that works.

printf is a great example. According to the C type system, it takes a string and a variable amount of untyped arguments dependent on the content of the string, but that doesn’t actually describe the allowed arguments.
Misusing printf like this printf("%s", 42); will get you a warning, but only because there is a special case for printf in the compiler. If you have your own function that does the same as printf, and you misuse the same way, you will find out by dissecting the core dump.

In rust the format string gets parsed at compile time by a macro, which decides the type of each arguments that can than be checked by the compiler. Imagine printf(“%s %d”,…) created a function with the signature specialized_printf(char* agr0, int arg1), it would be impossible to pass the wrong types of arguments.

Now that these tools exist people have gone further and made a library that checks SQL queries against the shema of a running database and causes a compile error if it doesn’t fit.

SerenityOS is “a love letter to '90s user interfaces with a custom Unix-like core”.
It’s good enough to be proud of, while alienating normal people, not incidentally, like linux used to, but on purpose, like this sentence does, making it a great for elitists.

They may not have noticed the cameras or not have a choice to go elsewhere in a reasonable time.

Nowadays he probably just arranges electrons.

Remember to put

#!/bin/rm

at the top of every file, to teach people not to execute files they shouldn’t.

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.