You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
86 lines
1.8 KiB
86 lines
1.8 KiB
// Unlike C/C++, there's no restriction on the order of function definitions
|
|
fn main() {
|
|
// We can use this function here, and define it somewhere later
|
|
fizzbuzz_to(100);
|
|
}
|
|
|
|
// Function that returns a boolean value
|
|
fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
|
|
// Corner case, early return
|
|
if rhs == 0 {
|
|
return false;
|
|
}
|
|
|
|
// This is an expression, the `return` keyword is not necessary here
|
|
lhs % rhs == 0
|
|
}
|
|
|
|
// Functions that "don't" return a value, actually return the unit type `()`
|
|
fn fizzbuzz(n: u32) -> () {
|
|
if is_divisible_by(n, 15) {
|
|
println!("fizzbuzz");
|
|
} else if is_divisible_by(n, 3) {
|
|
println!("fizz");
|
|
} else if is_divisible_by(n, 5) {
|
|
println!("buzz");
|
|
} else {
|
|
println!("{}", n);
|
|
}
|
|
}
|
|
|
|
// When a function returns `()`, the return type can be omitted from the
|
|
// signature
|
|
fn fizzbuzz_to(n: u32) {
|
|
for n in 1..n + 1 {
|
|
fizzbuzz(n);
|
|
}
|
|
}
|
|
|
|
async fn async_example(n: u32) {
|
|
for n in 1..n + 1 {
|
|
fizzbuzz(n);
|
|
}
|
|
}
|
|
|
|
const fn const_example(n: u32) {
|
|
for n in 1..n + 1 {
|
|
fizzbuzz(n);
|
|
}
|
|
}
|
|
|
|
extern "Rust" fn foo() {}
|
|
|
|
unsafe fn unsafe_example(n: u32) {
|
|
for n in 1..n + 1 {
|
|
fizzbuzz(n);
|
|
}
|
|
}
|
|
|
|
/*
|
|
unsafe fn commented_func(n: u32) {
|
|
for n in 1..n + 1 {
|
|
fizzbuzz(n);
|
|
}
|
|
}
|
|
*/
|
|
|
|
// Declares a function with the "C" ABI
|
|
extern "C" fn new_i32() -> i32 { 0 }
|
|
|
|
// Declares a function with the "stdcall" ABI
|
|
extern "stdcall" fn new_i32_stdcall() -> i32 { 0 }
|
|
|
|
async fn regular_example() { }
|
|
async unsafe fn unsafe_example() { }
|
|
|
|
const fn generic_example<'a>(x: &'a str) -> impl Future<Output = usize> + 'a {
|
|
async move { x.len() }
|
|
}
|
|
|
|
fn generic_example2<const N: usize>(arr: [i32; N]) {
|
|
// Used as a type within a function body.
|
|
let x: [i32; N];
|
|
// Used as an expression.
|
|
println!("{}", N * 2);
|
|
}
|