Last year, as an occasional contributor to the Rust project, I did not think much about the organisational structure of the team behind the project. I saw a hierarchy of teams and groups, team leaders, etc. Just like any other organisation. This year, after getting more involved, becoming a library team member and eventually team lead, I spent some more time thinking about why we have this structure, what these teams are for.
In this final part of the series,
we’ll explore a trick to make the behaviour of a macro depend
on whether it’s used as a statement or as part of an expression.
Using that, we’ll make the python!{} macro
more flexible to allow saving, reusing, and inspecting Python variables.
python!{} macro to make that happen.
In this part, we’ll extend our python!{}-macro to be able to seamlessly
use Rust variables in the Python code within.
We explore a few options, and implement two alternatives.
Before continuing to extend our python!{} macro in part 2,
let’s explore some things in more detail first.
About a year ago, I published a Rust crate called inline-python,
which allows you to easily mix some Python into your Rust code using a python!{ .. } macro.
In this series, I’ll go through the process of developing this crate from scratch.
In Software for Infrastructure, Bjarne Stroustrup shows a way to use templates to make the C++ compiler aware of the unit of a value (e.g. kilograms, seconds, etc.), such that it can check consistent use and prevent disasters like the well known error at NASA in 1999 caused by mixing incompatible units. In this article, I show how to extend this idea to support any number of base units and linearly related units (e.g. centimetres, metres and inches) by teaching the compiler how to do arithmetic on units.
Recently, gcc added support rvalue references for *this.
(Clang has supported it for quite a while now.)
In this post, I show how to use this feature, and how it means we can finally
define accessors and a few other things like operator= correctly.