674 lines
12 KiB
Text
674 lines
12 KiB
Text
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# Control flow"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Statements & Expressions\n",
|
|
"\n",
|
|
"### Statements\n",
|
|
"\n",
|
|
"* Statements must end with a semicolon"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"y = 30\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"let x = 10;\n",
|
|
"let mut y = 20;\n",
|
|
"y += x;\n",
|
|
"println!(\"y = {y}\");"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Expressions\n",
|
|
"\n",
|
|
"* Rust is an **expression-oriented language**, which means that most pieces of code are in fact expressions\n",
|
|
"* A code block is also an expression, which returns the value of its last expression if we omit the semicolon"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"result = 30\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"let result = {\n",
|
|
" let a = 10;\n",
|
|
" let b = 20;\n",
|
|
" a + b // no semicolon before end of the block\n",
|
|
"};\n",
|
|
"\n",
|
|
"println!(\"result = {}\", result);"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 5,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 5,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"let result = {\n",
|
|
" let a = 10;\n",
|
|
" let b = 20;\n",
|
|
" a + b; // now result of an expression is ()\n",
|
|
"};\n",
|
|
"\n",
|
|
"result"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Conditional Statements with `if` and `else`"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 6,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"The number 7 is odd.\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 6,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"let n = 7;\n",
|
|
"\n",
|
|
"if n % 2 == 0 {\n",
|
|
" println!(\"The number {n} is even.\");\n",
|
|
"} else {\n",
|
|
" println!(\"The number {n} is odd.\");\n",
|
|
"}"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### `if-else` as an expression\n",
|
|
"\n",
|
|
"* if else condition is an expression that returns a value\n",
|
|
"* all branches always must return a value of the same type"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"\"adult\""
|
|
]
|
|
},
|
|
"execution_count": 7,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"let age = 44;\n",
|
|
"let is_adult = if age >= 18 { true } else { false };\n",
|
|
"let description = if is_adult { \"adult\" } else { \"minor\" };\n",
|
|
"description"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## `while` loop"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 33,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Current count: 0\n",
|
|
"Current count: 1\n",
|
|
"Current count: 2\n",
|
|
"Current count: 3\n",
|
|
"Current count: 4\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 33,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"let mut count = 0;\n",
|
|
"\n",
|
|
"while count < 5 {\n",
|
|
" println!(\"Current count: {}\", count);\n",
|
|
" count += 1;\n",
|
|
"}"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Infinity `loop`\n",
|
|
"\n",
|
|
"Use loop to write infinite loops. It executes the block repeatedly forever (or until a break or return is reached, or the thread panics)."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 3,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"1 * 1 = 1\n",
|
|
"3 * 3 = 9\n",
|
|
"5 * 5 = 25\n",
|
|
"7 * 7 = 49\n",
|
|
"9 * 9 = 81\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 3,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"let mut n = 0;\n",
|
|
"let mut power: u32;\n",
|
|
"let max_power = 100;\n",
|
|
"\n",
|
|
"loop {\n",
|
|
" n += 1;\n",
|
|
" power = n * n;\n",
|
|
"\n",
|
|
" if power >= max_power {\n",
|
|
" break; \n",
|
|
" }\n",
|
|
"\n",
|
|
" if power % 2 == 0 {\n",
|
|
" continue;\n",
|
|
" }\n",
|
|
"\n",
|
|
" println!(\"{} * {} = {}\", n, n, power); \n",
|
|
"}"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Nested loops\n",
|
|
"\n",
|
|
"* When loops are nested inside each other, the `break` and `continue` statements apply to the immediate enclosing loop. \n",
|
|
"* Any loop statement (also the while and for loop) can be preceded by a label (denoted as labelname:) to allow us to jump to the next or outer enclosing loop"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 43,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Enter the outer loop\n",
|
|
"Enter the inner loop\n",
|
|
"Exited the outer loop\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"'outer: loop {\n",
|
|
" println!(\"Enter the outer loop\");\n",
|
|
" 'inner: loop {\n",
|
|
" println!(\"Enter the inner loop\");\n",
|
|
" break 'outer; // breaks the outer loop\n",
|
|
" }\n",
|
|
" println!(\"This will never be printed...\");\n",
|
|
"}\n",
|
|
"println!(\"Exited the outer loop\");"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## `for` loops"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"* looping where variable `i` begins from a start value `a` to an end value `b` (exclusive)\n",
|
|
"* each subsequent value is bound to the variable `i` and used in the next loop iteration"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 45,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"i = 0\n",
|
|
"i = 1\n",
|
|
"i = 2\n",
|
|
"i = 3\n",
|
|
"i = 4\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 45,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"for i in 0..5 {\n",
|
|
" println!(\"i = {}\", i);\n",
|
|
"}"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"* inclusive version of `for`"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"i = 1\n",
|
|
"i = 2\n",
|
|
"i = 3\n",
|
|
"i = 4\n",
|
|
"i = 5\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 56,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"for i in 1..=5 {\n",
|
|
" println!(\"i = {}\", i);\n",
|
|
"}"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"* if we don't need the value of the variable `i` in the loop, we can replace it with an `_` (underscore):"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 55,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Do it again!\n",
|
|
"Do it again!\n",
|
|
"Do it again!\n",
|
|
"Do it again!\n",
|
|
"Do it again!\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 55,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"for _ in 0..5 { println!(\"Do it again!\"); } "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"* iteration in reverse using `(a..b).rev()`"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 7,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"i: 10\n",
|
|
"i: 9\n",
|
|
"i: 8\n",
|
|
"i: 7\n",
|
|
"i: 6\n",
|
|
"i: 5\n",
|
|
"i: 4\n",
|
|
"i: 3\n",
|
|
"i: 2\n",
|
|
"i: 1\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 7,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"for i in (1..=10).rev() {\n",
|
|
" println!(\"i: {}\", i);\n",
|
|
"}"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Looping through the collection with `for`"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 4,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"item: 1\n",
|
|
"item: 64\n",
|
|
"item: 42\n",
|
|
"item: 665\n",
|
|
"item: -123\n",
|
|
"item: -2\n",
|
|
"item: 6\n",
|
|
"item: 0\n",
|
|
"item: 57\n",
|
|
"item: -1\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 4,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"let data: [i32; 10] = [1, 64, 42, 665, -123, -2, 6, 0, 57, -1];\n",
|
|
"\n",
|
|
"for item in data {\n",
|
|
" println!(\"item: {}\", item);\n",
|
|
"}"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Example"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 11,
|
|
"metadata": {
|
|
"vscode": {
|
|
"languageId": "rust"
|
|
}
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"2 is prime!\n",
|
|
"3 is prime!\n",
|
|
"5 is prime!\n",
|
|
"7 is prime!\n",
|
|
"11 is prime!\n",
|
|
"13 is prime!\n",
|
|
"17 is prime!\n",
|
|
"19 is prime!\n",
|
|
"23 is prime!\n",
|
|
"29 is prime!\n",
|
|
"31 is prime!\n",
|
|
"37 is prime!\n",
|
|
"41 is prime!\n",
|
|
"43 is prime!\n",
|
|
"47 is prime!\n",
|
|
"53 is prime!\n",
|
|
"59 is prime!\n",
|
|
"61 is prime!\n",
|
|
"67 is prime!\n",
|
|
"71 is prime!\n",
|
|
"73 is prime!\n",
|
|
"79 is prime!\n",
|
|
"83 is prime!\n",
|
|
"89 is prime!\n",
|
|
"97 is prime!\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"()"
|
|
]
|
|
},
|
|
"execution_count": 11,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"let max_prime = 100;\n",
|
|
"\n",
|
|
"for n in 2..=max_prime {\n",
|
|
" let mut is_prime = true;\n",
|
|
" for d in 2..=((n as f64).sqrt() as i32) {\n",
|
|
" if n % d == 0 {\n",
|
|
" is_prime = false;\n",
|
|
" break;\n",
|
|
" }\n",
|
|
" }\n",
|
|
"\n",
|
|
" if is_prime {\n",
|
|
" println!(\"{} is prime!\", n);\n",
|
|
" }\n",
|
|
"}"
|
|
]
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Rust",
|
|
"language": "rust",
|
|
"name": "rust"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": "rust",
|
|
"file_extension": ".rs",
|
|
"mimetype": "text/rust",
|
|
"name": "Rust",
|
|
"pygment_lexer": "rust",
|
|
"version": ""
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 2
|
|
}
|