Our great sponsors
Empowering everyone to build reliable and efficient software.
If you're willing to use nightly, you should be able to use the "type alias impl trait" (TAIT) feature (https://github.com/rust-lang/rust/issues/63063) to obtain a name for the anonymous types/closures. I've defintely done it in non const/static contexts, and it looks to me like it should be possible to do it in const/static contexts too.
RFCs for changes to Rust
There's currently an RFC under consideration for that.
Clean code begins in your IDE with SonarLint. Up your coding game and discover issues early. SonarLint is a free plugin that helps you find & fix bugs and security issues from the moment you start writing code. Install from your favorite IDE marketplace today.
The Rust package registry
The discoverability problem could be solved in other ways, like at least a community recommended libraries list, though curating it is difficult. Maybe something like most directly depended-upon crates is a good start, since transitive dependencies are by definition ones you didn't need to learn to use directly, but direct dependencies are ones that reflect how many people need to know a library exists. Someone did this analysis years ago, I guess it should be automated and made into a dynamic page. crates.io tracks the metadata for dependencies already, so that seems like a natural place for it.
A list of the few things I don't like about rust
I'm so glad you asked: https://github.com/Lucretiel/dislike-in-rust
An HTTP library for Rust (by hyperium)
Even extremely foundational crates like hyper and rustls have yet to make their 1.0 promise. Hyper is very close, in the -rc stages, but as of today it's not settled yet. Rustls is very important, something almost any production service will need, but still up in the air on compatibility. If you have multiple dependencies that aren't on the same page about something like hyper or rustls, you're either holding versions back or cramming multiple dependency graphs into one build. Cargo makes that easy when it's possible, but it's not always possible let alone practical, like when we had Tokio 0.2.x and 0.3.x at the same time.
Rust method delegation with less boilerplate
This is certainly one that's bugged me too. There's the delegate crate which helps, but is still a decent amount of boilerplate due to macro limitations
A refreshingly simple data-driven game engine built in Rust
Binaries file-sizes in debug are just insanely big, a Hello World will be around ~4MB, an empty Bevy project will be around ~600MB.
Access the most powerful time series database as a service. Ingest, store, & analyze all types of time series data in a fully-managed, purpose-built database. Keep data forever with low-cost storage and superior data compression.
An experiment of high level code optimization
A next-generation test runner for Rust.
Do you already use nextest or something else? That really leans into test parallelism and sounds like a perfect fit for how you structure the tests.
A small cross-platform library for retrieving random data from (operating) system source
I would wait for the getrandom crate to reach 1.0, which will answer many of the questions around what an API like this can look like, and then maybe the standard library discussion will be on firmer footing because at least we'll know what API we want to immortalize. Rushing that now just to save people importing a small crate does not seem to be the way to go.
A home for compiler team planning documents, meeting minutes, and other such things.
There's already an accepted but not yet implemented proposal for supporting sandboxed build-time execution.
General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.
As for what you're asking for specifically, keep an eye on zig cc and the Rust wrapper, cargo-zigbuild. (Behind the scenes, it's essentially an effort to complete LLVM's compiler_rt enough that you can use it instead of the platform C runtimes that are such a pain to cross-compile for.)
Modern embedded framework, using Rust and async.
And yet I think there are people enjoying async model for embedded systems. The embassy framework/executor is on my list of things I want to try out in Rust. Async/await isn't useful only for scaling with the amount of threads available, that's not even the main benefit of using of the model. I think async Rust is something novel that hits a middle ground between high and low levels of abstractions, making it mainly high-level for those who need to use it as such (most of the time).
An unofficial, experimental place for documenting and gathering feedback on the design problems around Rust's orphan rules
Well, unless someone comes up with better, compatible rules, the orpan rules are gonna stick around.
Rustlings 5 (5.2.1) Solutions
You will get used to it when you write more Rust code. Read the book, implement some exercises and watch some tutorial YT videos, everything will make sense eventually.
The Rust Programming Language
Firstly, I recommend you read the book. It explains pretty much everything you are confused about.
A minimal async executor that lets you block on a future
Check out https://github.com/zesterer/pollster. This can be the solution to the async problem you described
I believe SSO could be solved, in part, with the Storage proposal I made a while ago, which Christopher Duram refined in his storages-api repository.
This repository is for active development of the Azure SDK for .NET. For consumers of the SDK we recommend visiting our public developer docs at https://docs.microsoft.com/dotnet/azure/ or our versioned developer docs at https://azure.github.io/azure-sdk-for-net.
So how do you download part of a blob from Azure? Well, in https://github.com/Azure/azure-sdk-for-net/releases/tag/Azure.Storage.Blobs_12.12.0 there's a function that looks like this:
SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives
why doesn't the compiler panic if I cast -22.0 to u32 but make it 0?
1 project | /r/rust | 6 Jun 2023
Counterexamples in Type Systems: programs that crash, segfault or explode (2021)
2 projects | news.ycombinator.com | 6 Jun 2023
The Rust I Wanted Had No Future - Graydon Hoare
2 projects | /r/ProgrammingLanguages | 5 Jun 2023
struct mutates as a block in 1.70
1 project | /r/rust | 6 Jun 2023
A not-so-quick introduction to the C++ allocator model
2 projects | news.ycombinator.com | 4 Jun 2023