HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
rust-lang
lang-team
JavaScript2020–2024
rust-lang / lang-team

lang-team

Home of the Rust lang team

Explore on GitHubRead Hacker News discussions
12Distinct people
12Mentions
0Explicit recommenders
217GitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Home of the Rust lang team

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year12 dated mentions

Observed mentions: 2020-05-03 06:27:43 UTC to 2024-01-09 04:18:44 UTC.

012342020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments20202021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 4 mentions; 1 submissions, 3 comments20222023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments2024

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC303
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC101
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC413
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC303
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC101

What Hacker News says

12 sources
nyanpasu64·Dec 17, 2023
I'd say that method chaining (referential transparency, etc.) and implicit destructor calls with side effects don't mix. I have a general rule that "resource" types which own a heap allocation should usually be given a variable name with explicit scope (and likely even an explicit type, rather than `auto response` like in this post). This is a general guideline to avoid holding a reference to a temporary that gets destroyed, but doesn't protect against returning a dangling reference into a resource type from a function. In other places, where languages make the opposite decision (from this blog post) to extend the lifetime of a temporary variable with a destructor when you call methods on it, you get things like C++'s temporary lifetime extension (not a bug, note that I don't understand it well), and footguns like Rust's `match lock.lock(
Read the rest
).something {}` (https://github.com/rust-lang/lang-team/blob/master/design-me...).
In A curiously recurring lifetime issue
j-pb·Jan 20, 2023
The thing that's really missing for me in rust is a better way to modularize enums with associated data and their behaviour. There are many cases where you have a closed set of known variants for a type, but they have very different behaviour, e.g. nodes in any kind of adaptive tree data-structure, such as an ART, HOT or Judy Array. In those cases you don't want to bring out the big guns with dyn traits. But the current approach involving huge match forests, macros, helper functions and code duplication plainly sucks ^^'. This could be solved by making enum variants proper types. Something that has been proposed already, but which has been rejected due to lacking capacity. https://github.com/rust-lang/lang-team/issues/122
In Rust in 2023: Growing Up
TUSF·Sep 29, 2022
> Better interoperability AFAIK, the examples you give all target a basic C ABI [0] or can be made to target the same ABI. In Rust, it means targeting wasm32-unknown-emscripten The Rust team is also working on a "WASM ABI"[1] which would be useful in taking advantage of stuff like multi-value returns, and other compilers could just choose to target that. More likely, the C ABI on WASM will be updated to account for missing features, and that'll be the standard for interoperability in the WASM ecosystem. [0]: https://github.com/WebAssembly/tool-conventions/blob/main/Ba... [1]: https://github.com/rust-lang/lang-team/blob/master/design-me...
In Isolates, microVMs, and WebAssembly
roblabla·Jan 22, 2022
In current Rust, you'd do it with an unsafe std::mem::transmute - possibly using a crate that wraps this call behind a safe interface that asserts that alignment and size are correct, and that your type doesn't have any padding, etc... See for instance the bytemuck crate. In the future, rust might gain "Safe Transmutes", which would allow you to safely transmute from one type to another under some limited conditions. See https://github.com/rust-lang/lang-team/issues/21
In Why introduce `std::launder` rather than have the compiler take care of it?
nemothekid·Jul 27, 2020
Last I checked when I tried to the library last the blocker on stable was packed_simd, which provides vector instructions in Rust. I can imagine the arrow/datafusion-guy isn't too keen on dropping vectorized instructions as that would be letting up a huge advantage and I'm imagine it's used liberally throughout the code. As for stablizing packed_simd, It's completely unclear to me when that will land in stable rust. I recently had a project where I just ended up calling out to C code to handle vectorization. EDIT: According to, https://github.com/rust-lang/lang-team/issues/29, the effort looks abandonded/deprioritized, so it may be a long time before it sees stable rust
In Apache Arrow 1.0
pas·May 15, 2020
There are many places to follow: https://github.com/rust-lang/wg-traits/tree/master/minutes https://github.com/rust-lang/lang-team/tree/master/minutes https://rust-lang.github.io/compiler-team/ There's a youtube channel too. (Also start here: https://blog.rust-lang.org/inside-rust/2020/03/28/traits-spr... ) The important thing is the `chalk` work. And basically the rust-analyzer approach drives that. Hah, this branch PR got merged 6 days ago into rust master: https://github.com/rust-lang/rust/pull/69406
In Five Years of Rust
chubot·May 3, 2020
what do you think is a better tool to specify and parse languages? That's unfortunately an open problem. As I mentioned here, lexing is "solved" but parsing isn't: https://github.com/oilshell/oil/wiki/Why-Lexing-and-Parsing-... Here are what some recent languages do: Go: Maintain a written spec [1], with multiple hand-written parsers. (I think the main one is in Go, while gccgo has one in C++?) I believe Go used to be parsed with yacc, but they moved to a hand-written parser for error messages. It looks like [2] was an early attempt to keep it generated. [1] https://golang.org/ref/spec [2] https://research.swtch.com/yyerror ----- Rust: The parser is hand-written, like Go. There's a grammar in the spec, but like Go's, it's not used to generate code, so it isn't tested. They also have an LALR(1) grammar which was suppoed to be an exec
Read the rest
utable specification, but as far as I can tell that effort has not made progress recently. It used to be done with GNU yacc but it looks like they moved to a Rust-based tool [3] [1] https://doc.rust-lang.org/grammar.html [2] https://github.com/rust-lang/lang-team/tree/master/working-g... [3] https://github.com/rust-lang/wg-grammar/tree/master/grammar ----- So basically the state of the art is fairly laborious. It's basically write down the grammar, implement it by hand, and try not to make any mistakes. If you need to implement it again, which is extremely common (e.g. for gccgo, for Rust's language server), also try not to make any mistakes. When you need to change the language, update the spec, and change all the parsers by hand. I've written multiple recursive-descent parsers based on grammars, and it's not hard if you have examples to test with, but mistakes can easily creep in. Rely on users to report bugs. There is a "long tail" of programs that will tickle various corner cases. ----- Here's the approach I took with Oil: How to Parse Shell Like a Programming Language http://www.oilshell.org/blog/2019/02/07.html which is basically to do as much work as possible in the lexer, use a high-level programming language translated to C++ for the parser, and to use a DSL for specifying the AST. This approach keeps the mistakes and tedium down because shell is an extremely large language syntactically. (It could be the biggest of any language except for perhaps Perl. Shell is relatively small semantically, but huge syntactically (which is why I'm preoccupied with parsing :) ).
In The naked truth about writing a programming language (2014)

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.