From b5000277b4c7f78f1aa17809f620609e0765ef60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Clara=20Benedicta=20Maria=20M=C3=BCller?= Date: Sun, 1 Jul 2018 20:15:28 +0200 Subject: [PATCH] clean-up & updating passwordgenerator --- .gitignore | 2 + Cargo.toml | 17 ++++ borrowing.rs | 49 ------------ enum.rs | 35 -------- functions.rs | 60 -------------- guessing_game.rs | 56 ------------- looping.rs | 54 ------------- main.rs | 20 ----- match.rs | 67 ---------------- passwordgenerator.rs | 187 ++++++++++++++++++++++++++++--------------- pattern.rs | 44 ---------- struct.rs | 79 ------------------ synthax_semantics.rs | 60 -------------- test.rs | 9 --- tulpes_if.rs | 45 ----------- vectors.rs | 51 ------------ 16 files changed, 141 insertions(+), 694 deletions(-) create mode 100644 .gitignore create mode 100644 Cargo.toml delete mode 100755 borrowing.rs delete mode 100755 enum.rs delete mode 100755 functions.rs delete mode 100755 guessing_game.rs delete mode 100755 looping.rs delete mode 100755 main.rs delete mode 100755 match.rs delete mode 100755 pattern.rs delete mode 100755 struct.rs delete mode 100755 synthax_semantics.rs delete mode 100755 test.rs delete mode 100755 tulpes_if.rs delete mode 100755 vectors.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a9d37c5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +target +Cargo.lock diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..c3c68da --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,17 @@ +[package] + +name = "Rust_Playground" +version = "0.0.1" +authors = [ "Clara Benedicta Maria Mueller " ] + + +[[bin]] +name = "stuff" +path = "/media/win_e/Clara_Daten/etc/Programmierung/Rust/src/passwordgenerator.rs" + + +[dependencies] +regex = "0.2" +rand = "0.3.15" +getopts = "0.2" +text_io = "0.1.7" diff --git a/borrowing.rs b/borrowing.rs deleted file mode 100755 index a083762..0000000 --- a/borrowing.rs +++ /dev/null @@ -1,49 +0,0 @@ -// ownership -// Happy Jesus Respawn! ;D - - -// main function -fn main() { - // assign vectors - let v1 = vec![1, 2, 3]; - let v2 = vec![1, 2, 3]; - - // use functions - let (v1, v2, answer) = foo(v1, v2); - let answer2 = boo(&v1, &v2); - println!("Answer is: {}", answer); - println!("Second answer is: {}", answer2); - - // playing with mutable references - let mut x = 5; - { // needed for error free compiling - let y = &mut x; // y borrows x here - *y += 1; // '*' needed to access references - } - println!("{}", x); // tries to borrow x here -> only 1 &mut x allowed! - - let y = &5; // the same as 'let _y = 5; let y = &_y' - let f = Foo {x: y }; - println!("{}", f.x); -} - - -// functions -fn foo(v1: Vec, v2: Vec) -> (Vec, Vec, i32) { - // return answer // give back ownership of vectors - (v1, v2, 42) -} - -//better version of 'foo' using advantage of borrowing -fn boo(v1: &Vec, v2: &Vec) -> i32 { - // give back answer - 42 -} - - - - -// struct -> way for creating more complex data types -struct Foo<'a> { // declaring lifetime 'a - x: &'a i32, // using lifetime 'a -} diff --git a/enum.rs b/enum.rs deleted file mode 100755 index bb4384c..0000000 --- a/enum.rs +++ /dev/null @@ -1,35 +0,0 @@ -// enum -// - - -// main function -fn main() { - // use enums - let x: Message = Message::Move { x: 3, y: 4 }; - let y: BoardGameTurn = BoardGameTurn::Move { squares: 1 }; - - // enum working like function - let m = Message::Write("Hello World".to_string()); - let x = foo("Hello World".to_string()); // same as above, using function 'foo()' - - // convert vector of strings into vector of Message::Write - let v = vec!["Hello".to_string(), "World".to_string()]; - let v1: Vec = v.into_iter().map(Message::Write).collect(); -} - -// enmus -enum Message { - Quit, - ChangeColor(i32, i32, i32), // tulpe - Move { x: i32, y: i32 }, // struct - Write(String), -} -enum BoardGameTurn { - Move { squares: i32 }, - Pass, -} - -//functions -fn foo(x: String) -> Message { - Message::Write(x) -} diff --git a/functions.rs b/functions.rs deleted file mode 100755 index b3d04cf..0000000 --- a/functions.rs +++ /dev/null @@ -1,60 +0,0 @@ -// here plays the music! -// Syntax & Semantic - - -// main function -fn main() { - let x: i32 = 5; // set x unmutable, integer 5 - - let mut y = 7; // set y mutable 5 (here an integer) - println!("The value of y is: {}", y); - y = 4; // change y - println!("The value of y is: {}", y); - - { - println!("The value of x is: {}", x); - let x: i32 = 7; // changing x, only inside loop - println!("The value of x is: {}", x); - } - let y = "I'm a text now!"; // change y again (here as text) - println!("The value of y is: {} ", y); - - println!("The value of x is: {}", x); - - print_number(88); // call function - sum(3, 5); - let a = add_one(x); - - let z = (x + 2); - println!("New values a: {}, z: {}", a, z); - - // variable bindings with point to function - let f: fn(i32) -> i32 = add_one; // without type inference - //let f = add_one; // with type inference - let six = f(5); // call function - println!("called function says: {}", six); -} - - -// declaring function - -// function for printing numbers -fn print_number(x: i32) { - println!("x is: {}", x); -} - -// function for adding two numbers -fn sum(x: i32, y: i32) { - println!("sum is: {}", x + y); // print sum of numbers -} - -// adding 1 to number -fn add_one(i: i32) -> i32 { // -> i32 declairs return of function - i + 1 // here no ';' -> Rust = expression based language - // x + 1; doesn't retourn value -} - -// never returning function -fn diverges() -> ! { - panic!("This function never returns!"); // macro -> causes the current thread of execution to crash -} diff --git a/guessing_game.rs b/guessing_game.rs deleted file mode 100755 index c8c0ba2..0000000 --- a/guessing_game.rs +++ /dev/null @@ -1,56 +0,0 @@ -// another rust programm -// let's get started ^.^ - -extern crate rand; // actually using rand (declared in dependencies of 'Cargo.toml') - -// rust only uses few things by default ('prelude') -> add your needs! -use std::io; // use io library from the standard library -use std::cmp::Ordering; // use ordering type -use rand::Rng; // using rands function rand::thread_rng() - - -// main function -fn main() { - println!("guess a number!"); // macro, prints string - - let secret_number = rand::thread_rng() // get copy of random number generator - .gen_range(1, 101); // methods takes 2 arguments -> generate random number between (inclusive on the lower bound, but exclusive on the upper bound -> 1 - 100) - - // println!("The secret number is: {}", secret_number); // print out secret number // just for testing -> runs the game! - - - loop { // building infinity loop - - println!("please input your guess!."); // macro, prints string - - let mut guess = String::new(); // let -> create 'variable bindings'; String -> string type (UTF-8 encoded bit of text); '::' -> associate function; 'new()' -> created empty - let foo = 5; // 'foo' is immutable - let mut bar = 5; //'bar' is mutable - - io::stdin().read_line(&mut guess) // calling associated function // without std::io -> written 'std::io::stdin()' //returns handle to standard input - // read_line() -> calling method (like associate function, only on parcticular instant of type) an handle - // read_line():&mut guess -> passing argument to mutable reference of guess - .expect("failed to read line"); // io::Result encodes error handling information // not successful -> panic! with message "failed to read line" - // alternative written: 'io::stdin().read_line(&mut guess).expect("failed to read line");' - - // let guess: u32 = guess.trim().parse() // 'shadow' guess with new one -> convert string into u32 // 'trim()' eliminates whitespace // 'prase()' -> parses string into number - // .expect("Please type a number!"); // stop programm if not a number - - let guess: u32 = match guess.trim().parse() { // 'handling error' -> 'match' instead 'expect()' // result returned by prase() - Ok(num) => num, // success -> set name num on unwrapped Ok value (integer) - Err(_) => continue, // failure -> don't care of kind of error -> catch all _(everything not ok) // 'continue' -> move to next iteration of loop (aka ignore all errors) - }; - - println!("you guessed: {}", guess); // print out saved string from STDIN - println!("FOO: {} & BAR: {}", foo, bar); // print out string variables - - match guess.cmp(&secret_number) { // cmp can called on anything comparable, takes references to thing to compare // returns odering type // match -> determine exactly what typ of ordering (ordering = enum (enumeration)) // guess + secret_number have to be same type for comparision! - Ordering::Less => println!("To small!"), // ordering enum -> 3 possible variants (less/greater/equal) - Ordering::Greater => println!("To big!"), - Ordering::Equal => { - println!("You win!"); - break; - } - } - } -} diff --git a/looping.rs b/looping.rs deleted file mode 100755 index a960db7..0000000 --- a/looping.rs +++ /dev/null @@ -1,54 +0,0 @@ -// loops -// - - -// main function -fn main() { - - // infinity loop - // loop { - // println!("neverending looping!"); - // } - - let mut x = 5; // mut x: i32 - let mut done = false; // mut done: bool - - while !done { // looping as long as done == true - x += x - 3; // adding 2 to x - println!("{}", x); - if x % 5 == 0 { // stop looping if x is multiple of 5 - done = true; - } - } - - // redone of upper while loop -> better way - loop { - x += x - 3; // adding 2 to x - println!("{}", x); - if x % 5 == 0 { // stop looping if x is multiple of 5 - break; // break out loop - // return; // will do the same as 'break' - } - } - - // for loop - 'outer: for y in 0..10 { - 'inner: for mut x in 0..10 { // from 0 to 9, 10 (upper bound is exclusive) - x += 1 + x; - if x % 2 == 0 { continue 'inner; } // go to next step inner loop -> only print odd numbers - if y % 2 == 0 { continue 'outer; } // go to next step outer loop - println!("now x is: {} and y is: {}", x, y); // x: i32 - } - } - - for (index, value) in (5..10).enumerate() { - println!("index = {} value = {}", index, value); - } - - let line = "Hello\nWorld!".lines(); - - for (linenumber, line) in line.enumerate() { - println!("{}: {}", linenumber, line); - } -} - diff --git a/main.rs b/main.rs deleted file mode 100755 index 041447b..0000000 --- a/main.rs +++ /dev/null @@ -1,20 +0,0 @@ -// don't rust -> restart - -#[macro_use] extern crate text_io; - -// rust only uses few things by default ('prelude') -> add your needs! -use std::io; // use io library from the standard library - -fn main() { - //let n: i32 = read!(); - //println!("Read in: {}", n); - //fib (n); - let n: i32 = 1; - fib (n); -} - -// Write a function fib which takes a single i32 argument n < 10 and returns n's Fibonacci number (also i32). - -fn fib (n:i32) { - println!("{} \n", n); -} diff --git a/match.rs b/match.rs deleted file mode 100755 index ac67d90..0000000 --- a/match.rs +++ /dev/null @@ -1,67 +0,0 @@ -// match -// - - -// main function -fn main() { - let x = 2; - let a = 1; - - match a { - b => println!("a: {} b: {}", a, b), // catches '_' 'any case' - } - - match x { // more powerful than if/else - 1 => println!("one"), // - 2 => println!("two"), - 3 => println!("three"), - 4 => println!("four"), - _ => println!("something else"), // ‘exhaustiveness checking’ -> error if not used - } - - let number = match x { // use match for variable bindings - 1 => "one", // integer converted into string - 2 => "two", - 3 => "three", - 4 => "four", - 5 => "five", - _ => "something else", - }; - - println!("number is: {}", number); - - struct Point { - x: i32, - y: i32, - } - - let origin = Point { x: 0, y: 0 } - - match origin { // deconstruct compound data type - Point { x, y } => println!("({},{})", x, y), - } - -} - -// enmus -enum Message { - Quit, - ChangeColor(i32, i32, i32), // tulpe - Move { x: i32, y: i32 }, // struct - Write(String), -} - -// funtions -fn quit() { /* ... */ } -fn change_color(r: i32, g: i32, b: i32) { /* ... */ } -fn move_cursor(x: i32, y: i32) { /* ... */ } - -// process possible variants of enum with match -fn process_message(msg: Message) { - match msg { - Message::Quit => quit(), - Message::ChangeColor(r, g, b) => change_color(r, g, b), - Message::Move { x, y: new_name_for_y } => move_cursor(x, new_name_for_y), - Message::Write(s) => println!("{}", s), - }; -} diff --git a/passwordgenerator.rs b/passwordgenerator.rs index 1ad08b5..28295e3 100755 --- a/passwordgenerator.rs +++ b/passwordgenerator.rs @@ -1,78 +1,135 @@ #![allow(unstable)] // allow unstable libraries - // programm for password generation +// cargo run -- -l 10 -n 2 -s 50 + + +// To-Do + // variable for strength of password + // points for length of pw + // malus for same character, more often -> higher malus + // no special character -> malus + // same case -> malus + // length, special character, different characters, non redundance + // savety check of password + // password strenght by user input + + extern crate rand; +extern crate getopts; use rand::Rng; -// use std::__rand::thread_rng; +use getopts::Options; +use std::env; // use parameters -// main function -fn main() { - // variable for length of password - let pass_length: i32 = 8; - let mut password = String::new(); // assign password as empty string - let mut rng = rand::thread_rng(); // instance of thread; rng = random number generator (object) - - // variable for strength of password - - // length, special character, different characters, non redundance - - - // assign array with (ascii) signs - let mut signs : Vec = vec![]; - +// functions + +// print help menu +fn print_usage(program: &str, opts: Options) { + let brief = format!("Usage: {} FILE [options]", program); + print!("{}", opts.usage(&brief)); +} + +// create vector containing signs for password +fn filler () -> Vec { + let mut signs : Vec = vec![]; // assign empty vector // fill vector for i in 33u8..126u8 { - signs.push(i as char); + match i as char { // filtering I, l + 'l' => continue, + 'I' => continue, + 'O' => continue, + '°' => continue, + '²' => continue, + '³' => continue, + '€' => continue, + _ => signs.push(i as char) + } + } + return signs +} + +// creation of passward with certain length +fn pw (pass_length: &i32, signs: &Vec) -> String { + let mut password = String::new(); // assign password as empty string + let mut rng = rand::thread_rng(); // instance of thread; rng = random number generator (object) + for _ in 0..*pass_length { + //password.push(rng.choose(&signs).unwrap()); // get only password + let w = (*(rng.choose(&signs).unwrap())); + //password.push(*(rng.choose(&signs).unwrap())); // * for derefernces for processing + password.push(w); + } + return password +} + + +// main function +fn main() { + // variables + let mut pass_length: i32 = 8; // length of password + let mut number: i32 = 1; // set number of created passwords + let mut limit = 20; // set score threshold for password + let mut score = 0; // score for password quality + + // parameters + //let args: Vec = std::env::args().skip(1).collect(); // skip() -> skip programm call + let args: Vec = std::env::args().collect(); + let program = args[0].clone(); + + // create new option object + let mut opts = Options::new(); + opts.optopt("l", "length", "set length of password [default: 8]", "LENGTH"); + opts.optopt("n", "number", "set number of created passwords [default: 1]", "NUMBER"); + opts.optopt("s", "score", "set score of password", "SCORE"); + opts.optflag("h", "help", "print this help menu"); + let matches = match opts.parse(&args[1..]) { + Ok(m) => { m } + Err(f) => { panic!(f.to_string()) } + }; + + // print help menu?? + if matches.opt_present("h") { + print_usage(&program, opts); + return; + } + pass_length = matches.opt_str("l").unwrap().parse::().unwrap(); // unwrap Options from opt_str -> convert into int // unwrap_or(String::from()) + number = matches.opt_str("n").unwrap().parse::().unwrap(); + score = matches.opt_str("s").unwrap().parse::().unwrap(); + println!("Password length: {}, Number of passwords: {}, Score of Password: {}", pass_length, number, score); + score += pass_length; + + // assign array with (ascii) signs + let mut signs : Vec = filler(); + + // create n passwords + for x in 0..number { + // create password + let password = pw(&pass_length, &signs); + + //let mut control = String::new(); + let mut control: char = password.chars().next().unwrap(); // get first element of string + println!("first {}", control); + + for c in password.chars() { + + // c already used? + match c { + control => println!("{} is already in use -> {}", c, control), + _ => println!("{} is new, not {}", c, control), + } + + // same character more times in a row? + + // different cases + + println!("{} vs {}", control, c); + //control.push(c.clone()); + control = c; + } + + // we have a password + println!("password is: {}", password); } - - // looping -> creation of password - for _ in 0..pass_length { - //password.push(rng.choose(&signs).unwrap()); // get only password - password.push(*(rng.choose(&signs).unwrap())); // * for derefernces for processing - } - - // we have a password - println!("password is: {}", password); - - // create random number between (range array elements) - - // from number of array element -> password - - - // create password -// let s = rand::thread_rng() -// .gen_ascii_chars() // generate ASCII signs -// .take(pass_length) // take signs for password -// .collect::(); - - // print out password -// println!("random string: {}", s); - - // assign variable for password -// let mut str = String::new(); - - // create password -// for _ in () { -// str.push(rand::random::() as char); // push character to string str -// } - - // assing counter -// let mut i: i32 = 0; - -// for (i = 0, i < pass_length, i++) { -// str.push(rand::random::() as char); -// } - -// let choices = [33..126]; -// let mut rstr = String::new(); -// let mut rng = rand::thread_rng(); - -// for _ in 0..8 { -// rstr.push((rng.choose(&choices).unwrap() as u8) as char); // Return a random element from values -// } - } diff --git a/pattern.rs b/pattern.rs deleted file mode 100755 index 05cd556..0000000 --- a/pattern.rs +++ /dev/null @@ -1,44 +0,0 @@ -// patterns -// f*up life.. - - -// main function -fn main() { - // assign tuple - let tuple: (u32, String) = (5, String::from("five")); - - // move string -> move tiple - let (x, _s) = tuple; - - // gives error because tuple is moved - // println!("Tuple is: {:?}", tuple); - - let tuple = (5, String::from("five")); - - // tuple is not moved -> u32 is a copy - let (x, _) = tuple; - - // works - println!("Tuple is: {:?}", tuple); - - let x = 1; - - match x { // bind values to names - e @ 1 ... 5 => println!("got a range element {}", e), - _ => println!("anything"), - } - - #[derive(Debug)] // compiler -> basic implementations for some traits via the #[derive] attribute, traits can manually implemented - struct Person { - name: Option, - } - - let name = "Steve".to_string(); - let x: Option = Some(Person { name: Some(name) }; - - match x { - Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a), - _ => {} - } - -} diff --git a/struct.rs b/struct.rs deleted file mode 100755 index d0cfaae..0000000 --- a/struct.rs +++ /dev/null @@ -1,79 +0,0 @@ -// struct -// snowy eastern oO - - -// main function -fn main() { - // creating complex data type - let origin_x = 0; - let origin_y = 0; - - let origin = Point { x: 0, y: 0 }; // origin: Point - - println!("The origin is at ({}, {})", origin.x, origin.y); - - let mut point = Point { x: 0, y: 0 }; - point.x = 5; // excess field by name - - println!("The point is at ({}, {})", point.x, point.y); - - { - let r = PointRef { x: &mut point.x, y: &mut point.y }; - - *r.x = 5; - *r.y = 6; - } - - assert_eq!(5, point.x); // 'assert_eq' -> assert two expression are equal - assert_eq!(6, point.y); - - let mut point3d = Point3d { x: 0, y: 0, z: 0 }; - // point3d = { x: 1, .. point3d }; // gives point a new y, but keeps x and z // doesn't work anymore - - - // making new point - // let point_new = Point3d { z: 1, x: 2, .. origin }; - - // assigning color black (tuple struct) - let black = Color(0, 0, 0); // not the same type as 'let origin = Point(0, 0, 0)' - let origin = Point2(0, 0, 0); - - // tuple struct with only one element -> 'newtype' - let length = Inches(10); - - let Inches(inter_length) = length; // extract inner integer typ - let inter_length2 = length.0; // does the same as aboves - - println!("length is {} inches", inter_length); -} - -// combine two single data types into one -struct Point { // struct for creatiting 2D point - x: i32, // could use 'let' here - y: i32, -} - -// structure with reference pointer -struct PointRef<'a> { - x: &'a mut i32, - y: &'a mut i32, -} - -// structure for 3D points -struct Point3d { - x: i32, - y: i32, - z: i32, -} - -// tuple struct -//struct Color(i32, i32, i32); -struct Point2(i32, i32, i32); -struct Inches(i32); - -// struct -> clearer -struct Color { - red: i32, // actually names instead positions - blue: i32, - green: i32, -} diff --git a/synthax_semantics.rs b/synthax_semantics.rs deleted file mode 100755 index b3d04cf..0000000 --- a/synthax_semantics.rs +++ /dev/null @@ -1,60 +0,0 @@ -// here plays the music! -// Syntax & Semantic - - -// main function -fn main() { - let x: i32 = 5; // set x unmutable, integer 5 - - let mut y = 7; // set y mutable 5 (here an integer) - println!("The value of y is: {}", y); - y = 4; // change y - println!("The value of y is: {}", y); - - { - println!("The value of x is: {}", x); - let x: i32 = 7; // changing x, only inside loop - println!("The value of x is: {}", x); - } - let y = "I'm a text now!"; // change y again (here as text) - println!("The value of y is: {} ", y); - - println!("The value of x is: {}", x); - - print_number(88); // call function - sum(3, 5); - let a = add_one(x); - - let z = (x + 2); - println!("New values a: {}, z: {}", a, z); - - // variable bindings with point to function - let f: fn(i32) -> i32 = add_one; // without type inference - //let f = add_one; // with type inference - let six = f(5); // call function - println!("called function says: {}", six); -} - - -// declaring function - -// function for printing numbers -fn print_number(x: i32) { - println!("x is: {}", x); -} - -// function for adding two numbers -fn sum(x: i32, y: i32) { - println!("sum is: {}", x + y); // print sum of numbers -} - -// adding 1 to number -fn add_one(i: i32) -> i32 { // -> i32 declairs return of function - i + 1 // here no ';' -> Rust = expression based language - // x + 1; doesn't retourn value -} - -// never returning function -fn diverges() -> ! { - panic!("This function never returns!"); // macro -> causes the current thread of execution to crash -} diff --git a/test.rs b/test.rs deleted file mode 100755 index 16d31bf..0000000 --- a/test.rs +++ /dev/null @@ -1,9 +0,0 @@ -// play & learning with rust -// aka "rust playground" - - -// main function -fn main() { - -} - diff --git a/tulpes_if.rs b/tulpes_if.rs deleted file mode 100755 index 1b7b98b..0000000 --- a/tulpes_if.rs +++ /dev/null @@ -1,45 +0,0 @@ -// 'primitive' types -// what a sunny easter day - best for programming! - - -// main function -fn main() { - // assigning tulpes - let mut x = (1, 2); // x: (i32, i32) - let y = (2, 3); // y: (i32, i32) - x = y; // assign tulpe into another - - let x1 = x.0; // access first field of tulpe x - let x2 = x.1; // access second field of tulpe x - println!("the first element of x is: {}", x1); - - let (a, b, c) = (1, 2, 3,); // access tulpe by destructuring - println!("the value of a is: {}", a); - - let d =(0,); // single element tulpe - - - let z = 7; - - // some looping - if z == 5 { - println!("z is five!"); - } else if z == 3 { - println!("z is three!"); - } - - else { - println!("z is not five and not three! :("); - } - - // more looping, written differently - let z = 9; - - let y = if z == 5 { - 10 - } else { - 15 - }; // y: i32 - println!("y is defined as: {}", y); -} - diff --git a/vectors.rs b/vectors.rs deleted file mode 100755 index 47a148d..0000000 --- a/vectors.rs +++ /dev/null @@ -1,51 +0,0 @@ -// vectors -// jesus respawn is near! - - -// main function -fn main() { - // assigning vectors - let mut v = vec![1, 2, 3, 4, 5]; // v: vec - let w = vec![10; 0]; // vector of 10 zeroes - - // print particular element of v - println!("the 3. element of v is:{}", v[2]); // counting elements beginning at 0 - - // index - let i: usize = 0; - // let j: i32 = 0; // doesn't work! - println!("ite element: {}", v[i]); - - // handling out of bound errors - match w.get(8) { // use 'get()' or 'get_mut()' - Some(x) => println!("item 7 is: {}", x), - None => println!("Sorry, this vectori is to short!") - } - - // iteration of vectors - for i in &v { // using unmutable references - println!("A reference to {}", i); - } - for i in &mut v { - println!("A mutable reference to {}", i); - } - for i in v { // note: you cannot use vector again! - println!("Take ownership of the vector and its elements {}", i); - } - - let a = 5; // a: i32 - let b = true; // b: bool - let a2 = double(a); - let b2 = change_truth(b); - println!("{}", a); // works, because i32 has no pointer -> copy trait implemented - println!("{}", b); // works -> bool has copy trait -} - - -// function -fn double(x: i32) -> i32 { - x * 2 -} -fn change_truth(x: bool) -> bool { - !x -}