Please enable JavaScript.

Coggle requires JavaScript to display documents.

Rust (Flow (match (can destructure (reference (let reference = &1u32…

Rust

Flow

match

let number = 13;
match number {
    1 => println!("One!"),
    2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
    13...19 => println!("A teen"),
    _ => println!("Ain't special"),
}

can destructure

reference

let reference = &1u32
match reference {
    &v => println!("Destructured value {:?}", v)
}

let reference = &1u32
match *reference {
    v => println!("Dereferenced value {:?}", v)
}

value

let value = 1u32
match value {
    ref r => println!("Destructured reference {:?}", r)
}

let mut value = 1u32
match value {
    ref mut r => {
        *r += 1;
        println!("Destructured mutable reference {:?}", r)
    }
}

loop

is infinite

fn main() {
    let mut count = 0u32;
    loop {
        count += 1;
        if count == 3 {
            println!("three");
            continue;
        }
        println!("{}", count);
        if count == 5 {
            break;
        }
    }
}

can be labeled and nested

#![allow(unreachable_code)]
fn main() {
    'outer: loop {
        println!("Entered the outer loop");
        'inner: loop {
            println!("Entered the inner loop");
            // This would break only the inner loop
            //break;
            // This breaks the outer loop
            break 'outer;
        }
        println!("This point will never be reached");
    }
    println!("Exited the outer loop");
}

Closures

can also be functions:

fn apply<F: Fn()>(f: F) {
    f();
}

fn function() {
    println!("Function satisfying `Fn` bound");
}

fn main() {
    let closure = || println!("Closure satisfying `Fn` bound");
    apply(closure);
    apply(function);
}

as output parameters

fn create_fn() -> Box<Fn()> {
  Box::new(move || println!("Fn"))
}