Rust for professionals

const s: string = "";
let n: number = 0.9;
let i = 123; // Type inferred

let s: &str = "";
let mut n: f64 = 0.9;
let mut i = 123; // Type inferred

Most of the time, the type can be ommitted in Rust and the compiler will infer the correct type

int i = 123;
long l = 456L;

float f = 0.5f;
double d = 0.5;

String string = "Hello";

int[] arr = {1, 2, 3};

List<Integer> list = Arrays.asList(1, 2, 3);

let i: i32 = 123;
let l: i64 = 456;

let f: f32 = 0.5;
let d: f64 = 0.5f64;

let string: &str = "Hello";

let arr: [i32; 3] = [1, 2, 3];

let list: Vec<i32> = vec![1, 2, 3];

In Rust, numeric literals can optionally have a type suffix, for example 1000u32 or 0.5f64.

let arr1: string[] = [];
arr1.push("123"); // OK
arr1 = ["a", "b"]; // OK

const arr2: string[] = [];
arr2.push("123"); // OK, even though arr2 is const
arr2 = []; // error, arr2 is const

let mut arr1 = vec![];
arr1.push("123"); // OK
arr1 = vec!["a", "b"]; // OK

let arr2 = vec![];
arr2.push("123"); // error, arr2 is not mutable
arr2 = vec![]; // error, arr2 is not mutable

In TypeScript, declaring a variable as const only prevents reassignment, not modification. In Rust, only variables declared as mut can be modified

function distance(a, b) {
  const { x: x1, y: y1 } = a;
  const { x: x2, y: y2 } = b;
  return Math.sqrt(
    Math.pow(x2 - x1, 2) +
      Math.pow(y2 - y1, 2)
  );
}

fn distance(a: &Point, b: &Point) -> f32 {
    let Point { x: x1, y: y1 } = a;
    let Point { x: x2, y: y2 } = b;
    ((x2 - x1).powf(2.0) + (y2 - y1).powf(2.0)).sqrt()
}

struct Point {
    x: f32,
    y: f32,
}

More examples can be found in this section from the Rust for C++ programmers guide

void log(char* message) {
    printf("INFO %s\n", message);
}

fn log(message: &str) -> () {
    println!("INFO {}", message);
}

The unit type () (void in some languages) is the default return type when no type is given for a function. It could be omitted in this example, like fn log(message: &str) { ... }

public static int add(int a, int b) {
    return a + b;
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

Note that there is no semicolon in the Rust function, otherwise it would return void

const RE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;

function isValidRange(start, end) {
  function isValid(date) {
    return date && date.match(RE);
  }

  return isValid(start) && isValid(end);
}

use regex::Regex;

const RE: &str = r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$";

fn is_valid_range(start: &str, end: &str) -> bool {
    fn is_valid(date: &str) -> bool {
        !date.is_empty()
            && Regex::new(RE)
                .unwrap()
                .is_match(date)
    }

    is_valid(start) && is_valid(end)
}

Note that Regex is an external crate and not part of Rust’s standard library

typealias Range = Pair<String, String>

fun Range.isValid(): Boolean {
    val (start, end) = this
    return start.isNotEmpty() && end.isNotEmpty()
}

object Main {
    @JvmStatic
    fun main(args: Array<String>) {
        val range = Range("2020-01-01", "2020-12-31")
        if (range.isValid()) {
            println("Range is valid!")
        }
    }
}

type Range<'r> = (&'r str, &'r str);

trait IsValid {
    fn is_valid(&self) -> bool;
}

impl<'r> IsValid for Range<'r> {
    fn is_valid(&self) -> bool {
        let (start, end) = &self;
        !start.is_empty() && !end.is_empty()
    }
}

fn main() {
    let range = ("2020-01-01", "2020-12-31");
    if range.is_valid() {
        println!("Range is valid!");
    }
}

In Rust, extension methods are added by implementing a trait. When there is only one method, it’s common to name the trait like the method (IsValid). The 'r denotes a lifetime, for more information, see this section from the Rust book

function findEmails(list) {
  return list.filter(
    s => s && s.includes("@")
  );
}

fn find_emails(list: Vec<String>) -> Vec<String> {
    list.into_iter()
        .filter(|s| s.contains("@"))
        .collect()
}

For more filter examples, see this section from the documentation

function getLogLevel() {
  let level = process.env.TRACE
    ? "trace"
    : process.env.DEBUG
    ? "debug"
    : "info";

  level =
    level === "trace"
      ? 0
      : level === "debug"
      ? 1
      : 2;

  console.log("using log level", level);

  return level;
}

fn get_log_level() -> u32 {
    let level = if std::env::var("TRACE").is_ok() {
        "trace"
    } else if std::env::var("DEBUG").is_ok() {
        "debug"
    } else {
        "info"
    };

    let level = match level {
        "trace" => 0,
        "debug" => 1,
        _ => 2,
    };

    println!("using log level {}", level);

    level
}

The Rust code uses match, which is like switch in Java or JavaScript except that it’s an expression and provides more flexibility. Unless many other languages, Rust allows variable shadowing for local variables (level in this example)

public class HttpClient {
    private final ClientImpl clientImpl;

    public HttpClient() {
        clientImpl = new ClientImpl();
    }

    public String get(String url) {
        return clientImpl.newRequest()
            .get(url).asString();
    }
}

public static void main(String[] args) {
    HttpClient httpClient = new HttpClient();
    System.out.println(httpClient
        .get("https://example.com/"));
}

pub struct HttpClient {
    client_impl: ClientImpl,
}

impl HttpClient {
    pub fn new() -> HttpClient {
        HttpClient {
            client_impl: ClientImpl {},
        }
    }

    pub fn get(&self, url: &str) -> String {
        self.client_impl.new_request()
            .get(url)
            .as_string()
    }
}

fn main() {
    let http_client = HttpClient::new();
    println!("{}",
        http_client.get("https://example.com/"));
}

In Java, mutability is given on a field level, here clientImpl is immutable. In Rust, the mutability modifier is set on the instance variable and not per field, so you cannot have mutable and immutable fields in the same struct (see the Interior Mutability Pattern)

interface Named {
    fun name(): String
}

data class User(
    val id: Int,
    val name: String
) : Named {
    override fun name(): String {
        return this.name
    }
}

pub trait Named {
    fn name(&self) -> &String;
}

pub struct User {
    pub id: i32,
    pub name: String,
}

impl Named for User {
    fn name(&self) -> &String {
        return &self.name;
    }
}

interface FromList<T> {
    fun fromList(list: List<Int>): T?
}

data class MyPoint(val x: Int, val y: Int) {
    companion object : FromList<MyPoint> {
        override fun fromList(list: List<Int>):
                MyPoint? {
            return when (list.size) {
                2 -> MyPoint(list[0], list[1])
                else -> null
            }
        }
    }
}

object Main {
    @JvmStatic
    fun main(args: Array<String>) {
        val point = MyPoint.fromList(listOf(100, 200))
        println(point)
    }
}

trait FromList<T> {
    fn from_list(list: &Vec<i32>) -> Option<T>;
}

struct MyPoint {
    x: i32,
    y: i32,
}

impl FromList<Self> for MyPoint {
    fn from_list(list: &Vec<i32>) -> Option<Self> {
        match list.len() {
            2 => Some(MyPoint {
                x: list[0],
                y: list[1],
            }),
            _ => None,
        }
    }
}

fn main() {
    let point =
        MyPoint::from_list(&vec![100, 200]).unwrap();
    println!("({}, {})", point.x, point.y);
}

For more information about the Option type, see the Null values section below. The keyword Self (upper case) can be used to reference the current type

enum UserRole {
    RO("read-only"), USER("user"),
    ADMIN("administrator");

    private final String name;

    UserRole(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    boolean isAccessAllowed(String httpMethod) {
        switch (httpMethod) {
            case "HEAD":
            case "GET":
                return true;

            case "POST":
            case "PUT":
                return this == USER || this == ADMIN;

            case "DELETE":
                return this == ADMIN;

            default:
                return false;
        }
    }
}

class Main {
    public static void main(String[] args) {
        UserRole role = UserRole.RO;
        if (role.isAccessAllowed("POST")) {
            System.out.println("OK: "
                + role.getName());
        } else {
            System.out.println("Access denied: "
                + role.getName());
        }
    }
}

#[derive(PartialEq)]
enum UserRole {
    RO,
    USER,
    ADMIN,
}

impl UserRole {
    fn name(&self) -> &str {
        match *self {
            UserRole::RO => "read-only",
            UserRole::USER => "user",
            UserRole::ADMIN => "administrator",
        }
    }

    fn is_access_allowed(
        &self,
        http_method: &str,
    ) -> bool {
        match http_method {
            "HEAD" | "GET" => true,
            "POST" | "PUT" => {
                *self == UserRole::USER
                    || *self == UserRole::ADMIN
            }
            "DELETE" => *self == UserRole::ADMIN,
            _ => false,
        }
    }
}

fn main() {
    let role = UserRole::RO;
    if role.is_access_allowed("POST") {
        println!("OK: {}", role.name());
    } else {
        println!("Access denied: {}", role.name());
    }
}

Rust does not support constants in enums, so we need to use a match in the name method. The enum matches are checked at compile time, so when all enum variants are used, there is no need to have a default branch.

For more information about the #[derive(PartialEq)] line, see the section about Attributes

sealed class GitCommand {
    abstract fun execute()
}

object Status : GitCommand() {
    override fun execute() =
        executeCommand(listOf("status"))
}

class Checkout(
    private val branch: String
) : GitCommand() {
    override fun execute() =
        executeCommand(listOf("checkout", branch))
}

class Add(
    private val files: List<String>
) : GitCommand() {
    override fun execute() =
        executeCommand(listOf("add") + files)
}

class Log(
    private val decorate: Boolean,
    private val patch: Boolean
) : GitCommand() {
    override fun execute() {
        val args = mutableListOf("log")
        if (decorate) {
            args.add("--decorate")
        }
        if (patch) {
            args.add("--patch")
        }
        executeCommand(args)
    }
}

fun executeCommand(args: List<String>) {
    val redirect = ProcessBuilder.Redirect.INHERIT
    ProcessBuilder(listOf("git") + args)
        .redirectInput(redirect)
        .redirectOutput(redirect)
        .redirectError(redirect)
        .start()
        .waitFor()
}

object Main {
    @JvmStatic
    fun main(args: Array<String>) {
        val command =
            Log(decorate = false, patch = true)
        command.execute()
    }
}

use std::process::Command;

pub enum GitCommand<'g> {
    STATUS,
    CHECKOUT(&'g str),
    ADD(Vec<&'g str>),
    LOG { decorate: bool, patch: bool },
}

impl<'g> GitCommand<'g> {
    fn execute(self) {
        let args: Vec<&str> = match self {
            GitCommand::STATUS => vec!["status"],
            GitCommand::CHECKOUT(branch) => {
                vec!["checkout", branch]
            }
            GitCommand::ADD(files) => {
                [vec!["add"], files].concat()
            },
            GitCommand::LOG {
                decorate,
                patch,
            } => {
                let mut args = vec!["log"];
                if decorate {
                    args.push("--decorate")
                }
                if patch {
                    args.push("--patch")
                }
                args
            }
        };
        execute_command("git", &args);
    }
}

fn execute_command(command: &str, args: &[&str]) {
    Command::new(command)
        .args(args)
        .spawn()
        .expect("spawn failed!")
        .wait()
        .expect("command failed!");
}

fn main() {
    let command = GitCommand::LOG {
        decorate: false,
        patch: true,
    };
    command.execute();
}

Sealed Classes in Kotlin are similar to Rust’s enums, as they allow the modelling of a closed type hierarchy

class User {
    private String name;

    public User(String name) {
        this.name = name;
    }
}

public static void main(String[] args) {
    String name = "User";

    User user1 = new User(name);
    User user2 = new User(name);
}

struct User {
    name: String,
}

fn main() {
    let name = String::from("User");

    let user1 = User { name };
    let user2 = User { name }; // compile error
}

In Java, the garbage collector will regularly check the object references and when nothing references the User instances anymore, they will be deleted. Once both instances have been detected as unused, the "User" string can also be deleted.

In Rust, values can only be owned by one object at a time: the assignment to user1 is OK, because the value will be moved from the name variable to user1. The creation of user2, however, will give a compile error, because the string "User" is now owned by user1, not by name.

#include <string>

std::string* get_string() {
    std::string* string = new std::string("hello");

    delete string;

    return string;
}

fn get_string() -> String {
    let string = String::from("hello");

    drop(string);

    return string; // compile error!
}

In this example, the C++ code has a use after free error. Note that this is only an example, drop is rarely used in Rust code (values will be dropped automatically when they go out of scope)

#include <vector>
#include <thread>

int main() {
    std::vector<std::string> list;

    auto f = [&list]() {
        for (int i = 0; i < 10000; i++) {
            list.push_back("item 123");
        }
    };

    std::thread t1(f);
    std::thread t2(f);

    t1.join();
    t2.join();
}

use std::thread;

fn main() {
    let mut list = vec![];

    let f = move || {
        for _ in 0..10000 {
            list.push("item 123");
        }
    };

    let t1 = thread::spawn(f);
    let t2 = thread::spawn(f); // compile error!

    t1.join().unwrap();
    t2.join().unwrap();
}

The std::vector class is not thread-safe and the C++ program will compile without errors, but when running, it will probably crash with an error like pointer being freed was not allocated or similar. In Rust, the closure f takes ownership of list (indicated by the move keyword), that’s why the compiler gives an error when f is used more than once.

const FILE_DATE = "2020-01-01";

function printCopyright() {
  const year = FILE_DATE.substr(0, 4);
  const copyright = `(C) ${year}`;
  console.log(copyright);
}

const FILE_DATE: &str = "2020-01-01";

fn print_copyright() {
    let year: &str = &FILE_DATE[..4];
    let copyright: String = format!("(C) {}", year);
    println!("{}", copyright);
}

See this section about strings for more examples

public static String repeat(String s, int count) {
    StringBuilder result = new StringBuilder();
    for (int i = 0; i < count; i++) {
        result.append(s);
    }
    return result.toString();
}

fn repeat(s: &str, count: u32) -> String {
    let mut result = String::new();
    for _ in 0..count {
        result += s;
    }
    result
}

This is just an example, Rust already has String.repeat

data class User(
    private val source: String,
    private val name: String,
    private val address: String
) {
    companion object {
        fun fromString(string: String): User {
            val lines = string.lines()
            return User("kotlin-v1.0", lines[0],
                lines[1])
        }
    }
}

pub struct User {
    source: &'static str,
    name: String,
    address: String,
}

impl User {
    pub fn new(s: &str) -> User {
        let mut lines = s.lines();
        User {
            source: "rust-v1.0",
            name: lines.next().unwrap().to_owned(),
            address: lines.next().unwrap().to_owned(),
        }
    }
}

Note that default field access is private in Rust

public static Integer getYear(String date) {
    if (date.length() >= 4) {
        String s = date.substring(0, 4);
        try {
            return Integer.valueOf(s);
        } catch (NumberFormatException e) {
            return null;
        }
    } else {
        return null;
    }
}

public static void main(String[] args) {
    Integer year = getYear("2020-01-01");
    if (year != null) {
        System.out.println(year);
    }
}

fn get_year(date: &str) -> Option<u32> {
    if date.len() >= 4 {
        let s = date[..4];
        match s.parse() {
            Ok(year) => Some(year),
            Err(_) => None
        }
    } else {
        None
    }
}

fn main() {
    if let Some(year) = get_year("2020-01-01") {
        println!("{}", year);
    }
}

The Option type is just a regular enum from Rust’s standard library, with the two entries None and Some. When returning Option, empty (null) values can be returned as None and non-empty values need to be wrapped, like Some(year)

Integer year = getYear("");
if (year == null) {
    System.err.println("Invalid date given!");
}

let year: Option<u32> = get_year("");
if year.is_none() {
    println!("Invalid date given!");
}

String url = "https://github.com";

String content = cache.get(url);
if (content == null) {
    content = loadUrl(url);
}

let url = "https://github.com";

let content = match cache.get(url) {
    Some(content) => content,
    None => load_url(url),
};

Note that in the Rust code, content is immutable (to achieve the same in Java, we would need to introduce another local variable or a new method)

package main

import (
    "fmt"
    "log"
    "strconv"
)

func ParsePort(port string) (uint16, error) {
    p, err := strconv.ParseUint(port, 10, 16)
    if err != nil {
        return 0, err
    }
    if p == 0 {
        return 0, fmt.Errorf("invalid: %d", p)
    }
    return uint16(p), nil
}

func main() {
    port, err := ParsePort("123")
    if err != nil {
        log.Fatalf("failed to parse port: %v", err)
    }
    log.Printf("port: %d", port)
}

use std::error::Error;

fn parse_port(s: &str) -> Result<u16, Box<Error>> {
    let port: u16 = s.parse()?;
    if port == 0 {
        Err(Box::from(format!("invalid: {}", port)))
    } else {
        Ok(port)
    }
}

fn main() {
    match parse_port("123") {
        Ok(port) => println!("port: {}", port),
        Err(err) => panic!("{}", err),
    }
}

In Rust it’s common to have statements which cover all possible cases, either using if/else or match, so you are less likely to encounter an early return in Rust than in Go

const { stdin } = require("process");

function readStr() {
  return new Promise((resolve, reject) => {
    let result = "";

    stdin.setEncoding("utf8");

    stdin.on("readable", () => {
      let chunk;
      while ((chunk = stdin.read())) {
        result += chunk;
      }
    });

    stdin.once("error", err => reject(err));

    stdin.once("end", () => resolve(result));
  });
}

use std::io::{stdin, Read};

fn read_str() -> Option<String> {
    let mut buffer = String::new();
    match stdin().read_to_string(&mut buffer) {
        Ok(_) => Some(buffer),
        Err(err) => {
            eprintln!(
                "Error while reading input: {}",
                err
            );
            None
        }
    };
}

Note that the JavaScript code returns a Promise, so it’s asynchronous, while the Rust example code is synchronous

#include <cstdint>

[[nodiscard]] int32_t add(int32_t a, int32_t b) {
    return a + b;
}

int main() {
    add(1, 2); // warning: unused return value
}

#[must_use]
fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    add(1, 2); // warning: unused return value
}