michele@DartVader:~/bite_of_rust$ cargo init hello --bin
     Created binary (application) project
michele@DartVader:~/bite_of_rust$ cd hello/
michele@DartVader:~/bite_of_rust/hello$ cargo run
   Compiling hello v0.1.0 (file:///home/michele/bite_of_rust/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.54 secs
     Running `target/debug/hello`
Hello, world!
michele@DartVader:~/bite_of_rust/hello$ echo "
#[test]
fn ok() { assert!(true) }
#[test]
fn ko() { assert!(false) }
" >> src/main.rs 
michele@DartVader:~/bite_of_rust/hello$ cargo test
   Compiling hello v0.1.0 (file:///home/michele/bite_of_rust/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.37 secs
     Running target/debug/deps/hello-e41301c0dacd96ed

running 2 tests
test ok ... ok
test ko ... FAILED

failures:

---- ko stdout ----
	thread 'ko' panicked at 'assertion failed: false', src/main.rs:8
note: Run with `RUST_BACKTRACE=1` for a backtrace.


failures:
    ko

test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured

error: test failed

my_list = [1, 3, 5, 7, 9]
for index, val in enumerate(my_list):
    if val > 4:
        del my_list[index]
print("Output: ")
print(my_list)

Output: 
[1, 3, 7]

   Compiling vspython_remove v0.1.0 (file:///home/michele/learning/rust/vspython_remove)
error[E0502]: cannot borrow `my_vec` as mutable because it is also borrowed as immutable
 --> src/main.rs:5:13
  |
3 |     for (index, &val) in my_vec.iter().enumerate() {
  |                          ------ immutable borrow occurs here
4 |         if val > 4 {
5 |             my_vec.remove(index);
  |             ^^^^^^ mutable borrow occurs here
6 |         }
7 |     }
  |     - immutable borrow ends here

error: aborting due to previous error

fn main() {
    let mut my_vec = vec![1, 3, 5, 7, 9];
    my_vec = my_vec.into_iter().filter(|val| *val <= 4).collect();
    println!("Output:\n{:?}", my_vec);
}

import threading
import time

N = 10000
a = [0]
threads = []

def update():
    v = a[0]
    time.sleep(0)
    a[0] = v + 1

for i in range(N):
    t = threading.Thread(target=update)
    t.start()
    threads.append(t)

for t in threads:
    t.join()

assert a[0] == N, "a = {} != N = {}".format(a[0], N)

import kotlin.concurrent.thread

fun main(args : Array<String>) {
    val N = 10000
    var a = 0
    val threads = (1..N).map {
        thread { a += 1 }
    }
    threads.map { it.join() }

    assert(a == N) {
        "$a != $N"
    }
}

use std::thread::spawn;

fn main() {
    static N: usize = 10000;
    let mut val = 0;
    let r_val = &mut val;
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        handlers.push(spawn(|| {
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    print!("Sum = {}", val);
    assert_eq!(N, val);
}

for _ in 0..N {
    handlers.push(spawn(move || {
        *r_val += 1;
    }
    ));
}

use std::thread::spawn;

fn main() {
    static N: usize = 10000;
    let r_val = std::rc::Rc::new(0);
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        let r_val = r_val.clone();
        handlers.push(spawn(move || {
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    print!("Sum = {}", r_val);
    assert_eq!(N, *r_val);
}

use std::thread::spawn;

fn main() {
    static N: usize = 10000;
    let r_val = std::sync::Arc::new(0);
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        let r_val = r_val.clone();
        handlers.push(spawn(move || {
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    print!("Sum = {}", r_val);
    assert_eq!(N, *r_val);
}

use std::thread::spawn;

fn main() {
    static N: usize = 10000;
    let r_val = std::sync::Arc::new(std::sync::Mutex::new(0));
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        let r_val = r_val.clone();
        handlers.push(spawn(move || {
            let mut r_val = r_val.lock().unwrap();
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    let result = r_val.lock().unwrap().clone();
    print!("Sum = {}", result);
    assert_eq!(N, result);
}