[Rust]Rustlingsで学ぼう（Functions）

  Compiling of exercises/functions/functions1.rs failed! Please try again. Here's the output:
error[E0425]: cannot find function `call_me` in this scope
 --> exercises/functions/functions1.rs:9:5
  |
9 |     call_me();
  |     ^^^^^^^ not found in this scope

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0425`.

fn call_me() {}

⚠️  Compiling of exercises/functions/functions2.rs failed! Please try again. Here's the output:
error: expected type, found `)`
  --> exercises/functions/functions2.rs:12:16
   |
12 | fn call_me(num:) {
   |                ^ expected type

error[E0425]: cannot find value `num` in this scope
  --> exercises/functions/functions2.rs:13:17
   |
13 |     for i in 0..num {
   |                 ^^^ not found in this scope
   |
help: you might have meant to write `.` instead of `..`
   |
13 -     for i in 0..num {
13 +     for i in 0.num {
   |

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0425`.

fn call_me(num: i32) {

⚠️  Compiling of exercises/functions/functions3.rs failed! Please try again. Here's the output:
error[E0061]: this function takes 1 argument but 0 arguments were supplied
  --> exercises/functions/functions3.rs:9:5
   |
9  |     call_me();
   |     ^^^^^^^-- an argument of type `u32` is missing
   |
note: function defined here
  --> exercises/functions/functions3.rs:12:4
   |
12 | fn call_me(num: u32) {
   |    ^^^^^^^ --------
help: provide the argument
   |
9  |     call_me(/* u32 */);
   |            ~~~~~~~~~~~

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0061`.

fn main() {
    call_me(10);
}

  Compiling of exercises/functions/functions4.rs failed! Please try again. Here's the output:
error: expected type, found `{`
  --> exercises/functions/functions4.rs:18:30
   |
18 | fn sale_price(price: i32) -> {
   |                              ^ expected type

error: aborting due to 1 previous error

fn sale_price(price: i32) -> i32 {

price - 10

num % 2 == 0

⚠️  Compiling of exercises/functions/functions5.rs failed! Please try again. Here's the output:
error[E0308]: mismatched types
  --> exercises/functions/functions5.rs:13:24
   |
13 | fn square(num: i32) -> i32 {
   |    ------              ^^^ expected `i32`, found `()`
   |    |
   |    implicitly returns `()` as its body has no tail or `return` expression
14 |     num * num;
   |              - help: remove this semicolon to return this value

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0308`.

fn square(num: i32) -> i32 {
    num * num
}

An unresolved name was used.

Erroneous code examples:

something_that_doesnt_exist::foo;
// error: unresolved name `something_that_doesnt_exist::foo`

// or:

trait Foo {
    fn bar() {
        Self; // error: unresolved name `Self`
    }
}

// or:

let x = unknown_variable;  // error: unresolved name `unknown_variable`

Please verify that the name wasn't misspelled and ensure that the identifier being referred to is valid
for the given situation. Example:

enum something_that_does_exist {
    Foo,
}

Or:

mod something_that_does_exist {
    pub static foo : i32 = 0i32;
}

something_that_does_exist::foo; // ok!

Or:

let unknown_variable = 12u32;
let x = unknown_variable; // ok!

If the item is not defined in the current module, it must be imported using a use statement, like so:

use foo::bar;
bar();

If the item you are importing is not defined in some super-module of the current module, then it must
also be declared as public (e.g., pub fn).

An invalid number of arguments was passed when calling a function.

Erroneous code example:

fn f(u: i32) {}

f(); // error!

The number of arguments passed to a function must match the number of arguments specified in the
function signature.

For example, a function like:

fn f(a: u16, b: &str) {}

Must always be called with exactly two arguments, e.g., f(2, "test").

Note that Rust does not have a notion of optional function arguments or variadic functions (except for its C-FFI).

Expected type did not match the received type.

Erroneous code examples:

fn plus_one(x: i32) -> i32 {
    x + 1
}

plus_one("Not a number");
//       ^^^^^^^^^^^^^^ expected `i32`, found `&str`

if "Not a bool" {
// ^^^^^^^^^^^^ expected `bool`, found `&str`
}

let x: f32 = "Not a float";
//     ---   ^^^^^^^^^^^^^ expected `f32`, found `&str`
//     |
//     expected due to this

This error occurs when an expression was used in a place where the compiler expected an expression of a
different type. It can occur in several cases, the most common being when calling a function and passing an argument which has a different type than the matching type in the function declaration.