# Things Rust isn't good at yet

Make it faster

Want some feature from another language

Less colons

Bart: "Rust is a great language unless you're working with numbers or strings." DSP stuff is easier in C because I can read what I wrote and write what I mean, fewer parentheses and weird conversions. Casting is a disaster - `as` is short but can't error and may do the wrong thing, into and try_into are longer (and might not always do the right thing). Should be able to use any integral type to index an array.

Square matrix and doing stuff with neighbors. Want to have a value representing an offset from an index, but can't have a signed index. And `as usize` is dangerous.

`checked_add_signed` is long to write

Can't convert between usize and u32/u64 even on a machine where they're the same size. (Because you *might* run on u16 or u128 machines.)

Imaginary and complex numbers would be nice. Have done some DSPs and hand-rolling it was a pain.

Better literals, custom literal syntaxes.

Rust build system, custom build systems that aren't cargo are not that great. Especially without build-std.

Build-std and lack of status updates.

Partial borrows (not just on self!)

What would be the process for that?

What should the default cargo profile be?

What should the default debug profile opt level be?

When do we get format strings? Don't like the format macros, would like to use f strings instead. (Some discussion about whether it should be string or format_args or a trait.) "I want to use it as a string."

Arbitrary expressions in f-strings.

if statement with string produced vs string literal
Don't want to have to write to_string

Formatted byte strings!

match should be able to deref; hard to match on things that are Arc/Deref
We need DerefPure

More general Deref, access via a getter function

Can't implement Index/IndexMut, because you can't hand back an address
IndexAssign? IndexOwned? Support indexes into bit vectors or similar.

Adding combinations of references and values requires a lot of extra operator overloads.

Could the Rust compiler infer the associated type?
Could we at least let you put in `_` and have the compiler tell you what it is?

`impl Trait` but the function has two return points that are different types. Anonymous sum/enum types.

Unnamed structs and unions

WGPU has functions that take a struct instead of 15 arguments.

Partial default.

Inferred struct type `_ { ... }`

Cross-compilation as not as friction-free as I'd like it to be in practice. Weird GCC things I need to install. Linker doesn't actually work, looks like it works until it tries to link.
Zig does something reasonable here.

Interoperability with C++, make it easier for users.

Inlining from C to Rust without having to use LTO.
Gary: We have a trick for this, compile just the C functions we want to inline, then link it into the Rust library and do local LTO there. https://lwn.net/SubscriberLink/993163/391e1ec750cb9382/

Binary sizes! Rust binary size is very large.

When linking release binaries, could we not link debug symbols in the first place, rather than stripping the debug after linking?

Constant time execution, such as for cryptography to avoid timing side channels. Need the whole toolchain to know not to break that in the optimizer.

Orphan rule, have been hitting that a lot in Servo. Have to add dependencies we don't want. Should try various experiments here.

Cargo -Z flags and Rust -Z flags are not the same. Separate sets are confusing.

Big complex type declarations for embedded. Type for every pin on the board, monomorphized with type of board. Don't want to expose or see that huge type everywhere. Can't box a dyn Trait because embedded.

Trait aliases.

Generic constants. (const inside a generic function.) Nightmare to know whether it's a type or a value. `Foo<{expr}>`