Rust, Asynchronous

Online Rust Playground

use async_std::task;
use std::thread::sleep;
use std::time::Duration;

async fn fn1() {
    let two_secs = Duration::from_secs(2);
    for _ in 0..5 {
        sleep(two_secs);
        println!("-");
    }
}

async fn fn2() {
    let one_sec = Duration::from_secs(1);
    for _ in 0..5 {
        sleep(one_sec);
        println!("+");
    }
}

fn main() {
    println!("Hello, concurrent!");
    let task1 = task::spawn(async {
        fn1().await;
    });
    let task2 = task::spawn(async {
        fn2().await;
    });

    task::block_on(task1);
    task::block_on(task2);
}

Rust, Multithread

Online Rust Playground

//Multithread
use std::thread;
use std::sync::mpsc;

fn main() {
    //Создаем канал связи между параллельными потоками
    let (p_tx, p_rx) = mpsc::channel();
    //Создаем параллельный поток и биндим к ручке
    let handle = thread::spawn(move || {
        //Получаем данные из основного потока
        let d = p_rx.recv().unwrap();
        //Обрабатываем данные в параллельном потоке
        calc(d);
    });
   
    //Основной поток:
    //Создаем данные для обработки
    let data = Data { str: "parallel!".to_string() };
    //Передаем данные в параллельный поток
    p_tx.send(data).unwrap();
    //Сводим потоки через ручку
    handle.join().unwrap();
}

//Функция для обработки данных в параллельном потоке
fn calc(data: Data) {
    println!("Hello {}", data.str);
}

//Данные для передачи между потоками
struct Data {
    str: String,
}

Rust, Bitwise operators

Online Rust Playground

Бит как единица хранения информации.
 
fn main() {
    //shift left: <<
    //01 -> 10 = 2
    let a = 1 << 1;
    println!("{}", a);

    //shift right: >>
    //10 -> 01 = 1
    let b = 2 >> 1;
    println!("{}", b);

    //or: |
    //01 or 10 -> 11 = 3
    let c = 1 | 2;
    println!("{}", c);

    //and: &
    //01 and 10 -> 00 = 0
    let d = 1 & 2;
    println!("{}", d);

}

Rust, Loops, Iterators

Online Rust Playground

pub struct Items {
    minimum: i32,
    step: i32,
    maximum: i32,
}

impl Iterator for Items {
    type Item = i32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.minimum >= self.maximum {
            return None;
        }
        let current = self.minimum;
        self.minimum += self.step;
        Some(current)
    }
}

fn main() {
    println!("-> Loops");
    loops();

    println!("-> Iterator");
    iter();
}

//Loops
fn loops() {
    println!("loop");
    let mut n = 0;
    loop {
        n += 1; //step
        if n > 5 {
            break;
        }
        println!("{}", n);
    }

    println!("while");
    let mut m = 0;
    while m < 5 {
        m += 1; //step
        println!("{}", m)
    }

    println!("for - range");
    for mut i in (0..5).step_by(2) {
        i += 1;
        println!("{}", i);
    }
 
    println!("for - idx");
    for (idx, i) in (1..=5).enumerate().step_by(2) {
        println!("{}: {}", idx, i);
    }

    println!("for - array");
    let arr = [1, 2, 3];
    for a in arr.iter().step_by(2) {
        println!("{}", a);
    }
}

//Iterator
fn iter() {
    let mut it = Items {
        minimum: 2,
        step: 3,
        maximum: 15,
    };
    println!("loop");
    loop {
        match it.next() {
            Some(v) => println!("loop {}", v),
            None => break,
        }
    }

    println!("while");
    it = Items {
        minimum: 3,
        step: 4,
        maximum: 15,
    };
    while let Some(n) = it.next() {
        println!("while {}", n)
    }

    println!("for");
    it = Items {
        minimum: 5,
        step: 10,
        maximum: 50,
    };
    for i in it {
        println!("for {}", i);
    }
}