Domain Specific Languages

Introduction

In this lab, we explore the concept of Domain Specific Languages (DSLs) in Rust, which are mini "languages" embedded in Rust macros. These macros expand into normal Rust constructs but offer a concise and intuitive syntax for specific functionality. A practical example is demonstrated using a calculator API, where an expression is supplied to the macro, and the output is printed to the console. This allows for the creation of more complex interfaces like the ones found in libraries such as lazy_static or clap.

Note: If the lab does not specify a file name, you can use any file name you want. For example, you can use main.rs, compile and run it with rustc main.rs && ./main.

Skills Graph

Domain Specific Languages (DSLs)

A DSL is a mini "language" embedded in a Rust macro. It is completely valid Rust because the macro system expands into normal Rust constructs, but it looks like a small language. This allows you to define concise or intuitive syntax for some special functionality (within bounds).

Suppose that I want to define a little calculator API. I would like to supply an expression and have the output printed to console.

macro_rules! calculate {
    (eval $e:expr) => {
        {
            let val: usize = $e; // Force types to be integers
            println!("{} = {}", stringify!{$e}, val);
        }
    };
}

fn main() {
    calculate! {
        eval 1 + 2 // hehehe `eval` is _not_ a Rust keyword!
    }

    calculate! {
        eval (1 + 2) * (3 / 4)
    }
}

Output:

1 + 2 = 3
(1 + 2) * (3 / 4) = 0

This was a very simple example.

Also, note the two pairs of braces in the macro. The outer ones are part of the syntax of macro_rules!, in addition to () or [].

Summary

Congratulations! You have completed the Domain Specific Languages (DSLs) lab. You can practice more labs in LabEx to improve your skills.