Rust

let x: u8 = 1;
let mut x = 10; // ~mutability~, when a variable can be changed
let x = 2;  //    - ~shadowing~, if are the same type, although effectively are different variables
let x = 10;

use supper:**; // import all files on project

fn beta(MyStruct {y,z,..}: MyStruct) -> i32 // struct destructuring
fn beta() -> i32 {
  8 // expression
  // return 8;  // statement, same but less idiomatic
  // 8;         // with the ";" it will return "()"
}

if foo > 1 {} else if foo < 0 {} else {} // expression
if let MyStruct { x, .. } = foostruct {..} // if-let, non exhaustive
match ptr {
    Some(ptr) => ptr.g(),
    None      => {}
    // _ => println!("catch all pattern")
}

for num in nums {}
while let Some(i) = optional {..} // alternative to loop+match
loop{} // for infinite loop

struct Foo { // can be an enum
      x: usize
  pub y: usize
}
impl Foo {
        fn new0(x: usize) -> Self // static method
        fn this()         //        static method
    pub fn this()         // public static method
        fn this(&self)    //      instance method
        fn this(&mut self)
    pub fn this(self)     // takes the self itself
}

struct MyVect<T> {
    contents: T,
}
impl<T> MyVect<T> {
    pub fn find<P>(&self, predicate: P) -> Option<&T>
    where P: Fn(&T) -> bool {
        for v in self {
            if predicate(v) {
                return Some(v);
            }
        }
        None
    }
}

trait Foo { // like an interface
    fn method(&self) -> retType;
}
impl Foo for MyStruct {
    fn method(&self) -> retType {...}
}