Functions
This page is under construction. Please come back later.
fn printHello() -> () { println!("Hello, world!"); } fn main() { printHello(); }
Output
$ rustc Functions1.rs
warning: function `printHello` should have a snake case name
--> Functions1.rs:1:4
|
1 | fn printHello() -> () {
| ^^^^^^^^^^ help: convert the identifier to snake case: `print_hello`
|
= note: `#[warn(non_snake_case)]` on by default
warning: 1 warning emitted
$ ./Functions1
Hello, world!
fn printHello(name:&str) -> () { println!("Hello, {}!", name); } fn main() { printHello("Fred"); printHello("Wilma"); printHello("Barney"); printHello("Betty"); }
Output
$ rustc Functions2.rs
warning: function `printHello` should have a snake case name
--> Functions2.rs:1:4
|
1 | fn printHello(name:&str) -> () {
| ^^^^^^^^^^ help: convert the identifier to snake case: `print_hello`
|
= note: `#[warn(non_snake_case)]` on by default
warning: 1 warning emitted
$ ./Functions2
Hello, Fred!
Hello, Wilma!
Hello, Barney!
Hello, Betty!
fn squared(j:isize) -> isize { return j * j; } fn main() { { let mut i:isize = 1; while i <= 10 { println!("{}", format!("{0:d}^2 = {1:d}", i, squared(i))); i += 1; } } }
Output
$ rustc Functions3.rs
error: unknown format trait `d`
--> Functions3.rs:9:31
|
9 | println!("{}", format!("{0:d}^2 = {1:d}", i, squared(i)));
| ^
|
= note: the only appropriate formatting traits are:
- ``, which uses the `Display` trait
- `?`, which uses the `Debug` trait
- `e`, which uses the `LowerExp` trait
- `E`, which uses the `UpperExp` trait
- `o`, which uses the `Octal` trait
- `p`, which uses the `Pointer` trait
- `b`, which uses the `Binary` trait
- `x`, which uses the `LowerHex` trait
- `X`, which uses the `UpperHex` trait
error: unknown format trait `d`
--> Functions3.rs:9:41
|
9 | println!("{}", format!("{0:d}^2 = {1:d}", i, squared(i)));
| ^
|
= note: the only appropriate formatting traits are:
- ``, which uses the `Display` trait
- `?`, which uses the `Debug` trait
- `e`, which uses the `LowerExp` trait
- `E`, which uses the `UpperExp` trait
- `o`, which uses the `Octal` trait
- `p`, which uses the `Pointer` trait
- `b`, which uses the `Binary` trait
- `x`, which uses the `LowerHex` trait
- `X`, which uses the `UpperHex` trait
error: aborting due to 2 previous errors
fn exponentiation(base:f64, powerArg:isize) -> f64 { let mut power:isize = powerArg; let mut result:f64 = 1; while power > 0 { result *= base; power -= 1; } return result; } fn main() { { let mut b:f64 = 1.1f64; while b < 2.05f64 { { let mut p:isize = 2; while p <= 10 { println!("{}", format!("{0:f} ^ {1:d} = {2:f}", b, p, exponentiation(b, p))); p += 1; } } b += 0.1f64; } } }
Output
$ rustc Functions4.rs
error: unknown format trait `f`
--> Functions4.rs:18:33
|
18 | println!("{}", format!("{0:f} ^ {1:d} = {2:f}", b, p, exponentiation(b, p)));
| ^
|
= note: the only appropriate formatting traits are:
- ``, which uses the `Display` trait
- `?`, which uses the `Debug` trait
- `e`, which uses the `LowerExp` trait
- `E`, which uses the `UpperExp` trait
- `o`, which uses the `Octal` trait
- `p`, which uses the `Pointer` trait
- `b`, which uses the `Binary` trait
- `x`, which uses the `LowerHex` trait
- `X`, which uses the `UpperHex` trait
error: unknown format trait `d`
--> Functions4.rs:18:41
|
18 | println!("{}", format!("{0:f} ^ {1:d} = {2:f}", b, p, exponentiation(b, p)));
| ^
|
= note: the only appropriate formatting traits are:
- ``, which uses the `Display` trait
- `?`, which uses the `Debug` trait
- `e`, which uses the `LowerExp` trait
- `E`, which uses the `UpperExp` trait
- `o`, which uses the `Octal` trait
- `p`, which uses the `Pointer` trait
- `b`, which uses the `Binary` trait
- `x`, which uses the `LowerHex` trait
- `X`, which uses the `UpperHex` trait
error: unknown format trait `f`
--> Functions4.rs:18:49
|
18 | println!("{}", format!("{0:f} ^ {1:d} = {2:f}", b, p, exponentiation(b, p)));
| ^
|
= note: the only appropriate formatting traits are:
- ``, which uses the `Display` trait
- `?`, which uses the `Debug` trait
- `e`, which uses the `LowerExp` trait
- `E`, which uses the `UpperExp` trait
- `o`, which uses the `Octal` trait
- `p`, which uses the `Pointer` trait
- `b`, which uses the `Binary` trait
- `x`, which uses the `LowerHex` trait
- `X`, which uses the `UpperHex` trait
error[E0308]: mismatched types
--> Functions4.rs:3:23
|
3 | let mut result:f64 = 1;
| --- ^
| | |
| | expected `f64`, found integer
| | help: use a float literal: `1.0`
| expected due to this
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0308`.
fn factorial(x:isize) -> i64 { if x <= 1 { return 1; } return x * factorial(x - 1); } fn main() { { let mut x:isize = 1; while x < 10 { println!("{}", format!("{0:d}! = {1:d}", x, factorial(x))); x += 1.0; } } }
Output
File not found!: /kunden/homepages/39/d957328751/htdocs/pureprogrammer/rs/examples/output/Functions5.out
mod utils; fn reverseList(x:Vec<String>) -> Vec<String> { let mut y:Vec<String> = Vec::new(); { let mut i:isize = x.len() - 1; while i >= 0 { y.push(x[i]); i += -1; } } return y; } fn main() { let mut names:Vec<&str> = vec!["Fred", "Wilma", "Barney", "Betty"]; for name in names { println!("Hello, {}!", name); } names = reverseList(names); for name in names { println!("Hello, {}!", name); } println!("{}", utils::list_to_string(names)); }
Output
$ rustc Lists6.rs
error[E0308]: mismatched types
--> Lists6.rs:6:21
|
6 | let mut i:isize = x.len() - 1;
| ----- ^^^^^^^^^^^ expected `isize`, found `usize`
| |
| expected due to this
|
help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
|
6 | let mut i:isize = (x.len() - 1).try_into().unwrap();
| + +++++++++++++++++++++
error[E0277]: the type `[String]` cannot be indexed by `isize`
--> Lists6.rs:8:13
|
8 | y.push(x[i]);
| ^ slice indices are of type `usize` or ranges of `usize`
|
= help: the trait `SliceIndex<[String]>` is not implemented for `isize`
= help: the trait `SliceIndex<[T]>` is implemented for `usize`
= note: required for `Vec<String>` to implement `Index<isize>`
error[E0308]: mismatched types
--> Lists6.rs:22:22
|
22 | names = reverseList(names);
| ----------- ^^^^^ expected `Vec<String>`, found `Vec<&str>`
| |
| arguments to this function are incorrect
|
= note: expected struct `Vec<String>`
found struct `Vec<&str>`
note: function defined here
--> Lists6.rs:3:4
|
3 | fn reverseList(x:Vec<String>) -> Vec<String> {
| ^^^^^^^^^^^ -------------
error[E0308]: mismatched types
--> Lists6.rs:22:10
|
16 | let mut names:Vec<&str> = vec!["Fred", "Wilma", "Barney", "Betty"];
| --------- expected due to this type
...
22 | names = reverseList(names);
| ^^^^^^^^^^^^^^^^^^ expected `Vec<&str>`, found `Vec<String>`
|
= note: expected struct `Vec<&str>`
found struct `Vec<String>`
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0277, E0308.
For more information about an error, try `rustc --explain E0277`.
mod utils; use std::collections::HashMap; fn convertKMtoMiles(x:HashMap<String, isize>) -> HashMap<String, isize> { let mut y:HashMap<String, isize> = HashMap::new(); for planet in Utils::keys(x) { y[planet] = ((x.at(planet)) as f64 * 0.621371f64 + 0.5f64) as isize; } return y; } fn main() { let mut planetDiametersInKM:HashMap<String, isize> = [ {"Mercury", 4879}, {"Venus", 12103}, {"Earth", 12756}, {"Mars", 6794}, {"Jupiter", 142985}, {"Saturn", 120534}, {"Uranus", 51115}, {"Neptune", 49534}, {"Pluto", 2374}, {"Ceres", 946}, {"Eris", 2326}, {"Makemake", 1430} ]; let mut planetDiametersInMiles:HashMap<String, isize> = convertKMtoMiles(planetDiametersInKM); for planet in Utils::keys(planetDiametersInMiles) { println!("{} has a diameter of {} miles", planet, planetDiametersInMiles.at(planet)); } }
Output
$ rustc Maps3.rs
error: this is a block expression, not an array
--> Maps3.rs:14:3
|
14 | {"Mercury", 4879},
| ^^^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
14 | ["Mercury", 4879],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:15:3
|
15 | {"Venus", 12103},
| ^^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
15 | ["Venus", 12103],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:16:3
|
16 | {"Earth", 12756},
| ^^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
16 | ["Earth", 12756],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:17:3
|
17 | {"Mars", 6794},
| ^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
17 | ["Mars", 6794],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:18:3
|
18 | {"Jupiter", 142985},
| ^^^^^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
18 | ["Jupiter", 142985],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:19:3
|
19 | {"Saturn", 120534},
| ^^^^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
19 | ["Saturn", 120534],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:20:3
|
20 | {"Uranus", 51115},
| ^^^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
20 | ["Uranus", 51115],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:21:3
|
21 | {"Neptune", 49534},
| ^^^^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
21 | ["Neptune", 49534],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:22:3
|
22 | {"Pluto", 2374},
| ^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
22 | ["Pluto", 2374],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:23:3
|
23 | {"Ceres", 946},
| ^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
23 | ["Ceres", 946],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:24:3
|
24 | {"Eris", 2326},
| ^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
24 | ["Eris", 2326],
| ~ ~
error: this is a block expression, not an array
--> Maps3.rs:25:3
|
25 | {"Makemake", 1430}
| ^^^^^^^^^^^^^^^^^^
|
help: to make an array, use square brackets instead of curly braces
|
25 | ["Makemake", 1430]
| ~ ~
error[E0433]: failed to resolve: use of undeclared type `Utils`
--> Maps3.rs:6:16
|
6 | for planet in Utils::keys(x) {
| ^^^^^ use of undeclared type `Utils`
error[E0599]: no method named `at` found for struct `HashMap` in the current scope
--> Maps3.rs:7:19
|
7 | y[planet] = ((x.at(planet)) as f64 * 0.621371f64 + 0.5f64) as isize;
| ^^ method not found in `HashMap<String, isize>`
error[E0433]: failed to resolve: use of undeclared type `Utils`
--> Maps3.rs:29:16
|
29 | for planet in Utils::keys(planetDiametersInMiles) {
| ^^^^^ use of undeclared type `Utils`
error[E0599]: no method named `at` found for struct `HashMap` in the current scope
--> Maps3.rs:30:76
|
30 | println!("{} has a diameter of {} miles", planet, planetDiametersInMiles.at(planet));
| ^^ method not found in `HashMap<String, isize>`
error: aborting due to 16 previous errors
Some errors have detailed explanations: E0433, E0599.
For more information about an error, try `rustc --explain E0433`.
fn swap(x:(String, isize)) -> (isize, String) { let mut y:(isize, String); y = [x.1, x.0]; return y; } fn main() { let mut pair1 = ("Hello", 5); let mut pair2:(isize, String); pair2 = swap(pair1); println!("{} becomes {}", Utils.tupleToString(pair1), Utils.tupleToString(pair2)); }
Output
$ rustc Tuples3.rs
error[E0425]: cannot find value `Utils` in this scope
--> Tuples3.rs:11:28
|
11 | println!("{} becomes {}", Utils.tupleToString(pair1), Utils.tupleToString(pair2));
| ^^^^^ not found in this scope
error[E0425]: cannot find value `Utils` in this scope
--> Tuples3.rs:11:56
|
11 | println!("{} becomes {}", Utils.tupleToString(pair1), Utils.tupleToString(pair2));
| ^^^^^ not found in this scope
error[E0308]: mismatched types
--> Tuples3.rs:3:12
|
3 | y = [x.1, x.0];
| ^^^ expected `isize`, found `String`
error[E0308]: mismatched types
--> Tuples3.rs:10:15
|
10 | pair2 = swap(pair1);
| ---- ^^^^^ expected `(String, isize)`, found `(&str, {integer})`
| |
| arguments to this function are incorrect
|
= note: expected tuple `(String, isize)`
found tuple `(&str, {integer})`
note: function defined here
--> Tuples3.rs:1:4
|
1 | fn swap(x:(String, isize)) -> (isize, String) {
| ^^^^ -----------------
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0308, E0425.
For more information about an error, try `rustc --explain E0308`.
Questions
- {{Who's on first?}}
- {{Who's on second?}}
- {{Who's on third?}}
Projects
More ★'s indicate higher difficulty level.
- Alouette Lyrics
- Bingo Lyrics
- 99 Bottles of Beer Lyrics
- Bubble Sort
- Calculate Euler's Number
- Compute π Function
- Compute π (Monte Carlo with Central Limit Theorem)
- Credit Card Validator
- The Farmer in the Dell (Revisited)
- Fibonacci Numbers
- Football Passer Rating (Revisited)
- GCD
- Insertion Sort
- LCG Pseudo-Random Number Generator
- License Plate Generator (Revisited)
- Merge Sort
- Min/Max Functions
- Old MacDonald Lyrics
- Quicksort
- Renard Numbers with Rounding Function
- Roman Numerals
- Sign Function
- Spreadsheet Columns
- Tower of Hanoi
- Twelve Days of Christmas Lyrics
References
- [[Rust Language Reference]]
- [[Rust Compiler]]