Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on Twitter or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Official

• Officially announcing the types team
• Diversifying our Content Delivery Networks

Foundation

• Lars Bergstrom Elected as Rust Foundation Board of Directors Chair
• Join the Rust Foundation at Rust Nation UK 2023

Project/Tooling Updates

• rust-analyzer changelog #165
• hyper-ish 2022 in review
• Mobc 0.8.1 release with improved stability
• Zenoh 0.7.0, a pure Rust Pub/Sub/Query protocol for cloud-to-thing continuum, was released and it is packed with new features.
• Fornjot (code-first CAD in Rust) - Weekly Release
• Slint 0.3.4 release
• Astra: A Blocking HTTP Server Built on Top of Hyper
• First steps with NGenate - A dataflow and visual programming platform built with rust
• toml vs toml_edit
• This Week in Fyrox #11
• The year 2022 in Dimforge and our objectives for 2023

Observations/Thoughts

• Rust in 2023: Growing up
• The State of Developer Ecosystem 2022 in Rust: Discover recent trends
• The size of Rust Futures
• Capability-Safety I: Prelude
• Surprises in the Rust JSON Ecosystem
• The Git source code audit, viewed as a Rust programmer
• Turning a Rust struct into an enum is not always a major breaking change
• 14 Rust Tools for Linux Terminal Dwellers
• [audio] Rust Magazine with Shuang Zhu
• [audio] Rust Nation with Ernest Kissiedu

Rust Walkthroughs

• Temporary Values, Borrowing, and Lifetimes
• Due to limitations in the borrow checker, this implies a 'static lifetime
• Rust concepts I wish I learned earlier
• Comparative fuzzing in Rust
• domain-specific error macros
• Building a Simple DB in Rust - Part 2 - Basic Execution
• Rust FFI and cbindgen: Integrating Embedded Rust Code in C

Miscellaneous

• The crates.io registry is now a GitHub secret scanning integrator
• Six fun things to do with Rust operator overloading
• Packaging Rust Applications for the NPM Registry
• Announcing Rust Support in CodeSandbox
• [video] 10 Reasons Not To Use Rust (The Whole Truth)
• [video] Sneaking By The Rust Borrow Checker - Interior Mutability

Crate of the Week

This week's crate is Darkbird, a mnesia-inspired high concurrency, real time, in-memory storage library.

Thanks to DanyalMh for the self-suggestion!

Please submit your suggestions and votes for next week!

Call for Participation

Always wanted to contribute to open-source projects but did not know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

• Ockam - Implement 'ockam node logs' CLI command
• Ockam - Implement 'ockam worker list' CLI command
• Ockam - Add a CI check to avoid conflicts in 'TypeTag' ids

If you are a Rust project owner and are looking for contributors, please submit tasks here.

Updates from the Rust Project

378 pull requests were merged in the last week

• llvm-wrapper: adapt for LLVM API change
• enable sanitizers for s390x-linux
• put noundef on all scalars that don't allow uninit
• add 'static lifetime suggestion when GAT implied 'static requirement from HRTB
• add raw identifier for keyword in suggestion
• check ADT fields for copy implementations considering regions
• constify TypeId ordering impls
• diagnostics: suggest changing s@self::{macro}@::macro for exported
• dont randomly use _ to print out const generic arguments
• drop tracking Visit break expressions
• encode const mir for closures if they're const
• fix check macro expansion
• label closure captures/generator locals that make opaque types recursive
• lazy dominator tree construction in borrowck
• make CastError::NeedsDeref create a MachineApplicable suggestion
• make error emitted on impl &Trait nicer
• refactor basic blocks control flow caches
• simplify derive(Debug) output for fieldless enums
• suggest remove deref for type mismatch
• suggestion for attempted integer identifier in patterns
• tweak "borrow closure argument" suggestion
• unify stable and unstable sort implementations in same core module
• use UnordMap and UnordSet for id collections (DefIdMap, LocalDefIdMap, etc)
• various cleanups around pre-TyCtxt queries and functions
• add heapsort fallback in select_nth_unstable
• implement alloc::vec::IsZero for Option<$NUM> types
• lift T: Sized bounds from some strict_provenance pointer methods
• add Arc::into_inner for safely discarding Arcs without calling the destructor on the inner type
• hashbrown: provide default hasher types to Vacant and Occupied entries
• futures: add Either::as_pin_mut and Either::as_pin_ref
• futures: implement FusedStream for all streams in ReadyChunks
• (cherry-pick) WebAssembly multivalue stackify fix
• cargo: stabilize sparse-registry
• cargo: wrapper type for data that should never be logged
• rustfmt: correct span for structs with const generics
• clippy: add multiple_unsafe_ops_per_block lint
• clippy: add machine applicable suggestion for bool_assert_comparison
• clippy: fix false positive in unnecessary_safety_comment
• clippy: fix suggestion in transmutes_expressible_as_ptr_casts when the source type is a borrow
• rust-analyzer: don't escape non-snippets in assist
• rust-analyzer: don't respond with a ContentModified while loading the workspace
• rust-analyzer: fix checkOnSave to check config patching not always working
• rust-analyzer: fix markdown removal in hover handling whitespace weirdly
• rust-analyzer: handle slice patterns in "Fill match arms"
• rust-analyzer: more precise binop inference
• rust-analyzer: substitute vscode variables in config.serverPath
• rust-analyzer: parse const_closures syntax
• rust-analyzer: replace SmolStr usage with lang item enum for lang items
• rust-analyzer: use workspace.dependencies to declare local dependencies

Rust Compiler Performance Triage

Largely a win for compiler performance with 100 test cases in real-world crates showing some sort of change in performance with an average 1% improvement. These wins were a combination of many different changes including how doc(hidden) gets more efficiently encoded in metadata, some optimizations in the borrow checker, and simplification of the output from derive(Debug) for fieldless enums.

Triage done by @rylev. Revision range: 1f72129f..c8e6a9e8

Summary:

2 Regressions, 5 Improvements, 3 Mixed; 1 of them in rollups 34 artifact comparisons made in total

Full report here

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

• No RFCs were approved this week.

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

• No RFCs entered Final Comment Period this week.

Tracking Issues & PRs

• [disposition: merge] Autotrait bounds on dyn-safe trait methods
• [disposition: close] Stabilize ControlFlow::{BREAK, CONTINUE}
• [disposition: merge] Add missing normalization for union fields types
• [disposition: merge] rustdoc: change trait bound formatting

New and Updated RFCs

• [new] Cargo target features
• [new] Avoid non-local definitions in functions

Call for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

• No RFCs issued a call for testing this week.

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Upcoming Events

Rusty Events between 2023-01-25 - 2023-02-22 🦀

Virtual

• 2023-01-25 | Virtual (Redmond, WA, US; San Francisco, CA, US) | Microsoft Reactor Redmond | Microsoft Reactor San Francisco
  • Primeros pasos con Rust: QA y horas de comunidad | San Francisco Mirror
• 2023-01-26 | Virtual (Charlottesville, VA, US) | Charlottesville Rust Meetup
  • Rust Lightning Talks!
• 2023-01-26 | Virtual (Karlsruhe, DE) | The Karlsruhe Functional Programmers Meetup Group
  • Stammtisch (gemeinsam mit der C++ UG KA)
• 2023-01-26 | Virtual (Redmond, WA, US; San Francisco, CA, US; New York, NY, US; Stockholm, SE) | Microsoft Reactor Redmond and Microsoft Reactor New York and Microsoft Reactor San Francisco and Microsoft Reactor Stockholm
  • Crack code interview problems in Rust - Ep. 3 | New York Mirror | San Francisco Mirror | Stockholm Mirror
• 2023-01-27 | Virtual (Tunis, TN) | Rust Meetup Tunisia
  • Rust Meetup Tunisia - Volume I, Number I
• 2023-01-30 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US) | Microsoft Reactor Redmond and Microsoft Reactor New York and Microsoft Reactor San Francisco
  • Primeros pasos con Rust - Control de errores en Rust | New York Mirror | San Francisco Mirror
• 2023-01-31 | Virtual (Berlin, DE) | OpenTechSchool Berlin
  • Rust Hack and Learn
• 2023-01-31 | Virtual (Dallas, TX, US) | Dallas Rust
  • Last Tuesday
• 2023-01-31 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US) | Microsoft Reactor Redmond and Microsoft Reactor New York and Microsoft Reactor San Francisco
  • Primeros pasos con Rust - Compresión de cómo Rust administra la memoria | New York Mirror | San Francisco Mirror
• 2023-02-01 | Virtual (Cardiff, UK) | Rust and C++ Cardiff
  • New Year Virtual Social + Share
• 2023-02-01 | Virtual (Indianapolis, IN, US) | Indy Rust
  • Indy.rs - with Social Distancing
• 2023-02-01 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US) | Microsoft Reactor Redmond and Microsoft Reactor New York and Microsoft Reactor San Francisco
  • Primeros pasos con Rust: QA y horas de comunidad | New York Mirror | San Francisco Mirror
• 2023-02-01 | Virtual (Stuttgart, DE) | Rust Community Stuttgart
  • Rust-Meetup
• 2023-02-06 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US) | Microsoft Reactor Redmond and Microsoft Reactor New York and Microsoft Reactor San Francisco
  • Primeros pasos con Rust - Implementación de tipos y rasgos genéricos | New York Mirror | San Francisco Mirror
• 2023-02-07 | Virtual (Beijing, CN) | WebAssembly and Rust Meetup (Rustlang)
  • Monthly WasmEdge Community Meeting, a CNCF sandbox WebAssembly runtime
• 2023-02-07 | Virtual (Buffalo, NY, US) | Buffalo Rust Meetup
  • Buffalo Rust User Group, First Tuesdays
• 2023-02-07 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US) | Microsoft Reactor Redmond and Microsoft Reactor New York and Microsoft Reactor San Francisco
  • Primeros pasos con Rust - Módulos, paquetes y contenedores de terceros | New York Mirror | San Francisco Mirror
• 2023-02-08 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US) | Microsoft Reactor Redmond and Microsoft Rector New York and Microsoft Reactor San Francisco
  • Primeros pasos con Rust: QA y horas de comunidad | New York Mirror | San Francisco Mirror
• 2023-02-11 | Virtual | Rust GameDev
  • Rust GameDev Monthly Meetup
• 2023-02-13 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US) | Microsoft Reactor Redmond and Microsoft Rector New York and Microsoft Reactor San Francisco
  • Primeros pasos con Rust - Escritura de pruebas automatizadas | New York Mirror | San Francisco Mirror
• 2023-02-14 | Virtual (Berlin, DE) | OpenTechSchool Berlin
  • Rust Hack and Learn
• 2023-02-14 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US) | Microsoft Reactor Redmond and Microsoft Rector New York and Microsoft Reactor San Francisco
  • Primeros pasos con Rust - Creamos un programa de ToDos en la línea de comandos | San Francisco Mirror | New York Mirror
• 2023-02-14 | Virtual (Saarbrücken, DE) | Rust-Saar
  • Meetup: 26u16
• 2023-02-15 | Virtual (Redmond, WA, US; New York, NY, US; San Francisco, CA, US; São Paulo, BR) | Microsoft Reactor Redmond and Microsoft Rector New York and Microsoft Reactor San Francisco and Microsoft Reactor São Paulo
  • Primeros pasos con Rust: QA y horas de comunidad | San Francisco Mirror | New York Mirror | São Paulo Mirror
• 2023-02-15 | Virtual (Vancouver, BC, CA) | Vancouver Rust
  • Rust Study/Hack/Hang-out

Asia

• 2023-02-01 | Kyoto, JP | Kansai Rust
  • Rust talk: How to implement Iterator on tuples... kind of

Europe

• 2023-01-25 | Paris, FR | Rust Paris
  • Rust Paris meetup #55
• 2023-01-26 | Copenhagen, DK | Copenhagen Rust Meetup Group
  • Rust Hack Night #32
• 2023-02-02 | Berlin, DE | Prenzlauer Berg Software Engineers
  • PBerg engineers - inaugural meetup; Lukas: Serverless APIs using Rust and Azure functions (Fee)
• 2023-02-02 | Hamburg, DE | Rust Meetup Hamburg
  • Rust Hack & Learn February 2023
• 2023-02-02 | Lyon, FR | Rust Lyon
  • Rust Lyon meetup #01
• 2023-02-04 | Brussels, BE | FOSDEM
  • FOSDEM 2023 Conference: Rust devroom
• 2023-02-21 | Zurich, CH | Rust Zurich
  • Practical Cryptography - February Meetup (Registration opens 7 Feb 2023)

North America

• 2023-01-26 | Lehi, UT, US | Utah Rust
  • Building a Rust Playground with WASM and Lane and Food!

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

Rust has demonstrated that you using a type system as a vehicle for separation logic works, even in imperative languages, and it's nothing as arcane as those immutable functional predecessors would suggest. It did this by making sure the language defines a type system that helps you, by making sure core properties of soundness can be expressed in it.

• soundness requirement for memory access: lifetimes
• soundness requirements for references with value semantics: > &/&mut _
• soundness requirements for resources: Copy and Drop
• making sure your logic is monotic: traits instead of inheritance, lack of specialization (yes, that's a feature).
• (notably missing: no dependent types; apparently not 'necessary' but I'm sure it could be useful; however, research is heavily ongoing; caution is good)

This allows the standard library to encode all of its relevant requirements as types. And doing this everywhere is its soundness property: safe functions have no requirements beyond the sum of its parameter type, unsafe functions can. Nothing new or special there, nothing that makes Rust's notion of soundness special.

Basing your mathematical reasoning on separation logic makes soundness reviews local instead of requiring whole program analysis. This is what makes it practical. It did this pretty successfully and principled, but did no single truly revolutionary thing. It's a sum of good bits from the last decade of type system research. That's probably why people refer to it as 'the soundness definition', it's just a very poignant way to say: "we learned that a practical type systems works as a proof checker".

– HeroicKatora on /r/cpp

Thanks to Stephan Sokolow for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust