Hi, I’m Pascal Hertleif

• Dev tools team, CLI WG
• Co-organizer of Rust Cologne
• {twitter,github}.com/killercup
• Rust-centric blog: deterministic.space

What is a computer program?

To make a program work,

• you tell a computer what to do,
• in tiny steps, specific instructions.

Maintainable code

Is my code maintainable?

What is ‘Declarative Programming’

What instead of How

Get to the point

Declarative code in Rust

By example

Loops

Find the first element that ends with “m”

let xs = vec!["lorem", "ipsum", "dolor"];

for i in 0..xs.len() {
  if xs[i].ends_with('m') {
    return Some(xs[i]);
  }
}
return None;

New requirements! Find up to 5 elements that end with “m”

let xs = vec!["lorem", "ipsum", "dolor"];

let mut result = Vec::new();
for i in 0..xs.len() {
  if result.len() <= 5 && xs[i].ends_with('m') {
    result.push(xs[i]);
  }
}
return result;

Iterators

let xs = vec!["lorem", "ipsum", "dolor"];
xs.iter()
  .filter(|item| item.ends_with('m'))
  .take(5)
  .collect()

Another iterator example

Is there an item that starts with “l”?

let answer = xs.iter()
    .any(|item| item.starts_with('l'));

Parse JSON

{"a": 4}

First try

let v: serde_json::Value =
    serde_json::from_str("{\"a\": 4}")?;

if let Some(value) = v["a"].as_u64() {
    println!("{}", value);
}

New requirements!

This structure now has three fields

let v: serde_json::Value = serde_json::from_str(
    "{\"a\": 4, \"b\": 8, \"c\": 15}"
)?;

struct Response { a: u64, b: u64, c: u64 }

let a = if let Some(value) = v["a"].as_u64() {
    value
} else {
    return Err("invalid".into())
};

let b = if let Some(value) = v["b"].as_u64() {
    value
} else {
    return Err("invalid".into())
};

let c = if let Some(value) = v["c"].as_u64() {
    value
} else {
    return Err("invalid".into())
};

let res = Response { a, b, c };

Derive it.

#[derive(Deserialize)]
struct Response { a: u64, b: u64, c: u64 }

let v: Response = serde_json::from_str(
    "{\"a\": 4, \"b\": 8, \"c\": 15}"
)?;

Command Line Arguments

Plain old std

let args = std::env::args();
let input = args.next()
    .expect("USAGE: tool <input> <output>");
let output = args.next()
    .expect("USAGE: tool <input> <output>");

New requirements: Flags

tool -o Output.file Input.file

use getopts::Options;

let mut opts = Options::new();
opts.optopt("o", "", "set output file name", "NAME");
let matches = match opts.parse(&args[1..]) {
    Ok(m) => { m }
    Err(f) => { panic!(f.to_string()) }
};
let output = matches.opt_str("o");
let input = if !matches.free.is_empty() {
    matches.free[0].clone()
} else {
    print_usage(&program, opts);
    return;
};

Clap

use clap::{Arg, App, SubCommand};

let matches = App::new("My Super Program")
    .arg(Arg::with_name("output")
        .help("Sets a output file")
        .short("o").long("output")
        .takes_value(true))
    .arg(Arg::with_name("INPUT")
        .help("Sets the input file to use")
        .required(true).index(1))
    .get_matches();

if let Some(input) = matches.value_of("INPUT") {
    // ...
}

Isn’t this a data structure, too?

use structopt::StructOpt;

#[derive(StructOpt)]
struct Cli {
    /// Sets the input file to use
    input: String,
    /// Sets a output file
    #[structopt(short = "o", long = "output")]
    output: String,
}

Generic, type-driven behavior

Huh?

We write generic functions.

The concrete types will declare what the user wants

Read JSON data from a HTTP request

fn handle_login(req: Request) -> Response {
    let data: serde_json::Value =
        serde_json::from_reader(req.body())?;
    let name = data["name"].as_str().unwrap_or("Nobody");
    Ok(format!("hello, {}", name))
}

Extractors

fn handle_login(data: Json<LoginData>) -> Response {
    Ok(format!("hello, {}", data.name))
}

Be aware of your magic budget

Monads

What is magic?

Code whose behavior is hard to predict (or remember)

• Unfamiliar macros
• Very generic code
• But also: Very concise and ‘clever’ code

You can turn that magic into science, using the right tools

e.g. using cargo expand

How to teach this?

• Interactive learning: Clippy lints
• Write libraries that provide easy to use abstractions
• Give an introductory talk on it (👋)

Thank you!

Have a great lunch!

I’m Pascal and I want you to talk to me!

{twitter,github}.com/killercup

Slides: git.io/declarative-programming-in-rust