Return to Rust after the Honeymoon, Rust DevOps, Rust Bibliography, Rust Courses, Awesome Rust

“Two years ago, I had a Rust blog entry describing falling in love with Rust (http://dtrace.org/blogs/bmc/2018/09/18/falling-in-love-with-rust). Of course, a relationship with a technology is like any other relationship: as novelty and infatuation wears off, it can get on a longer term (and often more realistic and subdued) footing — or it can begin to fray. So well one might ask: how is Rust after the honeymoon?

By way of answering that, I should note that about a year ago (and a year into my relationship with Rust) we started Oxide. On the one hand, the name was no accident — we saw Rust playing a large role in our future. But on the other, we hadn’t yet started to build in earnest, so it was really more pointed question than assertion: where might Rust fit in a stack that stretches from the bowels of firmware through a hypervisor and control plane and into the lofty heights of REST APIs?

The short answer from an Oxide perspective is that Rust has proven to be a really good fit — remarkably good, honestly — at more or less all layers of the stack. You can expect much, much more to come from Oxide on this (we intend to open source more or less everything we’re building), but for a teaser of the scope, you can see it in the work of Oxide engineers: see Cliff’s blog, Adam and Dave’s talk on Dropshot, Jess on using Dropshot within Oxide, Laura on Rust macros, and Steve Klabnik on why he joined Oxide. (Requisite aside: we’re hiring!)

So Rust is going really well for us at Oxide, but for the moment I want to focus on more personal things — reasons that I personally have enjoyed implementing in Rust. These run the gamut: some are tiny but beautiful details that allow me to indulge in the pleasure of the craft; some are much more profound features that represent important advances in the state of the art; and some are bodies of software developed by the Rust community, notable as much for their reflection of who is attracted to Rust (and why) as for the artifacts themselves. It should also be said that I stand by absolutely everything I said two years ago; this is not as a replacement for that list, but rather a supplement to it. Finally, this list is highly incomplete; there’s a lot to love about Rust and this shouldn’t be thought of as any way exhaustive!

1. Rust no_std

When developing for Rust embedded systems — and especially for the flotilla of microcontrollers that surround a host CPU on the kinds of servers we’re building at Oxide — memory use is critical. Historically, C has been the best fit for these applications just because it so lean: by providing essentially nothing other than the portable assembler that is the language itself, it avoids the implicit assumptions (and girth) of a complicated runtime. But the nothing that C provides reflects history more than minimalism; it is not an elegant nothing, but rather an ill-considered nothing that leaves those who build embedded systems building effectively everything themselves — and in a language that does little to help them write correct software.

Meanwhile, having been generally designed around modern machines with seemingly limitless resources, higher-level languages and environments are simply too full-featured to fit into (say) tens of kilobytes or into the (highly) constrained environment of a microcontroller. And even where one could cajole these other languages into the embedded use case, it has generally been as a reimplementation, leaving developers on a fork that isn’t necessarily benefiting from development in the underlying language.

Rust has taken a different approach: a rich, default standard library but also a first-class mechanism for programs to opt out of that standard library. By marking themselves as no_std, programs confine themselves to the functionality found in Rust libcore. This functionality, in turn, makes no system assumptions — and in particular, performs no heap allocations. This is not easy for a system to do; it requires extraordinary discipline by those developing it (who must constantly differentiate between core functionality and standard functionality) and a broad empathy with the constraints of embedded software. Rust is blessed with both, and the upshot is remarkable: a safe, powerful language that can operate in the highly constrained environment of a microcontroller — with binaries every bit as small as those generated by C. This makes no_std — as Cliff has called it — the killer feature of embedded Rust, without real precedence or analogue.

2. {:#x?}

Two years ago, I mentioned that I love format!, and in particular the {:?} format specifier. What took me longer to discover was {:#?}, which formats a structure but also pretty-prints it (i.e., with newlines and indentation). This can be coupled with {:#x} to yield {:#x?} which pretty-prints a structure in hex. So this:

   println!("dumping {:#x?}", region);

Becomes this:

dumping Region {

   daddr: Some(
       0x4db8,
   ),
   base: 0x10000,
   size: 0x8000,
   attr: RegionAttr {
       read: true,
       write: false,
       execute: true,
       device: false,
       dma: false,
   },
   task: Task(
       0x0,
   ),

}

My fingers now type {:#x?} by default, and hot damn is it ever nice!

3. Rust Integer literal syntax

Okay, another small one: I love the Rust integer literal syntax! In hardware-facing systems, we are often expressing things in terms of masks that ultimately map to binary. It is beyond me why C thought to introduce octal and hexadecimal but not binary in their literal syntax; Rust addresses this gap with the same “0b” prefix as found in some non-standard C compiler extensions. Additionally, Rust allows for integer literals to be arbitrarily intra-delimited with an underscore character. Taken together, this allows for a mask consisting of bits 8 through 10 and bit 12 (say) to be expressed as 0b0000_1011_1000_0000 — which to me is clearer as to its intent and less error prone than (say) 0xb80 or 0b101110000000.

And as long as we’re on the subject of integer literals: I also love that the types (and the suffix that denotes a literal’s type) explicitly encode bit width and signedness. Instead of dealing with the implicit signedness and width of char, short, long and long long, we have u8, u16, u32, u64, etc. Much clearer!

4. DWARF support

Debugging software — and more generally, the debuggability of software systems — is in my marrow; it may come as no surprise that one of the things that I personally have been working on is the debugger for a de novo Rust operating system that we’re developing. To be useful, debuggers need help from the compiler in the way of type information — but this information has been historically excruciating to extract, especially in production systems. (Or as Robert phrased it concisely years ago: “the compiler is the enemy.”) And while DWARF is the de facto standard, it is only as good as the compiler’s willingness to supply it.

Given how much debuggability can (sadly) lag development, I wasn’t really sure what I would find with respect to Rust, but I have been delighted to discover thorough DWARF support. This is especially important for Rust because it (rightfully) makes extensive use of inlining; without DWARF support to make sense of this inlining, it can be hard to make any sense of the generated assembly. I have been able to use the DWARF information to build some pretty powerful Rust-based tooling — with much promise on the horizon. (You can see an early study for this work in Tockilator.)

5. Gimli and Goblin

Lest I sound like I am heaping too much praise on DWARF, let me be clear that DWARF is historically acutely painful to deal with. The specification (to the degree that one can call it that) is an elaborate mess, and the format itself seems to go out of its way to inflict pain on those who would consume it. Fortunately, the Gimli crate that consumes DWARF is really good, having made it easy to build DWARF-based tooling. (I have found that whenever I am frustrated with Gimli, I am, in fact, frustrated with some strange pedantry of DWARF — which Gimli rightfully refuses to paper over.)

In addition to Gimli, I have also enjoyed using Goblin to consume ELF. ELF — in stark contrast to DWARF — is tight and crisp (and the traditional C-based tooling for ELF is quite good), but it was nice nonetheless that Goblin makes it so easy to zing through an ELF binary.

6. Rust Data-bearing enums

Rust Enums — that is, the “sum” class of algebraic types — are core to Rust, and give it the beautiful error handling that I described falling in love with two years ago. Algebraic types allow much more than just beautiful error handling, e.g. Rust’s ubiquitous Option type, which allows for sentinel values to be eliminated from one’s code — and with it some significant fraction of defects. But it’s one thing to use these constructs, and another to begin to develop algebraic types for one’s own code, and I have found the ability for enums to optionally bear data to be incredibly useful. In particular, when parsing a protocol, one is often taking a stream of bytes and turning it into one of several different kinds of things; it is really, really nice to have the type system guide how software should consume the protocol. For example, here’s an enum that I defined when parsing data from ARM’s Embedded Trace Macrocell signal protocol:

1. [derive(Copy, Clone, Debug)]

pub enum ETM3Header {

   BranchAddress { addr: u8, c: bool },
   ASync,
   CycleCount,
   ISync,
   Trigger,
   OutOfOrder { tag: u8, size: u8 },
   StoreFailed,
   ISyncCycleCount,
   OutOfOrderPlaceholder { a: bool, tag: u8 },
   VMID,
   NormalData { a: bool, size: u8 },
   Timestamp { r: bool },
   DataSuppressed,
   Ignore,
   ValueNotTraced { a: bool },
   ContextID,
   ExceptionExit,
   ExceptionEntry,
   PHeaderFormat1 { e: u8, n: u8 },
   PHeaderFormat2 { e0: bool, e1: bool },

}

That variants can have wildly different types (and that some can bear data while others don’t — and some can be structured, while others are tuples) allows for the type definition to closely match the specification, and helps higher-level software consume the protocol correctly.

7. Rust Ternary operations In C, the ternary operator allows for a terse conditional expression that can be used as an rvalue, e.g.:

x = is_foo ? foo : bar;

This is equivalent to:

if (is_foo) {
	x = foo;
} else {
	x = bar;
}

This construct is particularly valuable when not actually assigning to an lvalue, but when (for example) returning a value or passing a parameter. And indeed, I would estimate that a plurality — if not a majority — of my lifetime-use of the ternary operator has been in arguments to printf.

While Rust has no ternary operator per se, it is expression-oriented: statements have values. So the above example becomes:

x = if is_foo { foo } else { bar };

That’s a bit more verbose than its C equivalent (though I personally like its explicitness), but it really starts to shine when things can marginally more complicated: nested ternary operators get gnarly in C, but they are easy to follow as simple nested if-then-else statements in Rust. And (of course) match is an expression as well — and I found that I often use match where I would have used a ternary operator in C, with the added benefit that I am forced to deal with every case. As a concrete example, take this code that is printing a slice of little-endian bytes as an 8-bit, 16-bit, or 32-bit quantity depending on a size parameter:

   print!("{:0width$x} ",
       match size {
           1 => line[i - offs] as u32,
           2 => u16::from_le_bytes(slice.try_into().unwrap()) as u32,
           4 => u32::from_le_bytes(slice.try_into().unwrap()) as u32,
           _ => {
               panic!("invalid size");
           }
       },
       width = size * 2
   );

For me, this is all of the power of the ternary operator, but without its pitfalls!

An interesting footnote on this: Rust once had the C-like ternary operator, but removed it, as the additional syntax didn’t carry its weight. This pruning in Rust’s early days — the idea that syntax should carry its weight by bringing unique expressive power — has kept Rust from the fate of languages that suffered from debilitating addictions to new syntax and concomitant complexity overdose; when there is more than one way to do it for absolutely everything, a language becomes so baroque as to become write-only!

8. Rust paste!

This is a small detail, but one that took me a little while to find. As I described in my blog entry two years ago, I have historically made heavy use of the C preprocessor. One (arcane) example of this is the ## token concatenation operator, which I have needed only rarely — but found essential in those moments. (Here’s a concrete example.) As part of a macro that I was developing, I found that I needed the equivalent for Rust, and was delighted to find David Tolnay’s Rust paste crate. paste! was exactly what I needed — and more testament to both the singular power of Rust’s macro system and David’s knack for build singularly useful things with it!

9. Rust unsafe

A great strength of Rust is its safety — but something I also appreciate about it is the escape hatch offered via unsafe, whereby certain actions are permitted that are otherwise disallowed. It should go without saying that one should not use unsafe without good reason — but such good reasons can and do exist, and I appreciate that Rust trusts the programmer enough to allow them to take their safety into their own hands. Speaking personally, most of my own uses of unsafe have boiled down to accesses to register blocks on a microcontroller: on the one hand, unsafe because they dereference arbitrary memory — but on the other, safe by inspection. That said, the one time I had to write unsafe code that actually felt dangerous (namely, in dealing with an outrageously unsafe C library), I was definitely in a heightened state of alert! Indeed, my extreme caution around unsafe code reflects how much Rust has changed my disposition: after nearly three decades working in C, I thought I appreciated its level of unsafety, but the truth is I had just become numb to it; to implement in Rust is to eat the fruit from the tree of knowledge of unsafe programs — and to go back to unsafe code is to realize that you were naked all along!

10. Rust Multi-platform support

When Steve Klabnik joined Oxide, we got not only an important new addition to the team, but a new platform as well: Steve is using Windows as his daily driver, in part because of his own personal dedication to keeping Rust multi-platform. While I’m not sure that anything could drive me personally to use Windows (aside: MS-DOS robbed me of my childhood), I do strongly believe in platform heterogeneity. I love that Rust forces the programmer to really think about implicitly platform-specific issues: Rust refuses to paper over the cracks in computing’s foundation for sake of expediency. If this can feel unnecessarily pedantic (can’t I just have a timestamp?!), it is in multi-platform support where this shines: software that I wrote just… worked on Windows. (And where it didn’t, it was despite Rust’s best efforts: when a standard library gives you first-class support to abstract the path separator, you have no one to blame but yourself if you hard-code your own!)

Making and keeping Rust multi-platform is hard work for everyone involved; but as someone who is currently writing Rust for multiple operating systems (Linux, illumos and — thanks to Steve — Windows) and multiple ISAs (e.g., x86-64, ARM Thumb-2), I very much appreciate that this is valued by the Rust community!

11. anyhow! + RUST_BACKTRACE

In my original piece, I praised the error handling of Rust, and that is certainly truer than ever: I simply cannot imagine going back to a world without algebraic types for error handling. The challenge that remained was that there were several conflicting crates building different error types and supporting routines, resulting in some confusion as to best practice. All of this left me — like many — simply rolling my own via Box<dyn Error>, which works well enough, but it doesn’t really help a thorny question: when an error emerges deep within a stack of composed software, where did it actually come from?

Enter David Tolnay (again!) and his handy anyhow! crate, which pulls together best practices and ties that into the improvements in the std::error::Error trait to yield a crate that is powerful without being imposing. Now, when an error emerges from within a stack of software, we can get a crisp chain of causality, e.g.:

readmem failed: A core architecture specific error occurred

Caused by:

   0: Failed to read register CSW at address 0x00000000
   1: Didn't receive any answer during batch processing: [Read(AccessPort(0), 0)]

And we can set RUST_BACKTRACE to get a full backtrace where an error actually originates — which is especially useful when a failure emerges from a surprising place, like this one from a Drop implementation in probe-rs:

Stack backtrace:

  0: probe_rs::probe::daplink::DAPLink::process_batch
  1: probe_rs::probe::daplink::DAPLink::batch_add
  2: ::read_register
  3: probe_rs::architecture::arm::communication_interface::ArmCommunicationInterface::read_ap_register
  4: probe_rs::architecture::arm::memory::adi_v5_memory_interface::ADIMemoryInterface::read_word_32
  5: ::read_word_32
  6: ::get_available_breakpoint_units
  7:  as core::iter::traits::iterator::Iterator>::next
  8: ::from_iter
  9: ::drop
 10: core::ptr::drop_in_place
 11: main
 12: std::sys_common::backtrace::__rust_begin_short_backtrace
 13: std::rt::lang_start::{{closure}}
 14: core::ops::function::impls:: for &F>::call_once
 15: main
 16: __libc_start_main
 17: _start) })

12. Rust asm!

When writing software at the hardware/software interface, there is inevitably some degree of direct machine interaction that must be done via assembly. Historically, I have done this via dedicated .s files — which are inconvenient, but explicit.

Over the years, compilers added the capacity to drop assembly into C, but the verb here is apt: the resulting assembly was often dropped on its surrounding C like a Looney Tunes anvil, with the interface between the two often being ill-defined, compiler-dependent or both. Rust took this approach at first too, but it suffered from all of the historical problems of inline assembly — which in Rust’s case meant being highly dependent on LLVM implementation details. This in turn meant that it was unlikely to ever become stabilized, which would relegate those who need inline assembly to forever be on nightly Rust.

Fortunately, Amanieu d’Antras took on this gritty problem, and landed a new asm! syntax. The new syntax is a pleasure to work with, and frankly Rust has now leapfrogged C in terms of ease and robustness of integrating inline assembly!

13. Rust String continuations

Okay, this is another tiny one, but meaningful for me and one that took me too long to discover. So first, something to know about me: I am an eighty column purist. For me, this has nothing to do with punchcards or whatnot, but rather with type readability, which tends to result in 50-100 characters per line — and generally about 70 or so. (I would redirect rebuttals to your bookshelf, where most any line of most any page of most any book will show this to be more or less correct.) So I personally embrace the “hard 80″, and have found that the rework that that can sometimes require results in more readable, better factored code. There is, however, one annoying exception to this: when programmatically printing a string that is itself long, one is left with much less horizontal real estate to work with! In C, this is a snap: string literals without intervening tokens are automatically concatenated, so the single literal can be made by multiple literals across multiple lines. But in Rust, string literals can span multiple lines (generally a feature!), so splitting the line will also embed the newline and any leading whitespace. e.g.:

   println!(
       "...government of the {p}, by the {p}, for the {p},
       shall not perish from the earth.",
       p = "people"
   );

Results in a newline and some leading whitespace that represent the structure of the program, not the desired structure of the string:

…government of the people, by the people, for the people,

       shall not perish from the earth.

I have historically worked around this by using the concat! macro to concatenate two (or more) static strings, which works well enough, but looks pretty clunky, e.g.:

   println!(
       concat!(
           "...government of the {p}, by the {p}, for the {p}, ",
           "shall not perish from the earth."
       ),
       p = "people"
   );

As it turns out, I was really overthinking it, though it took an embarrassingly long time to discover: Rust has support for continuation of string literals! If a line containing a string literal ends in a backslash, the literal continues on the next line, with the newline and any leading whitespace elided. This is one of those really nice things that Rust lets us have; the above example becomes:

   println!(
       "...government of the {p}, by the {p}, for the {p}, \
       shall not perish from the earth.",
       p = "people"
   );

So much cleaner!

14. –pretty=expanded and cargo expand

In C — especially C that makes heavy use of the preprocessor — the -E option can be invaluable: it stops the compilation after the preprocessing phase and dumps the result to standard output. Rust, as it turns out has an equivalent in the –pretty=expanded unstable compiler option. The output out of this can be a little hard on the eyes, so you want to send it through rustfmt — but the result can be really enlightening as to how things actually work. Take, for example, the following program:

fn main() {

   println!("{} has been quite a year!", 2020);

}

Here is the –pretty=expanded output:

$ rustc -Z unstable-options –pretty=expanded year.rs ]] | ![feature(prelude_import)] #![no_std] #[prelude_import] use std::prelude::v1::*; #[macro_use] extern crate std; fn main() { { ::std::io::_print(::core::fmt::Arguments::new_v1( &["", " has been quite a year!\n"], &match (&2020,) { (arg0,) => [::core::fmt::ArgumentV1::new( arg0, ::core::fmt::Display::fmt, )], }, )); }; } As an aside, [[Rust format_args! is really magical — and a subject that really merits its own blog post from someone with more expertise on the subject. (Yes, this is the Rust blogging equivalent of Chekhov’s gun!)

With so many great David Tolnay crates, it’s fitting we end on one final piece of software from him: cargo expand is a pleasant wrapper around –pretty=expanded that (among other things) allows you to only dump a particular function.

The perfect marriage?

All of this is not to say that Rust is perfect; there are certainly some minor annoyances (rustfmt: looking at you!), and some forthcoming features that I eagerly await (e.g., safe transmutes, const generics). And in case it needs to be said: just because Rust makes it easier to write robust software doesn’t mean that it makes it impossible to write shoddy software!

Dwelling on the imperfections, though, would be a mistake. When getting into a long-term relationship with anything — be it a person, or a company, or a technology — it can be tempting to look at its surface characteristics: does this person, or company or technology have attributes that I do or don’t like? And those are important, but they can be overemphasized: because things change over time, we sometimes look too much at what things are rather than what guides them. And in this regard, my relationship with Rust feels particularly sound: it feels like my values and Rust’s values are a good fit for one another — and that my growing relationship with Rust will be one of the most important of my career!”

Posted on October 11, 2020 at 10:21 am by bmc

GPT o1 Pro mode:

Rust Programming Language, Rust Compiler, Rust Cargo Build Tool, Rust Ownership System, Rust Borrow Checker, Rust Lifetime, Rust Crate, Rust Module, Rust Package, Rust Trait, Rust Struct, Rust Enum, Rust Function, Rust Macro, Rust Pattern Matching, Rust Closure, Rust Iterator, Rust Result Type, Rust Option Type, Rust Error Handling, Rust Vec Type, Rust String Type, Rust Slice Type, Rust Reference, Rust Mutable Reference, Rust Immutable Reference, Rust Smart Pointer, Rust Box Type, Rust Rc Type, Rust Arc Type, Rust Cell Type, Rust RefCell Type, Rust Mutex Type, Rust RwLock Type, Rust Atomic Types, Rust PhantomData, Rust Drop Trait, Rust From Trait, Rust Into Trait, Rust AsRef Trait, Rust AsMut Trait, Rust PartialEq Trait, Rust Eq Trait, Rust PartialOrd Trait, Rust Ord Trait, Rust Hash Trait, Rust Clone Trait, Rust Copy Trait, Rust Default Trait, Rust Debug Trait, Rust Display Trait, Rust ToString Trait, Rust Iterator Trait, Rust DoubleEndedIterator Trait, Rust ExactSizeIterator Trait, Rust FusedIterator Trait, Rust Extend Trait, Rust FromIterator Trait, Rust IntoIterator Trait, Rust Borrow Trait, Rust BorrowMut Trait, Rust Deref Trait, Rust DerefMut Trait, Rust Fn Trait, Rust FnMut Trait, Rust FnOnce Trait, Rust Send Marker Trait, Rust Sync Marker Trait, Rust Unpin Marker Trait, Rust Sized Marker Trait, Rust Unsized Trait, Rust Marker Traits, Rust dyn Trait, Rust Generic Type Parameter, Rust Generic Lifetime Parameter, Rust Generic Associated Type, Rust Generic Constraints, Rust Associated Type, Rust Associated Function, Rust Inherent Implementation, Rust Trait Implementation, Rust Trait Bounds, Rust Trait Object, Rust Impl Keyword, Rust Self Keyword, Rust Super Keyword, Rust Use Keyword, Rust mod Keyword, Rust pub Keyword, Rust crate Keyword, Rust extern Keyword, Rust const Keyword, Rust static Keyword, Rust async Keyword, Rust await Keyword, Rust match Keyword, Rust if let Expression, Rust while let Expression, Rust loop Keyword, Rust for Keyword, Rust break Keyword, Rust continue Keyword, Rust return Keyword, Rust move Keyword, Rust ref Keyword, Rust in Keyword, Rust Box Smart Pointer, Rust Rc Smart Pointer, Rust Arc Smart Pointer, Rust RefCell Interior Mutability, Rust Cell Interior Mutability, Rust Mutex Synchronization, Rust RwLock Synchronization, Rust AtomicBool, Rust AtomicIsize, Rust AtomicUsize, Rust AtomicPtr, Rust NonNull Pointer, Rust ManuallyDrop, Rust MaybeUninit, Rust Pin Type, Rust PhantomPinned, Rust std Library, Rust core Library, Rust alloc Library, io Module, fs Module, net Module, sync Module, thread Module, time Module, mem Module, ptr Module, slice Module, string Module, vec Module, env Module, process Module, collections Module, hash Module, fmt Module, error Module, option Module, result Module, mpsc Channel, atomic Operations, path Module, ffi Module, os Module, task Module, future Module, pin Module, marker Module, any Module, cmp Module, iter Module, ops Module, str Module, num Module, rc Module, Duration, sleep, spawn, args, var, set_var, swap, replace, take, null, null_mut, from_raw_parts, from_raw_parts_mut, from_utf8, Option, Result, Error Trait, Formatter, Display, Debug, Write Trait, Hasher, Hash, HashMap, HashSet, BTreeMap, BTreeSet, VecDeque, BinaryHeap, Iterator, IntoIterator, FromIterator, Add, Sub, Mul, Div, Rem, BitAnd, BitOr, BitXor, Not, Shl, Shr, Deref, DerefMut, Drop, Index, IndexMut, Range, RangeInclusive, RangeFrom, RangeTo, RangeFull, ControlFlow, Wrapping, NonZeroUsize, NonZeroIsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128, Rust Memory Safety, Rust Zero-Cost Abstractions, Rust Ownership Rules, Rust Move Semantics, Rust Clone Semantics, Rust Copy Semantics, Rust Partial Move, Rust Pattern Destructuring, Rust Type Inference, Rust Sized Type, Rust Unsized Type, Rust Coercion, Rust DST (Dynamically Sized Type), Rust FFI (Foreign Function Interface), Rust C ABI, Rust extern Function, Rust extern Block, [repr(C)], [derive(...)] Attribute, [cfg(...)] Attribute, [test] Attribute, [macro_use] Attribute, [no_mangle] Attribute, [inline] Attribute, [inline(always)] Attribute, [inline(never)] Attribute, [cold] Attribute, [must_use] Attribute, [deny(...)] Attribute, [allow(...)] Attribute, [warn(...)] Attribute, [forbid(...)] Attribute, [non_exhaustive] Attribute, [global_allocator] Attribute, [panic_handler] Attribute, [no_std] Attribute, [no_main] Attribute, [repr(transparent)] Attribute, [repr(packed)] Attribute, [repr(align(...))] Attribute, [export_name(...)] Attribute, [link(...)] Attribute, [used] Attribute, [no_coverage] Attribute, [track_caller] Attribute, Rust Cargo, Rust cargo build, Rust cargo run, Rust cargo test, Rust cargo bench, Rust cargo doc, Rust cargo fmt, Rust cargo clippy, Rust cargo clean, Rust cargo update, Rust cargo publish, Rust cargo login, Rust cargo yank, Rust cargo install, Rust cargo uninstall, Rust cargo tree, Rust cargo metadata, Rust cargo package, Rust cargo fix, Rust cargo generate-lockfile, Rust cargo vendor, Rust cargo +nightly Command, Rust cargo workspace, Rust Cargo.toml, Rust Cargo.lock, Rust crate-type, Rust crate-name, Rust edition (2015), Rust edition (2018), Rust edition (2021), Rust edition (2024 Proposed), Rust rustc Compiler, Rust rustdoc Tool, Rust rustfmt Tool, Rust clippy Linter, Rust miri Interpreter, Rust RLS (Rust Language Server), Rust rust-analyzer, Rust cargo-make, Rust cargo-tarpaulin, Rust cargo-audit, Rust cargo-outdated, Rust cargo-expand, Rust crates.io Registry, Rust Rustup Tool, Rust rustup default, Rust rustup toolchain, Rust rustup component add, Rust rustup target add, Rust stable Channel, Rust beta Channel, Rust nightly Channel, Rust LTS (Hypothetical), Rust MSRV (Minimum Supported Rust Version), Rust RFC (Request For Comments), Rust Edition Guide, Rust The Rustonomicon, Rust The Book (The Rust Programming Language), Rust unsafe Code, Rust unsafe Block, Rust unsafe Fn, Rust unsafe Trait, Rust raw Pointer, Rust *const T, Rust *mut T, Rust Dereferencing Raw Pointer, read, write, replace, transmute, forget, align_of, size_of, zeroed, MaybeUninit, Rust Union Type, Rust extern Crate (Legacy), Rust Edition Imports (no extern keyword), Rust pub(crate) Visibility, Rust pub(super) Visibility, Rust pub(in path) Visibility, Rust pub use Re-export, Rust glob import (*), Rust underscore import (_), Rust name Mangling, Rust LTO (Link Time Optimization), Rust ThinLTO, Rust Profile-Guided Optimization (PGO), Rust Codegen Units, Rust Incremental Compilation, arch Intrinsics, Rust simd Feature, Rust specialization (nightly), Rust const fn, Rust const generics (nightly), Rust async/await, Rust Future Trait, Rust Pin<P> Type, Rust poll Function, Rust Waker, Rust Context (in async), Rust async fn, Rust async move, Rust .await Operator, Rust async Streams (nightly), Rust Generator State, Rust Generator Trait, Rust yield Keyword (nightly), Rust proc_macro Crate, Rust proc_macro_derive Macro, Rust custom_derive Macro, Rust custom_attribute Macro (deprecated), Rust attribute Macro, Rust function-like Macro, Rust declarative Macro, Rust macro_rules! Macro, Rust macro Expansion, Rust Hygiene in Macros, Rust edition macros changes, Rust procedural Macro expansion, Rust Testing Framework, [test] Function, [bench] (deprecated), [should_panic] Attribute, Rust cargo test -- --nocapture, Rust doc Tests, Rust integration Tests directory (tests), Rust benches Directory, Rust examples Directory, Rust microbenchmarking (Criterion crate), Rust fuzz Testing (cargo-fuzz), Rust Miri Testing, Rust code coverage (LLVM), Rust Crate Features (Cargo), Rust optional Dependencies, Rust dev-dependencies, Rust build-dependencies, Rust cargo features, Rust feature flags in Cargo.toml, Rust unstable features (nightly), Rust [patch] section in Cargo.toml, Rust Path dependencies, Rust Git dependencies, Rust HTTP dependencies, Rust local Registries, Rust workspaces in Cargo, Rust crates.io Publishing, Rust crates.io yank, Rust crates.io owners, Rust Documentation Comments ///, ![doc(...)], Rust Documenting Modules, Rust Documenting Struct Fields, Rust Documenting Enum Variants, Rust Documenting Functions, Rust Documenting Traits, Rust Documenting Implementations, Rust Documenting Macros, Rust Documenting Constants, Rust Doc hidden, Rust Doc no_inline, Rust Doc cfg Attributes, Rust Code Examples in Docs, Rust doctest in Documentation, Rust Cross-Compilation, Rust Targets (e.g. wasm32-unknown-unknown), Rust wasm-bindgen Integration, Rust wasm-pack Tool, Rust wasm32-wasi Target, Rust Embedded Development, Rust no_std Environments, Rust alloc Crate in no_std, Rust Core Crate in no_std, [panic_handler], [alloc_error_handler], Rust Naked functions (nightly), Rust inline Assembly (asm! Macro), Rust Linker Arguments in Cargo, Rust build scripts (build.rs), Rust env! Macro, Rust option_env! Macro, Rust include! Macro, Rust include_str! Macro, Rust include_bytes! Macro, Rust concat! Macro, Rust line! Macro, Rust column! Macro, Rust file! Macro, Rust cfg! Macro, Rust stringify! Macro, Rust format! Macro, Rust println! Macro, Rust print! Macro, Rust eprintln! Macro, Rust eprint! Macro, Rust dbg! Macro, Rust panic! Macro, Rust unreachable! Macro, Rust unimplemented! Macro, Rust todo! Macro, Rust assert! Macro, Rust assert_eq! Macro, Rust assert_ne! Macro, Rust compile_error! Macro, Rust concat_idents! Macro (nightly), Rust global_asm! Macro (nightly), Rust log crates Integration, Rust serde Crate Integration, Rust serde_derive Macro, Rust anyhow Crate for Error Handling, Rust thiserror Crate for Error Derives, Rust clap Crate for CLI Arguments, Rust structopt Crate (deprecated in favor of clap), Rust tokio Crate (Async Runtime), Rust async-std Crate, Rust futures Crate, executor, channel, stream, sink, select! Macro, Rust pin_utils Crate, Rust lazy_static Crate (deprecated in favor of once_cell), Rust once_cell Crate, Rust crossbeam Crate, Rust rayon Crate (Data Parallelism), Rust nom Crate (Parsing), Rust regex Crate, Rust hyper Crate (HTTP), Rust reqwest Crate (HTTP Client), Rust warp Crate (Web Framework), Rust rocket Crate (Web Framework), Rust actix-web Crate, Rust axum Crate, Rust tonic Crate (gRPC), Rust prost Crate (Protocol Buffers), Rust capnproto-rust Crate, Rust diesel Crate (ORM), Rust sqlx Crate (Async SQL), Rust rusqlite Crate, Rust mongodb Crate, Rust redis Crate, Rust log Crate, Rust env_logger Crate, Rust tracing Crate, Rust tracing_subscriber Crate, Rust slog Crate, Rust sloggers Crate, Rust structopt Crate, Rust clap_derive Crate, Result, Error, Error Derive, Serialize, Deserialize, Rust serde_json Crate, Rust toml Crate, Rust yaml-rust Crate, Rust bincode Crate, Rust byteorder Crate, Rust rand Crate, Rng Trait, thread_rng, StdRng, SliceRandom, Rust chrono Crate, Utc, DateTime, NaiveDate, App Builder, Arg Builder, StructOpt Derive, main Macro, spawn, select! Macro, mpsc, oneshot, Mutex, RwLock, fs, net, time, Future Trait, Stream Trait, Sink Trait, join! Macro, try_join! Macro, select_biased! Macro, Rust pin_project Crate, pin_project Macro, Rust cfg_if Crate, Rust lazy_static! Macro, Lazy, Lazy, spawn, join, scope, parallel_iterator, prelude, IResult, complete, sequence, branch, combinator, multi, character, Regex, Captures, Server, Request, Response, Body, make_service_fn, service_fn, Client, Response, Error, Filter, Reply, path, query, body, header, Rocket, ignite (Deprecated), build, routes Macro, get Macro, post Macro, State, App, HttpServer, HttpRequest, HttpResponse, Router, routing, extract, Server, Request, Response, Status, Message Trait, EncodeError, DecodeError, prelude, Connection, Queryable Derive, Insertable Derive, Pool, query, query_as, Executor, Connection, params! Macro, Client, Collection, bson, Client, Commands Trait, Rust memory Safety Guarantee, Rust fearless Concurrency, Rust RAII (Resource Acquisition Is Initialization), Rust Zero-cost Interruptions, Rust Minimal Runtime Overhead, Rust Pattern Exhaustiveness, Rust match Guards, Rust let Binding Patterns, Rust destructuring assignment (nightly), Rust never Type (!), Rust Infallible Type, TryFrom, TryInto, FromStr, parse Method, Rust borrowing &T, Rust mutable borrowing &mut T, Rust Deref coercion, Rust Slice Patterns, Rust associated consts, Rust array Types, Rust tuple Types, Rust unit Type (), Rust underscore Lifetimes, Rust underscore Import `_`, Rust underscore Variable `_var`, Rust pub(crate), Rust pub(super), Rust inline Modules mod keyword, Rust nested Modules, item, Rust crate root, Rust crate level attributes, Rust doc tests, Rust doc hidden Items, Rust doc(cfg) attribute, Rust doc include attributes, Rust doc alias attributes, Rust doc comment triple slash ///, Rust doc inline code block, Rust doc code fencing ```, Rust doctest ignore, Rust doctest no_run, Rust doctest compile_fail, Rust doctest should_panic, Rust Benchmarking (nightly), [bench] attribute (deprecated), Rust Criterion Benchmarking, Rust cross compilation with cargo, Rust rustup target list, Rust rustup target add wasm32-unknown-unknown, Rust wasm32-unknown-emscripten Target, Rust cdylib Crate Type, Rust staticlib Crate Type, Rust bin Crate Type, Rust proc-macro Crate Type, [no_main], Rust link Sections, Rust extern crate (deprecated in 2018), identifier, Rust macro 2.0 (procedural macros), Rust macro hygiene improvements, Rust macro pattern matching, Rust macro pattern repetitions, Rust macro capture variables, Rust macro scoping rules, Rust macro modularization, Rust edition idioms, Rust edition linting, Rust Rustfix Tool, Rust cargo fix --edition, Rust lint warnings, Rust deny warnings policy, Rust forbid unsafe code policy, Rust cargo deny Crate, Rust cargo crev Crate (Code Review), Rust cargo geiger (count unsafe)

GPT 4o:

ABI Compatibility, Abstract Data Types, Abstract Syntax Tree, Access Modifiers, Accumulator Idiom, AddAssign Trait, Addition Operator Overloading, Address Sanitizer, Advanced Macros, Affine Types, Alias Types, Alignment, Allocator API, Allocators, Alphanumeric Identifiers, Anonymized Lifetimes, Arc Type, Array Initialization, Array Slices, As Keyword, Async/Await Syntax, Async Functions, Atomic Operations, Atomic Reference Counting, Attribute Macros, Attributes, Await Operator, Backtrace Support, Bare Metal Programming, Beginner Errors, Benchmarking, Binary Crates, Binary Operators, Binding Modes, Bit Manipulation, Bitfields, Bitflags Crate, Bitwise Operators, Block Expressions, Box Smart Pointer, Box Type, Boxed Closures, Boxed Trait Objects, Borrow Checker, Borrow Mutability, Borrowed Pointers, Borrowed Types, Borrowing, Bounds Checking, Break Expressions, Build Automation, Build Dependencies, Build Profiles, Build Scripts, Byte Order, Byte Strings, Bytecode, C ABI Compatibility, C FFI Integration, Cargo Bench Command, Cargo Binaries, Cargo Build Command, Cargo Build Scripts, Cargo Check Command, Cargo Clean Command, Cargo Clippy, Cargo Commands, Cargo Crates, Cargo Doc Command, Cargo Features, Cargo Install Command, Cargo Integration, Cargo Lock File, Cargo Metadata, Cargo New Command, Cargo Package Manager, Cargo Publish Command, Cargo Run Command, Cargo Scripts, Cargo Semver, Cargo Subcommands, Cargo Test Command, Cargo.toml File, Casting Between Types, Cell Type, Character Encoding, Character Literals, Closures as Arguments, Closures, Coercions, Collection Types, Combined Traits, Command Line Arguments, Command Line Parsing, Comment Syntax, Common Lifetime Errors, Common Traits, Compile Time Assertions, Compile Time Errors, Compile Time Function Evaluation, Compile-Time Functions, Compiler Hints, Compiler Internals, Compiler Options, Compiler Plugins, Compiler Warnings, Complex Number Types, Complex Types, Concurrency, Conditional Compilation, Conditional Expressions, Configuration Macros, Configuration Options, Const Context, Const Evaluator, Const Expressions, Const Functions, Const Generics, Const Trait Implementations, Constant Evaluation, Constant Generics, Constant Panic, Constant Promotion, Constructors, Container Types, Content Security Policies, Contextual Keywords, Continue Expressions, Copy Elision, Copy Trait, Covariance, Crate Attributes, Crate Dependencies, Crate Documentation, Crate Export, Crate Features, Crate Graph, Crate Import, Crate Level Attributes, Crate Manifest, Crate Metadata, Crate Registry, Crate Roots, Crate Types, Crate Visibility, Crates, Cross Compilation, Cross-Crate Inlining, Custom Allocators, Custom Attributes, Custom Derive Macros, Custom DSTs, Custom Lints, Custom Macros, Custom Smart Pointers, Custom Test Frameworks, Data Alignment, Data Ownership, Data Races, Data Structures, Data Types, Dead Code Elimination, Debug Trait, Debugging Rust Code, Debugging Symbols, Decimal Literal Suffixes, Default Generic Parameters, Default Implementations, Default Keyword, Default Trait, Deferred Initialization, Deref Coercion, Deref Trait, Derived Traits, Destructuring, Destructor, Deterministic Behavior, Developing Libraries, Diagnostic Messages, Diverging Functions, Doctests, Documentation Comments, Documentation Generation, Double Borrowing, Double-Free Errors, Downcasting, Drop Check, Drop Flag, Drop Glue, Drop Implementation, Drop Trait, Dynamic Dispatch, Dynamic Linking, Dynamic Polymorphism, Dynamic Sized Types, Dyn Trait Syntax, Elided Lifetimes, Else If Expressions, Embedded Development, Encapsulation, Enums with Data, Enum Discriminants, Enum Matching, Enum Variants, Enums, Error Handling in Rust, Error Messages, Error Trait, Escape Analysis, Escape Sequences, Exclusive Borrowing, Existential Types, Exhaustive Matching, Explicit Lifetimes, Expression Lifetimes, Expression Macros, Expressions, Extensible Enums, Extension Traits, Extern Crate, External Crates, External Macros, Extern Function Declarations, Extern Keyword, F32 Type, F64 Type, Fat Pointers, Feature Gates, Field Initializers, Field Offsets, Field Shorthands, Field Visibility, File Inclusion, Final Variables, Finalizers, Fixed Size Arrays, Flag Enums, Float Literal Suffixes, Floating Point Types, Fn Trait, FnMut Trait, FnOnce Trait, For Loop Syntax, Foreign Function Interface, Format Macros, Format Specifiers, Format Strings, Formatting Guidelines, Formatting Traits, Formatters, Forwarding Implementations, Futures, Future Combinators, Future Trait, Garbage Collection in Rust, Generic Associated Types, Generic Bounds, Generic Constraints, Generic Functions, Generic Lifetimes, Generic Parameters, Generic Trait Implementations, Generic Traits, Generics, Global Allocator, Global State, Global Variables, Graphical User Interfaces, Guaranteed Initialization, Hash Map Type, Hash Trait, Hashable Types, Hashing Algorithms, HashSet Type, Heap Allocation, Helper Macros, Higher Kinded Types, Higher Rank Trait Bounds, Higher-Rank Lifetimes, Hir (High-Level Intermediate Representation), Hygiene in Macros, Identifier Hygiene, Identifier Resolution, If Let Expressions, If Let Syntax, If Statements, Immutability, Implementation Blocks, Implicit Conversions, Implicit Lifetimes, Import Declarations, Import Paths, Indexed Access, Index Trait, IndexMut Trait, Infinite Loops, Inferable Types, Inherent Implementations, Inherent Methods, Initialization, Inline Assembly in Rust, Inline Attributes, Inline Functions, Inner Attributes, Input Streams, Integer Casting, Integer Literals, Integer Overflow, Integer Promotions, Integer Types, Integral Types, Integration Tests, Interior Mutability, Interoperability with C, Interoperability with C++, IntoIterator Trait, Into Trait, Intrinsic Functions, Invariant Lifetimes, IO Handling, IO Traits, Irrefutable Patterns, Iterator Adapters, Iterator Combinators, Iterator Trait, Iterators in Rust, Iterator Types, Key-Value Collections, Key-Value Store, Keyword Restrictions, Language Keywords, Labeled Breaks, Labeled Continue, Labeled Loops, Lambda Expressions, Lambdas, Lazy Evaluation, Lazy Static Initialization, Lexical Lifetimes, Lexical Scoping, Lifetime Annotations, Lifetime Bounds, Lifetime Elision Rules, Lifetime Elision, Lifetime Parameters, Lifetime Subtyping, Lifetime Variance, Lifetimes in Closures, Lifetimes, Line Comments, Linked Crates, Linked Lists, Linkage in Rust, Link Time Optimization, Lint Attributes, Linting, Literal Patterns, Literal Suffixes, Literals, Local Crates, Local Variables, Loop Expressions, Loop Labels, Loop Constructs, Macro Expansion, Macro Hygiene, Macro Invocation, Macros By Example, Macros in Rust, Main Function, Manually Drop Type, Manually Implemented Traits, Map Type, Match Arms, Match Expressions, Match Guards, Match Patterns, Match Statement, Memory Allocation, Memory Barriers, Memory Leaks, Memory Management, Memory Safety in Rust, Memory Safety, Meta Variables, Method Chaining, Method Dispatch, Method Overriding, Method Resolution, Methods, Mir (Mid-level Intermediate Representation), Module Attributes, Module Crates, Module Declarations, Module Imports, Module Level Attributes, Module Path, Module Privacy, Module Resolution, Module System, Modules, Monomorphization, Move Semantics, Mutable Aliases, Mutable Bindings, Mutable Borrowing, Mutable References, Mutable Variables, Mutability, Mutex Type, Name Mangling, Namespacing, Nested Closures, Nested Modules, New Type Idiom, Newtype Pattern, Nightly Builds, No Mangle Attribute, Non-Lexical Lifetimes, NonNull References, NonNull Type, Non-Copy Types, Non-Sized Types, Null Pointer Optimization, Null References, Number Literals, Numeric Traits, Object Safety, Object-Oriented Features, Offset Of Macro, Operators Overloading, Option and Result Types, Option Type, Order of Evaluation, Ord Trait, Orphan Rules, OsString Type, Outlives Syntax, Owned Types, Ownership and Borrowing, Ownership Rules, Ownership, Packed Structs, Panicking Behavior, Panic Macro, Panic Safety, Panic Unwind, Parallel Iterators, Parameter Lifetimes, Parameterized Types, Parentheses in Patterns, Partial Eq Trait, Partial Moves, Partial Ord Trait, Pattern Binding Modes, Pattern Guards in Match, Pattern Guards, Pattern Matching, PhantomData Type, Phantom Type Parameters, Pin API, Pinning, Placement New, Platform Abstraction, Platform-Specific Code, Pointer Types, Pointers, Polymorphic Code, Polymorphism, Postfix Macros, Powerful Enumerations, Precedence of Operators, Prefixed Literals, Prelude, Primitive Traits, Primitive Types, Privacy and Visibility, Privacy Rules, Proc Macro Attributes, Proc Macro Crates, Proc Macros, Process Crates, Process Management, Project Layout, Project Module, Promotable Constants, Pub Crate Visibility, Pub Keyword, Pub Restricted Visibility, Public Interfaces, Public Items, Qualified Paths, Question Mark Operator, Raw Identifiers, Raw Literals, Raw Pointers, Rc Type, Reborrowing References, Receiver Types, Re-exports, RefCell Type, Reference Counting, References, Reflexive Traits, Refutable Patterns, Regex Crate, Regression Testing, Regular Expressions, Release Channels, Release Profiles, Repeat Expressions, Repr Attributes, Reserved Keywords, Resource Management, Result Type, Return Type Notation, Return Type Polymorphism, Rewriting, Rust Analyzer, Rust Borrow Checker, Rust Build System, Rust Cargo, Rust Compiler, Rust Crates, Rust Design Patterns, Rust Documentation, Rust Edition, Rust Error Messages, Rust Formatting Tool, Rust Language Server, Rust Macros, Rust Playground, Rust Project, Rust RFCs, Rust Standard Library, Rust Style Guide, Rust Toolchain, Rust Traits, Rust Type System, Rustfmt, Rustlings Exercises, Rustup, Safety Checks, Safety in Rust, Safe Code in Rust, Safe Abstractions, Scoped Threads, Scope of Variables, Semver Compatibility, Send Trait, Shadowing Variables, Shared Libraries, Shared Ownership, Shared References, Shorthand Struct Initialization, Side Effects, Signal Handling, Sized Trait, Sizedness, Slice Patterns, Slice Type, Slices, Smart Pointer Implementations, Smart Pointer Types, Smart Pointers, Soft Keywords, Split Borrowing, Stack Allocation, Stack Memory, Standard Input and Output, Standard Library, State Machine, Static Assertions, Static Dispatch, Static Items, Static Keyword, Static Lifetimes, Static Methods, Static Variables, Statically Sized Types, String Formatting, String Literals, String Manipulation, String Slices, String Type, Strings in Rust, Strong Typing, Struct Definitions, Struct Embedding, Struct Expressions, Struct Fields, Struct Initialization, Struct Patterns in Match, Struct Patterns, Struct Update Syntax, Structs, Structured Concurrency, Submodules, Subtyping in Rust, Subtyping, Supertraits, Synchronization Primitives, Sync Trait, System Programming, Tail Call Optimization, Target Architecture, Target Specifications, Target Triple, Task Management, Task Spawning, Temporary Lifetimes, Temporary Variables, Thread Local Storage, Thread Safety, Thread Safety in Rust, Threads, Time Measurement, To Owned Trait, To String Trait, Toolchains, Trait Aliases, Trait Bounds in Generics, Trait Bounds in Rust, Trait Bounds, Trait Implementations in Rust, Trait Implementations, Trait Objects in Rust, Trait Objects, Trait Parameters, Trait Syntax, Trait Upcasting, Traits, Transitive Dependencies, Transmute Function, Transmute Unsafe, Type Aliases in Rust, Type Aliases, Type Annotations, Type Ascription, Type Checking, Type Coercion, Type Constraints, Type Conversion, Type Erasure in Rust, Type Erasure, Type Families, Type Inference in Rust, Type Inference, Type Layout, Type Lifetimes, Type Mismatch, Type Parameters in Traits, Type Parameters, Type Placeholder, Type Promotion, Type Safety, Type System in Rust, Type System, Type Variance in Rust, Type Variance, Typed Constants, Type-Safe Programming, Typeid Function, Unchecked Indexing, Unchecked Operations, Undefined Behavior, Underscore Imports, Underscore Lifetimes, Underscore Placeholder, Uninitialized Memory, Unit Structs, Universal Function Call Syntax, Unpin Trait, Unreachable Code, Unsafe Blocks, Unsafe Code in Rust, Unsafe Code, Unsafe Functions, Unsafe Trait Implementations, Unsafe Traits in Rust, Unsized Coercions, Unsized Trait, Unsized Types, Untyped Constants, Unused Code Warnings, Unused Import Warnings, Unused Variables, Upcasting in Rust, Use Declarations in Rust, Use Declarations, User-Defined Macros, UTF-8 Encoding, Variable Binding in Rust, Variable Binding, Variable Lifetimes, Variable Scope, Variadic Functions, Variance of Lifetimes, Variance of Types, Vec Deque Type, Vec Type, Vector Type, Vectors in Rust, Visibility in Rust, Visibility Modifiers in Rust, Visibility Modifiers, Volatile Access, Volatile Reads and Writes, Wait Groups, Weak Pointers, Weak Type, WebAssembly Support, WebAssembly Target, While Let Expressions, While Loops in Rust, Wrapping Arithmetic, Yield Expressions, Zero Overhead Abstraction, Zero Sized Types, Zero-Cost Abstractions, Zero-Sized Structs, Zero-Sized Types in Rust, Zero-Sized Types

Rust: Rust Best Practices, Rust Anti-Patterns, Rust Fundamentals, Rust Inventor: Rust Language Designer: Graydon Hoare on July 7, 2010; Cloud Native Rust https://CloudRust.rs, Rust Wasm - Rust WebAssembly https://WebAssembly.rs, Rust in the Cloud https://CloudRust.io, Rust RFCs https://github.com/rust-lang/rfcs, Rust Scripting, Rust Keywords, Rust Built-In Data Types, Rust Data Structures - Rust Algorithms, Rust Syntax, Rust OOP - Rust Design Patterns https://DesignPatterns.rs https://rust-unofficial.github.io/patterns/rust-design-patterns.pdf, Rust Package Manager (cargo-crates.io - Rust Crates - Rust Cargo), Rust Virtualization, Rust Interpreter, Rust REPL, Rust IDEs (JetBrains RustRover, IntelliJ - CLion with JetBrains Rust Plugins, Visual Studio Code), Rust Development Tools, Rust Linter, Rustaceans https://Rustaceans.rs Rust Users - Rust Programmers, List of Rust Software, Rust Popularity, Rust Compiler (rustc), Rust Transpiler, Rust DevOps - Rust SRE, Rust Data Science - Rust DataOps, Rust Machine Learning, Rust Deep Learning, Functional Rust, Rust Concurrency - Rust Parallel Programming - Async Rust, Rust Standard Library, Rust Testing, Rust Libraries, Rust Frameworks, Rust History, Rust Bibliography, Manning Rust Series, Rust Glossary - Rust Official Glossary - Glossaire de Rust - French, Rust Topics, Rust Courses, Rust Research, Rust GitHub, Written in Rust, Rust Awesome List. (navbar_rust - see also navbar_rust_domains)