syn + quote


rust + Ada

History of ada

  • In the 70s, the USDoD was using over 400 programming languages
  • This was probably too many
  • Designed from 1977 to 1980
  • First implemented completely in 1983
  • Standardized in 1987, updated in 1995 and 2012
-- Ada
type My_Integer is new Integer;
type My_Integer is new Long_Integer;
type My_Integer is new Integer_32;
type My_Integer is new Integer range 10..9_999;
type My_Integer is range 10..9_999;

Foo: My_Integer;
Bar: Not_My_Integer;
Qux: Integer;

Foo := Foo + 1;  -- OK
Foo := Foo + Bar;  -- Not OK!
Foo := Foo + Qux;  -- Not OK!
Foo := Foo + Foo(Qux);  -- OK
// Rust
struct MyInteger(i32);
// below are hypothetical!
struct MyInteger(impl Int);
struct MyInteger(i32<10..10_000>);
struct MyInteger(impl Int<10..10_000>);

let foo: MyInteger;
let bar: NotMyInteger;
let qux: i32;

foo += 1;  // OK?
foo += bar;  // Not OK
foo += qux;  // OK?
foo += qux.into();  // OK

ada vs rust

  • Inheritance vs Composition
  • Exceptions vs Result
  • Dynamic checks vs Static Checks

syn & quote

  • Libraries for turning Rust tokens into an abstract syntax tree, and vice versa
  • From dtolnay, maintainer of Serde
  • Used by Serde and every other proc macro
  • Without them, developing proc macros would be very, very painful
  • Seriously don't even try it

Proc Macros

  • Rust's secret-est weapon
  • Run arbitrary Rust code at compile-time to replace one token tree with any other token tree
  • The "heavyweight" alternative to Rust's "lightweight" declarative macros
  • Serde, Diesel, and Rocket all rely on this

what even is a token tree

  • Classical compiler architecture is described as a pipeline:                                                               Lexing Parsing Analysis Optimization Machine Code Generation
  • Token trees are the intermediate step between lexing and parsing
  • We can take as input any Rust code that passes the lexer, and output any Rust code
// Rust + procedural macros
struct MyInteger(i32);

struct MyInteger(i32);

struct MyInteger(impl Int);

#[range(1..10, 91..100)]
struct MyInteger(i32);

my_int += 1;  // OK
my_int += not_a_my_int;  // Not OK
my_int += some_i32;  // OK???
my_int += some_i32.into();  // OK
Made with