For some reason, I find myself thinking a lot about Rust enums, and matches, and the various ways one can write them.
I admit defeat.
A few weeks ago I was writing some Rust code, building basic data structures from scratch, just for practice and curiosity. At one point I wrote what I thought to be a fairly simple and straightforward function, and discovered that there is no way to convince the borrow checker of its correctness.
I spent a lot of time studying the code and a bunch of variations. After many attempts at fixing it, I am giving up: Rust will not allow this function to compile; the borrow checker wins this time.
What does the trait bound
'static mean in Rust?
After a few weeks of programming in Rust we should have a pretty good idea of what a
'static reference is, but a
'static trait bound can seem a bit more mysterious.
The first time I had to add a
'static trait bound to my code. I didn't feel like I understood what was happening, because there were no references involved. In fact, the only data involved were function arguments being passed by ownership, which is usually a pretty reliable way of avoiding borrow checker problems.
In many cases, the rust compiler will suggest a
'static trait bound to address a problem. The compiler is probably right, but let's explore what it really means so we can be confident that we understand the solution.
Here's a quick question to test your Rust knowledge: which of these lines of code do the same thing?
drop(a); let _ = b; c;
This is a demonstration of building a parser in Rust using the
nom crate. I recently built a parser for
cddl-cat crate using nom,
and I found it a surprisingly not-terrible experience, much better than my past
experiences with other parser-generators in other languages.
Since I like Rust a lot, and I need an excuse to do more writing about Rust, I thought I'd do another demonstration project. I decided to choose a simple syntax, to keep this a short project. So I'm going to build a parser for JSON.