+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/00-organizational/index.html b/lessons/00-organizational/index.html
new file mode 100644
index 0000000..1f599d4
--- /dev/null
+++ b/lessons/00-organizational/index.html
@@ -0,0 +1,257 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ JNP 2: Rust
+This is a website for the JNP2: Rust course at MIM UW.
+The course's instructor is Wojciech Przytuła (GitHub: wprzytula, e-mail: wp418383[at]students[dot]mimuw[dot]edu[dot]pl),
Instructori emeriti:
+-
+
- Piotr Wojtczak (GitHub: StarostaGit, e-mail:
pw394980[at]students[dot]mimuw[dot]edu[dot]pl),
+ - Andrzej Głuszak (GitHub: agluszak, e-mail:
agluszak[at]mimuw[dot]edu[dot]pl).
+
You can find lesson scenarios here.
+ + + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/01-introduction/a_taste_of_rust-introductory_slides/A_taste_of_Rust.html b/lessons/01-introduction/a_taste_of_rust-introductory_slides/A_taste_of_Rust.html
new file mode 100644
index 0000000..10f5407
--- /dev/null
+++ b/lessons/01-introduction/a_taste_of_rust-introductory_slides/A_taste_of_Rust.html
@@ -0,0 +1,4780 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Organizational lesson
++ 2024-10-03 (last edit: 2024-10-06) +
+Rust course
+We will be using Github Classroom for task submission and Discord for discussions.
+Our main learning/teaching resource will be "The Book".
+Also worth mentioning: "Rust by Example".
+Grading
+-
+
- 1/3 of the grade is based on small tasks. There will be approximately 1 task every two weeks and each task will be graded on a scale of 0 to 3. +
- 2/3 of the grade is based on a big project. You can choose a topic yourself, but it must be accepted by me. The project has to be split into two parts. It can be done in groups of two (or bigger, if ambitious enough). +
- The grade may be increased by a bonus. You can get a bonus for:
+
-
+
- Making a presentation about some advanced topic (const generics, futures, macros, etc.) or about architecture of a selected Rust open-source library +
- Contributing to a selected Rust open-source library +
- Contributing to this course's materials +
- Quizzes, homeworks, general activity etc. +
+
Project Deadlines
+-
+
- 2024-11-7: Project ideas should be presented to me for further refining. If you wish to pair up with someone, now is the time to tell me. +
- 2024-11-14: Final project ideas should be accepted by now. +
- 2024-12-12: Deadline for submitting the first part of the project. +
- 2025-01-09: Deadline for submitting the second and final part of the project. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/lessons/01-introduction/a_taste_of_rust-introductory_slides/A_taste_of_Rust.pdf b/lessons/01-introduction/a_taste_of_rust-introductory_slides/A_taste_of_Rust.pdf
new file mode 100644
index 0000000..c3b3167
Binary files /dev/null and b/lessons/01-introduction/a_taste_of_rust-introductory_slides/A_taste_of_Rust.pdf differ
diff --git a/lessons/01-introduction/clippy.jpg b/lessons/01-introduction/clippy.jpg
new file mode 100644
index 0000000..cf490ba
Binary files /dev/null and b/lessons/01-introduction/clippy.jpg differ
diff --git a/lessons/01-introduction/conditionals.rs b/lessons/01-introduction/conditionals.rs
new file mode 100644
index 0000000..441aba6
--- /dev/null
+++ b/lessons/01-introduction/conditionals.rs
@@ -0,0 +1,20 @@
+#![allow(unused_variables)]
+
+fn main() {
+ let x = 42;
+
+ if x == 42 {
+ println!("x is 42");
+ } else if x == 43 {
+ println!("x is 43");
+ } else {
+ println!("x is not 42 or 43");
+ }
+
+ // we can also use ifs as expressions
+ let a_or_b = if x == 0 {
+ "a" // notice no semicolon at the end
+ } else {
+ "b"
+ };
+}
diff --git a/lessons/01-introduction/cpp_meme.jpg b/lessons/01-introduction/cpp_meme.jpg
new file mode 100644
index 0000000..4ec2e17
Binary files /dev/null and b/lessons/01-introduction/cpp_meme.jpg differ
diff --git a/lessons/01-introduction/errors_demo.c b/lessons/01-introduction/errors_demo.c
new file mode 100644
index 0000000..936ac9c
--- /dev/null
+++ b/lessons/01-introduction/errors_demo.c
@@ -0,0 +1,35 @@
+#include
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/01-introduction/loops.rs b/lessons/01-introduction/loops.rs
new file mode 100644
index 0000000..8a02d72
--- /dev/null
+++ b/lessons/01-introduction/loops.rs
@@ -0,0 +1,55 @@
+#![allow(unused_variables)]
+
+fn main() {
+ for i in 0..10 {
+ println!("i is {}", i); // i in [0, 10)
+ }
+
+ let mut x = 0;
+
+ while x < 50 {
+ x += 1;
+ }
+
+ let mut y = 0;
+ let mut iterations = 0;
+ loop {
+ iterations += 1;
+ if iterations % 2 == 0 {
+ continue;
+ }
+ y += 1;
+ if y == 10 {
+ break;
+ }
+ }
+
+ // we can use labels to refer to a specific loop
+ let mut count = 0;
+ 'counting_up: loop {
+ let mut remaining = 10;
+
+ loop {
+ if remaining == 9 {
+ break;
+ }
+ if count == 2 {
+ break 'counting_up; // ends the outer loop
+ }
+ remaining -= 1;
+ }
+
+ count += 1;
+ }
+
+ // We can use break with a value.
+ // Because loops are expressions too,
+ // the value we break with will be returned from the functions
+ let mut counter = 0;
+ let value = loop {
+ counter += 1;
+ if counter == 10 {
+ break 32;
+ }
+ };
+}
diff --git a/lessons/01-introduction/students/gasinska.py b/lessons/01-introduction/students/gasinska.py
new file mode 100644
index 0000000..e4989f1
--- /dev/null
+++ b/lessons/01-introduction/students/gasinska.py
@@ -0,0 +1,107 @@
+# sample 1 - different ways of removing elements from the list while iterating
+list1 = [1, 2, 3, 4]
+for idx, item in enumerate(list1):
+ del item
+list1
+
+# [1, 2, 3, 4]
+
+list2 = [1, 2, 3, 4]
+for idx, item in enumerate(list2):
+ list2.remove(item)
+list2
+
+# [2, 4]
+
+list3 = [1, 2, 3, 4]
+for idx, item in enumerate(list3[:]):
+ list3.remove(item)
+list3
+
+# []
+
+list4 = [1, 2, 3, 4]
+for idx, item in enumerate(list4):
+ list4.pop(idx)
+list4
+
+# [2, 4]
+
+# sample 2 - string interning
+a = "abc"
+b = "abc"
+a is b
+
+# True
+
+a = ''.join(['a', 'b', 'c'])
+b = ''.join(['a', 'b', 'c'])
+a is b
+
+# False
+
+a = "abc!"
+b = "abc!"
+a is b
+
+# False
+
+# sample 3 - chained operations
+(False == False) in [False]
+
+# False
+
+False == (False in [False])
+
+# False
+
+False == False in [False] # unexpected...
+
+# True
+
+# sample 4 - is operator
+a = 256
+b = 256
+a is b
+
+# True
+
+a = 257
+b = 257
+a is b
+
+# False
+
+a, b = 257, 257
+a is b
+
+# True
+
+257 is 257
+
+# <>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# <>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# C:\Users\kgasinsk\AppData\Local\Temp\ipykernel_15776\331119389.py:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# 257 is 257
+
+# sample 5 - local variables
+def f(trufel):
+ if trufel:
+ y = 1
+ y += 1
+
+f(True) # everything is fine
+
+f(False) # gives error: local variable 'y' referenced before assignment
+
+# ---------------------------------------------------------------------------
+# UnboundLocalError Traceback (most recent call last)
+# Input In [17], in
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Introduction to Rust
++ 2024-10-03 (last edit: 2024-09-20) +
+
A language empowering everyone to build reliable and efficient software.
+ +Why use Rust?
+-
+
- It is safe (compared to C++ for example, as we will see in a minute) +
- It is fast (because it is compiled to machine code) +
- It is ergonomic and pleasant to use (static typing, expressive type system, helpful compiler +warnings) +
- It +is loved by programmers +
- It provides excellent tooling +
Why learn Rust?
+Even if you don't end up using Rust, learning it expands your horizons
+-
+
- it helps especially with the awareness of what you can and can't do in concurrent applications +
- it helps you understand memory management and learn its good practices +
Why not to learn Rust?
+-
+
- Some people say Rust is too hard to learn because of the borrow checker +
- Once you get to know Cargo you won't ever want to use a language without a built-in package +manager ;) +
- You will start hating C++ +
Demos
+
Let's compare the same code written in C, C++ +and Rust.
+Code you sent in previous editions!
+Aleksander Tudruj
+#include <iostream>
+#include <unordered_map>
+
+using name = std::string;
+using age = int;
+using person = std::pair<name, age>;
+using address = std::string;
+using address_book = std::unordered_map<person, address>;
+
+void print_address_book(const address_book &book)
+{
+ for (const auto &[person, address] : book)
+ {
+ std::cout << person.first << " is " << person.second << " years old and lives at " << address << std::endl;
+ }
+}
+
+int main()
+{
+
+ address_book people{};
+ people.insert({{"John", 20}, "221B Baker Street, London"});
+ people.insert({{"Mary", 30}, "Avenue des Champs-Élysées, Paris"});
+ people.insert({{"Jack", 73}, "Wall Street, New York"});
+ print_address_book(people);
+
+ return 0;
+}
+
+(Download the source code for this example: tudruj.cpp)
+Krystyna Gasińska
+# sample 1 - different ways of removing elements from the list while iterating
+list1 = [1, 2, 3, 4]
+for idx, item in enumerate(list1):
+ del item
+list1
+
+# [1, 2, 3, 4]
+
+list2 = [1, 2, 3, 4]
+for idx, item in enumerate(list2):
+ list2.remove(item)
+list2
+
+# [2, 4]
+
+list3 = [1, 2, 3, 4]
+for idx, item in enumerate(list3[:]):
+ list3.remove(item)
+list3
+
+# []
+
+list4 = [1, 2, 3, 4]
+for idx, item in enumerate(list4):
+ list4.pop(idx)
+list4
+
+# [2, 4]
+
+# sample 2 - string interning
+a = "abc"
+b = "abc"
+a is b
+
+# True
+
+a = ''.join(['a', 'b', 'c'])
+b = ''.join(['a', 'b', 'c'])
+a is b
+
+# False
+
+a = "abc!"
+b = "abc!"
+a is b
+
+# False
+
+# sample 3 - chained operations
+(False == False) in [False]
+
+# False
+
+False == (False in [False])
+
+# False
+
+False == False in [False] # unexpected...
+
+# True
+
+# sample 4 - is operator
+a = 256
+b = 256
+a is b
+
+# True
+
+a = 257
+b = 257
+a is b
+
+# False
+
+a, b = 257, 257
+a is b
+
+# True
+
+257 is 257
+
+# <>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# <>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# C:\Users\kgasinsk\AppData\Local\Temp\ipykernel_15776\331119389.py:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# 257 is 257
+
+# sample 5 - local variables
+def f(trufel):
+ if trufel:
+ y = 1
+ y += 1
+
+f(True) # everything is fine
+
+f(False) # gives error: local variable 'y' referenced before assignment
+
+# ---------------------------------------------------------------------------
+# UnboundLocalError Traceback (most recent call last)
+# Input In [17], in <cell line: 1>()
+# ----> 1 f(False)
+
+# Input In [15], in f(trufel)
+# 3 if trufel:
+# 4 y = 1
+# ----> 5 y += 1
+
+# UnboundLocalError: local variable 'y' referenced before assignment
+(Download the source code for this example: gasinska.py)
+Antoni Koszowski
+// mutowalność jest wbudowana w język
+
+type S struct {
+ A string
+ B []string
+}
+
+func main() {
+ x := S{"x-A", []string{"x-B"}}
+ y := x // copy the struct
+ y.A = "y-A"
+ y.B[0] = "y-B"
+
+ fmt.Println(x, y)
+ // Outputs "{x-A [y-B]} {y-A [y-B]}" -- x was modified!
+}
+
+// slices i kwestia append
+
+func doStuff(value []string) {
+ fmt.Printf("value=%v\n", value)
+
+ value2 := value[:]
+ value2 = append(value2, "b")
+ fmt.Printf("value=%v, value2=%v\n", value, value2)
+
+ value2[0] = "z"
+ fmt.Printf("value=%v, value2=%v\n", value, value2)
+}
+
+func main() {
+ slice1 := []string{"a"} // length 1, capacity 1
+
+ doStuff(slice1)
+ // Output:
+ // value=[a] -- ok
+ // value=[a], value2=[a b] -- ok: value unchanged, value2 updated
+ // value=[a], value2=[z b] -- ok: value unchanged, value2 updated
+
+ slice10 := make([]string, 1, 10) // length 1, capacity 10
+ slice10[0] = "a"
+
+ doStuff(slice10)
+ // Output:
+ // value=[a] -- ok
+ // value=[a], value2=[a b] -- ok: value unchanged, value2 updated
+ // value=[z], value2=[z b] -- WTF?!? value changed???
+}
+
+// error handling
+
+len, err := reader.Read(bytes)
+if err != nil {
+ if err == io.EOF {
+ // All good, end of file
+ } else {
+ return err
+ }
+}
+
+
+// interfejs nil
+
+type Explodes interface {
+ Bang()
+ Boom()
+}
+
+// Type Bomb implements Explodes
+type Bomb struct {}
+func (*Bomb) Bang() {}
+func (Bomb) Boom() {}
+
+func main() {
+ var bomb *Bomb = nil
+ var explodes Explodes = bomb
+ println(bomb, explodes) // '0x0 (0x10a7060,0x0)'
+ if explodes != nil {
+ println("Not nil!") // 'Not nil!' What are we doing here?!?!
+ explodes.Bang() // works fine
+ explodes.Boom() // panic: value method main.Bomb.Boom called using nil *Bomb pointer
+ } else {
+ println("nil!") // why don't we end up here?
+ }
+}
+
+// ubogie struktury danych, takie customowe tracą type safety m.in poprzez castowanie do interface{}
+// kiedyś brak generyków, choć teraz w znacznym stopniu problem został rozwiązany.
+(Download the source code for this example: koszowski.go)
+Mieszko Grodzicki
+def add_contents(input_list, contents=[]):
+ for val in input_list:
+ contents.append(val)
+ return contents
+
+print(add_contents([1])) # [1]
+print(add_contents([2])) # [1, 2]
+(Download the source code for this example: grodzicki.py)
+Installing Rust
+-
+
- Rustup +
- Setup an IDE
+
-
+
- CLion (you can get +it for free) +and RustRover +
- VSCode +and rust-analyzer +
- rust-analyzer also works +with other IDEs +
+
Useful tools
+
-
+
cargo clippy(for static analysis)
+- there's also
cargo check, but it's less powerful than clippy
+ cargo fmt(for code formatting)
+
Rust Playground
+ +Hello world
+fn main() {
+ let name = "World";
+ println!("Hello, {}!", name); // using the println! macro
+}
+
+(Download the source code for this example: hello_world.rs)
+Variables
+#![allow(unused_variables)]
+#![allow(unused_assignments)]
+
+fn main() {
+ let x = 40; // inferred type
+ let y: i32 = 100; // specified type
+
+ {
+ let x = 40 + 2; // shadowing
+ println!("x is {}", x); // prints 42
+ }
+
+ // x = 0; // compilation error, variables are by default immutable
+ let mut x = 40; // declare as mutable
+ x = 0; // now we can reassign
+
+ x += 1; // x = x + 1
+}
+
+(Download the source code for this example: variables.rs)
+Conditionals
+#![allow(unused_variables)]
+
+fn main() {
+ let x = 42;
+
+ if x == 42 {
+ println!("x is 42");
+ } else if x == 43 {
+ println!("x is 43");
+ } else {
+ println!("x is not 42 or 43");
+ }
+
+ // we can also use ifs as expressions
+ let a_or_b = if x == 0 {
+ "a" // notice no semicolon at the end
+ } else {
+ "b"
+ };
+}
+
+(Download the source code for this example: conditionals.rs)
+Loops
+#![allow(unused_variables)]
+
+fn main() {
+ for i in 0..10 {
+ println!("i is {}", i); // i in [0, 10)
+ }
+
+ let mut x = 0;
+
+ while x < 50 {
+ x += 1;
+ }
+
+ let mut y = 0;
+ let mut iterations = 0;
+ loop {
+ iterations += 1;
+ if iterations % 2 == 0 {
+ continue;
+ }
+ y += 1;
+ if y == 10 {
+ break;
+ }
+ }
+
+ // we can use labels to refer to a specific loop
+ let mut count = 0;
+ 'counting_up: loop {
+ let mut remaining = 10;
+
+ loop {
+ if remaining == 9 {
+ break;
+ }
+ if count == 2 {
+ break 'counting_up; // ends the outer loop
+ }
+ remaining -= 1;
+ }
+
+ count += 1;
+ }
+
+ // We can use break with a value.
+ // Because loops are expressions too,
+ // the value we break with will be returned from the functions
+ let mut counter = 0;
+ let value = loop {
+ counter += 1;
+ if counter == 10 {
+ break 32;
+ }
+ };
+}
+
+(Download the source code for this example: loops.rs)
+Functions
+fn get_5() -> u32 {
+ 5 // we could also write "return 5;"
+}
+
+fn print_sum(a: u32, b: u32) {
+ println!("a + b = {}", a + b);
+}
+
+fn main() {
+ let a = 100;
+ print_sum(a, get_5());
+}
+
+(Download the source code for this example: functions.rs)
+Test assignment (not graded)
+Click here
+Obligatory reading
+ +Additional reading
+ + + +
+
+
+
+
+
+
+
+
+
+
+
diff --git a/lessons/02-ownership/aliasing-xor-mutability/Cargo.toml b/lessons/02-ownership/aliasing-xor-mutability/Cargo.toml
new file mode 100644
index 0000000..c4044ef
--- /dev/null
+++ b/lessons/02-ownership/aliasing-xor-mutability/Cargo.toml
@@ -0,0 +1,4 @@
+[package]
+name = "aliasing_xor_mutability"
+version = "0.1.0"
+edition = "2021"
diff --git a/lessons/02-ownership/aliasing-xor-mutability/src/main.rs b/lessons/02-ownership/aliasing-xor-mutability/src/main.rs
new file mode 100644
index 0000000..d6fed8b
--- /dev/null
+++ b/lessons/02-ownership/aliasing-xor-mutability/src/main.rs
@@ -0,0 +1,39 @@
+fn next_int() -> i32 {
+ 42
+}
+
+struct Data(i32);
+impl Data {
+ fn new() -> Self {
+ Self(0)
+ }
+
+ fn read(&self) -> i32 { self.0 }
+
+ fn write(&mut self, n: i32) { self.0 = n }
+}
+
+fn thread1(shared_data: &mut Data) {
+ loop {
+ shared_data.write(next_int());
+ }
+}
+
+fn thread2(shared_data: &Data) {
+ loop {
+ println!("{}", shared_data.read());
+ }
+}
+
+fn main() {
+ let mut shared_data = Data::new();
+
+ std::thread::scope(|s| {
+ let t1 = s.spawn(|| {
+ thread1(&mut shared_data);
+ });
+ let t2 = s.spawn(|| {
+ thread2(&shared_data);
+ });
+ });
+}
\ No newline at end of file
diff --git a/lessons/02-ownership/dont_panic/dont_panic.html b/lessons/02-ownership/dont_panic/dont_panic.html
new file mode 100644
index 0000000..3963ba2
--- /dev/null
+++ b/lessons/02-ownership/dont_panic/dont_panic.html
@@ -0,0 +1,3903 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
+
+
+
diff --git a/lessons/02-ownership/dont_panic/dont_panic.pdf b/lessons/02-ownership/dont_panic/dont_panic.pdf
new file mode 100644
index 0000000..0928151
Binary files /dev/null and b/lessons/02-ownership/dont_panic/dont_panic.pdf differ
diff --git a/lessons/02-ownership/index.html b/lessons/02-ownership/index.html
new file mode 100644
index 0000000..70b5b34
--- /dev/null
+++ b/lessons/02-ownership/index.html
@@ -0,0 +1,515 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/02-ownership/string_formatting/string_formatting.html b/lessons/02-ownership/string_formatting/string_formatting.html
new file mode 100644
index 0000000..d891819
--- /dev/null
+++ b/lessons/02-ownership/string_formatting/string_formatting.html
@@ -0,0 +1,3842 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ownership Model
++ 2024-10-10 (last edit: 2024-10-08) +
+Why all the fuss?
+Even if you've never seen Rust code before, chances are you still heard the term borrow checker or something about Rust's ownership. Indeed, Rust's ownership model lies at the very core of its uniqueness. But to fully understand it and appreciate it, let's first take a look at how memory management is handled in most popular languages.
+-
+
-
+
Garbage Collection - in many high-level programming languages, like Java, Haskell or Python, memory management is done fully by the language, relieving the programmer from this burden. This prevents memory leaks and memory related errors (like use after free), but does come at a cost - there is a runtime overhead, both memory and performance wise, caused by the constantly running garbage collection algorithms and the programmer usually has very little control over when the garbage collection takes place. Also, garbage collection does not prevent concurrency-related errors, such as data races, in any way.
+
+ -
+
Mind your own memory - in low-level languages and specific ones like C++, performance comes first so we cannot really afford to run expansive bookkeeping and cleaning algorithms. Most of these languages compile directly to machine code and have no language-specific runtime environment. That means that the only place where memory management can happen is in the produced code. While compilers insert these construction and destruction calls for stack allocated memory, it generally requires a lot of discipline from the programmer to adhere to good practices and patterns to avoid as many memory related issues as possible and one such bug can be quite deadly to the program and a nightmare to find and fix. These languages basically live by the "your memory, your problem" mantra.
+
+
And then we have Rust. Rust is a systems programming language and in many ways it's akin to C++ - it's basically low-level with many high-level additions. But unlike C++, it doesn't exactly fall into either of the categories described above, though it's way closer to the second one. It performs no additional management at runtime, but instead imposes a set of rules on the code, making it easier to reason about and thus check for its safety and correctness at compile time - these rules make up Rust's ownership model.
+In a way, programming in Rust is like pair-programming with a patient and very experienced partner. Rust's compiler will make sure you follow all the good patterns and practices (by having them ingrained in the language itself) and very often even tell you how to fix the issues it finds.
+Disclaimer: when delving deeper into Rust below we will make heavy use of concepts like scopes, moving data, stack and heap, which should have been introduced as part of the C++ course. If you need a refresher of any of these, it's best to do so now, before reading further.
+Start with the basics - ownership
+In the paragraph above we mentioned a set of rules that comprise Rust's ownership model. The book starts off with the following three as its very foundation:
+-
+
-
+
Each value in Rust is tied to a specific variable - we call that variable its owner.
+
+ -
+
There can only be one owner at a time.
+
+ -
+
When the owner goes out of scope, the value will be destroyed (or in Rust terms - dropped).
+
+
The third point might make you think about C++ and its automatic storage duration. We will later see that, while very similar at first, Rust expands on these mechanics quite a bit. The following code illustrates the basic version of this:
+{
+ let a: i32 = 5; // allocation on the stack, 'a' becomes an owner
+
+ // do some stuff with 'a'
+
+} // 'a', the owner, goes out of scope and the value is dropped
+So far, so good. Variables are pushed onto the stack when they enter the scope and destroyed during stack unwinding that happens upon leaving their scope. However, allocating and deallocating simple integers doesn't impress anybody. Let's try something more complex:
+{
+ let s = String::from("a string"); // 's' is allocated on the stack, while its contents ("a string")
+ // are allocated on the heap. 's' is the owner of this String object.
+
+ // do some stuff with 's'
+
+} // 's', the owner, goes out of scope and the String is dropped, its heap allocated memory freed
+If you recall the RAII (Resource Acquisition Is Initialization) pattern from C++, the above is basically the same thing. We go two for two now in the similarity department, so... is Rust really any different then? There is a part of these examples that we skipped over - actually doing something with the values.
+Moving around is fun
+Let's expand on the last example. The scoping is not really important for that one, so we don't include it here.
+let s = String::from("a string"); // same thing, 's' is now an owner
+
+let s2 = s; // easy, 's2' becomes another owner... right?
+
+println!("And the contents are: {}", s); // this doesn't work, can you guess why?
+At first glance everything looks great. If we write this code (well, an equivalent of it) in basically any other popular language, it will compile no issue - but it does not here and there's a good reason why.
+To understand what's happening, we have to consult the rules again, rule 2 in particular. It says that there can only be one owner of any value at a given time. So, s and s2 cannot own the same object. Okay, makes sense, but what is happening in this line then - let s2 = s;? Experience probably tells you that s just gets copied into s2, creating a new String object. That would result in each variable owning its very own instance of the string and each instance having exactly one owner. Sounds like everyone should be happy now, but wait - in that case the last line should work no issue, right? But it doesn't, so can't be a copy. Let's see now what the compiler actually has to say:
error[E0382]: borrow of moved value: `s`
+ --> src/main.rs:6:42
+ |
+2 | let s = String::from("a string");
+ | - move occurs because `s` has type `String`, which does not implement the `Copy` trait
+3 |
+4 | let s2 = s;
+ | - value moved here
+5 |
+6 | println!("And the contents are: {}", s);
+ | ^ value borrowed here after move
+"value moved here" - gotcha! So s is being moved to s2, which also means that s2 now becomes the new owner of the string being moved and s cannot be used anymore. In Rust, the default method of passing values around is by move, not by copy. While it may sound a bit odd at first, it actually has some very interesting implications. But before we get to them, let's fix our code, so it compiles now. To do so, we have to explicitly tell Rust to make a copy by invoking the clone method:
let s = String::from("a string"); // 's' is an owner
+
+let s2 = s.clone(); // 's2' now contains its own copy
+
+println!("And the contents are: {}", s); // success!
+The compiler is happy now and so are we. The implicit move takes some getting used to, but the compiler is here to help us. Now, let's put the good, old C++ on the table again and compare the two lines:
+
+
+let s2 = s; is equivalent to auto s2 = std::move(s);
let s2 = s.clone() is equivalent to auto s2 = s
There are a few important things to note here:
+-
+
-
+
Making a copy is oftentimes not cheap. Memory needs to be allocated and copied, and a call to the system has to be made. We should prefer to move things as much as possible to avoid this cost - in C++ we have a myriad of language features like
+std::moveand r-references to achieve this. Every programmer worth their salt needs to be well versed in all of them to write efficient C++ code and simply forgetting one move can lead to significant performance loss (and this happens to even the most senior devs ever existing, let's not pretend). On the contrary, in Rust you need to make an effort to make a copy and that makes you very aware of the cost you're paying - something that we'll see quite a lot of in the language. Also, if you forget a clone there's no harm done - it just won't compile!
+ -
+
Hidden in all of this is another nice thing Rust gives us. In C++, nothing prevents you from using variables after they've been moved from, leading to unexpected errors in a more complex code. In Rust, that variable (in our case
+s) simply becomes invalid and the compiler gives us a nice error about it.
+
But what about ints?
+A good question to ask. Copying primitives is cheap. And it's not convenient for the programmer to have to always write .clone() after every primitive. If we take a look at the error from the previous example:
move occurs because `s` has type `String`, which does not implement the `Copy` trait`
+It says that s was moved because the String type doesn't have the Copy trait. We will talk about traits more in depth in the future lessons, but what this basically means is that String is not specified to be copied by default. All primitive types (i32, bool, f64, char, etc.) and tuples consisting only of primitive types implement the Copy trait.
Exercise
+How to fix that code?
+fn count_animals(num: u32, animal: String) {
+ println!("{} {} ...", num, animal);
+}
+
+fn main() {
+ let s = String::from("sheep");
+
+ count_animals(1, s);
+ count_animals(2, s);
+ count_animals(3, s);
+}
+Let's borrow some books
+We now know how to move things around and how to clone them if moving is not possible. But what if making a copy is unnecessary - maybe we just want to let someone look at our resource and keep on holding onto it once they're done. Consider the following example:
+fn read_book(book: String) {
+ println!("[Reading] {}", book);
+}
+
+fn main() {
+ let book = String::from("Merry lived in a big old house. The end.");
+
+ read_book(book.clone());
+
+ println!("Book is still there: {}", book);
+}
+Cloning is pretty excessive here. Imagine recommending a book to your friend and instead of lending it to them for the weekend, you scan it and print an exact copy. Not the best way to go about it, is it? Thankfully, Rust allows us to access a resource without becoming an owner through the use of references and the & operator. This is called a borrow.
The adjusted code should look like this:
+fn read_book(book: &String) {
+ println!("[Reading] {}", book);
+}
+
+fn main() {
+ let book = String::from("Merry lived in a big old house. The end.");
+
+ read_book(&book);
+
+ println!("Book is still there: {}", book);
+}
+As with everything, references are too, by default, immutable, which means that the read_book function is not able to modify that book passed into it. We can also borrow something mutably by specifying it both in the receiving function signature and the place it gets called. Maybe you want to have your book signed by its author?
fn sign_book(book: &mut String) {
+ book.push_str(" ~ Arthur Author");
+}
+
+fn main() {
+ // note that the book has to be marked as mutable in the first place
+ let mut book = String::from("Merry lived in a big old house. The end.");
+
+ sign_book(&mut book); // it's always clear when a parameter might get modified
+
+ println!("{}", book); // book is now signed
+}
+Pretty neat, but doesn't seem that safe right now. Let's try to surprise our friend:
+fn erase_book(book: &mut String) {
+ book.clear();
+}
+
+fn read_book(book: &String) {
+ println!("[Reading] {}", book);
+}
+
+fn main() {
+ let mut book = String::from("Merry lived in a big old house. The end.");
+
+ let r = &book; // an immutable borrow
+
+ erase_book(&mut book); // a mutable borrow
+
+ read_book(r); // would be pretty sad to open a blank book when it was not
+ // what we borrowed initially
+
+ println!("{}", book);
+}
+Fortunately for us (and our poor friend just wanting to read), the compiler steps in and doesn't let us do that, printing the following message:
+error[E0502]: cannot borrow `book` as mutable because it is also borrowed as immutable
+ --> src/main.rs:14:14
+ |
+12 | let r = &book; // an immutable borrow
+ | ----- immutable borrow occurs here
+13 |
+14 | erase_book(&mut book); // a mutable borrow
+ | ^^^^^^^^^ mutable borrow occurs here
+15 |
+16 | read_book(r); // would be pretty sad to open a blank book when it was not
+ | - immutable borrow later used here
+This is where the famous borrow checker comes in. To keep things super safe, Rust clearly states what can and cannot be done with references and tracks their lifetimes. Exactly one of the following is always true for references to a given resource:
+-
+
-
+
There exists only one mutable reference and no immutable references, or
+
+ -
+
There is any number of immutable references and no mutable ones.
+
+
You may notice a parallel to the readers - writers problem from concurrent programming. In fact, the way Rust's borrow checker is designed lends itself incredibly well to preventing data race related issues.
+Dangling references
+Rust also checks for dangling references. If we try to compile the following code:
+fn main() {
+ let reference_to_nothing = dangle();
+}
+
+fn dangle() -> &String {
+ let s = String::from("hello");
+
+ &s
+}
+we will get an adequate error:
+error[E0106]: missing lifetime specifier
+ --> src/main.rs:5:16
+ |
+5 | fn dangle() -> &String {
+ | ^ expected named lifetime parameter
+ |
+ = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
+help: consider using the `'static` lifetime
+ |
+5 | fn dangle() -> &'static String {
+ | ^^^^^^^^
+The message above suggests specifing a lifetime for the returned string. In Rust, the lifetime of each variable is also a part of its type, but we will talk more about it later.
+Exercise
+Our previous solution using clone() was pretty inefficient. How should this code look now?
fn count_animals(num: u32, animal: String) {
+ println!("{} {} ...", num, animal);
+}
+
+fn main() {
+ let s = String::from("sheep");
+
+ count_animals(1, s.clone());
+ count_animals(2, s.clone());
+ count_animals(3, s); // we could've ommitted the clone() here. Why?
+}
+Everyone gets a slice
+The last part of working with references that we will cover in this lesson are slices. A slice in Rust is a view over continuous data. Let us start with a string slice - the &str type.
Note: for the purposes of these examples we assume we are working with ASCII strings. More comprehensive articles on handling strings are linked at the end of this lesson.
+To create a string slice from the String object s, we can simply write:
let slice = &s[1..3]; // creates a slice of length 2, starting with the character at index 1
+This makes use of the & operator and Rust's range notation to specify the beginning and end of the slice. Thus, we can also write:
let slice = &s[2..]; // everything from index 2 till the end
+let slice = &s[..1]; // only the first byte
+let slice = &s[..]; // the whole string as a slice
+let slice = s.as_str(); // also the whole string
+You might have noticed that we always built String values using the from() method and never actually used the string literals directly. What type is a string literal then? Turns out it's the new string slice we just learned about!
let slice: &str = "string literal";
+In fact, it makes a lot sense - string literals, after all, are not allocated on the heap, but rather placed in a special section of the resulting binary. It's only natural we just reference that place with a slice.
+Slices can also be taken from arrays:
+let array: [i32; 4] = [42, 10, 5, 2]; // creates an array of four 32 bit integers
+let slice: &[i32] = &array[1..3]; // results in a slice [10, 5]
+Exercise
+Can this code still be improved from the previous version utilizing references? Think about the signature of count_animals.
fn count_animals(num: u32, animal: &String) {
+ println!("{} {} ...", num, animal);
+}
+
+fn main() {
+ let s = String::from("sheep");
+
+ count_animals(1, &s);
+ count_animals(2, &s);
+ count_animals(3, &s);
+}
+Further reading
+-
+
- + + +
- + + +
- + + +
Assignment 1 (graded)
+ +Deadline: 16.10.2024 23:59
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/lessons/02-ownership/string_formatting/string_formatting.pdf b/lessons/02-ownership/string_formatting/string_formatting.pdf
new file mode 100644
index 0000000..23ab234
Binary files /dev/null and b/lessons/02-ownership/string_formatting/string_formatting.pdf differ
diff --git a/lessons/02_ownership/dont_panic/dont-panic/index.html b/lessons/02_ownership/dont_panic/dont-panic/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/02_ownership/dont_panic/dont-panic/index.html
@@ -0,0 +1,43 @@
+
+
+
+
+
+
+
+
diff --git a/lessons/02_ownership/string_formatting/string-formatting/index.html b/lessons/02_ownership/string_formatting/string-formatting/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/02_ownership/string_formatting/string-formatting/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/03-data-types/data_types.rs b/lessons/03-data-types/data_types.rs
new file mode 100644
index 0000000..181acea
--- /dev/null
+++ b/lessons/03-data-types/data_types.rs
@@ -0,0 +1,88 @@
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct Position(i32, i32); // tuple struct
+
+// Could Hero derive the Copy trait?
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct Hero {
+ name: String,
+ level: u32,
+ experience: u32,
+ position: Position,
+}
+
+// we can add methods to structs using the 'impl' keyword
+impl Hero {
+ // static method (in Rust nomenclature: "associated function")
+ fn new(name: String) -> Hero {
+ Hero {
+ name,
+ level: 1,
+ experience: 0,
+ position: Position(0, 0),
+ }
+ }
+}
+
+// multiple impl blocks are possible for one struct
+impl Hero {
+ // instance method, first argument (self) is the calling instance
+ fn distance(&self, pos: Position) -> u32 {
+ // shorthand to: `self: &Self`
+ // field `i` of a tuple or a tuple struct can be accessed through 'tuple.i'
+ (pos.0 - self.position.0).unsigned_abs() + (pos.1 - self.position.1).unsigned_abs()
+ }
+
+ // mutable borrow of self allows to change instance fields
+ fn level_up(&mut self) {
+ // shorthand to: `self: &mut Self`
+ self.experience = 0;
+ self.level += 1;
+ }
+
+ // 'self' is not borrowed here and will be moved into the method
+ fn die(self) {
+ // shorthand to: `self: Self`
+ println!(
+ "Here lies {}, a hero who reached level {}. RIP.",
+ self.name, self.level
+ );
+ }
+}
+
+fn main() {
+ // Calling associated functions requires scope (`::`) operator.
+ let mut hero: Hero = Hero::new(String::from("Ferris"));
+ hero.level_up(); // 'self' is always passed implicitly
+
+ // fields other than 'name' will be the same as in 'hero'
+ let steve = Hero {
+ name: String::from("Steve The Normal Guy"),
+ ..hero
+ };
+
+ assert_eq!(hero.level, steve.level);
+
+ let mut twin = hero.clone();
+
+ // we can compare Hero objects because it derives the PartialEq trait
+ assert_eq!(hero, twin);
+ twin.level_up();
+ assert_ne!(hero, twin);
+ hero.level_up();
+ assert_eq!(hero, twin);
+
+ // we can print out a the struct's debug string with '{:?}'
+ println!("print to stdout: {:?}", hero);
+
+ hero.die(); // 'hero' is not usable after this invocation, see the method's definiton
+
+ // the dbg! macro prints debug strings to stderr along with file and line number
+ // dbg! takes its arguments by value, so better borrow them not to have them
+ // moved into dbg! and consumed.
+ dbg!("print to stderr: {}", &twin);
+
+ let pos = Position(42, 0);
+ let dist = steve.distance(pos); // no clone here as Position derives the Copy trait
+ println!("{:?}", pos);
+ assert_eq!(dist, 42);
+}
diff --git a/lessons/03-data-types/enums.c b/lessons/03-data-types/enums.c
new file mode 100644
index 0000000..0b20f64
--- /dev/null
+++ b/lessons/03-data-types/enums.c
@@ -0,0 +1,35 @@
+#include Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/03-data-types/module_system/module_system.html b/lessons/03-data-types/module_system/module_system.html
new file mode 100644
index 0000000..104212c
--- /dev/null
+++ b/lessons/03-data-types/module_system/module_system.html
@@ -0,0 +1,253 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Data Types
++ 2024-10-17 (last edit: 2024-10-17) +
+Aggregating data
+Below is a compact overview of Rust's structs
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct Position(i32, i32); // tuple struct
+
+// Could Hero derive the Copy trait?
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct Hero {
+ name: String,
+ level: u32,
+ experience: u32,
+ position: Position,
+}
+
+// we can add methods to structs using the 'impl' keyword
+impl Hero {
+ // static method (in Rust nomenclature: "associated function")
+ fn new(name: String) -> Hero {
+ Hero {
+ name,
+ level: 1,
+ experience: 0,
+ position: Position(0, 0),
+ }
+ }
+}
+
+// multiple impl blocks are possible for one struct
+impl Hero {
+ // instance method, first argument (self) is the calling instance
+ fn distance(&self, pos: Position) -> u32 {
+ // shorthand to: `self: &Self`
+ // field `i` of a tuple or a tuple struct can be accessed through 'tuple.i'
+ (pos.0 - self.position.0).unsigned_abs() + (pos.1 - self.position.1).unsigned_abs()
+ }
+
+ // mutable borrow of self allows to change instance fields
+ fn level_up(&mut self) {
+ // shorthand to: `self: &mut Self`
+ self.experience = 0;
+ self.level += 1;
+ }
+
+ // 'self' is not borrowed here and will be moved into the method
+ fn die(self) {
+ // shorthand to: `self: Self`
+ println!(
+ "Here lies {}, a hero who reached level {}. RIP.",
+ self.name, self.level
+ );
+ }
+}
+
+fn main() {
+ // Calling associated functions requires scope (`::`) operator.
+ let mut hero: Hero = Hero::new(String::from("Ferris"));
+ hero.level_up(); // 'self' is always passed implicitly
+
+ // fields other than 'name' will be the same as in 'hero'
+ let steve = Hero {
+ name: String::from("Steve The Normal Guy"),
+ ..hero
+ };
+
+ assert_eq!(hero.level, steve.level);
+
+ let mut twin = hero.clone();
+
+ // we can compare Hero objects because it derives the PartialEq trait
+ assert_eq!(hero, twin);
+ twin.level_up();
+ assert_ne!(hero, twin);
+ hero.level_up();
+ assert_eq!(hero, twin);
+
+ // we can print out a the struct's debug string with '{:?}'
+ println!("print to stdout: {:?}", hero);
+
+ hero.die(); // 'hero' is not usable after this invocation, see the method's definiton
+
+ // the dbg! macro prints debug strings to stderr along with file and line number
+ // dbg! takes its arguments by value, so better borrow them not to have them
+ // moved into dbg! and consumed.
+ dbg!("print to stderr: {}", &twin);
+
+ let pos = Position(42, 0);
+ let dist = steve.distance(pos); // no clone here as Position derives the Copy trait
+ println!("{:?}", pos);
+ assert_eq!(dist, 42);
+}
+
+(Download the source code for this example: data_types.rs)
+Enums
+It is often the case that we want to define a variable that can only take
+a certain set of values and the values are known up front. In C you can use an enum for this.
#include <stdio.h>
+
+enum shirt_size {
+ small,
+ medium,
+ large,
+ xlarge
+};
+
+void print_size(enum shirt_size size) {
+ printf("my size is ");
+ switch (size) {
+ case small:
+ printf("small");
+ break;
+ case medium:
+ printf("medium");
+ break;
+ case large:
+ printf("large");
+ break;
+ case xlarge:
+ printf("xlarge");
+ break;
+ default:
+ printf("unknown");
+ break;
+ }
+ printf("\n");
+}
+
+int main() {
+ enum shirt_size my_size = medium;
+ print_size(my_size);
+}
+
+(Download the source code for this example: enums.c)
+However, in C enums are just integers. Nothing prevents us from writing
+int main() {
+ enum shirt_size my_size = 666;
+ print_size(my_size);
+}
+C++ introduces enum classes which are type-safe. Legacy enums are also somewhat safer than in C (same code as above):
+<source>:27:31: error: invalid conversion from 'int' to 'shirt_size' [-fpermissive]
+ 27 | enum shirt_size my_size = 666;
+ | ^~~
+ | |
+ | int
+Some programming languages (especially functional ones) allow programmers to define
+enums which carry additional information. Such types are usually called tagged unions
+or algebraic data types.
In C++ we can use union with an enum tag to define it:
#include <iostream>
+
+// Taken from: https://en.cppreference.com/w/cpp/language/union
+
+// S has one non-static data member (tag), three enumerator members (CHAR, INT, DOUBLE),
+// and three variant members (c, i, d)
+struct S
+{
+ enum{CHAR, INT, DOUBLE} tag;
+ union
+ {
+ char c;
+ int i;
+ double d;
+ };
+};
+
+void print_s(const S& s)
+{
+ switch(s.tag)
+ {
+ case S::CHAR: std::cout << s.c << '\n'; break;
+ case S::INT: std::cout << s.i << '\n'; break;
+ case S::DOUBLE: std::cout << s.d << '\n'; break;
+ }
+}
+
+int main()
+{
+ S s = {S::CHAR, 'a'};
+ print_s(s);
+ s.tag = S::INT;
+ s.i = 123;
+ print_s(s);
+}
+
+(Download the source code for this example: tagged_union.cpp)
+C++17 introduced a new feature called variant which generalizes this concept.
+You can read more about it here.
Java has a more or less analogous feature called sealed classes
+since version 17.
Enums in Rust
+Let's see how they are defined in Rust.
+#![allow(unused_assignments)]
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+#[derive(Debug)]
+enum NamedSize {
+ Small,
+ Medium,
+ Large,
+ XL,
+}
+
+#[derive(Debug)]
+enum ShirtSize {
+ Named(NamedSize),
+ Numeric(u32),
+}
+
+fn main() {
+ println!(
+ "Isn't it strange that some clothes' sizes are adjectives like {:?},",
+ ShirtSize::Named(NamedSize::Small)
+ );
+ println!(
+ "but sometimes they are numbers like {:?}?",
+ ShirtSize::Numeric(42)
+ );
+}
+
+(Download the source code for this example: enums.rs)
+In Rust, enums are a core feature of the language.
+You may have heard that one of Rust's defining characteristics is
+the absence of "the billion dollar mistake".
+So what can we do to say that a value is missing if there is no null?
In Rust, we can use the Option type to represent the absence of a value.
Option is defined as:
+enum Option<T> {
+ Some(T),
+ None,
+}
+The <T> part is called the "type parameter" and it causes Option to be generic.
+We won't go deeper into this for now.
The fact that variables which could be null in other languages have a different type in Rust is
+the solution to the billion dollar mistake!
#![allow(unused_assignments)]
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+fn main() {
+ let mut not_null: i32 = 42;
+ not_null = 43;
+ // not_null = None; // this won't compile because it's a different type!
+
+ let mut nullable: Option<i32> = Some(42);
+ nullable = None;
+ nullable = Some(43);
+
+ // such construction is rare, but possible
+ let mut double_nullable: Option<Option<i32>> = Some(Some(42));
+ // assert_ne!(double_nullable, Some(42)); // this won't even compile because it's a different type!
+ double_nullable = None;
+ double_nullable = Some(None);
+
+ // None and Some(None) are different!
+ assert_ne!(double_nullable, None);
+
+ // Now recall that division by 0 *panics*
+ // A panic is an unrecoverable error
+ // It is not an exception!
+ // And in Rust there are no exceptions, so there are no try/catch blocks
+ // Now let's imagine that we want to divide one number by another
+ fn divide(dividend: i32, divisor: i32) -> i32 {
+ dividend / divisor
+ }
+
+ // We get the divisor from the user, so it can be 0
+ // We want to handle this situation gracefully - we don't want to crash the program!
+ // We can do this by using the Option<T> type
+ fn safe_divide(dividend: i32, divisor: i32) -> Option<i32> {
+ if divisor == 0 {
+ None
+ } else {
+ Some(dividend / divisor)
+ }
+ }
+
+ // Fortunately, such a function is already included in the standard library
+ let number: i32 = 42;
+ // We need to specify the type explicitly
+ // because checked_div is implemented for all integer types
+ // and Rust won't know which type we want to use
+ assert_eq!(number.checked_div(2), Some(21));
+ assert_eq!(number.checked_div(0), None);
+
+ // Now let's imagine we search for a value in an array.
+ let numbers = [1, 2, 3, 4, 5];
+ let three = numbers.iter().copied().find(|&x| x == 3);
+ assert_eq!(three, Some(3));
+ let seven = numbers.iter().copied().find(|&x| x == 7);
+ assert_eq!(seven, None);
+ // We won't delve deeper into the details of how iterators work for now,
+ // but the key takeaway is that there are no sentinel or special values like `nullptr` in Rust
+
+ // Usually there are two kinds of methods:
+ // ones that will panic if the argument is incorrect,
+ // numbers[8]; // this will panic!
+ // and `checked` ones that return an Option
+ assert_eq!(numbers.get(8), None);
+
+ // We can use `unwrap` to get the value out of an Option
+ // but we must be absolutely sure that the Option is Some, otherwise we'll get a panic
+ // numbers.get(8).unwrap(); // this will panic!
+ assert_eq!(numbers.get(8).copied().unwrap_or(0), 0); // or we can provide a default value
+
+ // Usually instead of unwrapping we use pattern matching, we'll get to this in a minute
+ // but first let's see what else we can do with an option
+ let number: Option<i32> = Some(42);
+ // We can use `map` to transform the value inside an Option
+ let doubled = number.map(|x| x * 2);
+ assert_eq!(doubled, Some(84));
+ // We can use flatten to reduce one level of nesting
+ let nested = Some(Some(42));
+ assert_eq!(nested.flatten(), Some(42));
+ // We can use `and_then` to chain multiple options
+ // This operation is called `flatmap` in some languages
+ let chained = number
+ .and_then(|x| x.checked_div(0))
+ .and_then(|x| x.checked_div(2));
+ assert_eq!(chained, None);
+
+ // The last two things we'll cover here are `take` and `replace`
+ // They are important when dealing with non-Copy types
+ // `take` will return the value inside an Option and leave a None in its place
+ let mut option: Option<i32> = None;
+ // Again, we need to specify the type
+ // Even though we want to say that there is no value inside the Option,
+ // this absent value must have a concrete type!
+ assert_eq!(option.take(), None);
+ assert_eq!(option, None);
+
+ let mut x = Some(2);
+ let y = x.take();
+ assert_eq!(x, None);
+ assert_eq!(y, Some(2));
+
+ // `replace` can be used to swap the value inside an Option
+ let mut x = Some(2);
+ let old = x.replace(5);
+ assert_eq!(x, Some(5));
+ assert_eq!(old, Some(2));
+
+ let mut x = None;
+ let old = x.replace(3);
+ assert_eq!(x, Some(3));
+ assert_eq!(old, None);
+}
+
+(Download the source code for this example: option.rs)
+Pattern matching
+Pattern matching is a powerful feature of Rust and many functional languages, but it's slowly making +its way into imperative languages like Java and Python as well.
+#![allow(dead_code)]
+#![allow(unused_variables)]
+
+fn main() {
+ // Pattern matching is basically a switch on steroids.
+ let number = rand::random::<i32>();
+ match number % 7 {
+ 0 => println!("{number} is divisible by 7"),
+ 1 => println!("{number} is *almost* divisible by 7"),
+ _ => println!("{number} is not divisible by 7"),
+ }
+
+ #[derive(Debug)]
+ enum Color {
+ Pink,
+ Brown,
+ Lime,
+ }
+
+ let color = Color::Lime;
+ match color {
+ Color::Pink => println!("My favorite color!"),
+ _ => println!("Not my favorite color!"), // _ is a wildcard
+ // Rust will statically check that we covered all cases or included a default case.
+ }
+
+ // We can also use pattern matching to match on multiple values.
+ match (color, number % 7) {
+ (Color::Pink, 0) => println!("My favorite color and number!"),
+ (Color::Pink, _) => println!("My favorite color!"),
+ (_, 0) => println!("My favorite number!"),
+ (_, _) => println!("Not my favorite color or number!"),
+ }
+ // (This is not special syntax, we're just pattern matching tuples.)
+
+ // But we can also *destructure* the value
+ struct Human {
+ age: u8,
+ favorite_color: Color,
+ }
+
+ let john = Human {
+ age: 42,
+ favorite_color: Color::Pink,
+ };
+
+ match &john {
+ Human {
+ age: 42,
+ favorite_color: Color::Pink,
+ } => println!("Okay, that's John!"),
+ Human {
+ favorite_color: Color::Pink,
+ ..
+ } => println!("Not John, but still his favorite color!"),
+ _ => println!("Somebody else?"),
+ }
+
+ // Note two things:
+ // 1. Color is *not* Eq, so we can't use == to compare it, but pattern matching is fine.
+ // 2. We *borrowed* the value, so we can use it after the match.
+
+ println!("John is {} years old and still kicking!", john.age);
+
+ // To save some time, we can use `if let` to match against only one thing
+ // We could also use `while let ... {}` in the same way
+ if let Color::Pink = &john.favorite_color {
+ println!("He's also a man of great taste");
+ }
+
+ // We can match ranges...
+ match john.age {
+ 0..=12 => println!("John is a kid!"),
+ 13..=19 => println!("John is a teenager!"),
+ 20..=29 => println!("John is a young adult!"),
+ 30..=49 => println!("John is an adult!"),
+ 50..=69 => println!("John is mature!"),
+ _ => println!("John is old!"),
+ }
+
+ // We can use match and capture the value at the same time.
+ match john.age {
+ age @ 0..=12 => println!("John is a kid, age {}", age),
+ age @ 13..=19 => println!("John is a teenager, age {}", age),
+ age @ 20..=29 => println!("John is a young adult, age {}", age),
+ age @ 30..=49 => println!("John is an adult, age {}", age),
+ age @ 50..=69 => println!("John is mature, age {}", age),
+ age => println!("John is old, age {}", age),
+ }
+
+ // We can use guards to check for multiple conditions.
+ match john.age {
+ age @ 12..=19 if age % 2 == 1 => println!("John is an *odd* teenager, age {}", age),
+ age if age % 2 == 0 => println!("John is an *even* man, age {}", age),
+ _ => println!("John is normal"),
+ }
+
+ // Finally, let's look at some references now
+ let reference: &i32 = &4;
+
+ match reference {
+ &val => println!("Value under reference is: {}", val),
+ }
+
+ // `ref` can be used to create a reference when destructuring
+ let Human {
+ age,
+ ref favorite_color,
+ } = john;
+ // `john` is still valid, because we borrowed using `ref`
+ if let Color::Pink = &john.favorite_color {
+ println!("John still has his color - {:?}!", favorite_color);
+ }
+
+ let mut john = john;
+
+ // `ref mut` borrows mutably
+ let Human {
+ age,
+ ref mut favorite_color,
+ } = john;
+ // We use `*` to dereference
+ *favorite_color = Color::Brown;
+ println!(
+ "Tastes do change with time and John likes {:?} now.",
+ john.favorite_color
+ );
+}
+
+(Download the source code for this example: pattern_matching.rs)
+Result
+We said there are no exceptions in Rust and panics mean errors which cannot be caught.
+So how do we handle situations which can fail? That's where the Result type comes in.
#![allow(dead_code)]
+#![allow(unused_variables)]
+
+use std::fs::File;
+use std::io;
+use std::io::Read;
+
+// Let's try reading from a file.
+// Obviously this can fail.
+fn first_try() -> io::Result<String> {
+ let file = File::open("/dev/random");
+ match file {
+ Ok(mut file) => {
+ // We got a file!
+ let mut buffer = vec![0; 128];
+ // Matching each result quickly become tedious...
+ match file.read_exact(&mut buffer) {
+ Ok(_) => {
+ let gibberish = String::from_utf8_lossy(&buffer);
+ Ok(gibberish.to_string())
+ }
+ Err(error) => Err(error),
+ }
+ }
+ Err(error) => {
+ Err(error) // This is needed in order to change the type from `io::Result<File>` to `io::Result<()>`
+ }
+ }
+}
+
+// The '?' operator allows us to return early in case of an error
+// (it automatically converts the error type)
+fn second_try(filename: &'static str) -> io::Result<String> {
+ let mut file = File::open(filename)?;
+ let mut buffer = vec![0; 128];
+ file.read_exact(&mut buffer)?;
+ let gibberish = String::from_utf8_lossy(&buffer);
+ Ok(gibberish.to_string())
+}
+
+fn main() {
+ let filenames = [
+ "/dev/random",
+ "/dev/null",
+ "/dev/cpu",
+ "/dev/fuse",
+ "there_certainly_is_no_such_file",
+ ];
+ for filename in filenames {
+ println!("Trying to read from '{}'", filename);
+ match second_try(filename) {
+ Ok(gibberish) => println!("{}", gibberish),
+ Err(error) => println!("Error: {}", error),
+ }
+ }
+}
+
+(Download the source code for this example: result.rs)
+Obligatory reading
+-
+
- The Book, chapters 5, +6, +8 +and 9 +
- Option docs +
- Result docs +
Assignment 2 (graded)
+ +Deadline: 23.10.2024 23:59
+ + +
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/03-data-types/module_system/module_system.pdf b/lessons/03-data-types/module_system/module_system.pdf
new file mode 100644
index 0000000..e58da88
Binary files /dev/null and b/lessons/03-data-types/module_system/module_system.pdf differ
diff --git a/lessons/03-data-types/option.rs b/lessons/03-data-types/option.rs
new file mode 100644
index 0000000..82faef9
--- /dev/null
+++ b/lessons/03-data-types/option.rs
@@ -0,0 +1,112 @@
+#![allow(unused_assignments)]
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+fn main() {
+ let mut not_null: i32 = 42;
+ not_null = 43;
+ // not_null = None; // this won't compile because it's a different type!
+
+ let mut nullable: Option
+
+
+
+
+
diff --git a/lessons/04-feedback-1/index.html b/lessons/04-feedback-1/index.html
new file mode 100644
index 0000000..4f7b607
--- /dev/null
+++ b/lessons/04-feedback-1/index.html
@@ -0,0 +1,301 @@
+
+
+
+
+
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/05-types-reasoning/basic_trait.rs b/lessons/05-types-reasoning/basic_trait.rs
new file mode 100644
index 0000000..1c76202
--- /dev/null
+++ b/lessons/05-types-reasoning/basic_trait.rs
@@ -0,0 +1,38 @@
+#![allow(dead_code)]
+
+trait Summary {
+ fn summarize(&self) -> String;
+}
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Summary for NewsArticle {
+ fn summarize(&self) -> String {
+ format!("{}, by {} ({})", self.headline, self.author, self.location)
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+impl Summary for Tweet {
+ fn summarize(&self) -> String {
+ format!("{}: {}", self.username, self.content)
+ }
+}
+
+fn main() {
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ println!("1 new tweet: {}", tweet.summarize());
+}
diff --git a/lessons/05-types-reasoning/basic_trait_display.rs b/lessons/05-types-reasoning/basic_trait_display.rs
new file mode 100644
index 0000000..07cf611
--- /dev/null
+++ b/lessons/05-types-reasoning/basic_trait_display.rs
@@ -0,0 +1,40 @@
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Display for NewsArticle {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(
+ f,
+ "{}, by {} ({})",
+ self.headline, self.author, self.location
+ )
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+impl Display for Tweet {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{}: {}", self.username, self.content)
+ }
+}
+
+fn main() {
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ println!("1 new tweet: {}", tweet);
+}
diff --git a/lessons/05-types-reasoning/generic_largest.rs b/lessons/05-types-reasoning/generic_largest.rs
new file mode 100644
index 0000000..7aa6a3b
--- /dev/null
+++ b/lessons/05-types-reasoning/generic_largest.rs
@@ -0,0 +1,23 @@
+fn largest
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Feedback #1
++ 2022-10-31 (last edit: 2022-10-31) +
+Feedback
+Unwrapping
+Instead of this:
+if self.favorite_color.is_some() {
+ self.favorite_color.as_mut().unwrap().lighten();
+}
+do this:
+if let Some(ref mut color) = self.favorite_color {
+ color.lighten();
+}
+or
+if let Some(color) = &mut self.favorite_color {
+ color.lighten();
+}
+(unwrapping is a code smell)
+Spot the overflow
+Color::Rgb(r, g, b) => *b > (*r + *g) / 2,
+1/3
+Color::Rgb(r, g, b) => (*b as u16) * 3 > (*r as u16) + (*g as u16) + (*b as u16),
+No need to cast to u16. If b accounts for 1/3 of the sum, it's enough to check that it's bigger than both r and g.
+Format
+Color::Named(ref mut name) => *name = "light ".to_string() + name,
+There's a format! macro for this.
Color::Named(ref mut name) => *name = format!("light {name}"),
+From vs Into vs as
+let tmp1: u32 = <u8 as Into<u32>>::into(*c) * 2;
+This could be written as
+let tmp1: u32 = (*c).into() * 2;
+or even simpler (note the omission of the type annotation):
+let tmp1 = u32::from(*c) * 2;
+However in most cases of numeric conversion you can just use as:
let tmp1 = *c as u32 * 2;
+Saturating addition
+There's a saturating_add method on u8 which does exactly what we wanted.
+But it was fun watching you struggle with it :)
fn lighten(&mut self) {
+ match self {
+ Color::Named(name) => *name = "light ".to_string() + name,
+ Color::Rgb(r, g, b) => {
+ *r = r.saturating_add(10);
+ *g = g.saturating_add(10);
+ *b = b.saturating_add(10);
+ }
+ }
+}
+Exchange
+fn exchange_items(robot1: &mut Robot, robot2: &mut Robot) {
+ mem::swap(&mut robot1.held_item, &mut robot2.held_item);
+}
+Swap is the preferred way to exchange the contents of two variables.
+Regex? Nope
+There's no need to use a regex here. String has a contains method.
If you really want to use a regex,
+you can use the lazy_static crate to avoid recompiling the regex every time you call the function.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/05-types-reasoning/lifetimes_basic.rs b/lessons/05-types-reasoning/lifetimes_basic.rs
new file mode 100644
index 0000000..a4eaa2b
--- /dev/null
+++ b/lessons/05-types-reasoning/lifetimes_basic.rs
@@ -0,0 +1,27 @@
+fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
+ if first.len() > second.len() {
+ first
+ } else {
+ second
+ }
+}
+
+fn main() {
+ let string1 = String::from("long string is long");
+
+ {
+ let string2 = String::from("xyz");
+ let result = longest(string1.as_str(), string2.as_str());
+ println!("The longest string is {}", result);
+ }
+
+ // This doesn't compile - incorrect lifetimes
+ //
+ // let string1 = String::from("long string is long");
+ // let result;
+ // {
+ // let string2 = String::from("xyz");
+ // result = longest(string1.as_str(), string2.as_str());
+ // }
+ // println!("The longest string is {}", result);
+}
diff --git a/lessons/05-types-reasoning/lifetimes_elision.rs b/lessons/05-types-reasoning/lifetimes_elision.rs
new file mode 100644
index 0000000..9633909
--- /dev/null
+++ b/lessons/05-types-reasoning/lifetimes_elision.rs
@@ -0,0 +1,16 @@
+fn first_two(seq: &[u32]) -> &[u32] {
+ if seq.len() < 2 {
+ seq
+ } else {
+ &seq[..2]
+ }
+}
+
+fn main() {
+ let seq = [1, 2, 3, 4];
+
+ println!(
+ "First two elements of the sequence: {:?}",
+ first_two(&seq[..])
+ );
+}
diff --git a/lessons/05-types-reasoning/non_generic.rs b/lessons/05-types-reasoning/non_generic.rs
new file mode 100644
index 0000000..c983e3b
--- /dev/null
+++ b/lessons/05-types-reasoning/non_generic.rs
@@ -0,0 +1,35 @@
+fn largest_i32(list: &[i32]) -> i32 {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn largest_char(list: &[char]) -> char {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn main() {
+ let number_list = vec![34, 50, 25, 100, 65];
+
+ let result = largest_i32(&number_list);
+ println!("The largest number is {}", result);
+
+ let char_list = vec!['y', 'm', 'a', 'q'];
+
+ let result = largest_char(&char_list);
+ println!("The largest char is {}", result);
+}
diff --git a/lessons/05-types-reasoning/static_dynamic_dispatch.rs b/lessons/05-types-reasoning/static_dynamic_dispatch.rs
new file mode 100644
index 0000000..2d9eeda
--- /dev/null
+++ b/lessons/05-types-reasoning/static_dynamic_dispatch.rs
@@ -0,0 +1,47 @@
+trait Speak {
+ fn speak(&self) -> &'static str;
+}
+
+struct Dog;
+
+impl Speak for Dog {
+ fn speak(&self) -> &'static str {
+ "Hau hau" // it's a Polish dog!
+ }
+}
+
+struct Human;
+
+impl Speak for Human {
+ fn speak(&self) -> &'static str {
+ "Hello world"
+ }
+}
+
+// It works like templates in C++
+// A different function will be generated for each T during compilation
+// This process is called "monomorphization"
+fn static_dispatch
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Reasoning About Types
++ 2024-10-24 (last edit: 2024-10-24) +
+Type traits
+Traits are a way to defined common behavior between different types. They can be compared to interfaces from many other mainstream languages or to type classes from Haskell, however, Rust is not an object-oriented language and there are some notable differences between type traits and Java interfaces.
+The way we describe behavior in Rust is through methods. Traits consist of a set of these methods which then should be implemented by a type. We've already encountered examples of these, like the Clone trait which specified that the clone() method can be called on some given type. Now, let's take a deeper look and try defining our own trait.
#![allow(dead_code)]
+
+trait Summary {
+ fn summarize(&self) -> String;
+}
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Summary for NewsArticle {
+ fn summarize(&self) -> String {
+ format!("{}, by {} ({})", self.headline, self.author, self.location)
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+impl Summary for Tweet {
+ fn summarize(&self) -> String {
+ format!("{}: {}", self.username, self.content)
+ }
+}
+
+fn main() {
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ println!("1 new tweet: {}", tweet.summarize());
+}
+
+(Download the source code for this example: basic_trait.rs)
+Default implementations
+Trait definitions can also be provided with default implementations of behaviors.
+#![allow(dead_code)]
+
+struct Upload {
+ filename: String,
+}
+
+#[allow(dead_code)]
+struct Photo {
+ filename: String,
+ width: u32,
+ height: u32,
+}
+
+trait Description {
+ fn describe(&self) -> String {
+ String::from("No description available.")
+ }
+}
+
+// All default implementations
+impl Description for Upload {}
+
+// Default implementations can be overwritten
+impl Description for Photo {
+ fn describe(&self) -> String {
+ format!("{} ({} x {})", self.filename, self.width, self.height)
+ }
+}
+
+// Default implementations can rely on methods with no defaults
+trait Size {
+ fn width(&self) -> u32;
+ fn height(&self) -> u32;
+
+ fn size(&self) -> u32 {
+ self.width() * self.height()
+ }
+}
+
+impl Size for Photo {
+ fn width(&self) -> u32 {
+ self.width
+ }
+
+ fn height(&self) -> u32 {
+ self.height
+ }
+
+ // Using default impl of `size()`
+}
+
+fn main() {
+ let upload = Upload {
+ filename: String::from("notes.txt"),
+ };
+
+ println!("Upload: {}", upload.describe());
+
+ let photo = Photo {
+ filename: String::from("stock_crustacean.png"),
+ width: 100,
+ height: 150,
+ };
+
+ println!("Photo: {}", photo.describe());
+ println!("Size: {}", photo.size());
+}
+
+(Download the source code for this example: trait_default.rs)
+What about derive?
+There is a trait-related thing we have used quite extensively and not explained yet, namely the #[derive] attribute. What it does is generate items (in our case a trait implementation) based on the given data definition (here a struct). Below you can find a list of derivable traits from the standard library. Writing derivation rules for user defined traits is also possible, but goes out of the scope of this lesson.
Derivable traits:
+-
+
-
+
Equality traits:
+Eq,PartialEqand comparison traits:OrdandPartialOrd. ThePartial-versions exist because there are types which don't fulfill the reflexivity requirement of equality (NaN != NaN) or do not form a total order (NaN < 0.0 == falseandNaN >= 0.0 == false).
+ -
+
Data duplication traits:
+CloneandCopy
+ -
+
+Hash- allows using values of that type as keys in a hashmap
+ -
+
+Default- provides a zero-arg constructor function
+ -
+
+Debug- provides a formatting of the value which can be used in debugging context. It should NOT be implemented manually. In general, if it's possible to derive theDebug, there are no reasons against doing it.
+
When is it possible to derive a trait?
+When all fields of a struct/variants of an enum implement that trait.
+Should all traits always be derived if it is possible?
+No. Although it may be tempting to just slap #[derive(Clone, Copy)] everywhere, it would be counter-effective. For example, at some later point you might add a non-Copy field to the struct and your (or, what's worse, someone else's!) code would break. Another example: it makes little sense to use containers as keys in hashmaps or to compare tweets.
Generics
+Suppose we want to find the largest element in a sequence and return it. Very much on purpose, we didn't specify what type these elements would be - ideally, we would love it to work on all types that have a defined notion of a largest element. However, to make things simpler for now, let's focus only on two primitive types: i32 and char. Let's try to write the code:
fn largest_i32(list: &[i32]) -> i32 {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn largest_char(list: &[char]) -> char {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn main() {
+ let number_list = vec![34, 50, 25, 100, 65];
+
+ let result = largest_i32(&number_list);
+ println!("The largest number is {}", result);
+
+ let char_list = vec!['y', 'm', 'a', 'q'];
+
+ let result = largest_char(&char_list);
+ println!("The largest char is {}", result);
+}
+
+(Download the source code for this example: non_generic.rs)
+Perfect, it works! Now only twenty more types to go...
+Fortunately, Rust gives us a way to avoid all this code duplication and generalize the types we're working on.
+fn largest<T>(list: &[T]) -> T {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+Cleaner already - we merged possibly very many implementations into one. But, when we try to compile this:
+error[E0369]: binary operation `>` cannot be applied to type `T`
+ --> src/main.rs:5:17
+ |
+5 | if item > largest {
+ | ---- ^ ------- T
+ | |
+ | T
+ |
+help: consider restricting type parameter `T`
+ |
+1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
+ | ++++++++++++++++++++++
+Since T can be of absolutely any type now, the compiler cannot be sure that operator > is defined. This aligns with what we wanted, as without comparing elements we don't have a notion of the largest one either. As always, the compiler comes to our aid:
fn largest<T: PartialOrd>(list: &[T]) -> T {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+We call this a trait bound, a way to provide constraints on what kind of types we are talking about in a given context. This implementation almost works now. Let's look at the new error.
+error[E0508]: cannot move out of type `[T]`, a non-copy slice
+ --> src/main.rs:2:23
+ |
+2 | let mut largest = list[0];
+ | ^^^^^^^
+ | |
+ | cannot move out of here
+ | move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait
+ | help: consider borrowing here: `&list[0]`
+
+error[E0507]: cannot move out of a shared reference
+ --> src/main.rs:4:18
+ |
+4 | for &item in list {
+ | ----- ^^^^
+ | ||
+ | |data moved here
+ | |move occurs because `item` has type `T`, which does not implement the `Copy` trait
+ | help: consider removing the `&`: `item`
+Our function attempts to take ownership, but, again, the compiler doesn't know whether T can just be trivially copied. Rust allows us to combine multiple trait bounds together:
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn main() {
+ let number_list = vec![34, 50, 25, 100, 65];
+
+ let result = largest(&number_list);
+ println!("The largest number is {}", result);
+
+ let char_list = vec!['y', 'm', 'a', 'q'];
+
+ let result = largest(&char_list);
+ println!("The largest char is {}", result);
+}
+
+(Download the source code for this example: generic_largest.rs)
+A powerful tool
+There's a lot more that we can do with generics:
+#![allow(dead_code)]
+
+use std::fmt::Debug;
+
+// generic enums
+enum OurOption<T> {
+ Some(T),
+ None,
+}
+
+// generic structs
+struct Tuple2<T, U> {
+ x: T,
+ y: U,
+}
+
+// generic implementation
+impl<T, U> Tuple2<T, U> {
+ fn new(x: T, y: U) -> Self {
+ Self { x, y }
+ }
+}
+
+struct Pair<T> {
+ x: T,
+ y: T,
+}
+
+// conditional implementation
+impl<T: PartialOrd + Copy> Pair<T> {
+ fn largest(&self) -> T {
+ if self.x > self.y {
+ self.x
+ } else {
+ self.y
+ }
+ }
+}
+
+// alternative syntax
+impl<T> Pair<T>
+where
+ T: PartialOrd + Copy,
+{
+ fn smallest(&self) -> T {
+ if self.x < self.y {
+ self.x
+ } else {
+ self.y
+ }
+ }
+}
+
+// Here information about the concrete underlying type is preserved.
+fn cloning_machine<T: Clone + Debug>(item: &T) -> T {
+ item.clone()
+}
+
+// Here information about the concrete underlying type is erased.
+// We can only either format or clone the result.
+fn erasing_cloning_machine1(item: &(impl Clone + Debug)) -> impl Clone + Debug {
+ item.clone()
+}
+
+// Ditto.
+fn erasing_cloning_machine2<T: Clone + Debug>(item: &T) -> impl Clone + Debug {
+ item.clone()
+}
+
+fn main() {
+ let _opt = OurOption::Some(10);
+
+ let _p1 = Tuple2 { x: 5, y: 10 };
+ let _p2 = Tuple2::new(1, 2.5);
+
+ let arr = [1, 2, 3];
+
+ let arr2 = cloning_machine(&arr);
+ let _x = arr2[0]; // This compiles, because `cloning_machine` preserves the type.
+ println!("{:?}", arr2);
+
+ let arr3 = erasing_cloning_machine1(&arr);
+ // arr3[0]; // won't compile: cannot index into a value of type `impl std::clone::Clone + std::fmt::Debug`
+ println!("{:?}", arr3);
+
+ let arr4 = erasing_cloning_machine2(&arr);
+ // arr4[0]; // won't compile: cannot index into a value of type `impl std::clone::Clone + std::fmt::Debug`
+ println!("{:?}", arr4);
+}
+
+(Download the source code for this example: generics.rs)
+A bit more involved example:
+use std::fmt::{Display, Formatter};
+
+trait DefaultishablyPrintable<T> {
+ fn defaultish_print()
+ where
+ T: Display + Default,
+ {
+ println!("{}", T::default())
+ }
+}
+
+struct Foo;
+
+struct Bar;
+
+impl Display for Bar {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ f.write_str("this is a bar")
+ }
+}
+
+impl Default for Bar {
+ fn default() -> Self {
+ Bar // well, we have no other choice
+ }
+}
+
+impl DefaultishablyPrintable<i32> for Foo {}
+
+impl DefaultishablyPrintable<Bar> for Foo {}
+
+fn main() {
+ <Foo as DefaultishablyPrintable<i32>>::defaultish_print();
+ <Foo as DefaultishablyPrintable<Bar>>::defaultish_print();
+}
+
+(Download the source code for this example: generics_fun.rs)
+Static vs dynamic dispatch
+trait Speak {
+ fn speak(&self) -> &'static str;
+}
+
+struct Dog;
+
+impl Speak for Dog {
+ fn speak(&self) -> &'static str {
+ "Hau hau" // it's a Polish dog!
+ }
+}
+
+struct Human;
+
+impl Speak for Human {
+ fn speak(&self) -> &'static str {
+ "Hello world"
+ }
+}
+
+// It works like templates in C++
+// A different function will be generated for each T during compilation
+// This process is called "monomorphization"
+fn static_dispatch<T: Speak>(speaking: &T) {
+ println!("{}!", speaking.speak());
+}
+
+// Only one copy of that function will exist in the compiled binary
+fn dynamic_dispatch(speaking: &dyn Speak) {
+ println!("{}!", speaking.speak());
+}
+
+fn main() {
+ let dog = Dog;
+ let human = Human;
+
+ static_dispatch(&dog);
+ static_dispatch(&human);
+
+ dynamic_dispatch(&dog);
+ dynamic_dispatch(&human);
+
+ // The observable behavior is identical
+ // Static dispatch in general is a bit faster,
+ // because there is no need to perform a "vtable lookup".
+ // But it can also result in bigger binary sizes.
+}
+
+(Download the source code for this example: static_dynamic_dispatch.rs)
+Lifetimes
+Going back to the lesson about ownership, if we try to compile the following code:
+{
+ let r;
+
+ {
+ let x = 5;
+ r = &x;
+ }
+
+ println!("r: {}", r);
+}
+we should expect to get an error:
+error[E0597]: `x` does not live long enough
+ --> src/main.rs:7:17
+ |
+7 | r = &x;
+ | ^^ borrowed value does not live long enough
+8 | }
+ | - `x` dropped here while still borrowed
+9 |
+10 | println!("r: {}", r);
+ | - borrow later used here
+Courtesy of the borrow checker, we didn't end up with a dangling reference. But what exactly is happening behind the scenes? Rust introduces a concept of annotated lifetimes, where the lifetime of each value is being marked and tracked by the checker. Let's look at some examples:
+{
+ let r; // ---------+-- 'a
+ // |
+ { // |
+ let x = 5; // -+-- 'b |
+ r = &x; // | |
+ } // -+ |
+ // |
+ println!("r: {}", r); // |
+} // ---------+
+{
+ let x = 5; // ----------+-- 'b
+ // |
+ let r = &x; // --+-- 'a |
+ // | |
+ println!("r: {}", r); // | |
+ // --+ |
+} // ----------+
+Annotations
+Let's consider the following code finding the longer out of two strings:
+fn longest(x: &str, y: &str) -> &str {
+ if x.len() > y.len() {
+ x
+ } else {
+ y
+ }
+}
+
+fn main() {
+ let string1 = String::from("abcd");
+ let string2 = "xyz";
+
+ let result = longest(string1.as_str(), string2);
+ println!("The longest string is {}", result);
+}
+If we try to compile this, we will get an error:
+error[E0106]: missing lifetime specifier
+ --> src/main.rs:9:33
+ |
+9 | fn longest(x: &str, y: &str) -> &str {
+ | ---- ---- ^ expected named lifetime parameter
+ |
+ = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
+help: consider introducing a named lifetime parameter
+ |
+9 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+ | ++++ ++ ++ ++
+This is because Rust doesn't know which of the two provided strings (x or y) will be returned from the function. And because they potentially have different lifetimes, the lifetime of what we are returning remains unclear to the compiler - it needs our help.
Rust provides syntax for specifying lifetimes. The lifetime parameter name from the example (a) doesn't have any concrete meaning - it's just an arbitrary name for this one lifetime.
&i32 // a reference
+&'a i32 // a reference with an explicit lifetime
+&'a mut i32 // a mutable reference with an explicit lifetime
+So, knowing this, let's address the compiler's demands.
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+ if x.len() > y.len() {
+ x
+ } else {
+ y
+ }
+}
+When working with lifetimes, our work will usually revolve around specifying relationships between lifetimes of different values so that the compiler can successfully reason about the program's safety. In the context of the example above, this signature means that both of the function's arguments and its output will live at least as long as lifetime 'a. In practice, this means that the output's lifetime will be equal to the smaller of the two inputs' lifetimes.
fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
+ if first.len() > second.len() {
+ first
+ } else {
+ second
+ }
+}
+
+fn main() {
+ let string1 = String::from("long string is long");
+
+ {
+ let string2 = String::from("xyz");
+ let result = longest(string1.as_str(), string2.as_str());
+ println!("The longest string is {}", result);
+ }
+
+ // This doesn't compile - incorrect lifetimes
+ //
+ // let string1 = String::from("long string is long");
+ // let result;
+ // {
+ // let string2 = String::from("xyz");
+ // result = longest(string1.as_str(), string2.as_str());
+ // }
+ // println!("The longest string is {}", result);
+}
+
+(Download the source code for this example: lifetimes_basic.rs)
+Trying to compile the second variant displeases the compiler (just like we hoped).
+error[E0597]: `string2` does not live long enough
+ --> src/main.rs:6:44
+ |
+6 | result = longest(string1.as_str(), string2.as_str());
+ | ^^^^^^^^^^^^^^^^ borrowed value does not live long enough
+7 | }
+ | - `string2` dropped here while still borrowed
+8 | println!("The longest string is {}", result);
+ | ------ borrow later used here
+Lifetime elision
+We now know how to explicitly write lifetime parameters, but you might recall that we don't always have to that. Indeed, Rust will first try to figure out the lifetimes itself, applying a set of predefined rules. We call this lifetime elision.
+fn first_two(seq: &[u32]) -> &[u32] {
+ if seq.len() < 2 {
+ seq
+ } else {
+ &seq[..2]
+ }
+}
+
+fn main() {
+ let seq = [1, 2, 3, 4];
+
+ println!(
+ "First two elements of the sequence: {:?}",
+ first_two(&seq[..])
+ );
+}
+
+(Download the source code for this example: lifetimes_elision.rs)
+The above works, even though we didn't specify any lifetime parameters at all. The reason lies in the rules we mentioned, which are as follows (where input lifetimes are lifetimes on parameters and output lifetimes are lifetimes on return values):
+-
+
-
+
Each parameter that is a reference gets its own lifetime parameter.
+
+ -
+
If there is exactly one input lifetime parameter, that lifetime is assigned to all output lifetime parameters.
+
+ -
+
If there are multiple input lifetime parameters, but one of them is
+&selfor&mut self, the lifetime ofselfis assigned to all output lifetime parameters.
+
Let's try to understand how the compiler inferred the lifetimes of our first_two functions. We start with the following signature:
fn first_two(seq: &[u32]) -> &[u32] {
+Then, we apply the first rule:
+fn first_two<'a>(seq: &'a [u32]) -> &[u32] {
+Next, we check the second rule. It applies here as well.
+fn first_two<'a>(seq: &'a [u32]) -> &'a [u32] {
+With that, we arrive at a state where all lifetimes are specified.
+Static lifetime
+There exists one special lifetime called 'static, which means that a reference can live for the entire duration of the program. All string literals are annotated with this lifetime as they are stored directly in the program's binary. Full type annotation of a string literal in Rust is therefore as follows:
let s: &'static str = "I have a static lifetime.";
+Trait + lifetimes - a challenging tandem
+Let's go back to our basic_trait.rs example. The Summary trait was really wasteful: it always allocated the Strings on heap, even though we only needed to display the formatted string, and we could do that without allocations. How? By using Display trait, of course.
The simplest possible optimisation would be like this:
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Display for NewsArticle {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(
+ f,
+ "{}, by {} ({})",
+ self.headline, self.author, self.location
+ )
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+impl Display for Tweet {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(f, "{}: {}", self.username, self.content)
+ }
+}
+
+fn main() {
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ println!("1 new tweet: {}", tweet);
+}
+
+(Download the source code for this example: basic_trait_display.rs)
+This eliminates the heap allocations, but there's another catch. What if NewsArticle already had another (non-summarizing) Display implementation? We would end up in a double-trait-implementation conflict, which is a compile-time error.
We can solve the one-type-one-trait-impl problem by introducing another type just for summarizing. The first attempt could be to use generics in traits:
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+trait Summary<'a, Summarizer: Display> {
+ fn summarize(&'a self) -> Summarizer;
+}
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Display for NewsArticle {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ writeln!(
+ f,
+ "{}, by {} ({})",
+ self.headline, self.author, self.location
+ )?;
+ f.write_str(&self.content)
+ }
+}
+
+struct NewsArticleSummarizer<'a>(&'a NewsArticle);
+
+impl Display for NewsArticleSummarizer<'_> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let article = self.0;
+ write!(
+ f,
+ "{}, by {} ({})",
+ article.headline, article.author, article.location
+ )
+ }
+}
+
+impl<'a> Summary<'a, NewsArticleSummarizer<'a>> for NewsArticle {
+ fn summarize(&'a self) -> NewsArticleSummarizer<'a> {
+ NewsArticleSummarizer(self)
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+struct TweetSummarizer<'a>(&'a Tweet);
+
+impl Display for TweetSummarizer<'_> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let tweet = self.0;
+ write!(f, "{}: {}", tweet.username, tweet.content)
+ }
+}
+
+impl<'a> Summary<'a, TweetSummarizer<'a>> for Tweet {
+ fn summarize(&'a self) -> TweetSummarizer<'a> {
+ TweetSummarizer(self)
+ }
+}
+
+impl<'a> Summary<'a, NewsArticleSummarizer<'a>> for Tweet {
+ fn summarize(&'a self) -> NewsArticleSummarizer<'a> {
+ unimplemented!("This is only to make code type-check and compile.");
+ }
+}
+
+fn main() {
+ let empty_article = NewsArticle {
+ headline: "".into(),
+ location: String::new(),
+ author: String::default(),
+ content: Default::default(),
+ };
+ println!("1 new article: {}", empty_article.summarize());
+
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ // Compile error: `type annotations needed; multiple `impl`s satisfying `Tweet: Summary<'_, _>` found`
+ // println!("1 new tweet: {}", tweet.summarize());
+ println!(
+ "1 new tweet: {}",
+ <Tweet as Summary<'_, TweetSummarizer>>::summarize(&tweet)
+ );
+ println!(
+ "1 new tweet: {}",
+ <Tweet as Summary<'_, NewsArticleSummarizer>>::summarize(&tweet)
+ );
+}
+
+(Download the source code for this example: trait_generic_type.rs)
+The problem here is that nothing hinders us from implement the trait (with various type parameters) for the same type, which leads to awkward ambiguity when calling the trait's methods (see main fn).
The use of generic types in Summary trait makes it semantics like this:
++A type can be summarized with any type supporting it.
+
When we want the trait to require exactly one possible generic implementation for a given type, we can leverage associated types. Example here:
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+trait Summary<'a> {
+ type Summarizer: Display;
+
+ fn summarize(&'a self) -> Self::Summarizer;
+}
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Display for NewsArticle {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ writeln!(
+ f,
+ "{}, by {} ({})",
+ self.headline, self.author, self.location
+ )?;
+ f.write_str(&self.content)
+ }
+}
+
+struct NewsArticleSummarizer<'a>(&'a NewsArticle);
+
+impl Display for NewsArticleSummarizer<'_> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let article = self.0;
+ write!(
+ f,
+ "{}, by {} ({})",
+ article.headline, article.author, article.location
+ )
+ }
+}
+
+impl<'a> Summary<'a> for NewsArticle {
+ type Summarizer = NewsArticleSummarizer<'a>;
+ fn summarize(&'a self) -> Self::Summarizer {
+ NewsArticleSummarizer(self)
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+struct TweetSummarizer<'a>(&'a Tweet);
+
+impl Display for TweetSummarizer<'_> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let tweet = self.0;
+ write!(f, "{}: {}", tweet.username, tweet.content)
+ }
+}
+
+impl<'a> Summary<'a> for Tweet {
+ type Summarizer = TweetSummarizer<'a>;
+ fn summarize(&'a self) -> Self::Summarizer {
+ TweetSummarizer(self)
+ }
+}
+
+fn main() {
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ println!("1 new tweet: {}", tweet.summarize());
+}
+
+(Download the source code for this example: trait_associated_type.rs)
+The use of associated types in Summary trait makes it semantics like this:
+++A type can be summarized with at most one specific type.
+
Yet another approach (arguably, the cleanest one) would be to use the impl trait syntax in a trait (quite recently stabilized!).
+Example:
#![allow(dead_code)]
+
+use std::fmt::Display;
+
+trait Summary {
+ fn summarize(&self) -> impl Display;
+}
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Display for NewsArticle {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ writeln!(
+ f,
+ "{}, by {} ({})",
+ self.headline, self.author, self.location
+ )?;
+ f.write_str(&self.content)
+ }
+}
+
+struct NewsArticleSummarizer<'a>(&'a NewsArticle);
+
+impl Display for NewsArticleSummarizer<'_> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let article = self.0;
+ write!(
+ f,
+ "{}, by {} ({})",
+ article.headline, article.author, article.location
+ )
+ }
+}
+
+impl Summary for NewsArticle {
+ fn summarize(&self) -> impl Display {
+ NewsArticleSummarizer(self)
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+impl Summary for Tweet {
+ fn summarize(&self) -> impl Display {
+ struct TweetSummarizer<'a>(&'a Tweet);
+
+ impl Display for TweetSummarizer<'_> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let tweet = self.0;
+ write!(f, "{}: {}", tweet.username, tweet.content)
+ }
+ }
+
+ TweetSummarizer(self)
+ }
+}
+
+fn main() {
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ println!("1 new tweet: {}", tweet.summarize());
+}
+
+(Download the source code for this example: impl_trait.rs)
+Obligatory reading
+-
+
- + + +
- + + +
Assignment 3 (graded)
+ +Deadline: 30.10.2024 23:59
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/06-closures-iterators/iterator_exhaustion.rs b/lessons/06-closures-iterators/iterator_exhaustion.rs
new file mode 100644
index 0000000..7374cd3
--- /dev/null
+++ b/lessons/06-closures-iterators/iterator_exhaustion.rs
@@ -0,0 +1,58 @@
+use std::collections::HashSet;
+
+fn main() {
+ // Various ways to create a String.
+ let mut strings = [
+ String::new(),
+ String::from("a"),
+ "b".into(),
+ "c".to_owned(),
+ "d".to_string(),
+ "e".chars().collect(),
+ ];
+
+ // `iter()` is a usual method that creates an iterator over immutable references to the collection's items.
+ let _all_len_0_or_1 = strings
+ .iter()
+ .filter(|s| !s.is_empty())
+ .all(|s| s.len() == 1);
+
+ // `iter_mut()` is a usual method that creates an iterator over mutable references to the collection's items.
+ for s in strings.iter_mut().map_while(|s| match s.as_str() {
+ "c" => None,
+ _ => Some(s),
+ }) {
+ *s = s.replace("b", "aba");
+ }
+
+ // This code is equivalent to the `for` above.
+ // `for` is usually more idiomatic, but `for_each` is sometimes cleaner and sometimes faster.
+ strings
+ .iter_mut()
+ .map_while(|s| match s.as_str() {
+ "c" => None,
+ _ => Some(s),
+ })
+ .for_each(|s| *s = s.replace("b", "aba"));
+
+ // `into_iter()` is a method from `IntoIterator` trait that converts a collection to an iterator
+ let mut empty_strings_iter = strings.into_iter().map(|mut s| {
+ s.clear();
+ s
+ });
+
+ // This is a set of empty Strings...
+ let empty_strings_set = empty_strings_iter.clone().collect::
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Closures and Iterators
++ 2024-10-31 (last edit: 2024-10-30) +
+Closures
+Closures (Polish: "domknięcia") are anonymous functions that can access variables from the scope in which they were defined.
+Closure syntax
+fn main() {
+ #[rustfmt::skip]
+ {
+ // This is formatted so that without rust-analyzer it renders as well-aligned.
+
+ fn add_one_v1 (x: u32) -> u32 { x + 1 } // This is an ordinary function.
+ let add_one_v2 = |x: u32| -> u32 { x + 1 }; // Closures use pipes instead of parentheses.
+ let add_one_v3 = |x| { x + 1 }; // Both parameters and return value can have their types inferred.
+ let add_one_v4 = |x| x + 1 ; // If the body is a single expression, braces can be omitted.
+
+ let _res = add_one_v1(0_u32);
+ let _res = add_one_v2(0_u32);
+ let _res = add_one_v3(0_u32);
+ let _res = add_one_v4(0_u32);
+
+ // This does not compile, because closures are not generic.
+ // Their type is inferred once and stays the same.
+ // let _res = add_one_v4(0_i32);
+ };
+}
+
+(Download the source code for this example: closures_syntax.rs)
+Closures' types
+Closures are unnameable types. That is, each closure gets its own unique type from the compiler,
+but we cannot name it. Therefore, closures' types must be inferred.
+We will often use impl keyword with closure traits (e.g., impl Fn) - those traits are described below.
Closures capture environment
+Closures can capture variables from the environment where they are defined. They can do that in two ways:
+-
+
- Capturing References (borrowing), or +
- Moving Ownership. +
HOW closures capture variables is one thing. +But even more important is WHAT closures do with their captures.
+Functions & closures hierarchy
+Based on WHAT a closure does with its captures, it implements closure traits:
+-
+
FnOnce- closures that may move out of their captures environment (and thus called once).
+FnMut- closures that may mutate their captures, but don't move out of their captures environment (so can be called multiple times, but require a mutable reference);
+Fn- closures that do not mutate their captures (so can be called multiple times through an immutable reference).
+
For completeness, there is a (concrete) type of function pointers:
+-
+
fn- functions, closures with no captures.
+
Those traits and the fn type form a hierarchy: fn ⊆ Fn ⊆ FnMut ⊆ FnOnce
The following code sample demonstrates various ways to capture environment (borrowing or moving) and various kinds of closures, based on what they do with their captures:
+fn main() {
+ borrowing_immutably_closure();
+ borrowing_mutably_closure();
+ moving_in_nonmutating_closure();
+ moving_in_mutating_closure();
+ moving_in_moving_out_closure();
+}
+
+fn borrowing_immutably_closure() {
+ let list = vec![1, 2, 3];
+ println!("Before defining closure: {:?}", list);
+
+ let only_borrows = || println!("From closure: {:?}", list);
+
+ // This would not really only borrow... (it needs Vec by value).
+ // let only_borrows = || std::mem::drop::<Vec<_>>(list);
+
+ println!("Before calling closure: {:?}", list);
+ only_borrows();
+ println!("After calling closure: {:?}", list);
+}
+
+fn borrowing_mutably_closure() {
+ let mut list = vec![1, 2, 3];
+ println!("Before defining closure: {:?}", list);
+
+ let mut borrows_mutably = || list.push(7);
+
+ // println!("Before calling closure: {:?}", list);
+ borrows_mutably();
+ println!("After calling closure: {:?}", list);
+}
+
+fn moving_in_nonmutating_closure() {
+ let list = vec![1, 2, 3];
+ println!("Before defining closure: {:?}", list);
+
+ // This closure would just borrow the list, because it only prints it.
+ // However, as spawning threads require passing `impl FnOnce + 'static`,
+ // we need to use `move` keyword to force the closure to move `list`
+ // into its captured environment.
+ std::thread::spawn(move || println!("From thread: {:?}", list))
+ .join()
+ .unwrap();
+}
+
+fn moving_in_mutating_closure() {
+ fn append_42(mut appender: impl FnMut(i32)) {
+ appender(42);
+ }
+
+ let mut appender = {
+ let mut list = vec![1, 2, 3];
+ println!("Before defining closure: {:?}", list);
+
+ // The `move` keyword is necessary to prevent dangling reference to `list`.
+ // Of course, the borrow checker protects us from compiling code without `move`.
+ move |num| list.push(num)
+ };
+
+ append_42(&mut appender);
+ append_42(&mut appender);
+}
+
+fn moving_in_moving_out_closure() {
+ fn append_multiple_times(appender: impl FnOnce(&mut Vec<String>) + Clone) {
+ let mut list = Vec::new();
+
+ // We can clone this `FnOnce`, because we additionally require `Clone`.
+ // If we didn't clone it, we couldn't call it more than *once*.
+ appender.clone()(&mut list);
+ appender(&mut list);
+ }
+
+ let appender = {
+ let string = String::from("Ala");
+ println!("Before defining closure: {:?}", string);
+
+ // The `move` keyword is necessary to prevent dangling reference to `list`.
+ // Of course, the borrow checker protects us from compiling code without `move`.
+ move |list: &mut Vec<String>| list.push(string)
+ };
+
+ // As `appender` is only `FnOnce`, we need to clone before we consume it by calling it.
+ append_multiple_times(appender.clone());
+ append_multiple_times(appender);
+}
+
+(Download the source code for this example: closures_capturing.rs)
+Closures as trait objects (in dynamic dispatch)
+The following code sample shows how one can use closures as dyn Trait objects, bypassing the problem of them having anonymous types:
fn main() {
+ fn some_function() -> String {
+ String::new()
+ }
+
+ let v1 = String::from("v1");
+ let mut borrowing_immutably_closure = || v1.clone();
+
+ let mut v2 = String::from("v2");
+ let mut borrowing_mutably_closure = || {
+ v2.push('.');
+ v2.clone()
+ };
+
+ let v3 = String::from("v3");
+ let mut moving_in_nonmutating_closure = move || v3.clone();
+
+ let mut v4 = String::from("v4");
+ let mut moving_in_mutating_closure = move || {
+ v4.push('.');
+ v4.clone()
+ };
+ let v5 = String::from("v5");
+ let moving_in_moving_out_closure = || v5;
+
+ let fn_once_callables: [&dyn FnOnce() -> String; 5] = [
+ &some_function,
+ &borrowing_immutably_closure,
+ &borrowing_mutably_closure,
+ &moving_in_nonmutating_closure,
+ &moving_in_moving_out_closure,
+ ];
+
+ #[allow(unused_variables)]
+ for fn_once_callable in fn_once_callables {
+ // Cannot move a value of type `dyn FnOnce() -> String`.
+ // The size of `dyn FnOnce() -> String` cannot be statically determined.
+ // println!("{}", fn_once_callable());
+
+ // So, for FnOnce, we need to be their owners to be able to call them,
+ // and we can't have a `dyn` object owned on stack.
+ // We will solve this problem soon with smart pointers (e.g., Box).
+ // This will give us `std::function` -like experience.
+ }
+
+ // Mutable reference to FnMut is required to be able to call it.
+ let fn_mut_callables: [&mut dyn FnMut() -> String; 4] = [
+ &mut borrowing_immutably_closure,
+ &mut borrowing_mutably_closure,
+ &mut moving_in_nonmutating_closure,
+ &mut moving_in_mutating_closure,
+ ];
+
+ for fn_mut_callable in fn_mut_callables {
+ println!("{}", fn_mut_callable());
+ }
+
+ let fn_callables: &[&dyn Fn() -> String] =
+ &[&borrowing_immutably_closure, &moving_in_nonmutating_closure];
+
+ for fn_callable in fn_callables {
+ println!("{}", fn_callable());
+ }
+}
+
+(Download the source code for this example: closures_fun.rs)
+Examples
+We'll go through the examples from Rust by Example. +More examples will be seen when working with iterators.
+Iterators
+In Rust, there is no hierarchy of types for collections (because there is no inheritance in general). +Instead, what makes a collection is that it can be iterated over.
+A usual way in Rust to perform an iteration over something, be it a range of values or items in a collection, is creating a (lazy) iterator over it and transforming it using iterator adaptors. For example, if T: Iterator, then T::map() creates a Map<T> adaptor. Once a final iterator is created, it has to be actually activated (iterated over), which is most commonly done by:
-
+
- exhausting it with the
forloop,
+ - manually iterating over it using
next()calls,
+ - collecting its contents into inferred collection (
collect()),
+ - consuming it with a consuming adaptor (e.g.,
sum(),count),
+
use std::collections::HashSet;
+
+fn main() {
+ // Various ways to create a String.
+ let mut strings = [
+ String::new(),
+ String::from("a"),
+ "b".into(),
+ "c".to_owned(),
+ "d".to_string(),
+ "e".chars().collect(),
+ ];
+
+ // `iter()` is a usual method that creates an iterator over immutable references to the collection's items.
+ let _all_len_0_or_1 = strings
+ .iter()
+ .filter(|s| !s.is_empty())
+ .all(|s| s.len() == 1);
+
+ // `iter_mut()` is a usual method that creates an iterator over mutable references to the collection's items.
+ for s in strings.iter_mut().map_while(|s| match s.as_str() {
+ "c" => None,
+ _ => Some(s),
+ }) {
+ *s = s.replace("b", "aba");
+ }
+
+ // This code is equivalent to the `for` above.
+ // `for` is usually more idiomatic, but `for_each` is sometimes cleaner and sometimes faster.
+ strings
+ .iter_mut()
+ .map_while(|s| match s.as_str() {
+ "c" => None,
+ _ => Some(s),
+ })
+ .for_each(|s| *s = s.replace("b", "aba"));
+
+ // `into_iter()` is a method from `IntoIterator` trait that converts a collection to an iterator
+ let mut empty_strings_iter = strings.into_iter().map(|mut s| {
+ s.clear();
+ s
+ });
+
+ // This is a set of empty Strings...
+ let empty_strings_set = empty_strings_iter.clone().collect::<HashSet<_>>();
+
+ // And this is a Vec of immutable references to empty Strings.
+ let empty_string_refs_vec = empty_strings_set.iter().collect::<Vec<_>>();
+
+ // equivalent to `empty_string_refs_vec.into_iter()`
+ for s in empty_string_refs_vec {
+ println!("{}", s)
+ }
+
+ while let Some(s) = empty_strings_iter.next_back() {
+ assert!(s.is_empty());
+ }
+}
+
+(Download the source code for this example: iterator_exhaustion.rs)
+Iterators are highly optimised, so they are high-level code that compiles down to simple and optimised machine code (intended as zero-cost abstractions).
+We'll go through the official docs.
+-
+
- Most methods are defined in the Iterator trait. +
- IntoIterator is also worth noting, because it makes types work with the
forloop.
+ - For completeness, there is FromIterator, which is required for
collect()to work.
+
Reading
+-
+
- The Book, chapter 12 (that's a project!) +
- The Book, chapter 13 +
- The Book, chapter 14 +
- The Book, Advanced Functions and Closures +
- The Book, Advanced Traits +
Assignment 4 (graded)
+ +Deadline: 06.11.2024 23:59
+ + +
+
+
+
+
+
+- ),
+ Nil,
+}
+
+fn main() {
+ box_simple();
+}
diff --git a/lessons/07-smart-pointers/deref_coercion.rs b/lessons/07-smart-pointers/deref_coercion.rs
new file mode 100644
index 0000000..c5b14c7
--- /dev/null
+++ b/lessons/07-smart-pointers/deref_coercion.rs
@@ -0,0 +1,39 @@
+use std::ops::Deref;
+
+struct MyBox
-
+
From
+&Tto&UwhenT: Deref<Target=U>
+ -
+
From
+&mut Tto&mut UwhenT: DerefMut<Target=U>
+ -
+
From
+&mut Tto&UwhenT: Deref<Target=U>
+ - + + +
-
+
std::borrow::Cow, a versatile copy-on-write smart pointer
+
+ - A type is
Sendif it is safe to move it (send it) to another thread.
+ - A type is
Syncif it is safe to share (sync) between threads (TisSyncif and only if&TisSend).
+ UnsafeCell(=>Cell,RefCell);
+Rc
+*const T,*mut T(raw pointers)
+MutexGuard(hint:!Sendfor POSIX reasons)
+- What color is your function +
- Pin and suffering +
- Understanding Rust futures by going way too deep +
- Desugaring and assembly of Rust async/await +
- + + +
- + + +
- + + +
- + [2024-10-03] Organizational lesson (last edited: 2024-10-06) + + +
- + [2024-10-03] Introduction to Rust (last edited: 2024-09-20) + + +
- + [2024-10-10] Ownership Model (last edited: 2024-10-08) + + +
- + [2024-10-17] Data Types (last edited: 2024-10-17) + + +
- + [2022-10-31] Feedback #1 (last edited: 2022-10-31) + + +
- + [2024-10-24] Reasoning About Types (last edited: 2024-10-24) + + +
- + [2024-10-31] Closures and Iterators (last edited: 2024-10-30) + + +
- + [2024-11-07] Smart Pointers (last edited: 2022-11-21) + + +
- + [2022-11-21] Feedback #2 (last edited: 2022-11-21) + + +
- + [2024-11-14] Fearless concurrency (last edited: 2024-11-14) + + +
- + [2024-11-21] Design patterns (last edited: 2022-12-05) + + +
- + [2024-11-28] Async: Part 1 (last edited: 2024-11-27) + + +
- + [2022-12-29] Project feedback (last edited: 2022-12-29) + + +
- + [2024-12-05] Async: Part 2 (last edited: 2022-05-23) + + +
- + [2024-12-12] Macros (last edited: 2022-06-07) + + +
- + [2022-10-17] 2021L Project showcase (last edited: 2022-10-17) + + +
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/07-smart-pointers/ref_count.rs b/lessons/07-smart-pointers/ref_count.rs
new file mode 100644
index 0000000..0f97932
--- /dev/null
+++ b/lessons/07-smart-pointers/ref_count.rs
@@ -0,0 +1,31 @@
+use std::rc::Rc;
+
+struct LoudInt(i32);
+
+impl Drop for LoudInt {
+ fn drop(&mut self) {
+ println!("[{}] Farewell!", self.0);
+ }
+}
+
+fn main() {
+ {
+ let outer_ref;
+
+ {
+ let inner_ref = Rc::new(LoudInt(5));
+
+ // strong_count represents the number of owning references pointing
+ // to data
+ assert_eq!(Rc::strong_count(&inner_ref), 1);
+
+ outer_ref = Rc::clone(&inner_ref);
+
+ assert_eq!(Rc::strong_count(&inner_ref), Rc::strong_count(&outer_ref));
+ assert_eq!(Rc::strong_count(&inner_ref), 2);
+ }
+
+ println!("The {} still lives!", outer_ref.0);
+ assert_eq!(Rc::strong_count(&outer_ref), 1);
+ }
+}
diff --git a/lessons/07-smart-pointers/weak_ref.rs b/lessons/07-smart-pointers/weak_ref.rs
new file mode 100644
index 0000000..6fa8e79
--- /dev/null
+++ b/lessons/07-smart-pointers/weak_ref.rs
@@ -0,0 +1,36 @@
+use std::rc::Rc;
+
+struct LoudInt(i32);
+
+impl Drop for LoudInt {
+ fn drop(&mut self) {
+ println!("[{}] Farewell!", self.0);
+ }
+}
+
+fn main() {
+ let weak_ref;
+
+ {
+ let shared_ref = Rc::new(LoudInt(5));
+
+ // weak_count keeps track of the non-owning reference to the data
+ assert_eq!(Rc::weak_count(&shared_ref), 0);
+
+ // `downgrade()` obtains a weak pointer to Rc's data
+ weak_ref = Rc::downgrade(&shared_ref);
+
+ assert_eq!(Rc::weak_count(&shared_ref), 1);
+ assert_eq!(Rc::strong_count(&shared_ref), 1);
+
+ // In order to use the the data underneath the weak pointer
+ // we need to obtain a new shared pointer from it.
+ // The `upgrade()` method returns `Option
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Convenient handling of
+
+ Smart Pointers
++ 2024-11-07 (last edit: 2022-11-21) +
+Working with the heap
+So far we've only used heap allocated memory indirectly by working with containers such as vectors, maps or the String type, otherwise allocating our variables on the stack. We didn't really have to be aware of the fact that these collections used the heap, as all that memory management details were hidden away from us. In this lesson we'll take a closer look at what is really happening there and how we can do that ourselves.
To work with heap-allocated memory, Rust features smart pointers. You should have already heard this term as it is a very important feature in C++ and the concept is virtually the same here - they are wrappers around raw allocated memory that provide additional, safety-ensuring mechanism. What defines a smart pointer in Rust is generally the implementation of two traits: Drop and Deref.
The Drop trait is pretty straightforward as it consists of one method - fn drop(&mut self) - that is, basically, the destructor, invoked during stack unwinding.
The Deref trait allows us to overload the dereference (*) operator.
Deref coercion
+Apart from enabling access to the underlying value, implementing the Deref trait enables Rust to perform deref coercion on the pointer - trying to remove as many levels of indirection as it can. What it means in practice is that we will be able to use it with any code working on plain references.
use std::ops::Deref;
+
+struct MyBox<T>(T);
+
+// We won't be allocating anything on the heap here as it is not important here.
+// We're only focusing on the dereference mechanisms.
+impl<T> MyBox<T> {
+ fn new(x: T) -> MyBox<T> {
+ MyBox(x)
+ }
+}
+
+impl<T> Deref for MyBox<T> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+fn hello(name: &str) {
+ println!("Hello, {}!", name);
+}
+
+fn main() {
+ let x = 5;
+ let int_box = MyBox::new(x);
+
+ assert_eq!(5, *int_box);
+
+ // String also implements the `Deref` trait.
+ // In fact, String actually is a smart pointer.
+ let s = String::from("I'm a smart pointer too");
+ hello(&s);
+
+ // Deref coercion can deal with multiple levels of indirection.
+ let str_box = MyBox::new(String::from("Rust"));
+ hello(&str_box);
+}
+
+(Download the source code for this example: deref_coercion.rs)
+In general, there are three possible coercions that Rust can perform:
+-
+
While the first two coercions are straightforward, the third one is possible because treating a mutable reference as an immutable one does not break the rules of ownership.
+Box - simple wrapper
+The Box<T> type is the most basic out of Rust's smart pointers, equivalent to C++'s std::unique_ptr<T>. It's a simple wrapper that makes sure the underlying memory gets allocated and freed properly.
fn box_simple() {
+ let b = Box::new(5);
+ println!("b = {}", b);
+
+ let _x = 10 + *b;
+}
+
+// `Box` gives us the indirection required to define
+// recursive types
+#[allow(dead_code)]
+enum List {
+ Cons(i32, Box<List>),
+ Nil,
+}
+
+fn main() {
+ box_simple();
+}
+
+(Download the source code for this example: box.rs)
+Reference counting
+The Rc<T> type is the equivalent of std::shared_ptr<T> from C++. There is one caveat to this though - because we're creating multiple references to the same object, those references have to be immutable in accordance with the ownership rules.
use std::rc::Rc;
+
+struct LoudInt(i32);
+
+impl Drop for LoudInt {
+ fn drop(&mut self) {
+ println!("[{}] Farewell!", self.0);
+ }
+}
+
+fn main() {
+ {
+ let outer_ref;
+
+ {
+ let inner_ref = Rc::new(LoudInt(5));
+
+ // strong_count represents the number of owning references pointing
+ // to data
+ assert_eq!(Rc::strong_count(&inner_ref), 1);
+
+ outer_ref = Rc::clone(&inner_ref);
+
+ assert_eq!(Rc::strong_count(&inner_ref), Rc::strong_count(&outer_ref));
+ assert_eq!(Rc::strong_count(&inner_ref), 2);
+ }
+
+ println!("The {} still lives!", outer_ref.0);
+ assert_eq!(Rc::strong_count(&outer_ref), 1);
+ }
+}
+
+(Download the source code for this example: ref_count.rs)
+Rust also provides a non-owning pointer in the form of Weak<T> (equivalent to std::weak_ptr<T>) that can be obtained from an instance of Rc<T>.
use std::rc::Rc;
+
+struct LoudInt(i32);
+
+impl Drop for LoudInt {
+ fn drop(&mut self) {
+ println!("[{}] Farewell!", self.0);
+ }
+}
+
+fn main() {
+ let weak_ref;
+
+ {
+ let shared_ref = Rc::new(LoudInt(5));
+
+ // weak_count keeps track of the non-owning reference to the data
+ assert_eq!(Rc::weak_count(&shared_ref), 0);
+
+ // `downgrade()` obtains a weak pointer to Rc's data
+ weak_ref = Rc::downgrade(&shared_ref);
+
+ assert_eq!(Rc::weak_count(&shared_ref), 1);
+ assert_eq!(Rc::strong_count(&shared_ref), 1);
+
+ // In order to use the the data underneath the weak pointer
+ // we need to obtain a new shared pointer from it.
+ // The `upgrade()` method returns `Option<Rc<T>>`.
+ let temp = weak_ref.upgrade();
+ assert_eq!(Rc::strong_count(&shared_ref), 2);
+ println!("The value is {}", temp.unwrap().0);
+ }
+
+ println!("The value should be deallocated by now.");
+ assert!(weak_ref.upgrade().is_none());
+}
+
+(Download the source code for this example: weak_ref.rs)
+Mutating the immutable
+Good examples and explanation of the interior mutability pattern and runtime borrow checking can be found in the book.
+Alongside the RefCell<T> type described above, there is an analogous Cell<T> type that operates on values instead of references.
Convenient handling of dyn objects
+In previous labs you learned about dynamic dispatch and its strengths. The largest drawback you noticed is most likely that they are unsized (!Sized, where ! being syntax signifying lack of trait implementation).
When storing an object on a heap, however, we can use it as a dyn object seamlessly.
Obligatory reading
+-
+
Additional reading
+ +Assignment 5 (graded)
+ +Deadline: 13.11.2024 23:59
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/09-concurrency/index.html b/lessons/09-concurrency/index.html
new file mode 100644
index 0000000..b3a7cc6
--- /dev/null
+++ b/lessons/09-concurrency/index.html
@@ -0,0 +1,389 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Feedback #2
++ 2022-11-21 (last edit: 2022-11-21) +
+Feedback
+Conditional implementation
+impl<const N: usize> Shape for SphereN<N> {
+ type Volume = VolumeN<N>;
+ fn volume(&self) -> Self::Volume {
+ let mut volume: u32 = (f64::from(self.radius) * f64::from(self.radius) * PI) as u32;
+ if N == 3 {
+ volume = (f64::from(self.radius)
+ * f64::from(self.radius)
+ * f64::from(self.radius)
+ * PI
+ * 4.0_f64
+ / 3.0_f64) as u32;
+ }
+ Self::Volume::new(volume)
+ }
+}
+Instead of checking N == 3, you can provide different impls for SphereN<2> and
+SphereN<3> (as they are different types).
u32 and u64
+They are different types, but because you can easily cast one to another, +it was not sufficient to make the implementation type-safe.
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/10-design-patterns/index.html b/lessons/10-design-patterns/index.html
new file mode 100644
index 0000000..39eb103
--- /dev/null
+++ b/lessons/10-design-patterns/index.html
@@ -0,0 +1,246 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Fearless concurrency
++ 2024-11-14 (last edit: 2024-11-14) +
+Parallelism vs Concurrency
+Concurrency is when tasks can make progress independently of each other.
+Parallelism is when multiple tasks make progress at the same time.
+Concurrency models in Rust
+Threads
+Nothing unusual here.
+Threads can be created with the thread::spawn function docs - please read them!.
This method returns a JoinHandle<T> which can be used to wait for the thread to finish. T is the type of the thread's return value.
Another way to spawn threads is using scope. Threads created in such way are mandatorily joined at the end of the scope, which guarantees that they will borrow items for no longer that the lifetime of the scope. Hence, they can borrow non-'static items!
Propagating panics
+In Rust a panic of one thread doesn't affect the other threads (similar to how Java handles exceptions in threads).
+Closures
+Closures which are used to create threads must take ownership of any values they use. It can be forced with the move keyword.
use std::thread;
+
+fn main() {
+ let v = vec![1, 2, 3];
+
+ let handle = thread::spawn(move || {
+ println!("Here's a vector: {:?}", v);
+ });
+
+ handle.join().unwrap();
+}
+Normal ownership rules still apply. It means that we cannot mutate the vector in the spawned thread from the main thread!
+But what if we need to share some state?
+Send and Sync
+They are marker traits used to indicate that a type or a reference to it can be used across threads. See the nomicon for more information.
++++
+
This makes sense, because Sync is about sharing object between threads, and & is the shared reference.
There is also a great answer on Rust forum, listing + explaining example types that are !Send or !Sync.
For more convenient analysis, examples are listed here:
+Send + !Sync:
+-
+
!Send + !Sync:
+-
+
!Send + Sync:
+-
+
Exercise for the reader: explain reasons for all limitations of the above types.
+Sharing state between threads
+Message passing
+One possible way is to use message passing. We can use a blocking queue (called mpsc - "multi producer single consumer FIFO queue") to do it.
+We talked about blocking queues in the Concurrent programming class. In Rust, they are strongly-typed. Sending and receiving ends have different types.
Mutexes
+In Rust, a mutex wraps a value and makes it thread-safe.
+Because it becomes a part of the type, it's impossible to access the underlying value in an unsynchronized manner. It is conceptually similar to the RefCell type.
Arc is a smart pointer like Rc but it can be shared between threads.
Please read more about them in the book.
+The docs also mention poisoning.
RwLocks
+RwLocks are similar to mutexes, but they distinguish between read and write locks.
+Atomic types
+Atomic types are described in the docs.
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::{hint, thread};
+
+fn main() {
+ let spinlock = Arc::new(AtomicUsize::new(1));
+
+ let spinlock_clone = Arc::clone(&spinlock);
+ let thread = thread::spawn(move|| {
+ spinlock_clone.store(0, Ordering::SeqCst);
+ });
+
+ // Wait for the other thread to release the lock
+ while spinlock.load(Ordering::SeqCst) != 0 {
+ hint::spin_loop();
+ }
+
+ if let Err(panic) = thread.join() {
+ println!("Thread had an error: {:?}", panic);
+ }
+}
+Note that atomic values don't have to be wrapped in a mutex when shared across threads.
Wait...
+If most types are Sync + Send, then what stops us from using a standard, non-atomic integer in the example above?
let spinlock = Arc::new(1);
+
+let spinlock_clone = Arc::clone(&spinlock);
+let thread = thread::spawn(move|| {
+ *spinlock_clone += 1;
+});
+
+while *spinlock != 0 {
+ hint::spin_loop();
+}
+error[E0594]: cannot assign to data in an `Arc`
+ --> src/main.rs:9:9
+ |
+9 | *spinlock_clone += 1;
+ | ^^^^^^^^^^^^^^^^^^^^ cannot assign
+ |
+ = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Arc<i32>`
+...so we would have to use a RefCell to be able to modify the value through a shared reference...
let spinlock = Arc::new(RefCell::new(1));
+
+let spinlock_clone = Arc::clone(&spinlock);
+let thread = thread::spawn(move|| {
+ *spinlock_clone.borrow_mut() += 1;
+});
+
+// Wait for the other thread to release the lock
+while *spinlock.borrow() != 0 {
+ hint::spin_loop();
+}
+...but RefCell isn't Sync:
error[E0277]: `RefCell<i32>` cannot be shared between threads safely
+ --> src/main.rs:9:18
+ |
+9 | let thread = thread::spawn(move|| {
+ | ^^^^^^^^^^^^^ `RefCell<i32>` cannot be shared between threads safely
+ |
+ = help: the trait `Sync` is not implemented for `RefCell<i32>`
+ = note: required because of the requirements on the impl of `Send` for `Arc<RefCell<i32>>`
+ = note: required because it appears within the type `[closure@src/main.rs:9:32: 11:6]`
+note: required by a bound in `spawn`
+And that bound mentioned in the last line looks like this:
+pub fn spawn<F, T>(f: F) -> JoinHandle<T> where
+ F: FnOnce() -> T,
+ F: Send + 'static,
+ T: Send + 'static,
+Exercise for the reader
+Why is it impossible to share a reference to a Mutex between threads spawned with std::thread::spawn?
Data parallelism with Rayon
+Rayon is a library for parallelization of data processing.
+It can be used to parallelize the execution of functions over a collection of data by switching the standard Iterator to a ParallelIterator.
+It works very similar to Java's parallel streams.
Why do that? Because thread synchronization is hard! Rust prevents data races, but logical races and deadlocks are impossible to prevent!!
+Rayon's FAQ is worth reading.
+Reading
+ +No assignment this week
+Please work on the first iteration of the big project instead.
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/11-async-1/index.html b/lessons/11-async-1/index.html
new file mode 100644
index 0000000..edf8ec1
--- /dev/null
+++ b/lessons/11-async-1/index.html
@@ -0,0 +1,240 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Design patterns
++ 2024-11-21 (last edit: 2022-12-05) +
+Object-oriented programming and Rust
+The book has a chapter dedicated to it. +Especially the "typestate" pattern is very interesting. +You can read more about it here.
+How to build a good library
+These guidelines have been created by the Rust library team.
+How to handle errors
+This post is from 2020, but the libraries it mentions (anyhow and thiserror) are still the most popular.
Serde
+Serde is the most popular serialization library for Rust.
+Assignment
+This week's assignment is to write a "distributed" calculator. +You should base your solution on the final project from the book.
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/12-project-feedback/index.html b/lessons/12-project-feedback/index.html
new file mode 100644
index 0000000..6feaa23
--- /dev/null
+++ b/lessons/12-project-feedback/index.html
@@ -0,0 +1,396 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Async: Part 1
++ 2024-11-28 (last edit: 2024-11-27) +
+Tokio
+We'll use the Tokio tutorial (chapters Overview-Channels).
Common Rust Lifetime Misconceptions
+Please read this blogpost.
+Assignment 6 (graded)
+ +Deadline: 04.12.2024 23:59
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/13-async-2/index.html b/lessons/13-async-2/index.html
new file mode 100644
index 0000000..d26f921
--- /dev/null
+++ b/lessons/13-async-2/index.html
@@ -0,0 +1,388 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Project feedback
++ 2022-12-29 (last edit: 2022-12-29) +
+Project feedback
+Unwrapping options/results
+Always ask yourself twice if you really need to unwrap. In most cases, you don't have to. Use pattern matching instead, +as it provides a static guarantee that the value is present.
+Pattern matching prevents you from writing code like this:
+fn main() {
+ let x: Option<i32> = some_function();
+
+ if x.is_some() {
+ println!("x is {}", x.unwrap());
+ }
+
+ // Let's say this line was added later and/or you forgot to put it in the if statement.
+ do_something(x.unwrap()); // this will blow up if x == None!
+}
+Instead, you can write:
+fn main() {
+ let x: Option<i32> = some_function();
+
+ if let Some(x) = x {
+ println!("x is {}", x);
+ do_something(x);
+ }
+}
+Question mark operator
+In methods that return Result or Option, you can use the question mark operator to return early if the value is None or Err.
+See: https://doc.rust-lang.org/rust-by-example/std/result/question_mark.html
Logging
+You can use the log crate to log messages. It's better than println! because it
+can be easily turned off. It also allows you to use different severity levels (e.g. info, warn, error) and only
+log messages above a certain level.
&String vs &str
+See https://doc.rust-lang.org/book/ch04-03-slices.html#string-slices-as-parameters
+In general, if you want to pass a reference to a string, use &str instead of &String.
Use current versions of dependencies
+You can use cargo upgrades to check for outdated dependencies.
+If your project has separate binaries, use multiple binaries or a workspace
+You can have multiple binaries in a single cargo project. Simply place them in the src/bin directory.
+You can run them with cargo run --bin <name>. Alternatively, you can setup a
+workspace.
Run clippy & cargo fmt
+This should have become a habit by now. You can disable clippy warnings for a single item with #[allow(clippy::...)],
+but in most cases you shouldn't do that.
If you need to escape characters in a string, use raw strings
+See https://doc.rust-lang.org/reference/tokens.html#raw-string-literals
+How to handle errors?
+Short: https://kerkour.com/rust-error-handling
+Long: https://www.lpalmieri.com/posts/error-handling-rust/
+Don't pass around locked mutex's contents
+If you have a mutex, you can use lock() to get a guard that will unlock the mutex when it goes out of scope.
+But don't pass the contents of the guard to functions that can block (unless the mutex must be locked for
+the entire duration of the function).
+Instead of:
use std::sync::Mutex;
+use std::thread;
+use std::time::Duration;
+use std::time::Instant;
+
+fn handle_function(counter: &mut i32) {
+ thread::sleep(Duration::from_secs(1));
+ *counter += 1;
+ thread::sleep(Duration::from_secs(1));
+}
+
+fn main() {
+ let counter = Mutex::new(1);
+
+ thread::scope(|s| {
+ for i in 0..10 {
+ let counter = &counter;
+ s.spawn(move || {
+ println!("Thread {i} started");
+ let now = Instant::now();
+ let mut counter = counter.lock().unwrap();
+ handle_function(&mut counter); // lock is held for 2 seconds
+ println!("Thread {i} finished after {}s", now.elapsed().as_secs());
+ });
+ }
+ })
+}
+You should do this:
+use std::sync::Mutex;
+use std::thread;
+use std::time::Duration;
+use std::time::Instant;
+
+fn handle_function(counter: &Mutex<i32>) { // <-- changed
+ thread::sleep(Duration::from_secs(1));
+ {
+ let mut counter = counter.lock().unwrap(); // <-- changed
+ *counter += 1;
+ // lock is held only for the duration of the block
+ // it is important to create a new scope here, otherwise the lock would be held for another second
+ }
+ thread::sleep(Duration::from_secs(1));
+}
+
+fn main() {
+ let counter = Mutex::new(1);
+
+ thread::scope(|s| {
+ for i in 0..10 {
+ let counter = &counter;
+ s.spawn(move || {
+ println!("Thread {i} started");
+ let now = Instant::now();
+ handle_function(counter); // <-- changed! we don't lock here
+ println!("Thread {i} finished after {}s", now.elapsed().as_secs());
+ });
+ }
+ })
+}
+
+Compare the output of the two programs. The first one will take 20 seconds to finish, while the second one will take 2 seconds.
+First one:
+Thread 1 started
+Thread 0 started
+Thread 2 started
+Thread 3 started
+Thread 4 started
+Thread 5 started
+Thread 6 started
+Thread 7 started
+Thread 8 started
+Thread 9 started
+Thread 1 finished after 2s
+Thread 0 finished after 4s
+Thread 2 finished after 6s
+Thread 3 finished after 8s
+Thread 4 finished after 10s
+Thread 5 finished after 12s
+Thread 6 finished after 14s
+Thread 7 finished after 16s
+Thread 8 finished after 18s
+Thread 9 finished after 20s
+
+Second one:
+Thread 0 started
+Thread 2 started
+Thread 1 started
+Thread 3 started
+Thread 4 started
+Thread 5 started
+Thread 6 started
+Thread 7 started
+Thread 8 started
+Thread 9 started
+Thread 1 finished after 2s
+Thread 2 finished after 2s
+Thread 0 finished after 2s
+Thread 3 finished after 2s
+Thread 4 finished after 2s
+Thread 5 finished after 2s
+Thread 6 finished after 2s
+Thread 7 finished after 2s
+Thread 8 finished after 2s
+Thread 9 finished after 2s
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/14-macros/index.html b/lessons/14-macros/index.html
new file mode 100644
index 0000000..a3d1702
--- /dev/null
+++ b/lessons/14-macros/index.html
@@ -0,0 +1,245 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Async: Part 2
++ 2024-12-05 (last edit: 2022-05-23) +
+Reinventing futures
+We recently got our feet wet with the async/await functionality of Rust by using the Tokio library. With this basic understanding of what we expect out of futures, let's try to come up with their details ourselves.
We know that, when asked, a future can either give us a ready value or still be waiting for it. Asking about the future's result is called polling. Our future could look something like this:
+trait SimpleFuture {
+ type Output;
+ fn poll(&mut self) -> Poll<Self::Output>;
+}
+
+enum Poll<T> {
+ Ready(T),
+ Pending,
+}
+The poll method can be called to check for the result of the future. There is a flaw in this however - whatever is coordinating our future-based computations will have to constantly poll each of them in hope they are ready to do some work.
trait SimpleFuture {
+ type Output;
+ fn poll(&mut self, wake: fn()) -> Poll<Self::Output>;
+}
+
+We can solve this by attaching a callback to our polling. The wake function passed to poll can be used to notify whoever issued the poll that the future is ready to make some progress and should be polled.
Let's picture a quick example of how our SimpleFuture could be used.
pub struct SocketRead<'a> {
+ socket: &'a Socket,
+}
+
+impl SimpleFuture for SocketRead<'_> {
+ type Output = Vec<u8>;
+
+ fn poll(&mut self, wake: fn()) -> Poll<Self::Output> {
+ if self.socket.has_data_to_read() {
+ // The socket has data -- read it into a buffer and return it.
+ Poll::Ready(self.socket.read_buf())
+ } else {
+ // The socket does not yet have data.
+ //
+ // Arrange for `wake` to be called once data is available.
+ // When data becomes available, `wake` will be called, and the
+ // user of this `Future` will know to call `poll` again and
+ // receive data.
+ self.socket.set_readable_callback(wake);
+ Poll::Pending
+ }
+ }
+}
+Combining futures
+With the SimpleFuture at our disposal we can easily model more advanced concurrent computations.
/// Concurrency is achieved via the fact that calls to `poll` each future
+/// may be interleaved, allowing each future to advance itself at its own pace.
+pub struct Join<FutureA, FutureB> {
+ // Each field may contain a future that should be run to completion.
+ // If the future has already completed, the field is set to `None`.
+ // This prevents us from polling a future after it has completed, which
+ // would violate the contract of the `Future` trait.
+ a: Option<FutureA>,
+ b: Option<FutureB>,
+}
+
+impl<FutureA, FutureB> SimpleFuture for Join<FutureA, FutureB>
+where
+ FutureA: SimpleFuture<Output = ()>,
+ FutureB: SimpleFuture<Output = ()>,
+{
+ type Output = ();
+ fn poll(&mut self, wake: fn()) -> Poll<Self::Output> {
+ // Attempt to complete future `a`.
+ if let Some(a) = &mut self.a {
+ if let Poll::Ready(()) = a.poll(wake) {
+ self.a.take();
+ }
+ }
+
+ // Attempt to complete future `b`.
+ if let Some(b) = &mut self.b {
+ if let Poll::Ready(()) = b.poll(wake) {
+ self.b.take();
+ }
+ }
+
+ if self.a.is_none() && self.b.is_none() {
+ // Both futures have completed -- we can return successfully
+ Poll::Ready(())
+ } else {
+ // One or both futures returned `Poll::Pending` and still have
+ // work to do. They will call `wake()` when progress can be made.
+ Poll::Pending
+ }
+ }
+}
+We can also queue futures like this:
+pub struct AndThenFut<FutureA, FutureB> {
+ first: Option<FutureA>,
+ second: FutureB,
+}
+
+impl<FutureA, FutureB> SimpleFuture for AndThenFut<FutureA, FutureB>
+where
+ FutureA: SimpleFuture<Output = ()>,
+ FutureB: SimpleFuture<Output = ()>,
+{
+ type Output = ();
+ fn poll(&mut self, wake: fn()) -> Poll<Self::Output> {
+ if let Some(first) = &mut self.first {
+ match first.poll(wake) {
+ // We've completed the first future -- remove it and start on
+ // the second!
+ Poll::Ready(()) => self.first.take(),
+ // We couldn't yet complete the first future.
+ Poll::Pending => return Poll::Pending,
+ };
+ }
+ // Now that the first future is done, attempt to complete the second.
+ self.second.poll(wake)
+ }
+}
+Exercise
+The last example assumes that both futures are already constructed. In practice, however, we often want to chain futures that use the results of their predecessors, like this - get_breakfast().and_then(|food| eat(food));. Try implementing this behavior by adding a new method to the SimpleFuture trait called and_then and something that models this sequential computation (like the previous AndThenFut future).
The real deal
+We weren't far from the actual way Rust's futures are structured. The Future trait looks as follows:
trait Future {
+ type Output;
+ fn poll(
+ // Note the change from `&mut self` to `Pin<&mut Self>`:
+ self: Pin<&mut Self>,
+ // and the change from `wake: fn()` to `cx: &mut Context<'_>`:
+ cx: &mut Context<'_>,
+ ) -> Poll<Self::Output>;
+}
+There are two differences here. Firstly, we use a context instead of a standalone wake method. Since this callback was just a simple function pointer, there was no way for it to hold any data pertaining to which future called it.
+Secondly, we take self as a Pin<>. This enables us to create immovable futures - we will go into it later.
Coordinating futures - waker & executor
+Using wakers and context
+We will follow the steps in the book to make a future that runs a separate thread that sleeps for a given duration and only then returns a result.
+Executor
+We will follow the steps in the book to create our own executor to run our futures on.
+Obligatory reading
+ +Additional reading
+-
+
Assignment 7 (graded)
+ +Deadline: 18.12.2024 23:59
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/index.html b/lessons/index.html
new file mode 100644
index 0000000..c0f6355
--- /dev/null
+++ b/lessons/index.html
@@ -0,0 +1,328 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Macros
++ 2024-12-12 (last edit: 2022-06-07) +
+Reading
+-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/old/2021L/00-organizational/index.html b/lessons/old/2021L/00-organizational/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/00-organizational/index.html
@@ -0,0 +1,43 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ List of lessons
+-
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/lessons/old/2021L/01-introduction/clippy.jpg b/lessons/old/2021L/01-introduction/clippy.jpg
new file mode 100644
index 0000000..cf490ba
Binary files /dev/null and b/lessons/old/2021L/01-introduction/clippy.jpg differ
diff --git a/lessons/old/2021L/01-introduction/conditionals.rs b/lessons/old/2021L/01-introduction/conditionals.rs
new file mode 100644
index 0000000..441aba6
--- /dev/null
+++ b/lessons/old/2021L/01-introduction/conditionals.rs
@@ -0,0 +1,20 @@
+#![allow(unused_variables)]
+
+fn main() {
+ let x = 42;
+
+ if x == 42 {
+ println!("x is 42");
+ } else if x == 43 {
+ println!("x is 43");
+ } else {
+ println!("x is not 42 or 43");
+ }
+
+ // we can also use ifs as expressions
+ let a_or_b = if x == 0 {
+ "a" // notice no semicolon at the end
+ } else {
+ "b"
+ };
+}
diff --git a/lessons/old/2021L/01-introduction/errors_demo.c b/lessons/old/2021L/01-introduction/errors_demo.c
new file mode 100644
index 0000000..936ac9c
--- /dev/null
+++ b/lessons/old/2021L/01-introduction/errors_demo.c
@@ -0,0 +1,35 @@
+#include Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/01-introduction/loops.rs b/lessons/old/2021L/01-introduction/loops.rs
new file mode 100644
index 0000000..8a02d72
--- /dev/null
+++ b/lessons/old/2021L/01-introduction/loops.rs
@@ -0,0 +1,55 @@
+#![allow(unused_variables)]
+
+fn main() {
+ for i in 0..10 {
+ println!("i is {}", i); // i in [0, 10)
+ }
+
+ let mut x = 0;
+
+ while x < 50 {
+ x += 1;
+ }
+
+ let mut y = 0;
+ let mut iterations = 0;
+ loop {
+ iterations += 1;
+ if iterations % 2 == 0 {
+ continue;
+ }
+ y += 1;
+ if y == 10 {
+ break;
+ }
+ }
+
+ // we can use labels to refer to a specific loop
+ let mut count = 0;
+ 'counting_up: loop {
+ let mut remaining = 10;
+
+ loop {
+ if remaining == 9 {
+ break;
+ }
+ if count == 2 {
+ break 'counting_up; // ends the outer loop
+ }
+ remaining -= 1;
+ }
+
+ count += 1;
+ }
+
+ // We can use break with a value.
+ // Because loops are expressions too,
+ // the value we break with will be returned from the functions
+ let mut counter = 0;
+ let value = loop {
+ counter += 1;
+ if counter == 10 {
+ break 32;
+ }
+ };
+}
diff --git a/lessons/old/2021L/01-introduction/variables.rs b/lessons/old/2021L/01-introduction/variables.rs
new file mode 100644
index 0000000..3350568
--- /dev/null
+++ b/lessons/old/2021L/01-introduction/variables.rs
@@ -0,0 +1,18 @@
+#![allow(unused_variables)]
+#![allow(unused_assignments)]
+
+fn main() {
+ let x = 40; // inferred type
+ let y: i32 = 100; // specified type
+
+ {
+ let x = 40 + 2; // shadowing
+ println!("x is {}", x); // prints 42
+ }
+
+ // x = 0; // compilation error, variables are by default immutable
+ let mut x = 40; // declare as mutable
+ x = 0; // now we can reassign
+
+ x += 1; // x = x + 1
+}
diff --git a/lessons/old/2021L/02-ownership/index.html b/lessons/old/2021L/02-ownership/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/02-ownership/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/03-data-types/data_types.rs b/lessons/old/2021L/03-data-types/data_types.rs
new file mode 100644
index 0000000..78cd053
--- /dev/null
+++ b/lessons/old/2021L/03-data-types/data_types.rs
@@ -0,0 +1,82 @@
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct Position(i32, i32); // tuple struct
+
+// Could Hero derive the Copy trait?
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct Hero {
+ name: String,
+ level: u32,
+ experience: u32,
+ position: Position,
+}
+
+// we can add methods to structs using the 'impl' keyword
+impl Hero {
+ // static method
+ fn new(name: String) -> Hero {
+ Hero {
+ name,
+ level: 1,
+ experience: 0,
+ position: Position(0, 0),
+ }
+ }
+}
+
+// multiple impl blocks are possible for one struct
+impl Hero {
+ // instance method, first argument (self) is the calling instance
+ fn distance(&self, pos: Position) -> u32 {
+ // fields of tuples and tuple structs can be accessed through 'tuple.[i]'
+ (pos.0 - self.position.0).unsigned_abs() + (pos.1 - self.position.1).unsigned_abs()
+ }
+
+ // mutable borrow of self allows to change instance fields
+ fn level_up(&mut self) {
+ self.experience = 0;
+ self.level += 1;
+ }
+
+ // 'self' is not borrowed here and will be moved into the method
+ fn die(self) {
+ println!(
+ "Here lies {}, a hero who reached level {}. RIP.",
+ self.name, self.level
+ );
+ }
+}
+
+fn main() {
+ let mut hero: Hero = Hero::new(String::from("Marty The Brave"));
+ hero.level_up(); // 'self' is always passed implicitly
+
+ // fields other than 'name' will be the same as in 'hero'
+ let steve = Hero {
+ name: String::from("Steve The Normal Guy"),
+ ..hero
+ };
+
+ assert_eq!(hero.level, steve.level);
+
+ let mut twin = hero.clone();
+
+ // we can compare Hero objects because it derives the PartialEq trait
+ assert_eq!(hero, twin);
+ twin.level_up();
+ assert_ne!(hero, twin);
+ hero.level_up();
+ assert_eq!(hero, twin);
+
+ // we can print out a the struct's debug string with '{:?}'
+ println!("print to stdout: {:?}", hero);
+
+ hero.die(); // 'hero' is not usable after this invocation, see the method's definiton
+
+ // the dbg! macro prints debug strings to stderr along with file and line number
+ dbg!("print to stderr: {}", twin);
+
+ let pos = Position(42, 0);
+ let dist = steve.distance(pos); // no clone here as Position derives the Copy trait
+ println!("{:?}", pos);
+ assert_eq!(dist, 42);
+}
diff --git a/lessons/old/2021L/03-data-types/index.html b/lessons/old/2021L/03-data-types/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/03-data-types/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/04-enums/enums.c b/lessons/old/2021L/04-enums/enums.c
new file mode 100644
index 0000000..9e60c40
--- /dev/null
+++ b/lessons/old/2021L/04-enums/enums.c
@@ -0,0 +1,29 @@
+#include Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/04-enums/option.rs b/lessons/old/2021L/04-enums/option.rs
new file mode 100644
index 0000000..3c73877
--- /dev/null
+++ b/lessons/old/2021L/04-enums/option.rs
@@ -0,0 +1,112 @@
+#![allow(unused_assignments)]
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+fn main() {
+ let mut not_null: i32 = 42;
+ not_null = 43;
+ // not_null = None; // this won't compile because it's a different type!
+
+ let mut nullable: OptionWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/05-tests/test.rs b/lessons/old/2021L/05-tests/test.rs
new file mode 100644
index 0000000..e78bb7f
--- /dev/null
+++ b/lessons/old/2021L/05-tests/test.rs
@@ -0,0 +1,30 @@
+// This function is going to be used only in the tests, so we add the `#[cfg(test)]` attribute.
+// It means that it won't be compiled in the final executable.
+#[cfg(test)]
+fn return_42() -> i32 {
+ 42
+}
+
+fn frobnicate(x: i32) -> i32 {
+ println!("frobicating...!");
+ x + 40
+}
+
+fn main() {
+ frobnicate(2);
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn it_works() {
+ assert_eq!(return_42(), 42);
+ }
+
+ #[test]
+ fn test_frobnicate() {
+ assert_eq!(frobnicate(2), 42);
+ }
+}
diff --git a/lessons/old/2021L/06-types-reasoning/basic_trait.rs b/lessons/old/2021L/06-types-reasoning/basic_trait.rs
new file mode 100644
index 0000000..1c76202
--- /dev/null
+++ b/lessons/old/2021L/06-types-reasoning/basic_trait.rs
@@ -0,0 +1,38 @@
+#![allow(dead_code)]
+
+trait Summary {
+ fn summarize(&self) -> String;
+}
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Summary for NewsArticle {
+ fn summarize(&self) -> String {
+ format!("{}, by {} ({})", self.headline, self.author, self.location)
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+impl Summary for Tweet {
+ fn summarize(&self) -> String {
+ format!("{}: {}", self.username, self.content)
+ }
+}
+
+fn main() {
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ println!("1 new tweet: {}", tweet.summarize());
+}
diff --git a/lessons/old/2021L/06-types-reasoning/generic_largest.rs b/lessons/old/2021L/06-types-reasoning/generic_largest.rs
new file mode 100644
index 0000000..7aa6a3b
--- /dev/null
+++ b/lessons/old/2021L/06-types-reasoning/generic_largest.rs
@@ -0,0 +1,23 @@
+fn largestWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/06-types-reasoning/lifetimes_basic.rs b/lessons/old/2021L/06-types-reasoning/lifetimes_basic.rs
new file mode 100644
index 0000000..a4eaa2b
--- /dev/null
+++ b/lessons/old/2021L/06-types-reasoning/lifetimes_basic.rs
@@ -0,0 +1,27 @@
+fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
+ if first.len() > second.len() {
+ first
+ } else {
+ second
+ }
+}
+
+fn main() {
+ let string1 = String::from("long string is long");
+
+ {
+ let string2 = String::from("xyz");
+ let result = longest(string1.as_str(), string2.as_str());
+ println!("The longest string is {}", result);
+ }
+
+ // This doesn't compile - incorrect lifetimes
+ //
+ // let string1 = String::from("long string is long");
+ // let result;
+ // {
+ // let string2 = String::from("xyz");
+ // result = longest(string1.as_str(), string2.as_str());
+ // }
+ // println!("The longest string is {}", result);
+}
diff --git a/lessons/old/2021L/06-types-reasoning/lifetimes_elision.rs b/lessons/old/2021L/06-types-reasoning/lifetimes_elision.rs
new file mode 100644
index 0000000..9633909
--- /dev/null
+++ b/lessons/old/2021L/06-types-reasoning/lifetimes_elision.rs
@@ -0,0 +1,16 @@
+fn first_two(seq: &[u32]) -> &[u32] {
+ if seq.len() < 2 {
+ seq
+ } else {
+ &seq[..2]
+ }
+}
+
+fn main() {
+ let seq = [1, 2, 3, 4];
+
+ println!(
+ "First two elements of the sequence: {:?}",
+ first_two(&seq[..])
+ );
+}
diff --git a/lessons/old/2021L/06-types-reasoning/non_generic.rs b/lessons/old/2021L/06-types-reasoning/non_generic.rs
new file mode 100644
index 0000000..c983e3b
--- /dev/null
+++ b/lessons/old/2021L/06-types-reasoning/non_generic.rs
@@ -0,0 +1,35 @@
+fn largest_i32(list: &[i32]) -> i32 {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn largest_char(list: &[char]) -> char {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn main() {
+ let number_list = vec![34, 50, 25, 100, 65];
+
+ let result = largest_i32(&number_list);
+ println!("The largest number is {}", result);
+
+ let char_list = vec!['y', 'm', 'a', 'q'];
+
+ let result = largest_char(&char_list);
+ println!("The largest char is {}", result);
+}
diff --git a/lessons/old/2021L/06-types-reasoning/static_dynamic_dispatch.rs b/lessons/old/2021L/06-types-reasoning/static_dynamic_dispatch.rs
new file mode 100644
index 0000000..2d9eeda
--- /dev/null
+++ b/lessons/old/2021L/06-types-reasoning/static_dynamic_dispatch.rs
@@ -0,0 +1,47 @@
+trait Speak {
+ fn speak(&self) -> &'static str;
+}
+
+struct Dog;
+
+impl Speak for Dog {
+ fn speak(&self) -> &'static str {
+ "Hau hau" // it's a Polish dog!
+ }
+}
+
+struct Human;
+
+impl Speak for Human {
+ fn speak(&self) -> &'static str {
+ "Hello world"
+ }
+}
+
+// It works like templates in C++
+// A different function will be generated for each T during compilation
+// This process is called "monomorphization"
+fn static_dispatchWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/07-feedback/number_conversions.rs b/lessons/old/2021L/07-feedback/number_conversions.rs
new file mode 100644
index 0000000..9dd324b
--- /dev/null
+++ b/lessons/old/2021L/07-feedback/number_conversions.rs
@@ -0,0 +1,9 @@
+fn main() {
+ let small_number: u32 = u32::MAX;
+ // dbg!(small_number + 1); // this will panic (in debug builds, in release build it will wrap)
+ assert_eq!(small_number as u8, 255);
+ assert_eq!(small_number as i8, -1);
+ assert_eq!(small_number as i64, 4294967295);
+ let converted: ResultWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/09-feedback2/combinators.rs b/lessons/old/2021L/09-feedback2/combinators.rs
new file mode 100644
index 0000000..f82b7f7
--- /dev/null
+++ b/lessons/old/2021L/09-feedback2/combinators.rs
@@ -0,0 +1,37 @@
+fn main() {
+ let mut res: ResultWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/10-smart-pointers/box.rs b/lessons/old/2021L/10-smart-pointers/box.rs
new file mode 100644
index 0000000..9a9f99e
--- /dev/null
+++ b/lessons/old/2021L/10-smart-pointers/box.rs
@@ -0,0 +1,18 @@
+fn box_simple() {
+ let b = Box::new(5);
+ println!("b = {}", b);
+
+ let _x = 10 + *b;
+}
+
+// `Box` gives us the indirection required to define
+// recursive types
+#[allow(dead_code)]
+enum List {
+ Cons(i32, BoxWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
- ),
+ Nil,
+}
+
+fn main() {
+ box_simple();
+}
diff --git a/lessons/old/2021L/10-smart-pointers/deref_coercion.rs b/lessons/old/2021L/10-smart-pointers/deref_coercion.rs
new file mode 100644
index 0000000..c5b14c7
--- /dev/null
+++ b/lessons/old/2021L/10-smart-pointers/deref_coercion.rs
@@ -0,0 +1,39 @@
+use std::ops::Deref;
+
+struct MyBox
+
+
+
+
+
diff --git a/lessons/old/2021L/10-smart-pointers/ref_count.rs b/lessons/old/2021L/10-smart-pointers/ref_count.rs
new file mode 100644
index 0000000..0f97932
--- /dev/null
+++ b/lessons/old/2021L/10-smart-pointers/ref_count.rs
@@ -0,0 +1,31 @@
+use std::rc::Rc;
+
+struct LoudInt(i32);
+
+impl Drop for LoudInt {
+ fn drop(&mut self) {
+ println!("[{}] Farewell!", self.0);
+ }
+}
+
+fn main() {
+ {
+ let outer_ref;
+
+ {
+ let inner_ref = Rc::new(LoudInt(5));
+
+ // strong_count represents the number of owning references pointing
+ // to data
+ assert_eq!(Rc::strong_count(&inner_ref), 1);
+
+ outer_ref = Rc::clone(&inner_ref);
+
+ assert_eq!(Rc::strong_count(&inner_ref), Rc::strong_count(&outer_ref));
+ assert_eq!(Rc::strong_count(&inner_ref), 2);
+ }
+
+ println!("The {} still lives!", outer_ref.0);
+ assert_eq!(Rc::strong_count(&outer_ref), 1);
+ }
+}
diff --git a/lessons/old/2021L/10-smart-pointers/weak_ref.rs b/lessons/old/2021L/10-smart-pointers/weak_ref.rs
new file mode 100644
index 0000000..b2406f6
--- /dev/null
+++ b/lessons/old/2021L/10-smart-pointers/weak_ref.rs
@@ -0,0 +1,36 @@
+use std::rc::Rc;
+
+struct LoudInt(i32);
+
+impl Drop for LoudInt {
+ fn drop(&mut self) {
+ println!("[{}] Farewell!", self.0);
+ }
+}
+
+fn main() {
+ let weak_ref;
+
+ {
+ let shared_ref = Rc::new(LoudInt(5));
+
+ // weak_count keeps track of the non-owning reference to the data
+ assert_eq!(Rc::weak_count(&shared_ref), 0);
+
+ // `downgrade()` obtains a weak pointer to Rc's data
+ weak_ref = Rc::downgrade(&shared_ref);
+
+ assert_eq!(Rc::weak_count(&shared_ref), 1);
+ assert_eq!(Rc::strong_count(&shared_ref), 1);
+
+ // In order to use the the data underneath the weak pointer
+ // we need to obtain a new shared pointer from it.
+ // The `upgrade()` method returns `OptionWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/12-concurrency/index.html b/lessons/old/2021L/12-concurrency/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/12-concurrency/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/13-design-patterns/index.html b/lessons/old/2021L/13-design-patterns/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/13-design-patterns/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/14-async-1/index.html b/lessons/old/2021L/14-async-1/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/14-async-1/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/15-async-2/index.html b/lessons/old/2021L/15-async-2/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/15-async-2/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/16-macros/index.html b/lessons/old/2021L/16-macros/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/16-macros/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2021L/b1-rusty-graphs/index.html b/lessons/old/2021L/b1-rusty-graphs/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2021L/b1-rusty-graphs/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/00-organizational/index.html b/lessons/old/2022Z/00-organizational/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2022Z/00-organizational/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/01-introduction/clippy.jpg b/lessons/old/2022Z/01-introduction/clippy.jpg
new file mode 100644
index 0000000..cf490ba
Binary files /dev/null and b/lessons/old/2022Z/01-introduction/clippy.jpg differ
diff --git a/lessons/old/2022Z/01-introduction/conditionals.rs b/lessons/old/2022Z/01-introduction/conditionals.rs
new file mode 100644
index 0000000..441aba6
--- /dev/null
+++ b/lessons/old/2022Z/01-introduction/conditionals.rs
@@ -0,0 +1,20 @@
+#![allow(unused_variables)]
+
+fn main() {
+ let x = 42;
+
+ if x == 42 {
+ println!("x is 42");
+ } else if x == 43 {
+ println!("x is 43");
+ } else {
+ println!("x is not 42 or 43");
+ }
+
+ // we can also use ifs as expressions
+ let a_or_b = if x == 0 {
+ "a" // notice no semicolon at the end
+ } else {
+ "b"
+ };
+}
diff --git a/lessons/old/2022Z/01-introduction/cpp_meme.jpg b/lessons/old/2022Z/01-introduction/cpp_meme.jpg
new file mode 100644
index 0000000..4ec2e17
Binary files /dev/null and b/lessons/old/2022Z/01-introduction/cpp_meme.jpg differ
diff --git a/lessons/old/2022Z/01-introduction/errors_demo.c b/lessons/old/2022Z/01-introduction/errors_demo.c
new file mode 100644
index 0000000..936ac9c
--- /dev/null
+++ b/lessons/old/2022Z/01-introduction/errors_demo.c
@@ -0,0 +1,35 @@
+#include Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/01-introduction/loops.rs b/lessons/old/2022Z/01-introduction/loops.rs
new file mode 100644
index 0000000..8a02d72
--- /dev/null
+++ b/lessons/old/2022Z/01-introduction/loops.rs
@@ -0,0 +1,55 @@
+#![allow(unused_variables)]
+
+fn main() {
+ for i in 0..10 {
+ println!("i is {}", i); // i in [0, 10)
+ }
+
+ let mut x = 0;
+
+ while x < 50 {
+ x += 1;
+ }
+
+ let mut y = 0;
+ let mut iterations = 0;
+ loop {
+ iterations += 1;
+ if iterations % 2 == 0 {
+ continue;
+ }
+ y += 1;
+ if y == 10 {
+ break;
+ }
+ }
+
+ // we can use labels to refer to a specific loop
+ let mut count = 0;
+ 'counting_up: loop {
+ let mut remaining = 10;
+
+ loop {
+ if remaining == 9 {
+ break;
+ }
+ if count == 2 {
+ break 'counting_up; // ends the outer loop
+ }
+ remaining -= 1;
+ }
+
+ count += 1;
+ }
+
+ // We can use break with a value.
+ // Because loops are expressions too,
+ // the value we break with will be returned from the functions
+ let mut counter = 0;
+ let value = loop {
+ counter += 1;
+ if counter == 10 {
+ break 32;
+ }
+ };
+}
diff --git a/lessons/old/2022Z/01-introduction/students/gasinska.py b/lessons/old/2022Z/01-introduction/students/gasinska.py
new file mode 100644
index 0000000..e4989f1
--- /dev/null
+++ b/lessons/old/2022Z/01-introduction/students/gasinska.py
@@ -0,0 +1,107 @@
+# sample 1 - different ways of removing elements from the list while iterating
+list1 = [1, 2, 3, 4]
+for idx, item in enumerate(list1):
+ del item
+list1
+
+# [1, 2, 3, 4]
+
+list2 = [1, 2, 3, 4]
+for idx, item in enumerate(list2):
+ list2.remove(item)
+list2
+
+# [2, 4]
+
+list3 = [1, 2, 3, 4]
+for idx, item in enumerate(list3[:]):
+ list3.remove(item)
+list3
+
+# []
+
+list4 = [1, 2, 3, 4]
+for idx, item in enumerate(list4):
+ list4.pop(idx)
+list4
+
+# [2, 4]
+
+# sample 2 - string interning
+a = "abc"
+b = "abc"
+a is b
+
+# True
+
+a = ''.join(['a', 'b', 'c'])
+b = ''.join(['a', 'b', 'c'])
+a is b
+
+# False
+
+a = "abc!"
+b = "abc!"
+a is b
+
+# False
+
+# sample 3 - chained operations
+(False == False) in [False]
+
+# False
+
+False == (False in [False])
+
+# False
+
+False == False in [False] # unexpected...
+
+# True
+
+# sample 4 - is operator
+a = 256
+b = 256
+a is b
+
+# True
+
+a = 257
+b = 257
+a is b
+
+# False
+
+a, b = 257, 257
+a is b
+
+# True
+
+257 is 257
+
+# <>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# <>:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# C:\Users\kgasinsk\AppData\Local\Temp\ipykernel_15776\331119389.py:1: SyntaxWarning: "is" with a literal. Did you mean "=="?
+# 257 is 257
+
+# sample 5 - local variables
+def f(trufel):
+ if trufel:
+ y = 1
+ y += 1
+
+f(True) # everything is fine
+
+f(False) # gives error: local variable 'y' referenced before assignment
+
+# ---------------------------------------------------------------------------
+# UnboundLocalError Traceback (most recent call last)
+# Input In [17], in Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/03-data-types/data_types.rs b/lessons/old/2022Z/03-data-types/data_types.rs
new file mode 100644
index 0000000..78cd053
--- /dev/null
+++ b/lessons/old/2022Z/03-data-types/data_types.rs
@@ -0,0 +1,82 @@
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct Position(i32, i32); // tuple struct
+
+// Could Hero derive the Copy trait?
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct Hero {
+ name: String,
+ level: u32,
+ experience: u32,
+ position: Position,
+}
+
+// we can add methods to structs using the 'impl' keyword
+impl Hero {
+ // static method
+ fn new(name: String) -> Hero {
+ Hero {
+ name,
+ level: 1,
+ experience: 0,
+ position: Position(0, 0),
+ }
+ }
+}
+
+// multiple impl blocks are possible for one struct
+impl Hero {
+ // instance method, first argument (self) is the calling instance
+ fn distance(&self, pos: Position) -> u32 {
+ // fields of tuples and tuple structs can be accessed through 'tuple.[i]'
+ (pos.0 - self.position.0).unsigned_abs() + (pos.1 - self.position.1).unsigned_abs()
+ }
+
+ // mutable borrow of self allows to change instance fields
+ fn level_up(&mut self) {
+ self.experience = 0;
+ self.level += 1;
+ }
+
+ // 'self' is not borrowed here and will be moved into the method
+ fn die(self) {
+ println!(
+ "Here lies {}, a hero who reached level {}. RIP.",
+ self.name, self.level
+ );
+ }
+}
+
+fn main() {
+ let mut hero: Hero = Hero::new(String::from("Marty The Brave"));
+ hero.level_up(); // 'self' is always passed implicitly
+
+ // fields other than 'name' will be the same as in 'hero'
+ let steve = Hero {
+ name: String::from("Steve The Normal Guy"),
+ ..hero
+ };
+
+ assert_eq!(hero.level, steve.level);
+
+ let mut twin = hero.clone();
+
+ // we can compare Hero objects because it derives the PartialEq trait
+ assert_eq!(hero, twin);
+ twin.level_up();
+ assert_ne!(hero, twin);
+ hero.level_up();
+ assert_eq!(hero, twin);
+
+ // we can print out a the struct's debug string with '{:?}'
+ println!("print to stdout: {:?}", hero);
+
+ hero.die(); // 'hero' is not usable after this invocation, see the method's definiton
+
+ // the dbg! macro prints debug strings to stderr along with file and line number
+ dbg!("print to stderr: {}", twin);
+
+ let pos = Position(42, 0);
+ let dist = steve.distance(pos); // no clone here as Position derives the Copy trait
+ println!("{:?}", pos);
+ assert_eq!(dist, 42);
+}
diff --git a/lessons/old/2022Z/03-data-types/enums.c b/lessons/old/2022Z/03-data-types/enums.c
new file mode 100644
index 0000000..9e60c40
--- /dev/null
+++ b/lessons/old/2022Z/03-data-types/enums.c
@@ -0,0 +1,29 @@
+#include Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/03-data-types/option.rs b/lessons/old/2022Z/03-data-types/option.rs
new file mode 100644
index 0000000..3c73877
--- /dev/null
+++ b/lessons/old/2022Z/03-data-types/option.rs
@@ -0,0 +1,112 @@
+#![allow(unused_assignments)]
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+fn main() {
+ let mut not_null: i32 = 42;
+ not_null = 43;
+ // not_null = None; // this won't compile because it's a different type!
+
+ let mut nullable: OptionWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/05-types-reasoning/basic_trait.rs b/lessons/old/2022Z/05-types-reasoning/basic_trait.rs
new file mode 100644
index 0000000..1c76202
--- /dev/null
+++ b/lessons/old/2022Z/05-types-reasoning/basic_trait.rs
@@ -0,0 +1,38 @@
+#![allow(dead_code)]
+
+trait Summary {
+ fn summarize(&self) -> String;
+}
+
+struct NewsArticle {
+ headline: String,
+ location: String,
+ author: String,
+ content: String,
+}
+
+impl Summary for NewsArticle {
+ fn summarize(&self) -> String {
+ format!("{}, by {} ({})", self.headline, self.author, self.location)
+ }
+}
+
+struct Tweet {
+ username: String,
+ content: String,
+}
+
+impl Summary for Tweet {
+ fn summarize(&self) -> String {
+ format!("{}: {}", self.username, self.content)
+ }
+}
+
+fn main() {
+ let tweet = Tweet {
+ username: String::from("horse_ebooks"),
+ content: String::from("of course, as you probably already know, people"),
+ };
+
+ println!("1 new tweet: {}", tweet.summarize());
+}
diff --git a/lessons/old/2022Z/05-types-reasoning/generic_largest.rs b/lessons/old/2022Z/05-types-reasoning/generic_largest.rs
new file mode 100644
index 0000000..7aa6a3b
--- /dev/null
+++ b/lessons/old/2022Z/05-types-reasoning/generic_largest.rs
@@ -0,0 +1,23 @@
+fn largestWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/05-types-reasoning/lifetimes_basic.rs b/lessons/old/2022Z/05-types-reasoning/lifetimes_basic.rs
new file mode 100644
index 0000000..a4eaa2b
--- /dev/null
+++ b/lessons/old/2022Z/05-types-reasoning/lifetimes_basic.rs
@@ -0,0 +1,27 @@
+fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
+ if first.len() > second.len() {
+ first
+ } else {
+ second
+ }
+}
+
+fn main() {
+ let string1 = String::from("long string is long");
+
+ {
+ let string2 = String::from("xyz");
+ let result = longest(string1.as_str(), string2.as_str());
+ println!("The longest string is {}", result);
+ }
+
+ // This doesn't compile - incorrect lifetimes
+ //
+ // let string1 = String::from("long string is long");
+ // let result;
+ // {
+ // let string2 = String::from("xyz");
+ // result = longest(string1.as_str(), string2.as_str());
+ // }
+ // println!("The longest string is {}", result);
+}
diff --git a/lessons/old/2022Z/05-types-reasoning/lifetimes_elision.rs b/lessons/old/2022Z/05-types-reasoning/lifetimes_elision.rs
new file mode 100644
index 0000000..9633909
--- /dev/null
+++ b/lessons/old/2022Z/05-types-reasoning/lifetimes_elision.rs
@@ -0,0 +1,16 @@
+fn first_two(seq: &[u32]) -> &[u32] {
+ if seq.len() < 2 {
+ seq
+ } else {
+ &seq[..2]
+ }
+}
+
+fn main() {
+ let seq = [1, 2, 3, 4];
+
+ println!(
+ "First two elements of the sequence: {:?}",
+ first_two(&seq[..])
+ );
+}
diff --git a/lessons/old/2022Z/05-types-reasoning/non_generic.rs b/lessons/old/2022Z/05-types-reasoning/non_generic.rs
new file mode 100644
index 0000000..c983e3b
--- /dev/null
+++ b/lessons/old/2022Z/05-types-reasoning/non_generic.rs
@@ -0,0 +1,35 @@
+fn largest_i32(list: &[i32]) -> i32 {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn largest_char(list: &[char]) -> char {
+ let mut largest = list[0];
+
+ for &item in list {
+ if item > largest {
+ largest = item;
+ }
+ }
+
+ largest
+}
+
+fn main() {
+ let number_list = vec![34, 50, 25, 100, 65];
+
+ let result = largest_i32(&number_list);
+ println!("The largest number is {}", result);
+
+ let char_list = vec!['y', 'm', 'a', 'q'];
+
+ let result = largest_char(&char_list);
+ println!("The largest char is {}", result);
+}
diff --git a/lessons/old/2022Z/05-types-reasoning/static_dynamic_dispatch.rs b/lessons/old/2022Z/05-types-reasoning/static_dynamic_dispatch.rs
new file mode 100644
index 0000000..2d9eeda
--- /dev/null
+++ b/lessons/old/2022Z/05-types-reasoning/static_dynamic_dispatch.rs
@@ -0,0 +1,47 @@
+trait Speak {
+ fn speak(&self) -> &'static str;
+}
+
+struct Dog;
+
+impl Speak for Dog {
+ fn speak(&self) -> &'static str {
+ "Hau hau" // it's a Polish dog!
+ }
+}
+
+struct Human;
+
+impl Speak for Human {
+ fn speak(&self) -> &'static str {
+ "Hello world"
+ }
+}
+
+// It works like templates in C++
+// A different function will be generated for each T during compilation
+// This process is called "monomorphization"
+fn static_dispatchWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/07-smart-pointers/box.rs b/lessons/old/2022Z/07-smart-pointers/box.rs
new file mode 100644
index 0000000..9a9f99e
--- /dev/null
+++ b/lessons/old/2022Z/07-smart-pointers/box.rs
@@ -0,0 +1,18 @@
+fn box_simple() {
+ let b = Box::new(5);
+ println!("b = {}", b);
+
+ let _x = 10 + *b;
+}
+
+// `Box` gives us the indirection required to define
+// recursive types
+#[allow(dead_code)]
+enum List {
+ Cons(i32, BoxWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
- ),
+ Nil,
+}
+
+fn main() {
+ box_simple();
+}
diff --git a/lessons/old/2022Z/07-smart-pointers/deref_coercion.rs b/lessons/old/2022Z/07-smart-pointers/deref_coercion.rs
new file mode 100644
index 0000000..c5b14c7
--- /dev/null
+++ b/lessons/old/2022Z/07-smart-pointers/deref_coercion.rs
@@ -0,0 +1,39 @@
+use std::ops::Deref;
+
+struct MyBox
+
+
+
+
+
diff --git a/lessons/old/2022Z/07-smart-pointers/ref_count.rs b/lessons/old/2022Z/07-smart-pointers/ref_count.rs
new file mode 100644
index 0000000..0f97932
--- /dev/null
+++ b/lessons/old/2022Z/07-smart-pointers/ref_count.rs
@@ -0,0 +1,31 @@
+use std::rc::Rc;
+
+struct LoudInt(i32);
+
+impl Drop for LoudInt {
+ fn drop(&mut self) {
+ println!("[{}] Farewell!", self.0);
+ }
+}
+
+fn main() {
+ {
+ let outer_ref;
+
+ {
+ let inner_ref = Rc::new(LoudInt(5));
+
+ // strong_count represents the number of owning references pointing
+ // to data
+ assert_eq!(Rc::strong_count(&inner_ref), 1);
+
+ outer_ref = Rc::clone(&inner_ref);
+
+ assert_eq!(Rc::strong_count(&inner_ref), Rc::strong_count(&outer_ref));
+ assert_eq!(Rc::strong_count(&inner_ref), 2);
+ }
+
+ println!("The {} still lives!", outer_ref.0);
+ assert_eq!(Rc::strong_count(&outer_ref), 1);
+ }
+}
diff --git a/lessons/old/2022Z/07-smart-pointers/weak_ref.rs b/lessons/old/2022Z/07-smart-pointers/weak_ref.rs
new file mode 100644
index 0000000..b2406f6
--- /dev/null
+++ b/lessons/old/2022Z/07-smart-pointers/weak_ref.rs
@@ -0,0 +1,36 @@
+use std::rc::Rc;
+
+struct LoudInt(i32);
+
+impl Drop for LoudInt {
+ fn drop(&mut self) {
+ println!("[{}] Farewell!", self.0);
+ }
+}
+
+fn main() {
+ let weak_ref;
+
+ {
+ let shared_ref = Rc::new(LoudInt(5));
+
+ // weak_count keeps track of the non-owning reference to the data
+ assert_eq!(Rc::weak_count(&shared_ref), 0);
+
+ // `downgrade()` obtains a weak pointer to Rc's data
+ weak_ref = Rc::downgrade(&shared_ref);
+
+ assert_eq!(Rc::weak_count(&shared_ref), 1);
+ assert_eq!(Rc::strong_count(&shared_ref), 1);
+
+ // In order to use the the data underneath the weak pointer
+ // we need to obtain a new shared pointer from it.
+ // The `upgrade()` method returns `OptionWelcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/09-concurrency/index.html b/lessons/old/2022Z/09-concurrency/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2022Z/09-concurrency/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/10-design-patterns/index.html b/lessons/old/2022Z/10-design-patterns/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2022Z/10-design-patterns/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/11-async-1/index.html b/lessons/old/2022Z/11-async-1/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2022Z/11-async-1/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/old/2022Z/12-project-feedback/index.html b/lessons/old/2022Z/12-project-feedback/index.html
new file mode 100644
index 0000000..2bbc7ae
--- /dev/null
+++ b/lessons/old/2022Z/12-project-feedback/index.html
@@ -0,0 +1,43 @@
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
diff --git a/lessons/project-showcase/fail-menu.png b/lessons/project-showcase/fail-menu.png
new file mode 100644
index 0000000..ecee149
Binary files /dev/null and b/lessons/project-showcase/fail-menu.png differ
diff --git a/lessons/project-showcase/game.png b/lessons/project-showcase/game.png
new file mode 100644
index 0000000..65acfa6
Binary files /dev/null and b/lessons/project-showcase/game.png differ
diff --git a/lessons/project-showcase/graph_vis_demo.mkv b/lessons/project-showcase/graph_vis_demo.mkv
new file mode 100644
index 0000000..a2f08eb
Binary files /dev/null and b/lessons/project-showcase/graph_vis_demo.mkv differ
diff --git a/lessons/project-showcase/index.html b/lessons/project-showcase/index.html
new file mode 100644
index 0000000..420bd0d
--- /dev/null
+++ b/lessons/project-showcase/index.html
@@ -0,0 +1,277 @@
+
+
+
+
+
+
+
+ Welcome to Zola!
++ You're seeing this page because we couldn't find a template to render. +
+
+ To modify this page, create a page.html file in the templates directory or
+ install a theme.
+
+ You can find what variables are available in this template in the documentation.
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/lessons/project-showcase/rusty-dungeon.png b/lessons/project-showcase/rusty-dungeon.png
new file mode 100644
index 0000000..01f149d
Binary files /dev/null and b/lessons/project-showcase/rusty-dungeon.png differ
diff --git a/robots.txt b/robots.txt
new file mode 100644
index 0000000..c41df62
--- /dev/null
+++ b/robots.txt
@@ -0,0 +1,4 @@
+User-agent: *
+Disallow:
+Allow: /
+Sitemap: https://mimuw-jnp2-rust.github.io/sitemap.xml
diff --git a/search_index.en.js b/search_index.en.js
new file mode 100644
index 0000000..0a5842f
--- /dev/null
+++ b/search_index.en.js
@@ -0,0 +1 @@
+window.searchIndex = {"fields":["title","body"],"pipeline":["trimmer","stopWordFilter","stemmer"],"ref":"id","version":"0.9.5","index":{"body":{"root":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.3166247903554},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":6,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2}},"=":{"docs":{},"df":0,"1":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}},"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}},"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1},"4":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":1}}}}}}}}},"6":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}},"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1},"x":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"1":{"docs":{},"df":0,"0":{"docs":{},"df":0,"a":{"docs":{},"df":0,"7":{"docs":{},"df":0,"0":{"docs":{},"df":0,"6":{"docs":{},"df":0,"0":{"docs":{},"df":0,",":{"docs":{},"df":0,"0":{"docs":{},"df":0,"x":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":5.0990195135927845},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":12,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"/":{"docs":{},"df":0,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951}},"df":2}},"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":5,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":2}},"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951}},"df":1,":":{"docs":{},"df":0,"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":4,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"=":{"docs":{},"df":0,"1":{"docs":{},"df":0,"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"=":{"docs":{},"df":0,"1":{"docs":{},"df":0,"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}},"1":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":4},"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{},"df":0,".":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}},"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2},"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"2":{"docs":{},"df":0,".":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}},"9":{"docs":{},"df":0,".":{"docs":{},"df":0,"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"tf":1.0}},"df":1}}}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":12,".":{"docs":{},"df":0,"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"/":{"docs":{},"df":0,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}},"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"=":{"docs":{},"df":0,"2":{"docs":{},"df":0,"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}},"2":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1},"1":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.7320508075688772}},"df":1},"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}},"2":{"docs":{},"df":0,"1":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{},"df":0,".":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}},":":{"docs":{},"df":0,"5":{"docs":{},"df":0,"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":7}}}},"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1},"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.8284271247461903}},"df":1}},"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":3.3166247903554}},"df":1}},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":10,".":{"docs":{},"df":0,"0":{"docs":{},"df":0,"_":{"docs":{},"df":0,"f":{"docs":{},"df":0,"6":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}}},"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"=":{"docs":{},"df":0,"4":{"docs":{},"df":0,"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}},"1":{"docs":{},"df":0,"0":{"docs":{},"df":0,".":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2}},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":6,".":{"docs":{},"df":0,"0":{"docs":{},"df":0,"_":{"docs":{},"df":0,"f":{"docs":{},"df":0,"6":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}}},"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979}},"df":3},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}},"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":7,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"=":{"docs":{},"df":0,"6":{"docs":{},"df":0,"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}},"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":5,"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1},"6":{"docs":{},"df":0,"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}},"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"a":{"docs":{},"df":0,"7":{"docs":{},"df":0,"5":{"docs":{},"df":0,"0":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"0":{"docs":{},"df":0,"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}},"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":3,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}},"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":5},"_":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.1622776601683795},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":2,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"_":{"docs":{},"df":0,"0":{"docs":{},"df":0,"_":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979}},"df":1}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"a":{"docs":{},"df":0,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"(":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}},"_":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"b":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1},"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0}},"df":1},"o":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":7}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}},"c":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951}},"df":1}},"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":5}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}}}}},"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}}},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4}}}}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772}},"df":1}}}}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"v":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"0":{"docs":{},"df":0,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"0":{"docs":{},"df":0,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"0":{"docs":{},"df":0,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"0":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":6,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}},"e":{"docs":{},"df":0,"q":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":3}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"n":{"docs":{},"df":0,"2":{"docs":{},"df":0,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":5.5677643628300215}},"df":2,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}}}},"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"z":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1,"[":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"w":{"docs":{},"df":0,"[":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"[":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"k":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"k":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"b":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":2.0}},"df":2}}}}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}},"l":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.449489742783178}},"df":3},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":7,"(":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}},"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}}}}}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":2}}}}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":3}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":4}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}},"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":4}}}},"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":6,";":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979}},"df":1,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"'":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":3}}}}},"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"[":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"df":0,"y":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1},"u":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1}}}},"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{},"df":0,"[":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}}},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":2}},"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}},"d":{"docs":{},"df":0,"y":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}},"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":1}}}},"j":{"docs":{},"df":0,"o":{"docs":{},"df":0,"h":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"[":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.449489742783178}},"df":8,"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"[":{"docs":{},"df":0,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"1":{"docs":{},"df":0,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2,".":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}},"q":{"docs":{},"df":0,"[":{"docs":{},"df":0,".":{"docs":{},"df":0,".":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}},"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":4}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3,"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"y":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2}},"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}}},"d":{"docs":{},"df":0,"/":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}}},"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2,"(":{"docs":{},"df":0,"|":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"r":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"j":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178}},"df":1}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":2}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"y":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":6}}},"s":{"docs":{},"df":0,"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"y":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}}},"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.449489742783178}},"df":2,"(":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"_":{"docs":{},"df":0,"4":{"docs":{},"df":0,"2":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"(":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}},"4":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}},".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":2}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"x":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1},"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}}}}}}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"[":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"[":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"[":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}},"i":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":2,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}},"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":3},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"!":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"p":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"df":0,"e":{"docs":{},"df":0,"q":{"docs":{},"df":0,"!":{"docs":{},"df":0,"(":{"docs":{},"df":0,"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,".":{"docs":{},"df":0,"f":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"(":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"_":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"(":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}},"p":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}},"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":1}}}}}}}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}},"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"!":{"docs":{},"df":0,"(":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":10}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2}}},"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}},"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":2,"/":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0}},"df":1}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":2}}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":2}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":2,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}}}}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":2}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3}}}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},"k":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":5.291502622129181},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":5,"\"":{"docs":{},"df":0,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"(":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}},"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"k":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"ł":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"j":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5},"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,".":{"docs":{},"df":0,"7":{"docs":{},"df":0,"@":{"docs":{},"df":0,"g":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}},"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":3}}},"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":4}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.8284271247461903}},"df":2}}}}},"v":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":2.0}},"df":1}}},"i":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3}}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772}},"df":3}}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1},"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":3}},"g":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":1}}}}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.8284271247461903}},"df":1}},"n":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951}},"df":1}},"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":5.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"tf":1.4142135623730951}},"df":11,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}},"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}},"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":4.47213595499958},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.1622776601683795},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":7,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":1}}}}}}}}}}}}}}}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":1}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}}}}}}},"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":5}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":2,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}},".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}},"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2,"a":{"docs":{},"df":0,"ł":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":2},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"y":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.1622776601683795},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":7,"\"":{"docs":{},"df":0,".":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}},")":{"docs":{},"df":0,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}},"+":{"docs":{},"df":0,"+":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1},"1":{"docs":{},"df":0,"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},":":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"k":{"docs":{},"df":0,"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"y":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"_":{"docs":{},"df":0,"1":{"docs":{},"df":0,"5":{"docs":{},"df":0,"7":{"docs":{},"df":0,"7":{"docs":{},"df":0,"6":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"3":{"docs":{},"df":0,"3":{"docs":{},"df":0,"1":{"docs":{},"df":0,"1":{"docs":{},"df":0,"1":{"docs":{},"df":0,"9":{"docs":{},"df":0,"3":{"docs":{},"df":0,"8":{"docs":{},"df":0,"9":{"docs":{},"df":0,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"y":{"docs":{},"df":0,":":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":3.0}},"df":8,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}}}},"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":4}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.7416573867739413}},"df":2}}}},"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":2}},"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.3166247903554},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":5},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":2,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}},"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"m":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":4},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":2}}}},"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"tf":1.0}},"df":9}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":3,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}},"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":2.0}},"df":1,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}},"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":9,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":4}}}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}},"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979}},"df":4},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":6.164414002968976},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2,"e":{"docs":{},"df":0,"@":{"docs":{},"df":0,"s":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"/":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,":":{"docs":{},"df":0,"9":{"docs":{},"df":0,":":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}},"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"x":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.358898943540674},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.3166247903554},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":9}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.23606797749979}},"df":1}}}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":4,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951}},"df":1}}}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"b":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951}},"df":1}}}}}}}}},"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.8284271247461903}},"df":1}}}},"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"b":{"docs":{},"df":0,"(":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}},"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}},"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":2,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":2.0}},"df":2}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":5,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.47213595499958},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979}},"df":5,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":3.0}},"df":2},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.7320508075688772}},"df":2}}}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":3}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":4}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":4,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}},"f":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":2},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":6,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}},"x":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":2,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951}},"df":2}}}},"o":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}},"r":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":2},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}}},"p":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":4.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":5},"y":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"'":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}}}},"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"s":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1},"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":3.0}},"df":3,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"r":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":5,"e":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":2}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.7320508075688772}},"df":9}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1,"\"":{"docs":{},"df":0,".":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}},"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":3}},"y":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.449489742783178}},"df":6,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}},"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"m":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}},"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1,"!":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":8}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}}}},"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":2,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}},"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3}}}},"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.3166247903554},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"_":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"_":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"_":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":4,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":3.0}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"=":{"docs":{},"df":0,"u":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}},"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"=":{"docs":{},"df":0,"u":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.8284271247461903}},"df":2,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}}},"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}},"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":5,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}},"p":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1}}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":2}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4}}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"p":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}}}},"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":8}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}},"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.47213595499958}},"df":1,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}},"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178}},"df":1}}}}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"(":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772}},"df":4,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}}}}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}},"m":{"docs":{},"df":0,"k":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"ę":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}},"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":7}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}},"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}}}}}},"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0}},"df":5}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0}},"df":3,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}}},"y":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":2,"_":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"_":{"docs":{},"df":0,"e":{"docs":{},"df":0,"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}},"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}},"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.7320508075688772}},"df":1,"\"":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},".":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}},"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":8}},"r":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}},"s":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}}}},"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":3}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":2}}}}},"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":2.8284271247461903}},"df":1}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"7":{"docs":{},"df":0,"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1},"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":4},"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":3}}}},"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}},"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":4.123105625617661},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}},"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"{":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.449489742783178}},"df":2}}}}}},"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}},"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":3}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"1":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2,"(":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979}},"df":1}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772}},"df":7,"[":{"docs":{},"df":0,"e":{"docs":{},"df":0,"0":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{},"df":0,"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}},"2":{"docs":{},"df":0,"7":{"docs":{},"df":0,"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}},"3":{"docs":{},"df":0,"6":{"docs":{},"df":0,"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"8":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"5":{"docs":{},"df":0,"0":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1},"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"9":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1},"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}},"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":3}}}}},"t":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":7},"r":{"docs":{},"df":0,"y":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":2}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":2}},"w":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}},"x":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":3}}}},"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.3166247903554},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.795831523312719},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":9,"e":{"docs":{},"df":0,"/":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"d":{"docs":{},"df":0,"/":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"/":{"docs":{},"df":0,"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"k":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"m":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"p":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2}},"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"s":{"docs":{},"df":0,"(":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":1}}}}},"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":2}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":2},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}},"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":3,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3}}}}}},"o":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.449489742783178}},"df":1,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.358898943540674},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772}},"df":2,"(":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}}}}},".":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}},"6":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":2.23606797749979}},"df":1}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4}},"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}},"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2}},"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}}},"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907}},"df":1,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.8284271247461903}},"df":1}}}}}}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":3}}}},"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":3}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":3}}},"f":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907}},"df":2,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"/":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"/":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}},"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":2}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":3},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":4.795831523312719}},"df":2}}}},"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":9,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"(":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}},"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"w":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"a":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0}},"df":1}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.4641016151377544}},"df":1}}}}}}}}}},".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"f":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"=":{"docs":{},"df":0,"%":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,"\\":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"l":{"docs":{},"df":0,"n":{"docs":{},"df":0,"(":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":4.358898943540674},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":8.660254037844387},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":4.69041575982343},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":3.3166247903554},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":3.3166247903554}},"df":11,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":1}}}}}}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":1}}}}}}}}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979}},"df":1,"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.1622776601683795},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":4}}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1},"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"|":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}},"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}},"o":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":4,"!":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3}}},"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1}}}},"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":2,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.449489742783178}},"df":1,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.0}},"df":9,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2},"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}},"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":3}}}}},"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":5.916079783099616}},"df":3,"e":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1},"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1},"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":1,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.449489742783178}},"df":1}}}}}}}}}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.6457513110645907}},"df":1,".":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"i":{"docs":{},"df":0,"@":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"w":{"docs":{},"df":0,".":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":2.449489742783178}},"df":1}},"r":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0}},"df":1}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"a":{"docs":{},"df":0,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"ń":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":7,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}},"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"_":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}},"y":{"docs":{},"df":0,"k":{"docs":{},"df":0,"ó":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4,"_":{"docs":{},"df":0,"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1},"b":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}}}}},"h":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":4.47213595499958}},"df":3}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":6,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":5,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":3},"o":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":4}},"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"d":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":9}},"p":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"z":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}},"u":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}},"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":6.324555320336759},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":8.717797887081348},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":3.4641016151377544}},"df":10},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1}}}}}},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"ł":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"z":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772}},"df":7,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"j":{"docs":{},"df":0,"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"_":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}},"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}}},"t":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1},"v":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":1}}}},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.449489742783178}},"df":3},"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}},"v":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772}},"df":1},"l":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"_":{"docs":{},"df":0,"w":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":4}},"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":11},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.872983346207417}},"df":1,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"d":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772}},"df":1}}}}}}},"g":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":3,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}}}},"p":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0}},"df":1}}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"s":{"docs":{},"df":0,":":{"docs":{},"df":0,"/":{"docs":{},"df":0,"/":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"/":{"docs":{},"df":0,"w":{"docs":{},"df":0,"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{},"df":0,"/":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"/":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"k":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"/":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"w":{"docs":{},"df":0,"w":{"docs":{},"df":0,"w":{"docs":{},"df":0,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"/":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"/":{"docs":{},"df":0,"k":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"z":{"docs":{},"df":0,"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}},"p":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"y":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"/":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":2}}}},"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":5}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951}},"df":1,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0}},"df":1}},"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":2}}}},"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":4}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":5.830951894845301},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":7,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"a":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1}}}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":2}}}}}}}},"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}},"`":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1},"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.358898943540674},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":10}}}}},"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":5}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":3}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"d":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2}},"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":3}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1,"r":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}},"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":2,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1}},"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.7320508075688772}},"df":1}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3},"t":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":9}}},"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.8284271247461903}},"df":3,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}},"e":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3},"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":2}}},"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2}},"e":{"docs":{},"df":0,"j":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"u":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"(":{"docs":{},"df":0,"*":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":3,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}}}},"o":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2},"l":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,".":{"docs":{},"df":0,"e":{"docs":{},"df":0,"o":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2}}},"s":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}},"t":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":8},"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":5,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":4.242640687119285},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":4,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}},"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}}}}},"z":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"j":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"z":{"docs":{},"df":0,"@":{"docs":{},"df":0,"g":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":4,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"h":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.0}},"df":1,".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1}},"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}},"(":{"docs":{},"df":0,"[":{"docs":{},"df":0,"'":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}},"w":{"docs":{},"df":0,"z":{"docs":{},"df":0,"1":{"docs":{},"df":0,"9":{"docs":{},"df":0,"9":{"docs":{},"df":0,"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}},"ę":{"docs":{},"df":0,"z":{"docs":{},"df":0,"y":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"k":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"z":{"docs":{},"df":0,"@":{"docs":{},"df":0,"g":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"z":{"docs":{},"df":0,"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}},"k":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2,"w":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}}}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"z":{"docs":{},"df":0,"3":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1},"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":3}},"r":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"k":{"docs":{},"df":0,"4":{"docs":{},"df":0,"2":{"docs":{},"df":0,"9":{"docs":{},"df":0,"3":{"docs":{},"df":0,"1":{"docs":{},"df":0,"7":{"docs":{},"df":0,"@":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"w":{"docs":{},"df":0,".":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":5,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"z":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"g":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"y":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,".":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"/":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{},"df":0,"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"0":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"/":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"m":{"docs":{},"df":0,"l":{"docs":{},"df":0,"#":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5}}}}},"r":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":5.385164807134504},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}},"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}},"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}},"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":6}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4}}},"z":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1},"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"r":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"/":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}}}}}}}}},"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}},"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1},"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2}}}},"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":6}}}},"t":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":6}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":5,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"p":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3,"b":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":6}}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":6.48074069840786},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":4,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"k":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}},"n":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":6},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":4.69041575982343},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":6,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"(":{"docs":{},"df":0,"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}},"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}},"[":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":1},"_":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":4}},"t":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"tf":1.0}},"df":3}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772}},"df":1},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":1}},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.6457513110645907}},"df":2}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2,"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"a":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}},"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1}}}}}}}}}}}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}},"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":6,"u":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":2,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2},"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1,"(":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772}},"df":3,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,":":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}}},"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178}},"df":2}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}},"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}}}}}}}}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,":":{"docs":{},"df":0,"2":{"docs":{},"df":0,"7":{"docs":{},"df":0,":":{"docs":{},"df":0,"3":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}},"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}},"u":{"docs":{},"df":0,"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"y":{"docs":{},"df":0,"s":{"docs":{},"df":0,"é":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":3}}},"r":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"tf":1.7320508075688772}},"df":5}}},"d":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}},"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.7320508075688772}},"df":1},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.872983346207417},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":10,".":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,".":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}},"k":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":9,"(":{"docs":{},"df":0,"[":{"docs":{},"df":0,"]":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}},"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}}},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}},"_":{"docs":{},"df":0,"w":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}}}},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":3,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":4.898979485566356},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}},"y":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":6}},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":2}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1}}}},"m":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}},"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.23606797749979}},"df":3}}}},"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":5}}}}},"r":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4}}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":10,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"z":{"docs":{},"df":0,"k":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"k":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"j":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{},"df":0,"@":{"docs":{},"df":0,"g":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"ł":{"docs":{},"df":0,"a":{"docs":{},"df":0,"j":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}}}},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1},"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}}},"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":1}}}}}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4}},"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4}}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"p":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":7},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":4.242640687119285},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.872983346207417},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":6},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":1}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}},"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":6}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.872983346207417},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":9,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":6}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}},"e":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772}},"df":2,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}}}},"g":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}},"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"x":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":1,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}},"(":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"ę":{"docs":{},"df":0,"d":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.7320508075688772}},"df":2,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":8,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}}}}},"e":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":8}},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":8,"(":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.242640687119285}},"df":1,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}},"a":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}}}},"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}},"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":4,"_":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":4.242640687119285},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5}},"p":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2}}}},"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}},"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":6},"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":4},"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3},"f":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":8,".":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}},"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}},"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4,".":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}},"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"8":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"[":{"docs":{},"df":0,"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"(":{"docs":{},"df":0,"u":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":7}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":1}}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"c":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2}}}},"d":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979}},"df":1,"(":{"docs":{},"df":0,"_":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"b":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"a":{"docs":{},"df":0,"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979}},"df":3}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.3166247903554},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":2.0}},"df":10,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772}},"df":1}}}}}}}}},"t":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":2},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":6}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":2}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}},"b":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}}},"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2}}}}}},"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}},".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"/":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":6,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"q":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":2}}}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":3}}}}}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":7,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}},"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.449489742783178}},"df":4,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"f":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":2}}}},"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}},"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":3,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":5}}}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1},"k":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"g":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}},"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772}},"df":3}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.449489742783178}},"df":2,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":5}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":6,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":6,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"w":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"y":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":5,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"b":{"docs":{},"df":0,"4":{"docs":{},"df":0,"2":{"docs":{},"df":0,"9":{"docs":{},"df":0,"1":{"docs":{},"df":0,"5":{"docs":{},"df":0,"9":{"docs":{},"df":0,"@":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"w":{"docs":{},"df":0,".":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"y":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":2,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"{":{"docs":{},"df":0,"{":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"j":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"h":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":4}}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1,".":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.4142135623730951}},"df":1,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}}}}}},"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"ó":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":3}},"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":2,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5}}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":3.3166247903554}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.449489742783178}},"df":1}}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.23606797749979}},"df":1}}}}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.23606797749979}},"df":1}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.0}},"df":1},"y":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{},"df":0,".":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"p":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.4142135623730951}},"df":2}}}}},"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979}},"df":1,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"(":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"4":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":6}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5}}}}},"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}},"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":2}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}},"r":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":6}}},"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5}}}}},"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}},"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":4,"(":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,"(":{"docs":{},"df":0,"[":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{},"df":0,"(":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"(":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"(":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}}}},"f":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"s":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"x":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}},"l":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":7,"!":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":1},"[":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1}}}}},"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"f":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}},"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1}}},"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.6457513110645907}},"df":1}}}},"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"j":{"docs":{},"df":0,"o":{"docs":{},"df":0,"h":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":4.123105625617661}},"df":1}}}},"m":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}},"o":{"docs":{},"df":0,"k":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":2,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":2}}}}},"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}},"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2},"{":{"docs":{},"df":0,"n":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}}}}}},"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":2}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":4}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2}}}},"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":7,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":3}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":2}}}}},"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":6}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":6}}}},"z":{"docs":{},"df":0,"y":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"ł":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}}},"u":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":2},"r":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}},"s":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}},"w":{"docs":{},"df":0,"3":{"docs":{},"df":0,"9":{"docs":{},"df":0,"4":{"docs":{},"df":0,"9":{"docs":{},"df":0,"8":{"docs":{},"df":0,"0":{"docs":{},"df":0,"[":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,"[":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"w":{"docs":{},"df":0,"[":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"[":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}}}}}},"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2}}}}},"u":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":2},"z":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.1622776601683795}},"df":3,".":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2}},"i":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":3}},"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":3},"y":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":1,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}},"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}}}},"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"tf":1.0}},"df":11,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}}}}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"b":{"docs":{},"df":0,"y":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":1},"y":{"docs":{},"df":0,"(":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":6}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":3}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3}},"e":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}},"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}}},"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979}},"df":1,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}},"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0}},"df":1,"l":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"i":{"docs":{},"df":0,"3":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772}},"df":1}}}}}},"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":8,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.0}},"df":1}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":1}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4}}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}},"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}}},"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.23606797749979}},"df":6}}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0}},"df":2}}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.358898943540674},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.0}},"df":5,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.23606797749979}},"df":9}}}},"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1}}},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951}},"df":1,"1":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"z":{"docs":{},"df":0,"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"ą":{"docs":{},"df":0,"z":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}},"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"y":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":4}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}}},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":4.47213595499958},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.1622776601683795},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.7320508075688772}},"df":14,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4},"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"f":{"docs":{},"df":0,"m":{"docs":{},"df":0,"t":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"k":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"u":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"w":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":1}}}}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":6.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":7,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":2}}}}}},"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0}},"df":1}}}}},"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}},"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{},"df":0,"(":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.7416573867739413}},"df":1},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}},"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}},"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"j":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"k":{"docs":{},"df":0,"@":{"docs":{},"df":0,"g":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.6457513110645907}},"df":5,"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4}}}},"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":7},"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":2}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":6}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"m":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":5,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"y":{"docs":{},"df":0,"(":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}},"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":7,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}},"g":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}}},"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.1622776601683795},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.8284271247461903}},"df":5,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}},".":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":2},"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1}}}}}},"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}},"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1}}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}},"o":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"0":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"1":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"(":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"(":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}},"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}},"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"v":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":3.7416573867739413}},"df":1,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}},"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1},"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.7320508075688772}},"df":2},"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5,"u":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":3.3166247903554}},"df":3,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}},"i":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178}},"df":1}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"(":{"docs":{},"df":0,"4":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}},"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}}}},"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}}},"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":2}}}},"i":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0}},"df":2}}}},"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":5,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.8284271247461903}},"df":1,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.0}},"df":1}}}}}}}}}}}}}}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":3}}}},"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":3}}},"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}},"z":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"k":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":4.358898943540674},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":4,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"[":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"m":{"docs":{},"df":0,"l":{"docs":{},"df":0,"#":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":2,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}},"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}}},"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.0}},"df":1,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"a":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"f":{"docs":{},"df":0,"t":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":3}},"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772}},"df":1,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1},"4":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"8":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1},"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1},"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}},"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}},"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}},"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"4":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}},"_":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3}},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":3},"i":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":2}}},"w":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}},"r":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0}},"df":6}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0}},"df":2,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,".":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}},"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":4}},"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":3,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.6457513110645907}},"df":4}}}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"2":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}},"3":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0}},"df":1,".":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{},"df":0,"(":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"q":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.23606797749979}},"df":1,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}},"o":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,"/":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,":":{"docs":{},"df":0,"1":{"docs":{},"df":0,"4":{"docs":{},"df":0,":":{"docs":{},"df":0,"1":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"2":{"docs":{},"df":0,":":{"docs":{},"df":0,"2":{"docs":{},"df":0,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"4":{"docs":{},"df":0,":":{"docs":{},"df":0,"1":{"docs":{},"df":0,"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"5":{"docs":{},"df":0,":":{"docs":{},"df":0,"1":{"docs":{},"df":0,"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"6":{"docs":{},"df":0,":":{"docs":{},"df":0,"4":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"7":{"docs":{},"df":0,":":{"docs":{},"df":0,"1":{"docs":{},"df":0,"7":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"9":{"docs":{},"df":0,":":{"docs":{},"df":0,"1":{"docs":{},"df":0,"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}},"3":{"docs":{},"df":0,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"9":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":3}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":3}}}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":4.69041575982343},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":5}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":3,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}},"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":7,"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"d":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}},"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}},"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}},"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":2}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"f":{"docs":{},"df":0,"m":{"docs":{},"df":0,"t":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1}}}}}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.3166247903554}},"df":1}}}}}}}}}}}}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.4641016151377544}},"df":1}}}}}},"{":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}},"s":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}},"i":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"(":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"s":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}},"r":{"docs":{},"df":0,"c":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}},"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}}},"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"{":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"q":{"docs":{},"df":0,"u":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,"_":{"docs":{},"df":0,"p":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"{":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":2},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"v":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"p":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}},"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":7}}},"o":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.605551275463989}},"df":2,"_":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{},"df":0,"t":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}},"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}},"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":5.916079783099616},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":7.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":8,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":1,".":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2,"b":{"docs":{},"df":0,"c":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"_":{"docs":{},"df":0,"e":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"o":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1}}}}}}}}}}},"i":{"docs":{},"df":0,"'":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}},"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0}},"df":1}}}}},"n":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"t":{"docs":{},"df":0,"x":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}},"o":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979}},"df":1}},"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":1}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"p":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1},"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"x":{"docs":{},"df":0,"y":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}},"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"f":{"docs":{},"df":0,"8":{"docs":{},"df":0,"_":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"y":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":2}}}}},"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"_":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"_":{"docs":{},"df":0,"w":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":5.196152422706632},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772}},"df":5,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"/":{"docs":{},"df":0,"v":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"g":{"docs":{},"df":0,"g":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}},"k":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"’":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"f":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}}},"y":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}}},"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951}},"df":1}}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"q":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772}},"df":1}}}}}},"c":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}}}}}}}},"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":4}},"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}},"g":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.0}},"df":1,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.0}},"df":1,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.6457513110645907}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.449489742783178}},"df":1}}}}}}}}}}}}},"y":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"_":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1},"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}},"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}},"p":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4},"p":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}},"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":2}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2,"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}},"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":3.4641016151377544}},"df":1,"h":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772}},"df":1}}}}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":2}}}}},"{":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.795831523312719},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.449489742783178}},"df":4,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"(":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"k":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":7,"a":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"l":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}},"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1}},"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}}}},"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772}},"df":2}},"m":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{},"df":0,"(":{"docs":{},"df":0,")":{"docs":{},"df":0,".":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}},"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"k":{"docs":{},"df":0,"f":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}},"t":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}},"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":4},"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"l":{"docs":{},"df":0,"y":{"docs":{},"df":0,"_":{"docs":{},"df":0,"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"n":{"docs":{},"df":0,"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"_":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}}}},"y":{"docs":{},"df":0,"'":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":4},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}},"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}}}}}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}},"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":4}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":5.5677643628300215},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":6.324555320336759},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":4,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1},".":{"docs":{},"df":0,"j":{"docs":{},"df":0,"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"|":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"(":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"s":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1,"(":{"docs":{},"df":0,"m":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.23606797749979}},"df":1}}}}}}}}}}}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"g":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":5}}}}},"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"m":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":8}}},"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.0}},"df":1}}},"o":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951}},"df":1}}}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"k":{"docs":{},"df":0,"i":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.7320508075688772}},"df":3}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1,"k":{"docs":{},"df":0,"u":{"docs":{},"df":0,"b":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"4":{"docs":{},"df":0,"@":{"docs":{},"df":0,"g":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}},"p":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.4142135623730951}},"df":1}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":3}},"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":6.48074069840786},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.449489742783178}},"df":8,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1},"_":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{},"df":0,"a":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}},"g":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"_":{"docs":{},"df":0,"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"s":{"docs":{},"df":0,"f":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}}}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}},"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":5,"v":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}},"y":{"docs":{},"df":0,"/":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}},"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"r":{"docs":{},"df":0,"u":{"docs":{},"df":0,"j":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"p":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}},"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":2,"e":{"docs":{},"df":0,".":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{},"df":0,"(":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}},"r":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":1}}}}},"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":6.082762530298219}},"df":1,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}},"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}},"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"w":{"docs":{},"df":0,"e":{"docs":{},"df":0,"e":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"_":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}},"a":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,";":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"'":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}}}},"(":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}}}}}}}}}}}}}}}},"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.0}},"df":1,".":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"_":{"docs":{},"df":0,"u":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}},"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":10}},"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":4.358898943540674},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":6.708203932499369},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.449489742783178}},"df":10,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}}},"1":{"docs":{},"df":0,"6":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.23606797749979}},"df":1}},"3":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.1622776601683795},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":2.0}},"df":7,":":{"docs":{},"df":0,":":{"docs":{},"df":0,"f":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{},"df":0,"(":{"docs":{},"df":0,"*":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}}}}}}}}}},"6":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}},"8":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":2},"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"g":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}}}},"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772}},"df":1}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"l":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":3}},"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":4}}}}}}}},"e":{"docs":{},"df":0,"x":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":2}}}}}},"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"!":{"docs":{},"df":0,"(":{"docs":{},"df":0,"\"":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772}},"df":1}},"q":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}},"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}},"i":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}},"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}},"o":{"docs":{},"df":0,"f":{"docs":{},"df":0,"f":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1},"i":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}},"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}},"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":2}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":4}}}}},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":7,"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.7320508075688772}},"df":1}}},"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}}},"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1,".":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"b":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}}}}}}}}},"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.872983346207417},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":5.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":4.242640687119285},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":3.872983346207417},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":4.242640687119285},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":2.23606797749979}},"df":13,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.7320508075688772}},"df":4,"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.1622776601683795}},"df":1}}}}},"i":{"docs":{},"df":0,"z":{"docs":{},"df":0,"e":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}}},"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0}},"df":4}}}},"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}},"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}}},"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"p":{"docs":{},"df":0,"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}}},"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1},"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}},"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":3.4641016151377544},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.605551275463989},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":4.242640687119285},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.1622776601683795},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":9,"e":{"docs":{},"df":0,"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.6457513110645907}},"df":1,"=":{"docs":{},"df":0,"%":{"docs":{},"df":0,"v":{"docs":{},"df":0,"\\":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}}},"[":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1},"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1}}},"[":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"=":{"docs":{},"df":0,"[":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979}},"df":1},"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":6,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"u":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772}},"df":2}}}}},"e":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1,"!":{"docs":{},"df":0,"[":{"docs":{},"df":0,"'":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}},"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1},"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2},"3":{"docs":{},"df":0,"4":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}},"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"g":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951}},"df":1}}}}}}}}},"u":{"docs":{},"df":0,"8":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}}}}}},":":{"docs":{},"df":0,":":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"o":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2}}}},"r":{"docs":{},"df":0,"i":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":3.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":5},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":5}}}}}},"i":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1},"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"r":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}},"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"a":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":1}}}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":2}},"l":{"docs":{},"df":0,"u":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.7320508075688772}},"df":1,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}}}}}}},"n":{"docs":{},"df":0,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"n":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0}},"df":1}}}}}}}}}}}}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":5,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"b":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951}},"df":1,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}},"k":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":3.1622776601683795}},"df":1,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":1}}},"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":8}},"r":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":2},"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1},"s":{"docs":{},"df":0,"a":{"docs":{},"df":0,"w":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,".":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"k":{"docs":{},"df":0,"o":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"j":{"docs":{},"df":0,"1":{"docs":{},"df":0,"@":{"docs":{},"df":0,"g":{"docs":{},"df":0,"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"i":{"docs":{},"df":0,"l":{"docs":{},"df":0,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0}},"df":1}}},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":9}},"b":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}},"e":{"docs":{},"df":0,"'":{"docs":{},"df":0,"l":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":5}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":3},"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3}},"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1,"&":{"docs":{},"df":0,"l":{"docs":{},"df":0,"t":{"docs":{},"df":0,";":{"docs":{},"df":0,"t":{"docs":{},"df":0,"&":{"docs":{},"df":0,"g":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}},"_":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.4142135623730951}},"df":1,".":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1},"u":{"docs":{},"df":0,"p":{"docs":{},"df":0,"g":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"b":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":2,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1},"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"l":{"docs":{},"df":0,"c":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":4}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1},"’":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"h":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"'":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2},"e":{"docs":{},"df":0,"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"e":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}},"o":{"docs":{},"df":0,"e":{"docs":{},"df":0,"v":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":1}}}},"l":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.4142135623730951}},"df":1}},"s":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}},"i":{"docs":{},"df":0,"d":{"docs":{},"df":0,"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1,"(":{"docs":{},"df":0,"&":{"docs":{},"df":0,"a":{"docs":{},"df":0,"m":{"docs":{},"df":0,"p":{"docs":{},"df":0,";":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}}}}}}}}}}},"l":{"docs":{},"df":0,"d":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}},"s":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}},"o":{"docs":{},"df":0,"u":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772}},"df":4}}}}}},"o":{"docs":{},"df":0,"j":{"docs":{},"df":0,"c":{"docs":{},"df":0,"i":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"c":{"docs":{},"df":0,"z":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}},"n":{"docs":{},"df":0,"'":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":5}}},"r":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.7320508075688772},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":2.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.4142135623730951}},"df":8,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"tf":1.0}},"df":1}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":1}}}}},"l":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":3}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1},"t":{"docs":{},"df":0,"h":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":4}}}},"p":{"docs":{},"df":0,"4":{"docs":{},"df":0,"1":{"docs":{},"df":0,"8":{"docs":{},"df":0,"3":{"docs":{},"df":0,"8":{"docs":{},"df":0,"3":{"docs":{},"df":0,"[":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"s":{"docs":{},"df":0,"[":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"m":{"docs":{},"df":0,"i":{"docs":{},"df":0,"m":{"docs":{},"df":0,"u":{"docs":{},"df":0,"w":{"docs":{},"df":0,"[":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"[":{"docs":{},"df":0,"d":{"docs":{},"df":0,"o":{"docs":{},"df":0,"t":{"docs":{},"df":0,"]":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"df":0,"z":{"docs":{},"df":0,"y":{"docs":{},"df":0,"t":{"docs":{},"df":0,"u":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}}}}}}},"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951}},"df":2,"p":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.7320508075688772}},"df":1}}}}},"i":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":2.23606797749979},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.6457513110645907},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.4142135623730951},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.4142135623730951}},"df":8,"!":{"docs":{},"df":0,"(":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":2.0}},"df":1}}},"l":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.7320508075688772}},"df":1}},"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.4142135623730951}},"df":3}}}}}},"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"d":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}},"t":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"x":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":4.47213595499958},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":2.449489742783178},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.7416573867739413},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":2.8284271247461903},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":2.23606797749979}},"df":6,".":{"docs":{},"df":0,"c":{"docs":{},"df":0,"h":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"_":{"docs":{},"df":0,"d":{"docs":{},"df":0,"i":{"docs":{},"df":0,"v":{"docs":{},"df":0,"(":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}}}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"_":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"p":{"docs":{},"df":0,"l":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"e":{"docs":{},"df":0,"(":{"docs":{},"df":0,"3":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1},"5":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}}}}}}},"t":{"docs":{},"df":0,"a":{"docs":{},"df":0,"k":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}}},"u":{"docs":{},"df":0,"n":{"docs":{},"df":0,"w":{"docs":{},"df":0,"r":{"docs":{},"df":0,"a":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":1}}}}}}},"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}}}},"y":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}},"y":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":4.123105625617661},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":3.605551275463989}},"df":3,".":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1},"b":{"docs":{},"df":0,"[":{"docs":{},"df":0,"0":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.4142135623730951}},"df":1}}}},"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":2}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}},"u":{"docs":{},"df":0,"'":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1},"v":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}},"n":{"docs":{},"df":0,"g":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.4142135623730951}},"df":1}},"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{},"df":0,"f":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":2}}}}}}}},"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1,"e":{"docs":{},"df":0,"m":{"docs":{},"df":0,"b":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"i":{"docs":{},"df":0,"c":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}}},"r":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":2}}},"n":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"z":{"docs":{},"df":0,"n":{"docs":{},"df":0,"y":{"docs":{},"df":0,"m":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}},"title":{"root":{"docs":{},"df":0,"1":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0}},"df":2},"2":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":3,"0":{"docs":{},"df":0,"2":{"docs":{},"df":0,"1":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}},"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"y":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}}}}},"c":{"docs":{},"df":0,"l":{"docs":{},"df":0,"o":{"docs":{},"df":0,"s":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"n":{"docs":{},"df":0,"c":{"docs":{},"df":0,"u":{"docs":{},"df":0,"r":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}}},"d":{"docs":{},"df":0,"a":{"docs":{},"df":0,"t":{"docs":{},"df":0,"a":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0}},"df":1}}},"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"i":{"docs":{},"df":0,"g":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1}}}}}},"f":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"tf":1.0}},"df":1}}}}}},"e":{"docs":{},"df":0,"d":{"docs":{},"df":0,"b":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"k":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0}},"df":3}}}}}}}},"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"u":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":1}}}}}}}},"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"tf":1.0}},"df":1}}}},"j":{"docs":{},"df":0,"n":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0}},"df":1}}},"l":{"docs":{},"df":0,"e":{"docs":{},"df":0,"s":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":2}}}}},"i":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/":{"tf":1.0}},"df":1}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"c":{"docs":{},"df":0,"r":{"docs":{},"df":0,"o":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"tf":1.0}},"df":1}}}},"o":{"docs":{},"df":0,"d":{"docs":{},"df":0,"e":{"docs":{},"df":0,"l":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}},"o":{"docs":{},"df":0,"r":{"docs":{},"df":0,"g":{"docs":{},"df":0,"a":{"docs":{},"df":0,"n":{"docs":{},"df":0,"i":{"docs":{},"df":0,"z":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"tf":1.0}},"df":1}}}}}},"w":{"docs":{},"df":0,"n":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"i":{"docs":{},"df":0,"p":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"tf":1.0}},"df":1}}}}}}}}},"p":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"tf":1.0}},"df":2}},"t":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"tf":1.0}},"df":1}}}}}},"o":{"docs":{},"df":0,"i":{"docs":{},"df":0,"n":{"docs":{},"df":0,"t":{"docs":{},"df":0,"e":{"docs":{},"df":0,"r":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}}},"r":{"docs":{},"df":0,"o":{"docs":{},"df":0,"j":{"docs":{},"df":0,"e":{"docs":{},"df":0,"c":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":2}}}}}}},"r":{"docs":{},"df":0,"e":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{},"df":0,"o":{"docs":{},"df":0,"n":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":1}}}}},"u":{"docs":{},"df":0,"s":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"tf":1.0}},"df":2}}}},"s":{"docs":{},"df":0,"h":{"docs":{},"df":0,"o":{"docs":{},"df":0,"w":{"docs":{},"df":0,"c":{"docs":{},"df":0,"a":{"docs":{},"df":0,"s":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"tf":1.0}},"df":1}}}}}},"m":{"docs":{},"df":0,"a":{"docs":{},"df":0,"r":{"docs":{},"df":0,"t":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"tf":1.0}},"df":1}}}}},"t":{"docs":{},"df":0,"y":{"docs":{},"df":0,"p":{"docs":{},"df":0,"e":{"docs":{"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"tf":1.0},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"tf":1.0}},"df":2}}}}}}},"documentStore":{"save":true,"docs":{"https://mimuw-jnp2-rust.github.io/":{"body":"This is a website for the JNP2: Rust course at MIM UW.\nThe course's instructor is Wojciech Przytuła (GitHub: wprzytula, e-mail: wp418383[at]students[dot]mimuw[dot]edu[dot]pl),\nInstructori emeriti:\n\nPiotr Wojtczak (GitHub: StarostaGit, e-mail: pw394980[at]students[dot]mimuw[dot]edu[dot]pl),\nAndrzej Głuszak (GitHub: agluszak, e-mail: agluszak[at]mimuw[dot]edu[dot]pl).\n\nYou can find lesson scenarios here.\nContributions are welcome! ;)\n","id":"https://mimuw-jnp2-rust.github.io/","title":"JNP 2: Rust"},"https://mimuw-jnp2-rust.github.io/lessons/":{"body":"","id":"https://mimuw-jnp2-rust.github.io/lessons/","title":"List of lessons"},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"body":"Rust course\nWe will be using Github Classroom for task submission and Discord for discussions.\nOur main learning/teaching resource will be \"The Book\".\nAlso worth mentioning: \"Rust by Example\".\nGrading\n\n1/3 of the grade is based on small tasks. There will be approximately 1 task every two weeks and each task will be graded on a scale of 0 to 3.\n2/3 of the grade is based on a big project. You can choose a topic yourself, but it must be accepted by me. The project has to be split into two parts. It can be done in groups of two (or bigger, if ambitious enough).\nThe grade may be increased by a bonus. You can get a bonus for:\n\nMaking a presentation about some advanced topic (const generics, futures, macros, etc.) or about architecture of a selected Rust open-source library\nContributing to a selected Rust open-source library\nContributing to this course's materials\nQuizzes, homeworks, general activity etc.\n\n\n\nProject Deadlines\n\n2024-11-7: Project ideas should be presented to me for further refining. If you wish to pair up with someone, now is the time to tell me.\n2024-11-14: Final project ideas should be accepted by now.\n2024-12-12: Deadline for submitting the first part of the project.\n2025-01-09: Deadline for submitting the second and final part of the project.\n\n","id":"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/","title":"Organizational lesson"},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"body":"\nA language empowering everyone to build reliable and efficient software.\n(unofficial logo)\nWhy use Rust?\n\nIt is safe (compared to C++ for example, as we will see in a minute)\nIt is fast (because it is compiled to machine code)\nIt is ergonomic and pleasant to use (static typing, expressive type system, helpful compiler\nwarnings)\nIt\nis loved by programmers\nIt provides excellent tooling\n\nWhy learn Rust?\nEven if you don't end up using Rust, learning it expands your horizons\n\nit helps especially with the awareness of what you can and can't do in concurrent applications\nit helps you understand memory management and learn its good practices\n\nWhy not to learn Rust?\n\nSome people say Rust is too hard to learn because of the borrow checker\nOnce you get to know Cargo you won't ever want to use a language without a built-in package\nmanager ;)\nYou will start hating C++\n\nDemos\n\nLet's compare the same code written in C, C++\nand Rust.\nCode you sent in previous editions!\nAleksander Tudruj\n#include <iostream>\n#include <unordered_map>\n\nusing name = std::string;\nusing age = int;\nusing person = std::pair<name, age>;\nusing address = std::string;\nusing address_book = std::unordered_map<person, address>;\n\nvoid print_address_book(const address_book &book)\n{\n for (const auto &[person, address] : book)\n {\n std::cout << person.first << \" is \" << person.second << \" years old and lives at \" << address << std::endl;\n }\n}\n\nint main()\n{\n\n address_book people{};\n people.insert({{\"John\", 20}, \"221B Baker Street, London\"});\n people.insert({{\"Mary\", 30}, \"Avenue des Champs-Élysées, Paris\"});\n people.insert({{\"Jack\", 73}, \"Wall Street, New York\"});\n print_address_book(people);\n\n return 0;\n}\n\n\n(Download the source code for this example: tudruj.cpp)\nKrystyna Gasińska\n# sample 1 - different ways of removing elements from the list while iterating\nlist1 = [1, 2, 3, 4]\nfor idx, item in enumerate(list1):\n del item\nlist1\n\n# [1, 2, 3, 4]\n\nlist2 = [1, 2, 3, 4]\nfor idx, item in enumerate(list2):\n list2.remove(item)\nlist2\n\n# [2, 4]\n\nlist3 = [1, 2, 3, 4]\nfor idx, item in enumerate(list3[:]):\n list3.remove(item)\nlist3\n\n# []\n\nlist4 = [1, 2, 3, 4]\nfor idx, item in enumerate(list4):\n list4.pop(idx)\nlist4\n\n# [2, 4]\n\n# sample 2 - string interning\na = \"abc\"\nb = \"abc\"\na is b\n\n# True\n\na = ''.join(['a', 'b', 'c'])\nb = ''.join(['a', 'b', 'c'])\na is b\n\n# False\n\na = \"abc!\"\nb = \"abc!\"\na is b\n\n# False\n\n# sample 3 - chained operations\n(False == False) in [False]\n\n# False\n\nFalse == (False in [False])\n\n# False\n\nFalse == False in [False] # unexpected...\n\n# True\n\n# sample 4 - is operator\na = 256\nb = 256\na is b\n\n# True\n\na = 257\nb = 257\na is b\n\n# False\n\na, b = 257, 257\na is b\n\n# True\n\n257 is 257\n\n# <>:1: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n# <>:1: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n# C:\\Users\\kgasinsk\\AppData\\Local\\Temp\\ipykernel_15776\\331119389.py:1: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n# 257 is 257\n\n# sample 5 - local variables\ndef f(trufel):\n if trufel:\n y = 1\n y += 1\n\nf(True) # everything is fine\n\nf(False) # gives error: local variable 'y' referenced before assignment\n\n# ---------------------------------------------------------------------------\n# UnboundLocalError Traceback (most recent call last)\n# Input In [17], in <cell line: 1>()\n# ----> 1 f(False)\n\n# Input In [15], in f(trufel)\n# 3 if trufel:\n# 4 y = 1\n# ----> 5 y += 1\n\n# UnboundLocalError: local variable 'y' referenced before assignment\n\n(Download the source code for this example: gasinska.py)\nAntoni Koszowski\n// mutowalność jest wbudowana w język\n\ntype S struct {\n A string\n B []string\n}\n \nfunc main() {\n x := S{\"x-A\", []string{\"x-B\"}}\n y := x // copy the struct\n y.A = \"y-A\"\n y.B[0] = \"y-B\"\n \n fmt.Println(x, y)\n // Outputs \"{x-A [y-B]} {y-A [y-B]}\" -- x was modified!\n}\n\n// slices i kwestia append\n\nfunc doStuff(value []string) {\n fmt.Printf(\"value=%v\\n\", value)\n \n value2 := value[:]\n value2 = append(value2, \"b\")\n fmt.Printf(\"value=%v, value2=%v\\n\", value, value2)\n \n value2[0] = \"z\"\n fmt.Printf(\"value=%v, value2=%v\\n\", value, value2)\n}\n \nfunc main() {\n slice1 := []string{\"a\"} // length 1, capacity 1\n \n doStuff(slice1)\n // Output:\n // value=[a] -- ok\n // value=[a], value2=[a b] -- ok: value unchanged, value2 updated\n // value=[a], value2=[z b] -- ok: value unchanged, value2 updated\n \n slice10 := make([]string, 1, 10) // length 1, capacity 10\n slice10[0] = \"a\"\n \n doStuff(slice10)\n // Output:\n // value=[a] -- ok\n // value=[a], value2=[a b] -- ok: value unchanged, value2 updated\n // value=[z], value2=[z b] -- WTF?!? value changed???\n}\n\n// error handling\n\nlen, err := reader.Read(bytes)\nif err != nil {\n if err == io.EOF {\n // All good, end of file\n } else {\n return err\n }\n}\n\n\n// interfejs nil\n\ntype Explodes interface {\n Bang()\n Boom()\n}\n \n// Type Bomb implements Explodes\ntype Bomb struct {}\nfunc (*Bomb) Bang() {}\nfunc (Bomb) Boom() {}\n \nfunc main() {\n var bomb *Bomb = nil\n var explodes Explodes = bomb\n println(bomb, explodes) // '0x0 (0x10a7060,0x0)'\n if explodes != nil {\n println(\"Not nil!\") // 'Not nil!' What are we doing here?!?!\n explodes.Bang() // works fine\n explodes.Boom() // panic: value method main.Bomb.Boom called using nil *Bomb pointer\n } else {\n println(\"nil!\") // why don't we end up here?\n }\n}\n\n// ubogie struktury danych, takie customowe tracą type safety m.in poprzez castowanie do interface{}\n// kiedyś brak generyków, choć teraz w znacznym stopniu problem został rozwiązany.\n\n(Download the source code for this example: koszowski.go)\nMieszko Grodzicki\ndef add_contents(input_list, contents=[]):\n for val in input_list:\n contents.append(val)\n return contents\n\nprint(add_contents([1])) # [1]\nprint(add_contents([2])) # [1, 2]\n\n(Download the source code for this example: grodzicki.py)\nInstalling Rust\n\nRustup\nSetup an IDE\n\nCLion (you can get\nit for free)\nand RustRover\nVSCode\nand rust-analyzer\nrust-analyzer also works\nwith other IDEs\n\n\n\nUseful tools\n\n\ncargo clippy (for static analysis)\nthere's also cargo check, but it's less powerful than clippy\ncargo fmt (for code formatting)\n\nRust Playground\n\nonline Rust compiler\n\nHello world\nfn main() {\n let name = \"World\";\n println!(\"Hello, {}!\", name); // using the println! macro\n}\n\n\n(Download the source code for this example: hello_world.rs)\nVariables\n#![allow(unused_variables)]\n#![allow(unused_assignments)]\n\nfn main() {\n let x = 40; // inferred type\n let y: i32 = 100; // specified type\n\n {\n let x = 40 + 2; // shadowing\n println!(\"x is {}\", x); // prints 42\n }\n\n // x = 0; // compilation error, variables are by default immutable\n let mut x = 40; // declare as mutable\n x = 0; // now we can reassign\n\n x += 1; // x = x + 1\n}\n\n\n(Download the source code for this example: variables.rs)\nConditionals\n#![allow(unused_variables)]\n\nfn main() {\n let x = 42;\n\n if x == 42 {\n println!(\"x is 42\");\n } else if x == 43 {\n println!(\"x is 43\");\n } else {\n println!(\"x is not 42 or 43\");\n }\n\n // we can also use ifs as expressions\n let a_or_b = if x == 0 {\n \"a\" // notice no semicolon at the end\n } else {\n \"b\"\n };\n}\n\n\n(Download the source code for this example: conditionals.rs)\nLoops\n#![allow(unused_variables)]\n\nfn main() {\n for i in 0..10 {\n println!(\"i is {}\", i); // i in [0, 10)\n }\n\n let mut x = 0;\n\n while x < 50 {\n x += 1;\n }\n\n let mut y = 0;\n let mut iterations = 0;\n loop {\n iterations += 1;\n if iterations % 2 == 0 {\n continue;\n }\n y += 1;\n if y == 10 {\n break;\n }\n }\n\n // we can use labels to refer to a specific loop\n let mut count = 0;\n 'counting_up: loop {\n let mut remaining = 10;\n\n loop {\n if remaining == 9 {\n break;\n }\n if count == 2 {\n break 'counting_up; // ends the outer loop\n }\n remaining -= 1;\n }\n\n count += 1;\n }\n\n // We can use break with a value.\n // Because loops are expressions too,\n // the value we break with will be returned from the functions\n let mut counter = 0;\n let value = loop {\n counter += 1;\n if counter == 10 {\n break 32;\n }\n };\n}\n\n\n(Download the source code for this example: loops.rs)\nFunctions\nfn get_5() -> u32 {\n 5 // we could also write \"return 5;\"\n}\n\nfn print_sum(a: u32, b: u32) {\n println!(\"a + b = {}\", a + b);\n}\n\nfn main() {\n let a = 100;\n print_sum(a, get_5());\n}\n\n\n(Download the source code for this example: functions.rs)\nTest assignment (not graded)\nClick here\nObligatory reading\n\nThe Book, chapters 1-3\n\nAdditional reading\n\nRust By Example\n\n","id":"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/","title":"Introduction to Rust"},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"body":"Why all the fuss?\nEven if you've never seen Rust code before, chances are you still heard the term borrow checker or something about Rust's ownership. Indeed, Rust's ownership model lies at the very core of its uniqueness. But to fully understand it and appreciate it, let's first take a look at how memory management is handled in most popular languages.\n\n\nGarbage Collection - in many high-level programming languages, like Java, Haskell or Python, memory management is done fully by the language, relieving the programmer from this burden. This prevents memory leaks and memory related errors (like use after free), but does come at a cost - there is a runtime overhead, both memory and performance wise, caused by the constantly running garbage collection algorithms and the programmer usually has very little control over when the garbage collection takes place. Also, garbage collection does not prevent concurrency-related errors, such as data races, in any way.\n\n\nMind your own memory - in low-level languages and specific ones like C++, performance comes first so we cannot really afford to run expansive bookkeeping and cleaning algorithms. Most of these languages compile directly to machine code and have no language-specific runtime environment. That means that the only place where memory management can happen is in the produced code. While compilers insert these construction and destruction calls for stack allocated memory, it generally requires a lot of discipline from the programmer to adhere to good practices and patterns to avoid as many memory related issues as possible and one such bug can be quite deadly to the program and a nightmare to find and fix. These languages basically live by the \"your memory, your problem\" mantra.\n\n\nAnd then we have Rust. Rust is a systems programming language and in many ways it's akin to C++ - it's basically low-level with many high-level additions. But unlike C++, it doesn't exactly fall into either of the categories described above, though it's way closer to the second one. It performs no additional management at runtime, but instead imposes a set of rules on the code, making it easier to reason about and thus check for its safety and correctness at compile time - these rules make up Rust's ownership model.\nIn a way, programming in Rust is like pair-programming with a patient and very experienced partner. Rust's compiler will make sure you follow all the good patterns and practices (by having them ingrained in the language itself) and very often even tell you how to fix the issues it finds.\nDisclaimer: when delving deeper into Rust below we will make heavy use of concepts like scopes, moving data, stack and heap, which should have been introduced as part of the C++ course. If you need a refresher of any of these, it's best to do so now, before reading further.\nStart with the basics - ownership\nIn the paragraph above we mentioned a set of rules that comprise Rust's ownership model. The book starts off with the following three as its very foundation:\n\n\nEach value in Rust is tied to a specific variable - we call that variable its owner.\n\n\nThere can only be one owner at a time.\n\n\nWhen the owner goes out of scope, the value will be destroyed (or in Rust terms - dropped).\n\n\nThe third point might make you think about C++ and its automatic storage duration. We will later see that, while very similar at first, Rust expands on these mechanics quite a bit. The following code illustrates the basic version of this:\n{\n let a: i32 = 5; // allocation on the stack, 'a' becomes an owner\n\n // do some stuff with 'a'\n\n} // 'a', the owner, goes out of scope and the value is dropped\n\nSo far, so good. Variables are pushed onto the stack when they enter the scope and destroyed during stack unwinding that happens upon leaving their scope. However, allocating and deallocating simple integers doesn't impress anybody. Let's try something more complex:\n{\n let s = String::from(\"a string\"); // 's' is allocated on the stack, while its contents (\"a string\")\n // are allocated on the heap. 's' is the owner of this String object.\n\n // do some stuff with 's'\n\n} // 's', the owner, goes out of scope and the String is dropped, its heap allocated memory freed\n\nIf you recall the RAII (Resource Acquisition Is Initialization) pattern from C++, the above is basically the same thing. We go two for two now in the similarity department, so... is Rust really any different then? There is a part of these examples that we skipped over - actually doing something with the values.\nMoving around is fun\nLet's expand on the last example. The scoping is not really important for that one, so we don't include it here.\nlet s = String::from(\"a string\"); // same thing, 's' is now an owner\n\nlet s2 = s; // easy, 's2' becomes another owner... right?\n\nprintln!(\"And the contents are: {}\", s); // this doesn't work, can you guess why?\n\nAt first glance everything looks great. If we write this code (well, an equivalent of it) in basically any other popular language, it will compile no issue - but it does not here and there's a good reason why.\nTo understand what's happening, we have to consult the rules again, rule 2 in particular. It says that there can only be one owner of any value at a given time. So, s and s2 cannot own the same object. Okay, makes sense, but what is happening in this line then - let s2 = s;? Experience probably tells you that s just gets copied into s2, creating a new String object. That would result in each variable owning its very own instance of the string and each instance having exactly one owner. Sounds like everyone should be happy now, but wait - in that case the last line should work no issue, right? But it doesn't, so can't be a copy. Let's see now what the compiler actually has to say:\nerror[E0382]: borrow of moved value: `s`\n --> src/main.rs:6:42\n |\n2 | let s = String::from(\"a string\");\n | - move occurs because `s` has type `String`, which does not implement the `Copy` trait\n3 |\n4 | let s2 = s;\n | - value moved here\n5 |\n6 | println!(\"And the contents are: {}\", s);\n | ^ value borrowed here after move\n\n\"value moved here\" - gotcha! So s is being moved to s2, which also means that s2 now becomes the new owner of the string being moved and s cannot be used anymore. In Rust, the default method of passing values around is by move, not by copy. While it may sound a bit odd at first, it actually has some very interesting implications. But before we get to them, let's fix our code, so it compiles now. To do so, we have to explicitly tell Rust to make a copy by invoking the clone method:\nlet s = String::from(\"a string\"); // 's' is an owner\n\nlet s2 = s.clone(); // 's2' now contains its own copy\n\nprintln!(\"And the contents are: {}\", s); // success!\n\nThe compiler is happy now and so are we. The implicit move takes some getting used to, but the compiler is here to help us. Now, let's put the good, old C++ on the table again and compare the two lines:\n\nlet s2 = s; is equivalent to auto s2 = std::move(s);\nlet s2 = s.clone() is equivalent to auto s2 = s\n\nThere are a few important things to note here:\n\n\nMaking a copy is oftentimes not cheap. Memory needs to be allocated and copied, and a call to the system has to be made. We should prefer to move things as much as possible to avoid this cost - in C++ we have a myriad of language features like std::move and r-references to achieve this. Every programmer worth their salt needs to be well versed in all of them to write efficient C++ code and simply forgetting one move can lead to significant performance loss (and this happens to even the most senior devs ever existing, let's not pretend). On the contrary, in Rust you need to make an effort to make a copy and that makes you very aware of the cost you're paying - something that we'll see quite a lot of in the language. Also, if you forget a clone there's no harm done - it just won't compile!\n\n\nHidden in all of this is another nice thing Rust gives us. In C++, nothing prevents you from using variables after they've been moved from, leading to unexpected errors in a more complex code. In Rust, that variable (in our case s) simply becomes invalid and the compiler gives us a nice error about it.\n\n\nBut what about ints?\nA good question to ask. Copying primitives is cheap. And it's not convenient for the programmer to have to always write .clone() after every primitive. If we take a look at the error from the previous example:\nmove occurs because `s` has type `String`, which does not implement the `Copy` trait`\n\nIt says that s was moved because the String type doesn't have the Copy trait. We will talk about traits more in depth in the future lessons, but what this basically means is that String is not specified to be copied by default. All primitive types (i32, bool, f64, char, etc.) and tuples consisting only of primitive types implement the Copy trait.\nExercise\nHow to fix that code?\nfn count_animals(num: u32, animal: String) {\n println!(\"{} {} ...\", num, animal);\n}\n\nfn main() {\n let s = String::from(\"sheep\");\n\n count_animals(1, s);\n count_animals(2, s);\n count_animals(3, s);\n}\n\nLet's borrow some books\nWe now know how to move things around and how to clone them if moving is not possible. But what if making a copy is unnecessary - maybe we just want to let someone look at our resource and keep on holding onto it once they're done. Consider the following example:\nfn read_book(book: String) {\n println!(\"[Reading] {}\", book);\n}\n\nfn main() {\n let book = String::from(\"Merry lived in a big old house. The end.\");\n\n read_book(book.clone());\n\n println!(\"Book is still there: {}\", book);\n}\n\nCloning is pretty excessive here. Imagine recommending a book to your friend and instead of lending it to them for the weekend, you scan it and print an exact copy. Not the best way to go about it, is it? Thankfully, Rust allows us to access a resource without becoming an owner through the use of references and the & operator. This is called a borrow.\nThe adjusted code should look like this:\nfn read_book(book: &String) {\n println!(\"[Reading] {}\", book);\n}\n\nfn main() {\n let book = String::from(\"Merry lived in a big old house. The end.\");\n\n read_book(&book);\n\n println!(\"Book is still there: {}\", book);\n}\n\nAs with everything, references are too, by default, immutable, which means that the read_book function is not able to modify that book passed into it. We can also borrow something mutably by specifying it both in the receiving function signature and the place it gets called. Maybe you want to have your book signed by its author?\nfn sign_book(book: &mut String) {\n book.push_str(\" ~ Arthur Author\");\n}\n\nfn main() {\n // note that the book has to be marked as mutable in the first place\n let mut book = String::from(\"Merry lived in a big old house. The end.\");\n\n sign_book(&mut book); // it's always clear when a parameter might get modified\n\n println!(\"{}\", book); // book is now signed\n}\n\nPretty neat, but doesn't seem that safe right now. Let's try to surprise our friend:\nfn erase_book(book: &mut String) {\n book.clear();\n}\n\nfn read_book(book: &String) {\n println!(\"[Reading] {}\", book);\n}\n\nfn main() {\n let mut book = String::from(\"Merry lived in a big old house. The end.\");\n\n let r = &book; // an immutable borrow\n\n erase_book(&mut book); // a mutable borrow\n\n read_book(r); // would be pretty sad to open a blank book when it was not\n // what we borrowed initially\n\n println!(\"{}\", book);\n}\n\nFortunately for us (and our poor friend just wanting to read), the compiler steps in and doesn't let us do that, printing the following message:\nerror[E0502]: cannot borrow `book` as mutable because it is also borrowed as immutable\n --> src/main.rs:14:14\n |\n12 | let r = &book; // an immutable borrow\n | ----- immutable borrow occurs here\n13 |\n14 | erase_book(&mut book); // a mutable borrow\n | ^^^^^^^^^ mutable borrow occurs here\n15 |\n16 | read_book(r); // would be pretty sad to open a blank book when it was not\n | - immutable borrow later used here\n\nThis is where the famous borrow checker comes in. To keep things super safe, Rust clearly states what can and cannot be done with references and tracks their lifetimes. Exactly one of the following is always true for references to a given resource:\n\n\nThere exists only one mutable reference and no immutable references, or\n\n\nThere is any number of immutable references and no mutable ones.\n\n\nYou may notice a parallel to the readers - writers problem from concurrent programming. In fact, the way Rust's borrow checker is designed lends itself incredibly well to preventing data race related issues.\nDangling references\nRust also checks for dangling references. If we try to compile the following code:\nfn main() {\n let reference_to_nothing = dangle();\n}\n\nfn dangle() -> &String {\n let s = String::from(\"hello\");\n\n &s\n}\n\nwe will get an adequate error:\nerror[E0106]: missing lifetime specifier\n --> src/main.rs:5:16\n |\n5 | fn dangle() -> &String {\n | ^ expected named lifetime parameter\n |\n = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from\nhelp: consider using the `'static` lifetime\n |\n5 | fn dangle() -> &'static String {\n | ^^^^^^^^\n\nThe message above suggests specifing a lifetime for the returned string. In Rust, the lifetime of each variable is also a part of its type, but we will talk more about it later.\nExercise\nOur previous solution using clone() was pretty inefficient. How should this code look now?\nfn count_animals(num: u32, animal: String) {\n println!(\"{} {} ...\", num, animal);\n}\n\nfn main() {\n let s = String::from(\"sheep\");\n\n count_animals(1, s.clone());\n count_animals(2, s.clone());\n count_animals(3, s); // we could've ommitted the clone() here. Why?\n}\n\nEveryone gets a slice\nThe last part of working with references that we will cover in this lesson are slices. A slice in Rust is a view over continuous data. Let us start with a string slice - the &str type.\nNote: for the purposes of these examples we assume we are working with ASCII strings. More comprehensive articles on handling strings are linked at the end of this lesson.\nTo create a string slice from the String object s, we can simply write:\nlet slice = &s[1..3]; // creates a slice of length 2, starting with the character at index 1\n\nThis makes use of the & operator and Rust's range notation to specify the beginning and end of the slice. Thus, we can also write:\nlet slice = &s[2..]; // everything from index 2 till the end\nlet slice = &s[..1]; // only the first byte\nlet slice = &s[..]; // the whole string as a slice\nlet slice = s.as_str(); // also the whole string\n\nYou might have noticed that we always built String values using the from() method and never actually used the string literals directly. What type is a string literal then? Turns out it's the new string slice we just learned about!\nlet slice: &str = \"string literal\";\n\nIn fact, it makes a lot sense - string literals, after all, are not allocated on the heap, but rather placed in a special section of the resulting binary. It's only natural we just reference that place with a slice.\nSlices can also be taken from arrays:\nlet array: [i32; 4] = [42, 10, 5, 2]; // creates an array of four 32 bit integers\nlet slice: &[i32] = &array[1..3]; // results in a slice [10, 5]\n\nExercise\nCan this code still be improved from the previous version utilizing references? Think about the signature of count_animals.\nfn count_animals(num: u32, animal: &String) {\n println!(\"{} {} ...\", num, animal);\n}\n\nfn main() {\n let s = String::from(\"sheep\");\n\n count_animals(1, &s);\n count_animals(2, &s);\n count_animals(3, &s);\n}\n\nFurther reading\n\n\nChar documentation\n\n\nWorking with strings in Rust\n\n\nThe Book, chapter 4\n\n\nAssignment 1 (graded)\nordering in Van Binh\nDeadline: 16.10.2024 23:59\n","id":"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/","title":"Ownership Model"},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"body":"Aggregating data\nBelow is a compact overview of Rust's structs\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\nstruct Position(i32, i32); // tuple struct\n\n// Could Hero derive the Copy trait?\n#[derive(Clone, Debug, Eq, PartialEq)]\nstruct Hero {\n name: String,\n level: u32,\n experience: u32,\n position: Position,\n}\n\n// we can add methods to structs using the 'impl' keyword\nimpl Hero {\n // static method (in Rust nomenclature: \"associated function\")\n fn new(name: String) -> Hero {\n Hero {\n name,\n level: 1,\n experience: 0,\n position: Position(0, 0),\n }\n }\n}\n\n// multiple impl blocks are possible for one struct\nimpl Hero {\n // instance method, first argument (self) is the calling instance\n fn distance(&self, pos: Position) -> u32 {\n // shorthand to: `self: &Self`\n // field `i` of a tuple or a tuple struct can be accessed through 'tuple.i'\n (pos.0 - self.position.0).unsigned_abs() + (pos.1 - self.position.1).unsigned_abs()\n }\n\n // mutable borrow of self allows to change instance fields\n fn level_up(&mut self) {\n // shorthand to: `self: &mut Self`\n self.experience = 0;\n self.level += 1;\n }\n\n // 'self' is not borrowed here and will be moved into the method\n fn die(self) {\n // shorthand to: `self: Self`\n println!(\n \"Here lies {}, a hero who reached level {}. RIP.\",\n self.name, self.level\n );\n }\n}\n\nfn main() {\n // Calling associated functions requires scope (`::`) operator.\n let mut hero: Hero = Hero::new(String::from(\"Ferris\"));\n hero.level_up(); // 'self' is always passed implicitly\n\n // fields other than 'name' will be the same as in 'hero'\n let steve = Hero {\n name: String::from(\"Steve The Normal Guy\"),\n ..hero\n };\n\n assert_eq!(hero.level, steve.level);\n\n let mut twin = hero.clone();\n\n // we can compare Hero objects because it derives the PartialEq trait\n assert_eq!(hero, twin);\n twin.level_up();\n assert_ne!(hero, twin);\n hero.level_up();\n assert_eq!(hero, twin);\n\n // we can print out a the struct's debug string with '{:?}'\n println!(\"print to stdout: {:?}\", hero);\n\n hero.die(); // 'hero' is not usable after this invocation, see the method's definiton\n\n // the dbg! macro prints debug strings to stderr along with file and line number\n // dbg! takes its arguments by value, so better borrow them not to have them\n // moved into dbg! and consumed.\n dbg!(\"print to stderr: {}\", &twin);\n\n let pos = Position(42, 0);\n let dist = steve.distance(pos); // no clone here as Position derives the Copy trait\n println!(\"{:?}\", pos);\n assert_eq!(dist, 42);\n}\n\n\n(Download the source code for this example: data_types.rs)\nEnums\nIt is often the case that we want to define a variable that can only take\na certain set of values and the values are known up front. In C you can use an enum for this.\n#include <stdio.h>\n\nenum shirt_size {\n small,\n medium,\n large,\n xlarge\n};\n\nvoid print_size(enum shirt_size size) {\n printf(\"my size is \");\n switch (size) {\n case small:\n printf(\"small\");\n break;\n case medium:\n printf(\"medium\");\n break;\n case large:\n printf(\"large\");\n break;\n case xlarge:\n printf(\"xlarge\");\n break;\n default:\n printf(\"unknown\");\n break;\n }\n printf(\"\\n\");\n}\n\nint main() {\n enum shirt_size my_size = medium;\n print_size(my_size);\n}\n\n\n(Download the source code for this example: enums.c)\nHowever, in C enums are just integers. Nothing prevents us from writing\nint main() {\n enum shirt_size my_size = 666;\n print_size(my_size);\n}\n\nC++ introduces enum classes which are type-safe. Legacy enums are also somewhat safer than in C (same code as above):\n<source>:27:31: error: invalid conversion from 'int' to 'shirt_size' [-fpermissive]\n 27 | enum shirt_size my_size = 666;\n | ^~~\n | |\n | int\n\nSome programming languages (especially functional ones) allow programmers to define\nenums which carry additional information. Such types are usually called tagged unions\nor algebraic data types.\nIn C++ we can use union with an enum tag to define it:\n#include <iostream>\n\n// Taken from: https://en.cppreference.com/w/cpp/language/union\n\n// S has one non-static data member (tag), three enumerator members (CHAR, INT, DOUBLE),\n// and three variant members (c, i, d)\nstruct S\n{\n enum{CHAR, INT, DOUBLE} tag;\n union\n {\n char c;\n int i;\n double d;\n };\n};\n\nvoid print_s(const S& s)\n{\n switch(s.tag)\n {\n case S::CHAR: std::cout << s.c << '\\n'; break;\n case S::INT: std::cout << s.i << '\\n'; break;\n case S::DOUBLE: std::cout << s.d << '\\n'; break;\n }\n}\n\nint main()\n{\n S s = {S::CHAR, 'a'};\n print_s(s);\n s.tag = S::INT;\n s.i = 123;\n print_s(s);\n}\n\n\n(Download the source code for this example: tagged_union.cpp)\nC++17 introduced a new feature called variant which generalizes this concept.\nYou can read more about it here.\nJava has a more or less analogous feature called sealed classes\nsince version 17.\nEnums in Rust\nLet's see how they are defined in Rust.\n#![allow(unused_assignments)]\n#![allow(unused_variables)]\n#![allow(dead_code)]\n\n#[derive(Debug)]\nenum NamedSize {\n Small,\n Medium,\n Large,\n XL,\n}\n\n#[derive(Debug)]\nenum ShirtSize {\n Named(NamedSize),\n Numeric(u32),\n}\n\nfn main() {\n println!(\n \"Isn't it strange that some clothes' sizes are adjectives like {:?},\",\n ShirtSize::Named(NamedSize::Small)\n );\n println!(\n \"but sometimes they are numbers like {:?}?\",\n ShirtSize::Numeric(42)\n );\n}\n\n\n(Download the source code for this example: enums.rs)\nIn Rust, enums are a core feature of the language.\nYou may have heard that one of Rust's defining characteristics is\nthe absence of \"the billion dollar mistake\".\nSo what can we do to say that a value is missing if there is no null?\nIn Rust, we can use the Option type to represent the absence of a value.\nOption is defined as:\nenum Option<T> {\n Some(T),\n None,\n}\n\nThe <T> part is called the \"type parameter\" and it causes Option to be generic.\nWe won't go deeper into this for now.\nThe fact that variables which could be null in other languages have a different type in Rust is\nthe solution to the billion dollar mistake!\n#![allow(unused_assignments)]\n#![allow(unused_variables)]\n#![allow(dead_code)]\n\nfn main() {\n let mut not_null: i32 = 42;\n not_null = 43;\n // not_null = None; // this won't compile because it's a different type!\n\n let mut nullable: Option<i32> = Some(42);\n nullable = None;\n nullable = Some(43);\n\n // such construction is rare, but possible\n let mut double_nullable: Option<Option<i32>> = Some(Some(42));\n // assert_ne!(double_nullable, Some(42)); // this won't even compile because it's a different type!\n double_nullable = None;\n double_nullable = Some(None);\n\n // None and Some(None) are different!\n assert_ne!(double_nullable, None);\n\n // Now recall that division by 0 *panics*\n // A panic is an unrecoverable error\n // It is not an exception!\n // And in Rust there are no exceptions, so there are no try/catch blocks\n // Now let's imagine that we want to divide one number by another\n fn divide(dividend: i32, divisor: i32) -> i32 {\n dividend / divisor\n }\n\n // We get the divisor from the user, so it can be 0\n // We want to handle this situation gracefully - we don't want to crash the program!\n // We can do this by using the Option<T> type\n fn safe_divide(dividend: i32, divisor: i32) -> Option<i32> {\n if divisor == 0 {\n None\n } else {\n Some(dividend / divisor)\n }\n }\n\n // Fortunately, such a function is already included in the standard library\n let number: i32 = 42;\n // We need to specify the type explicitly\n // because checked_div is implemented for all integer types\n // and Rust won't know which type we want to use\n assert_eq!(number.checked_div(2), Some(21));\n assert_eq!(number.checked_div(0), None);\n\n // Now let's imagine we search for a value in an array.\n let numbers = [1, 2, 3, 4, 5];\n let three = numbers.iter().copied().find(|&x| x == 3);\n assert_eq!(three, Some(3));\n let seven = numbers.iter().copied().find(|&x| x == 7);\n assert_eq!(seven, None);\n // We won't delve deeper into the details of how iterators work for now,\n // but the key takeaway is that there are no sentinel or special values like `nullptr` in Rust\n\n // Usually there are two kinds of methods:\n // ones that will panic if the argument is incorrect,\n // numbers[8]; // this will panic!\n // and `checked` ones that return an Option\n assert_eq!(numbers.get(8), None);\n\n // We can use `unwrap` to get the value out of an Option\n // but we must be absolutely sure that the Option is Some, otherwise we'll get a panic\n // numbers.get(8).unwrap(); // this will panic!\n assert_eq!(numbers.get(8).copied().unwrap_or(0), 0); // or we can provide a default value\n\n // Usually instead of unwrapping we use pattern matching, we'll get to this in a minute\n // but first let's see what else we can do with an option\n let number: Option<i32> = Some(42);\n // We can use `map` to transform the value inside an Option\n let doubled = number.map(|x| x * 2);\n assert_eq!(doubled, Some(84));\n // We can use flatten to reduce one level of nesting\n let nested = Some(Some(42));\n assert_eq!(nested.flatten(), Some(42));\n // We can use `and_then` to chain multiple options\n // This operation is called `flatmap` in some languages\n let chained = number\n .and_then(|x| x.checked_div(0))\n .and_then(|x| x.checked_div(2));\n assert_eq!(chained, None);\n\n // The last two things we'll cover here are `take` and `replace`\n // They are important when dealing with non-Copy types\n // `take` will return the value inside an Option and leave a None in its place\n let mut option: Option<i32> = None;\n // Again, we need to specify the type\n // Even though we want to say that there is no value inside the Option,\n // this absent value must have a concrete type!\n assert_eq!(option.take(), None);\n assert_eq!(option, None);\n\n let mut x = Some(2);\n let y = x.take();\n assert_eq!(x, None);\n assert_eq!(y, Some(2));\n\n // `replace` can be used to swap the value inside an Option\n let mut x = Some(2);\n let old = x.replace(5);\n assert_eq!(x, Some(5));\n assert_eq!(old, Some(2));\n\n let mut x = None;\n let old = x.replace(3);\n assert_eq!(x, Some(3));\n assert_eq!(old, None);\n}\n\n\n(Download the source code for this example: option.rs)\nPattern matching\nPattern matching is a powerful feature of Rust and many functional languages, but it's slowly making\nits way into imperative languages like Java and Python as well.\n#![allow(dead_code)]\n#![allow(unused_variables)]\n\nfn main() {\n // Pattern matching is basically a switch on steroids.\n let number = rand::random::<i32>();\n match number % 7 {\n 0 => println!(\"{number} is divisible by 7\"),\n 1 => println!(\"{number} is *almost* divisible by 7\"),\n _ => println!(\"{number} is not divisible by 7\"),\n }\n\n #[derive(Debug)]\n enum Color {\n Pink,\n Brown,\n Lime,\n }\n\n let color = Color::Lime;\n match color {\n Color::Pink => println!(\"My favorite color!\"),\n _ => println!(\"Not my favorite color!\"), // _ is a wildcard\n // Rust will statically check that we covered all cases or included a default case.\n }\n\n // We can also use pattern matching to match on multiple values.\n match (color, number % 7) {\n (Color::Pink, 0) => println!(\"My favorite color and number!\"),\n (Color::Pink, _) => println!(\"My favorite color!\"),\n (_, 0) => println!(\"My favorite number!\"),\n (_, _) => println!(\"Not my favorite color or number!\"),\n }\n // (This is not special syntax, we're just pattern matching tuples.)\n\n // But we can also *destructure* the value\n struct Human {\n age: u8,\n favorite_color: Color,\n }\n\n let john = Human {\n age: 42,\n favorite_color: Color::Pink,\n };\n\n match &john {\n Human {\n age: 42,\n favorite_color: Color::Pink,\n } => println!(\"Okay, that's John!\"),\n Human {\n favorite_color: Color::Pink,\n ..\n } => println!(\"Not John, but still his favorite color!\"),\n _ => println!(\"Somebody else?\"),\n }\n\n // Note two things:\n // 1. Color is *not* Eq, so we can't use == to compare it, but pattern matching is fine.\n // 2. We *borrowed* the value, so we can use it after the match.\n\n println!(\"John is {} years old and still kicking!\", john.age);\n\n // To save some time, we can use `if let` to match against only one thing\n // We could also use `while let ... {}` in the same way\n if let Color::Pink = &john.favorite_color {\n println!(\"He's also a man of great taste\");\n }\n\n // We can match ranges...\n match john.age {\n 0..=12 => println!(\"John is a kid!\"),\n 13..=19 => println!(\"John is a teenager!\"),\n 20..=29 => println!(\"John is a young adult!\"),\n 30..=49 => println!(\"John is an adult!\"),\n 50..=69 => println!(\"John is mature!\"),\n _ => println!(\"John is old!\"),\n }\n\n // We can use match and capture the value at the same time.\n match john.age {\n age @ 0..=12 => println!(\"John is a kid, age {}\", age),\n age @ 13..=19 => println!(\"John is a teenager, age {}\", age),\n age @ 20..=29 => println!(\"John is a young adult, age {}\", age),\n age @ 30..=49 => println!(\"John is an adult, age {}\", age),\n age @ 50..=69 => println!(\"John is mature, age {}\", age),\n age => println!(\"John is old, age {}\", age),\n }\n\n // We can use guards to check for multiple conditions.\n match john.age {\n age @ 12..=19 if age % 2 == 1 => println!(\"John is an *odd* teenager, age {}\", age),\n age if age % 2 == 0 => println!(\"John is an *even* man, age {}\", age),\n _ => println!(\"John is normal\"),\n }\n\n // Finally, let's look at some references now\n let reference: &i32 = &4;\n\n match reference {\n &val => println!(\"Value under reference is: {}\", val),\n }\n\n // `ref` can be used to create a reference when destructuring\n let Human {\n age,\n ref favorite_color,\n } = john;\n // `john` is still valid, because we borrowed using `ref`\n if let Color::Pink = &john.favorite_color {\n println!(\"John still has his color - {:?}!\", favorite_color);\n }\n\n let mut john = john;\n\n // `ref mut` borrows mutably\n let Human {\n age,\n ref mut favorite_color,\n } = john;\n // We use `*` to dereference\n *favorite_color = Color::Brown;\n println!(\n \"Tastes do change with time and John likes {:?} now.\",\n john.favorite_color\n );\n}\n\n\n(Download the source code for this example: pattern_matching.rs)\nResult\nWe said there are no exceptions in Rust and panics mean errors which cannot be caught.\nSo how do we handle situations which can fail? That's where the Result type comes in.\n#![allow(dead_code)]\n#![allow(unused_variables)]\n\nuse std::fs::File;\nuse std::io;\nuse std::io::Read;\n\n// Let's try reading from a file.\n// Obviously this can fail.\nfn first_try() -> io::Result<String> {\n let file = File::open(\"/dev/random\");\n match file {\n Ok(mut file) => {\n // We got a file!\n let mut buffer = vec![0; 128];\n // Matching each result quickly become tedious...\n match file.read_exact(&mut buffer) {\n Ok(_) => {\n let gibberish = String::from_utf8_lossy(&buffer);\n Ok(gibberish.to_string())\n }\n Err(error) => Err(error),\n }\n }\n Err(error) => {\n Err(error) // This is needed in order to change the type from `io::Result<File>` to `io::Result<()>`\n }\n }\n}\n\n// The '?' operator allows us to return early in case of an error\n// (it automatically converts the error type)\nfn second_try(filename: &'static str) -> io::Result<String> {\n let mut file = File::open(filename)?;\n let mut buffer = vec![0; 128];\n file.read_exact(&mut buffer)?;\n let gibberish = String::from_utf8_lossy(&buffer);\n Ok(gibberish.to_string())\n}\n\nfn main() {\n let filenames = [\n \"/dev/random\",\n \"/dev/null\",\n \"/dev/cpu\",\n \"/dev/fuse\",\n \"there_certainly_is_no_such_file\",\n ];\n for filename in filenames {\n println!(\"Trying to read from '{}'\", filename);\n match second_try(filename) {\n Ok(gibberish) => println!(\"{}\", gibberish),\n Err(error) => println!(\"Error: {}\", error),\n }\n }\n}\n\n\n(Download the source code for this example: result.rs)\nObligatory reading\n\nThe Book, chapters 5,\n6,\n8\nand 9\nOption docs\nResult docs\n\nAssignment 2 (graded)\nCommunications\nDeadline: 23.10.2024 23:59\n","id":"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/","title":"Data Types"},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"body":"Feedback\nUnwrapping\nInstead of this:\nif self.favorite_color.is_some() {\n self.favorite_color.as_mut().unwrap().lighten();\n}\n\ndo this:\nif let Some(ref mut color) = self.favorite_color {\n color.lighten();\n}\n\nor\nif let Some(color) = &mut self.favorite_color {\n color.lighten();\n}\n\n(unwrapping is a code smell)\nSpot the overflow\nColor::Rgb(r, g, b) => *b > (*r + *g) / 2,\n\n1/3\nColor::Rgb(r, g, b) => (*b as u16) * 3 > (*r as u16) + (*g as u16) + (*b as u16),\n\nNo need to cast to u16. If b accounts for 1/3 of the sum, it's enough to check that it's bigger than both r and g.\nFormat\nColor::Named(ref mut name) => *name = \"light \".to_string() + name,\n\nThere's a format! macro for this.\nColor::Named(ref mut name) => *name = format!(\"light {name}\"),\n\nFrom vs Into vs as\nlet tmp1: u32 = <u8 as Into<u32>>::into(*c) * 2;\n\nThis could be written as\nlet tmp1: u32 = (*c).into() * 2;\n\nor even simpler (note the omission of the type annotation):\nlet tmp1 = u32::from(*c) * 2;\n\nHowever in most cases of numeric conversion you can just use as:\nlet tmp1 = *c as u32 * 2;\n\nInto trait docs\nSaturating addition\nThere's a saturating_add method on u8 which does exactly what we wanted.\nBut it was fun watching you struggle with it :)\nfn lighten(&mut self) {\n match self {\n Color::Named(name) => *name = \"light \".to_string() + name,\n Color::Rgb(r, g, b) => {\n *r = r.saturating_add(10);\n *g = g.saturating_add(10);\n *b = b.saturating_add(10);\n }\n }\n}\n\nExchange\nfn exchange_items(robot1: &mut Robot, robot2: &mut Robot) {\n mem::swap(&mut robot1.held_item, &mut robot2.held_item);\n}\n\nSwap is the preferred way to exchange the contents of two variables.\nRegex? Nope\nThere's no need to use a regex here. String has a contains method.\nIf you really want to use a regex,\nyou can use the lazy_static crate to avoid recompiling the regex every time you call the function.\n","id":"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/","title":"Feedback #1"},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"body":"Type traits\nTraits are a way to defined common behavior between different types. They can be compared to interfaces from many other mainstream languages or to type classes from Haskell, however, Rust is not an object-oriented language and there are some notable differences between type traits and Java interfaces.\nThe way we describe behavior in Rust is through methods. Traits consist of a set of these methods which then should be implemented by a type. We've already encountered examples of these, like the Clone trait which specified that the clone() method can be called on some given type. Now, let's take a deeper look and try defining our own trait.\n#![allow(dead_code)]\n\ntrait Summary {\n fn summarize(&self) -> String;\n}\n\nstruct NewsArticle {\n headline: String,\n location: String,\n author: String,\n content: String,\n}\n\nimpl Summary for NewsArticle {\n fn summarize(&self) -> String {\n format!(\"{}, by {} ({})\", self.headline, self.author, self.location)\n }\n}\n\nstruct Tweet {\n username: String,\n content: String,\n}\n\nimpl Summary for Tweet {\n fn summarize(&self) -> String {\n format!(\"{}: {}\", self.username, self.content)\n }\n}\n\nfn main() {\n let tweet = Tweet {\n username: String::from(\"horse_ebooks\"),\n content: String::from(\"of course, as you probably already know, people\"),\n };\n\n println!(\"1 new tweet: {}\", tweet.summarize());\n}\n\n\n(Download the source code for this example: basic_trait.rs)\nDefault implementations\nTrait definitions can also be provided with default implementations of behaviors.\n#![allow(dead_code)]\n\nstruct Upload {\n filename: String,\n}\n\n#[allow(dead_code)]\nstruct Photo {\n filename: String,\n width: u32,\n height: u32,\n}\n\ntrait Description {\n fn describe(&self) -> String {\n String::from(\"No description available.\")\n }\n}\n\n// All default implementations\nimpl Description for Upload {}\n\n// Default implementations can be overwritten\nimpl Description for Photo {\n fn describe(&self) -> String {\n format!(\"{} ({} x {})\", self.filename, self.width, self.height)\n }\n}\n\n// Default implementations can rely on methods with no defaults\ntrait Size {\n fn width(&self) -> u32;\n fn height(&self) -> u32;\n\n fn size(&self) -> u32 {\n self.width() * self.height()\n }\n}\n\nimpl Size for Photo {\n fn width(&self) -> u32 {\n self.width\n }\n\n fn height(&self) -> u32 {\n self.height\n }\n\n // Using default impl of `size()`\n}\n\nfn main() {\n let upload = Upload {\n filename: String::from(\"notes.txt\"),\n };\n\n println!(\"Upload: {}\", upload.describe());\n\n let photo = Photo {\n filename: String::from(\"stock_crustacean.png\"),\n width: 100,\n height: 150,\n };\n\n println!(\"Photo: {}\", photo.describe());\n println!(\"Size: {}\", photo.size());\n}\n\n\n(Download the source code for this example: trait_default.rs)\nWhat about derive?\nThere is a trait-related thing we have used quite extensively and not explained yet, namely the #[derive] attribute. What it does is generate items (in our case a trait implementation) based on the given data definition (here a struct). Below you can find a list of derivable traits from the standard library. Writing derivation rules for user defined traits is also possible, but goes out of the scope of this lesson.\nDerivable traits:\n\n\nEquality traits: Eq, PartialEq and comparison traits: Ord and PartialOrd. The Partial- versions exist because there are types which don't fulfill the reflexivity requirement of equality (NaN != NaN) or do not form a total order ( NaN < 0.0 == false and NaN >= 0.0 == false).\n\n\nData duplication traits: Clone and Copy\n\n\nHash - allows using values of that type as keys in a hashmap\n\n\nDefault - provides a zero-arg constructor function\n\n\nDebug - provides a formatting of the value which can be used in debugging context. It should NOT be implemented manually. In general, if it's possible to derive the Debug, there are no reasons against doing it.\n\n\nWhen is it possible to derive a trait?\nWhen all fields of a struct/variants of an enum implement that trait.\nShould all traits always be derived if it is possible?\nNo. Although it may be tempting to just slap #[derive(Clone, Copy)] everywhere, it would be counter-effective. For example, at some later point you might add a non-Copy field to the struct and your (or, what's worse, someone else's!) code would break. Another example: it makes little sense to use containers as keys in hashmaps or to compare tweets.\nGenerics\nSuppose we want to find the largest element in a sequence and return it. Very much on purpose, we didn't specify what type these elements would be - ideally, we would love it to work on all types that have a defined notion of a largest element. However, to make things simpler for now, let's focus only on two primitive types: i32 and char. Let's try to write the code:\nfn largest_i32(list: &[i32]) -> i32 {\n let mut largest = list[0];\n\n for &item in list {\n if item > largest {\n largest = item;\n }\n }\n\n largest\n}\n\nfn largest_char(list: &[char]) -> char {\n let mut largest = list[0];\n\n for &item in list {\n if item > largest {\n largest = item;\n }\n }\n\n largest\n}\n\nfn main() {\n let number_list = vec![34, 50, 25, 100, 65];\n\n let result = largest_i32(&number_list);\n println!(\"The largest number is {}\", result);\n\n let char_list = vec!['y', 'm', 'a', 'q'];\n\n let result = largest_char(&char_list);\n println!(\"The largest char is {}\", result);\n}\n\n\n(Download the source code for this example: non_generic.rs)\nPerfect, it works! Now only twenty more types to go...\nFortunately, Rust gives us a way to avoid all this code duplication and generalize the types we're working on.\nfn largest<T>(list: &[T]) -> T {\n let mut largest = list[0];\n\n for &item in list {\n if item > largest {\n largest = item;\n }\n }\n\n largest\n}\n\nCleaner already - we merged possibly very many implementations into one. But, when we try to compile this:\nerror[E0369]: binary operation `>` cannot be applied to type `T`\n --> src/main.rs:5:17\n |\n5 | if item > largest {\n | ---- ^ ------- T\n | |\n | T\n |\nhelp: consider restricting type parameter `T`\n |\n1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {\n | ++++++++++++++++++++++\n\nSince T can be of absolutely any type now, the compiler cannot be sure that operator > is defined. This aligns with what we wanted, as without comparing elements we don't have a notion of the largest one either. As always, the compiler comes to our aid:\nfn largest<T: PartialOrd>(list: &[T]) -> T {\n let mut largest = list[0];\n\n for &item in list {\n if item > largest {\n largest = item;\n }\n }\n\n largest\n}\n\nWe call this a trait bound, a way to provide constraints on what kind of types we are talking about in a given context. This implementation almost works now. Let's look at the new error.\nerror[E0508]: cannot move out of type `[T]`, a non-copy slice\n --> src/main.rs:2:23\n |\n2 | let mut largest = list[0];\n | ^^^^^^^\n | |\n | cannot move out of here\n | move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait\n | help: consider borrowing here: `&list[0]`\n\nerror[E0507]: cannot move out of a shared reference\n --> src/main.rs:4:18\n |\n4 | for &item in list {\n | ----- ^^^^\n | ||\n | |data moved here\n | |move occurs because `item` has type `T`, which does not implement the `Copy` trait\n | help: consider removing the `&`: `item`\n\nOur function attempts to take ownership, but, again, the compiler doesn't know whether T can just be trivially copied. Rust allows us to combine multiple trait bounds together:\nfn largest<T: PartialOrd + Copy>(list: &[T]) -> T {\n let mut largest = list[0];\n\n for &item in list {\n if item > largest {\n largest = item;\n }\n }\n\n largest\n}\n\nfn main() {\n let number_list = vec![34, 50, 25, 100, 65];\n\n let result = largest(&number_list);\n println!(\"The largest number is {}\", result);\n\n let char_list = vec!['y', 'm', 'a', 'q'];\n\n let result = largest(&char_list);\n println!(\"The largest char is {}\", result);\n}\n\n\n(Download the source code for this example: generic_largest.rs)\nA powerful tool\nThere's a lot more that we can do with generics:\n#![allow(dead_code)]\n\nuse std::fmt::Debug;\n\n// generic enums\nenum OurOption<T> {\n Some(T),\n None,\n}\n\n// generic structs\nstruct Tuple2<T, U> {\n x: T,\n y: U,\n}\n\n// generic implementation\nimpl<T, U> Tuple2<T, U> {\n fn new(x: T, y: U) -> Self {\n Self { x, y }\n }\n}\n\nstruct Pair<T> {\n x: T,\n y: T,\n}\n\n// conditional implementation\nimpl<T: PartialOrd + Copy> Pair<T> {\n fn largest(&self) -> T {\n if self.x > self.y {\n self.x\n } else {\n self.y\n }\n }\n}\n\n// alternative syntax\nimpl<T> Pair<T>\nwhere\n T: PartialOrd + Copy,\n{\n fn smallest(&self) -> T {\n if self.x < self.y {\n self.x\n } else {\n self.y\n }\n }\n}\n\n// Here information about the concrete underlying type is preserved.\nfn cloning_machine<T: Clone + Debug>(item: &T) -> T {\n item.clone()\n}\n\n// Here information about the concrete underlying type is erased.\n// We can only either format or clone the result.\nfn erasing_cloning_machine1(item: &(impl Clone + Debug)) -> impl Clone + Debug {\n item.clone()\n}\n\n// Ditto.\nfn erasing_cloning_machine2<T: Clone + Debug>(item: &T) -> impl Clone + Debug {\n item.clone()\n}\n\nfn main() {\n let _opt = OurOption::Some(10);\n\n let _p1 = Tuple2 { x: 5, y: 10 };\n let _p2 = Tuple2::new(1, 2.5);\n\n let arr = [1, 2, 3];\n\n let arr2 = cloning_machine(&arr);\n let _x = arr2[0]; // This compiles, because `cloning_machine` preserves the type.\n println!(\"{:?}\", arr2);\n\n let arr3 = erasing_cloning_machine1(&arr);\n // arr3[0]; // won't compile: cannot index into a value of type `impl std::clone::Clone + std::fmt::Debug`\n println!(\"{:?}\", arr3);\n\n let arr4 = erasing_cloning_machine2(&arr);\n // arr4[0]; // won't compile: cannot index into a value of type `impl std::clone::Clone + std::fmt::Debug`\n println!(\"{:?}\", arr4);\n}\n\n\n(Download the source code for this example: generics.rs)\nA bit more involved example:\nuse std::fmt::{Display, Formatter};\n\ntrait DefaultishablyPrintable<T> {\n fn defaultish_print()\n where\n T: Display + Default,\n {\n println!(\"{}\", T::default())\n }\n}\n\nstruct Foo;\n\nstruct Bar;\n\nimpl Display for Bar {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n f.write_str(\"this is a bar\")\n }\n}\n\nimpl Default for Bar {\n fn default() -> Self {\n Bar // well, we have no other choice\n }\n}\n\nimpl DefaultishablyPrintable<i32> for Foo {}\n\nimpl DefaultishablyPrintable<Bar> for Foo {}\n\nfn main() {\n <Foo as DefaultishablyPrintable<i32>>::defaultish_print();\n <Foo as DefaultishablyPrintable<Bar>>::defaultish_print();\n}\n\n\n(Download the source code for this example: generics_fun.rs)\nStatic vs dynamic dispatch\ntrait Speak {\n fn speak(&self) -> &'static str;\n}\n\nstruct Dog;\n\nimpl Speak for Dog {\n fn speak(&self) -> &'static str {\n \"Hau hau\" // it's a Polish dog!\n }\n}\n\nstruct Human;\n\nimpl Speak for Human {\n fn speak(&self) -> &'static str {\n \"Hello world\"\n }\n}\n\n// It works like templates in C++\n// A different function will be generated for each T during compilation\n// This process is called \"monomorphization\"\nfn static_dispatch<T: Speak>(speaking: &T) {\n println!(\"{}!\", speaking.speak());\n}\n\n// Only one copy of that function will exist in the compiled binary\nfn dynamic_dispatch(speaking: &dyn Speak) {\n println!(\"{}!\", speaking.speak());\n}\n\nfn main() {\n let dog = Dog;\n let human = Human;\n\n static_dispatch(&dog);\n static_dispatch(&human);\n\n dynamic_dispatch(&dog);\n dynamic_dispatch(&human);\n\n // The observable behavior is identical\n // Static dispatch in general is a bit faster,\n // because there is no need to perform a \"vtable lookup\".\n // But it can also result in bigger binary sizes.\n}\n\n\n(Download the source code for this example: static_dynamic_dispatch.rs)\nLifetimes\nGoing back to the lesson about ownership, if we try to compile the following code:\n{\n let r;\n\n {\n let x = 5;\n r = &x;\n }\n\n println!(\"r: {}\", r);\n}\n\nwe should expect to get an error:\nerror[E0597]: `x` does not live long enough\n --> src/main.rs:7:17\n |\n7 | r = &x;\n | ^^ borrowed value does not live long enough\n8 | }\n | - `x` dropped here while still borrowed\n9 |\n10 | println!(\"r: {}\", r);\n | - borrow later used here\n\nCourtesy of the borrow checker, we didn't end up with a dangling reference. But what exactly is happening behind the scenes? Rust introduces a concept of annotated lifetimes, where the lifetime of each value is being marked and tracked by the checker. Let's look at some examples:\n{\n let r; // ---------+-- 'a\n // |\n { // |\n let x = 5; // -+-- 'b |\n r = &x; // | |\n } // -+ |\n // |\n println!(\"r: {}\", r); // |\n} // ---------+\n\n{\n let x = 5; // ----------+-- 'b\n // |\n let r = &x; // --+-- 'a |\n // | |\n println!(\"r: {}\", r); // | |\n // --+ |\n} // ----------+\n\nAnnotations\nLet's consider the following code finding the longer out of two strings:\nfn longest(x: &str, y: &str) -> &str {\n if x.len() > y.len() {\n x\n } else {\n y\n }\n}\n\nfn main() {\n let string1 = String::from(\"abcd\");\n let string2 = \"xyz\";\n\n let result = longest(string1.as_str(), string2);\n println!(\"The longest string is {}\", result);\n}\n\nIf we try to compile this, we will get an error:\nerror[E0106]: missing lifetime specifier\n --> src/main.rs:9:33\n |\n9 | fn longest(x: &str, y: &str) -> &str {\n | ---- ---- ^ expected named lifetime parameter\n |\n = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`\nhelp: consider introducing a named lifetime parameter\n |\n9 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {\n | ++++ ++ ++ ++\n\nThis is because Rust doesn't know which of the two provided strings (x or y) will be returned from the function. And because they potentially have different lifetimes, the lifetime of what we are returning remains unclear to the compiler - it needs our help.\nRust provides syntax for specifying lifetimes. The lifetime parameter name from the example (a) doesn't have any concrete meaning - it's just an arbitrary name for this one lifetime.\n&i32 // a reference\n&'a i32 // a reference with an explicit lifetime\n&'a mut i32 // a mutable reference with an explicit lifetime\n\nSo, knowing this, let's address the compiler's demands.\nfn longest<'a>(x: &'a str, y: &'a str) -> &'a str {\n if x.len() > y.len() {\n x\n } else {\n y\n }\n}\n\nWhen working with lifetimes, our work will usually revolve around specifying relationships between lifetimes of different values so that the compiler can successfully reason about the program's safety. In the context of the example above, this signature means that both of the function's arguments and its output will live at least as long as lifetime 'a. In practice, this means that the output's lifetime will be equal to the smaller of the two inputs' lifetimes.\nfn longest<'a>(first: &'a str, second: &'a str) -> &'a str {\n if first.len() > second.len() {\n first\n } else {\n second\n }\n}\n\nfn main() {\n let string1 = String::from(\"long string is long\");\n\n {\n let string2 = String::from(\"xyz\");\n let result = longest(string1.as_str(), string2.as_str());\n println!(\"The longest string is {}\", result);\n }\n\n // This doesn't compile - incorrect lifetimes\n //\n // let string1 = String::from(\"long string is long\");\n // let result;\n // {\n // let string2 = String::from(\"xyz\");\n // result = longest(string1.as_str(), string2.as_str());\n // }\n // println!(\"The longest string is {}\", result);\n}\n\n\n(Download the source code for this example: lifetimes_basic.rs)\nTrying to compile the second variant displeases the compiler (just like we hoped).\nerror[E0597]: `string2` does not live long enough\n --> src/main.rs:6:44\n |\n6 | result = longest(string1.as_str(), string2.as_str());\n | ^^^^^^^^^^^^^^^^ borrowed value does not live long enough\n7 | }\n | - `string2` dropped here while still borrowed\n8 | println!(\"The longest string is {}\", result);\n | ------ borrow later used here\n\nLifetime elision\nWe now know how to explicitly write lifetime parameters, but you might recall that we don't always have to that. Indeed, Rust will first try to figure out the lifetimes itself, applying a set of predefined rules. We call this lifetime elision.\nfn first_two(seq: &[u32]) -> &[u32] {\n if seq.len() < 2 {\n seq\n } else {\n &seq[..2]\n }\n}\n\nfn main() {\n let seq = [1, 2, 3, 4];\n\n println!(\n \"First two elements of the sequence: {:?}\",\n first_two(&seq[..])\n );\n}\n\n\n(Download the source code for this example: lifetimes_elision.rs)\nThe above works, even though we didn't specify any lifetime parameters at all. The reason lies in the rules we mentioned, which are as follows (where input lifetimes are lifetimes on parameters and output lifetimes are lifetimes on return values):\n\n\nEach parameter that is a reference gets its own lifetime parameter.\n\n\nIf there is exactly one input lifetime parameter, that lifetime is assigned to all output lifetime parameters.\n\n\nIf there are multiple input lifetime parameters, but one of them is &self or &mut self, the lifetime of self is assigned to all output lifetime parameters.\n\n\nLet's try to understand how the compiler inferred the lifetimes of our first_two functions. We start with the following signature:\nfn first_two(seq: &[u32]) -> &[u32] {\n\nThen, we apply the first rule:\nfn first_two<'a>(seq: &'a [u32]) -> &[u32] {\n\nNext, we check the second rule. It applies here as well.\nfn first_two<'a>(seq: &'a [u32]) -> &'a [u32] {\n\nWith that, we arrive at a state where all lifetimes are specified.\nStatic lifetime\nThere exists one special lifetime called 'static, which means that a reference can live for the entire duration of the program. All string literals are annotated with this lifetime as they are stored directly in the program's binary. Full type annotation of a string literal in Rust is therefore as follows:\nlet s: &'static str = \"I have a static lifetime.\";\n\nTrait + lifetimes - a challenging tandem\nLet's go back to our basic_trait.rs example. The Summary trait was really wasteful: it always allocated the Strings on heap, even though we only needed to display the formatted string, and we could do that without allocations. How? By using Display trait, of course.\nThe simplest possible optimisation would be like this:\n#![allow(dead_code)]\n\nuse std::fmt::Display;\n\nstruct NewsArticle {\n headline: String,\n location: String,\n author: String,\n content: String,\n}\n\nimpl Display for NewsArticle {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(\n f,\n \"{}, by {} ({})\",\n self.headline, self.author, self.location\n )\n }\n}\n\nstruct Tweet {\n username: String,\n content: String,\n}\n\nimpl Display for Tweet {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"{}: {}\", self.username, self.content)\n }\n}\n\nfn main() {\n let tweet = Tweet {\n username: String::from(\"horse_ebooks\"),\n content: String::from(\"of course, as you probably already know, people\"),\n };\n\n println!(\"1 new tweet: {}\", tweet);\n}\n\n\n(Download the source code for this example: basic_trait_display.rs)\nThis eliminates the heap allocations, but there's another catch. What if NewsArticle already had another (non-summarizing) Display implementation? We would end up in a double-trait-implementation conflict, which is a compile-time error.\nWe can solve the one-type-one-trait-impl problem by introducing another type just for summarizing. The first attempt could be to use generics in traits:\n#![allow(dead_code)]\n\nuse std::fmt::Display;\n\ntrait Summary<'a, Summarizer: Display> {\n fn summarize(&'a self) -> Summarizer;\n}\n\nstruct NewsArticle {\n headline: String,\n location: String,\n author: String,\n content: String,\n}\n\nimpl Display for NewsArticle {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n writeln!(\n f,\n \"{}, by {} ({})\",\n self.headline, self.author, self.location\n )?;\n f.write_str(&self.content)\n }\n}\n\nstruct NewsArticleSummarizer<'a>(&'a NewsArticle);\n\nimpl Display for NewsArticleSummarizer<'_> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let article = self.0;\n write!(\n f,\n \"{}, by {} ({})\",\n article.headline, article.author, article.location\n )\n }\n}\n\nimpl<'a> Summary<'a, NewsArticleSummarizer<'a>> for NewsArticle {\n fn summarize(&'a self) -> NewsArticleSummarizer<'a> {\n NewsArticleSummarizer(self)\n }\n}\n\nstruct Tweet {\n username: String,\n content: String,\n}\n\nstruct TweetSummarizer<'a>(&'a Tweet);\n\nimpl Display for TweetSummarizer<'_> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let tweet = self.0;\n write!(f, \"{}: {}\", tweet.username, tweet.content)\n }\n}\n\nimpl<'a> Summary<'a, TweetSummarizer<'a>> for Tweet {\n fn summarize(&'a self) -> TweetSummarizer<'a> {\n TweetSummarizer(self)\n }\n}\n\nimpl<'a> Summary<'a, NewsArticleSummarizer<'a>> for Tweet {\n fn summarize(&'a self) -> NewsArticleSummarizer<'a> {\n unimplemented!(\"This is only to make code type-check and compile.\");\n }\n}\n\nfn main() {\n let empty_article = NewsArticle {\n headline: \"\".into(),\n location: String::new(),\n author: String::default(),\n content: Default::default(),\n };\n println!(\"1 new article: {}\", empty_article.summarize());\n\n let tweet = Tweet {\n username: String::from(\"horse_ebooks\"),\n content: String::from(\"of course, as you probably already know, people\"),\n };\n\n // Compile error: `type annotations needed; multiple `impl`s satisfying `Tweet: Summary<'_, _>` found`\n // println!(\"1 new tweet: {}\", tweet.summarize());\n println!(\n \"1 new tweet: {}\",\n <Tweet as Summary<'_, TweetSummarizer>>::summarize(&tweet)\n );\n println!(\n \"1 new tweet: {}\",\n <Tweet as Summary<'_, NewsArticleSummarizer>>::summarize(&tweet)\n );\n}\n\n\n(Download the source code for this example: trait_generic_type.rs)\nThe problem here is that nothing hinders us from implement the trait (with various type parameters) for the same type, which leads to awkward ambiguity when calling the trait's methods (see main fn).\nThe use of generic types in Summary trait makes it semantics like this:\n\nA type can be summarized with any type supporting it.\n\nWhen we want the trait to require exactly one possible generic implementation for a given type, we can leverage associated types. Example here:\n#![allow(dead_code)]\n\nuse std::fmt::Display;\n\ntrait Summary<'a> {\n type Summarizer: Display;\n\n fn summarize(&'a self) -> Self::Summarizer;\n}\n\nstruct NewsArticle {\n headline: String,\n location: String,\n author: String,\n content: String,\n}\n\nimpl Display for NewsArticle {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n writeln!(\n f,\n \"{}, by {} ({})\",\n self.headline, self.author, self.location\n )?;\n f.write_str(&self.content)\n }\n}\n\nstruct NewsArticleSummarizer<'a>(&'a NewsArticle);\n\nimpl Display for NewsArticleSummarizer<'_> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let article = self.0;\n write!(\n f,\n \"{}, by {} ({})\",\n article.headline, article.author, article.location\n )\n }\n}\n\nimpl<'a> Summary<'a> for NewsArticle {\n type Summarizer = NewsArticleSummarizer<'a>;\n fn summarize(&'a self) -> Self::Summarizer {\n NewsArticleSummarizer(self)\n }\n}\n\nstruct Tweet {\n username: String,\n content: String,\n}\n\nstruct TweetSummarizer<'a>(&'a Tweet);\n\nimpl Display for TweetSummarizer<'_> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let tweet = self.0;\n write!(f, \"{}: {}\", tweet.username, tweet.content)\n }\n}\n\nimpl<'a> Summary<'a> for Tweet {\n type Summarizer = TweetSummarizer<'a>;\n fn summarize(&'a self) -> Self::Summarizer {\n TweetSummarizer(self)\n }\n}\n\nfn main() {\n let tweet = Tweet {\n username: String::from(\"horse_ebooks\"),\n content: String::from(\"of course, as you probably already know, people\"),\n };\n\n println!(\"1 new tweet: {}\", tweet.summarize());\n}\n\n\n(Download the source code for this example: trait_associated_type.rs)\nThe use of associated types in Summary trait makes it semantics like this:\n\nA type can be summarized with at most one specific type.\n\nYet another approach (arguably, the cleanest one) would be to use the impl trait syntax in a trait (quite recently stabilized!).\nExample:\n#![allow(dead_code)]\n\nuse std::fmt::Display;\n\ntrait Summary {\n fn summarize(&self) -> impl Display;\n}\n\nstruct NewsArticle {\n headline: String,\n location: String,\n author: String,\n content: String,\n}\n\nimpl Display for NewsArticle {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n writeln!(\n f,\n \"{}, by {} ({})\",\n self.headline, self.author, self.location\n )?;\n f.write_str(&self.content)\n }\n}\n\nstruct NewsArticleSummarizer<'a>(&'a NewsArticle);\n\nimpl Display for NewsArticleSummarizer<'_> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let article = self.0;\n write!(\n f,\n \"{}, by {} ({})\",\n article.headline, article.author, article.location\n )\n }\n}\n\nimpl Summary for NewsArticle {\n fn summarize(&self) -> impl Display {\n NewsArticleSummarizer(self)\n }\n}\n\nstruct Tweet {\n username: String,\n content: String,\n}\n\nimpl Summary for Tweet {\n fn summarize(&self) -> impl Display {\n struct TweetSummarizer<'a>(&'a Tweet);\n\n impl Display for TweetSummarizer<'_> {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n let tweet = self.0;\n write!(f, \"{}: {}\", tweet.username, tweet.content)\n }\n }\n\n TweetSummarizer(self)\n }\n}\n\nfn main() {\n let tweet = Tweet {\n username: String::from(\"horse_ebooks\"),\n content: String::from(\"of course, as you probably already know, people\"),\n };\n\n println!(\"1 new tweet: {}\", tweet.summarize());\n}\n\n\n(Download the source code for this example: impl_trait.rs)\nObligatory reading\n\n\nThe Book, chapter 10\n\n\nPolymorphism in Rust\n\n\nAssignment 3 (graded)\nPassage Pathing\nDeadline: 30.10.2024 23:59\n","id":"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/","title":"Reasoning About Types"},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"body":"Closures\nClosures (Polish: \"domknięcia\") are anonymous functions that can access variables from the scope in which they were defined.\nClosure syntax\nfn main() {\n #[rustfmt::skip]\n {\n // This is formatted so that without rust-analyzer it renders as well-aligned.\n\n fn add_one_v1 (x: u32) -> u32 { x + 1 } // This is an ordinary function.\n let add_one_v2 = |x: u32| -> u32 { x + 1 }; // Closures use pipes instead of parentheses.\n let add_one_v3 = |x| { x + 1 }; // Both parameters and return value can have their types inferred.\n let add_one_v4 = |x| x + 1 ; // If the body is a single expression, braces can be omitted.\n\n let _res = add_one_v1(0_u32);\n let _res = add_one_v2(0_u32);\n let _res = add_one_v3(0_u32);\n let _res = add_one_v4(0_u32);\n \n // This does not compile, because closures are not generic.\n // Their type is inferred once and stays the same.\n // let _res = add_one_v4(0_i32);\n };\n}\n\n\n(Download the source code for this example: closures_syntax.rs)\nClosures' types\nClosures are unnameable types. That is, each closure gets its own unique type from the compiler,\nbut we cannot name it. Therefore, closures' types must be inferred.\nWe will often use impl keyword with closure traits (e.g., impl Fn) - those traits are described below.\nClosures capture environment\nClosures can capture variables from the environment where they are defined. They can do that in two ways:\n\nCapturing References (borrowing), or\nMoving Ownership.\n\nHOW closures capture variables is one thing.\nBut even more important is WHAT closures do with their captures.\nFunctions & closures hierarchy\nBased on WHAT a closure does with its captures, it implements closure traits:\n\nFnOnce - closures that may move out of their captures environment (and thus called once).\nFnMut - closures that may mutate their captures, but don't move out of their captures environment (so can be called multiple times, but require a mutable reference);\nFn - closures that do not mutate their captures (so can be called multiple times through an immutable reference).\n\nFor completeness, there is a (concrete) type of function pointers:\n\nfn - functions, closures with no captures.\n\nThose traits and the fn type form a hierarchy: fn ⊆ Fn ⊆ FnMut ⊆ FnOnce\n $$ fn \\subseteq Fn \\subseteq FnMut \\subseteq FnOnce $$ -->\nThe following code sample demonstrates various ways to capture environment (borrowing or moving) and various kinds of closures, based on what they do with their captures:\nfn main() {\n borrowing_immutably_closure();\n borrowing_mutably_closure();\n moving_in_nonmutating_closure();\n moving_in_mutating_closure();\n moving_in_moving_out_closure();\n}\n\nfn borrowing_immutably_closure() {\n let list = vec![1, 2, 3];\n println!(\"Before defining closure: {:?}\", list);\n\n let only_borrows = || println!(\"From closure: {:?}\", list);\n\n // This would not really only borrow... (it needs Vec by value).\n // let only_borrows = || std::mem::drop::<Vec<_>>(list);\n\n println!(\"Before calling closure: {:?}\", list);\n only_borrows();\n println!(\"After calling closure: {:?}\", list);\n}\n\nfn borrowing_mutably_closure() {\n let mut list = vec![1, 2, 3];\n println!(\"Before defining closure: {:?}\", list);\n\n let mut borrows_mutably = || list.push(7);\n\n // println!(\"Before calling closure: {:?}\", list);\n borrows_mutably();\n println!(\"After calling closure: {:?}\", list);\n}\n\nfn moving_in_nonmutating_closure() {\n let list = vec![1, 2, 3];\n println!(\"Before defining closure: {:?}\", list);\n\n // This closure would just borrow the list, because it only prints it.\n // However, as spawning threads require passing `impl FnOnce + 'static`,\n // we need to use `move` keyword to force the closure to move `list`\n // into its captured environment.\n std::thread::spawn(move || println!(\"From thread: {:?}\", list))\n .join()\n .unwrap();\n}\n\nfn moving_in_mutating_closure() {\n fn append_42(mut appender: impl FnMut(i32)) {\n appender(42);\n }\n\n let mut appender = {\n let mut list = vec![1, 2, 3];\n println!(\"Before defining closure: {:?}\", list);\n\n // The `move` keyword is necessary to prevent dangling reference to `list`.\n // Of course, the borrow checker protects us from compiling code without `move`.\n move |num| list.push(num)\n };\n\n append_42(&mut appender);\n append_42(&mut appender);\n}\n\nfn moving_in_moving_out_closure() {\n fn append_multiple_times(appender: impl FnOnce(&mut Vec<String>) + Clone) {\n let mut list = Vec::new();\n\n // We can clone this `FnOnce`, because we additionally require `Clone`.\n // If we didn't clone it, we couldn't call it more than *once*.\n appender.clone()(&mut list);\n appender(&mut list);\n }\n\n let appender = {\n let string = String::from(\"Ala\");\n println!(\"Before defining closure: {:?}\", string);\n\n // The `move` keyword is necessary to prevent dangling reference to `list`.\n // Of course, the borrow checker protects us from compiling code without `move`.\n move |list: &mut Vec<String>| list.push(string)\n };\n\n // As `appender` is only `FnOnce`, we need to clone before we consume it by calling it.\n append_multiple_times(appender.clone());\n append_multiple_times(appender);\n}\n\n\n(Download the source code for this example: closures_capturing.rs)\nClosures as trait objects (in dynamic dispatch)\nThe following code sample shows how one can use closures as dyn Trait objects, bypassing the problem of them having anonymous types:\nfn main() {\n fn some_function() -> String {\n String::new()\n }\n\n let v1 = String::from(\"v1\");\n let mut borrowing_immutably_closure = || v1.clone();\n\n let mut v2 = String::from(\"v2\");\n let mut borrowing_mutably_closure = || {\n v2.push('.');\n v2.clone()\n };\n\n let v3 = String::from(\"v3\");\n let mut moving_in_nonmutating_closure = move || v3.clone();\n\n let mut v4 = String::from(\"v4\");\n let mut moving_in_mutating_closure = move || {\n v4.push('.');\n v4.clone()\n };\n let v5 = String::from(\"v5\");\n let moving_in_moving_out_closure = || v5;\n\n let fn_once_callables: [&dyn FnOnce() -> String; 5] = [\n &some_function,\n &borrowing_immutably_closure,\n &borrowing_mutably_closure,\n &moving_in_nonmutating_closure,\n &moving_in_moving_out_closure,\n ];\n\n #[allow(unused_variables)]\n for fn_once_callable in fn_once_callables {\n // Cannot move a value of type `dyn FnOnce() -> String`.\n // The size of `dyn FnOnce() -> String` cannot be statically determined.\n // println!(\"{}\", fn_once_callable());\n\n // So, for FnOnce, we need to be their owners to be able to call them,\n // and we can't have a `dyn` object owned on stack.\n // We will solve this problem soon with smart pointers (e.g., Box).\n // This will give us `std::function` -like experience.\n }\n\n // Mutable reference to FnMut is required to be able to call it.\n let fn_mut_callables: [&mut dyn FnMut() -> String; 4] = [\n &mut borrowing_immutably_closure,\n &mut borrowing_mutably_closure,\n &mut moving_in_nonmutating_closure,\n &mut moving_in_mutating_closure,\n ];\n\n for fn_mut_callable in fn_mut_callables {\n println!(\"{}\", fn_mut_callable());\n }\n\n let fn_callables: &[&dyn Fn() -> String] =\n &[&borrowing_immutably_closure, &moving_in_nonmutating_closure];\n\n for fn_callable in fn_callables {\n println!(\"{}\", fn_callable());\n }\n}\n\n\n(Download the source code for this example: closures_fun.rs)\nExamples\nWe'll go through the examples from Rust by Example.\nMore examples will be seen when working with iterators.\nIterators\nIn Rust, there is no hierarchy of types for collections (because there is no inheritance in general).\nInstead, what makes a collection is that it can be iterated over.\nA usual way in Rust to perform an iteration over something, be it a range of values or items in a collection, is creating a (lazy) iterator over it and transforming it using iterator adaptors. For example, if T: Iterator, then T::map() creates a Map<T> adaptor. Once a final iterator is created, it has to be actually activated (iterated over), which is most commonly done by:\n\nexhausting it with the for loop,\nmanually iterating over it using next() calls,\ncollecting its contents into inferred collection (collect()),\nconsuming it with a consuming adaptor (e.g., sum(), count),\n\nuse std::collections::HashSet;\n\nfn main() {\n // Various ways to create a String.\n let mut strings = [\n String::new(),\n String::from(\"a\"),\n \"b\".into(),\n \"c\".to_owned(),\n \"d\".to_string(),\n \"e\".chars().collect(),\n ];\n\n // `iter()` is a usual method that creates an iterator over immutable references to the collection's items.\n let _all_len_0_or_1 = strings\n .iter()\n .filter(|s| !s.is_empty())\n .all(|s| s.len() == 1);\n\n // `iter_mut()` is a usual method that creates an iterator over mutable references to the collection's items.\n for s in strings.iter_mut().map_while(|s| match s.as_str() {\n \"c\" => None,\n _ => Some(s),\n }) {\n *s = s.replace(\"b\", \"aba\");\n }\n\n // This code is equivalent to the `for` above.\n // `for` is usually more idiomatic, but `for_each` is sometimes cleaner and sometimes faster.\n strings\n .iter_mut()\n .map_while(|s| match s.as_str() {\n \"c\" => None,\n _ => Some(s),\n })\n .for_each(|s| *s = s.replace(\"b\", \"aba\"));\n\n // `into_iter()` is a method from `IntoIterator` trait that converts a collection to an iterator\n let mut empty_strings_iter = strings.into_iter().map(|mut s| {\n s.clear();\n s\n });\n\n // This is a set of empty Strings...\n let empty_strings_set = empty_strings_iter.clone().collect::<HashSet<_>>();\n\n // And this is a Vec of immutable references to empty Strings.\n let empty_string_refs_vec = empty_strings_set.iter().collect::<Vec<_>>();\n\n // equivalent to `empty_string_refs_vec.into_iter()`\n for s in empty_string_refs_vec {\n println!(\"{}\", s)\n }\n\n while let Some(s) = empty_strings_iter.next_back() {\n assert!(s.is_empty());\n }\n}\n\n\n(Download the source code for this example: iterator_exhaustion.rs)\nIterators are highly optimised, so they are high-level code that compiles down to simple and optimised machine code (intended as zero-cost abstractions).\nWe'll go through the official docs.\n\nMost methods are defined in the Iterator trait.\nIntoIterator is also worth noting, because it makes types work with the for loop.\nFor completeness, there is FromIterator, which is required for collect() to work.\n\nReading\n\nThe Book, chapter 12 (that's a project!)\nThe Book, chapter 13\nThe Book, chapter 14\nThe Book, Advanced Functions and Closures\nThe Book, Advanced Traits\n\nAssignment 4 (graded)\nLazy\nDeadline: 06.11.2024 23:59\n","id":"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/","title":"Closures and Iterators"},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"body":"Working with the heap\nSo far we've only used heap allocated memory indirectly by working with containers such as vectors, maps or the String type, otherwise allocating our variables on the stack. We didn't really have to be aware of the fact that these collections used the heap, as all that memory management details were hidden away from us. In this lesson we'll take a closer look at what is really happening there and how we can do that ourselves.\nTo work with heap-allocated memory, Rust features smart pointers. You should have already heard this term as it is a very important feature in C++ and the concept is virtually the same here - they are wrappers around raw allocated memory that provide additional, safety-ensuring mechanism. What defines a smart pointer in Rust is generally the implementation of two traits: Drop and Deref.\nThe Drop trait is pretty straightforward as it consists of one method - fn drop(&mut self) - that is, basically, the destructor, invoked during stack unwinding.\nThe Deref trait allows us to overload the dereference (*) operator.\nDeref coercion\nApart from enabling access to the underlying value, implementing the Deref trait enables Rust to perform deref coercion on the pointer - trying to remove as many levels of indirection as it can. What it means in practice is that we will be able to use it with any code working on plain references.\nuse std::ops::Deref;\n\nstruct MyBox<T>(T);\n\n// We won't be allocating anything on the heap here as it is not important here.\n// We're only focusing on the dereference mechanisms.\nimpl<T> MyBox<T> {\n fn new(x: T) -> MyBox<T> {\n MyBox(x)\n }\n}\n\nimpl<T> Deref for MyBox<T> {\n type Target = T;\n\n fn deref(&self) -> &Self::Target {\n &self.0\n }\n}\n\nfn hello(name: &str) {\n println!(\"Hello, {}!\", name);\n}\n\nfn main() {\n let x = 5;\n let int_box = MyBox::new(x);\n\n assert_eq!(5, *int_box);\n\n // String also implements the `Deref` trait.\n // In fact, String actually is a smart pointer.\n let s = String::from(\"I'm a smart pointer too\");\n hello(&s);\n\n // Deref coercion can deal with multiple levels of indirection.\n let str_box = MyBox::new(String::from(\"Rust\"));\n hello(&str_box);\n}\n\n\n(Download the source code for this example: deref_coercion.rs)\nIn general, there are three possible coercions that Rust can perform:\n\n\nFrom &T to &U when T: Deref<Target=U>\n\n\nFrom &mut T to &mut U when T: DerefMut<Target=U>\n\n\nFrom &mut T to &U when T: Deref<Target=U>\n\n\nWhile the first two coercions are straightforward, the third one is possible because treating a mutable reference as an immutable one does not break the rules of ownership.\nBox - simple wrapper\nThe Box<T> type is the most basic out of Rust's smart pointers, equivalent to C++'s std::unique_ptr<T>. It's a simple wrapper that makes sure the underlying memory gets allocated and freed properly.\nfn box_simple() {\n let b = Box::new(5);\n println!(\"b = {}\", b);\n\n let _x = 10 + *b;\n}\n\n// `Box` gives us the indirection required to define\n// recursive types\n#[allow(dead_code)]\nenum List {\n Cons(i32, Box<List>),\n Nil,\n}\n\nfn main() {\n box_simple();\n}\n\n\n(Download the source code for this example: box.rs)\nReference counting\nThe Rc<T> type is the equivalent of std::shared_ptr<T> from C++. There is one caveat to this though - because we're creating multiple references to the same object, those references have to be immutable in accordance with the ownership rules.\nuse std::rc::Rc;\n\nstruct LoudInt(i32);\n\nimpl Drop for LoudInt {\n fn drop(&mut self) {\n println!(\"[{}] Farewell!\", self.0);\n }\n}\n\nfn main() {\n {\n let outer_ref;\n\n {\n let inner_ref = Rc::new(LoudInt(5));\n\n // strong_count represents the number of owning references pointing\n // to data\n assert_eq!(Rc::strong_count(&inner_ref), 1);\n\n outer_ref = Rc::clone(&inner_ref);\n\n assert_eq!(Rc::strong_count(&inner_ref), Rc::strong_count(&outer_ref));\n assert_eq!(Rc::strong_count(&inner_ref), 2);\n }\n\n println!(\"The {} still lives!\", outer_ref.0);\n assert_eq!(Rc::strong_count(&outer_ref), 1);\n }\n}\n\n\n(Download the source code for this example: ref_count.rs)\nRust also provides a non-owning pointer in the form of Weak<T> (equivalent to std::weak_ptr<T>) that can be obtained from an instance of Rc<T>.\nuse std::rc::Rc;\n\nstruct LoudInt(i32);\n\nimpl Drop for LoudInt {\n fn drop(&mut self) {\n println!(\"[{}] Farewell!\", self.0);\n }\n}\n\nfn main() {\n let weak_ref;\n\n {\n let shared_ref = Rc::new(LoudInt(5));\n\n // weak_count keeps track of the non-owning reference to the data\n assert_eq!(Rc::weak_count(&shared_ref), 0);\n\n // `downgrade()` obtains a weak pointer to Rc's data\n weak_ref = Rc::downgrade(&shared_ref);\n\n assert_eq!(Rc::weak_count(&shared_ref), 1);\n assert_eq!(Rc::strong_count(&shared_ref), 1);\n\n // In order to use the the data underneath the weak pointer\n // we need to obtain a new shared pointer from it.\n // The `upgrade()` method returns `Option<Rc<T>>`.\n let temp = weak_ref.upgrade();\n assert_eq!(Rc::strong_count(&shared_ref), 2);\n println!(\"The value is {}\", temp.unwrap().0);\n }\n\n println!(\"The value should be deallocated by now.\");\n assert!(weak_ref.upgrade().is_none());\n}\n\n\n(Download the source code for this example: weak_ref.rs)\nMutating the immutable\nGood examples and explanation of the interior mutability pattern and runtime borrow checking can be found in the book.\nAlongside the RefCell<T> type described above, there is an analogous Cell<T> type that operates on values instead of references.\nConvenient handling of dyn objects\nIn previous labs you learned about dynamic dispatch and its strengths. The largest drawback you noticed is most likely that they are unsized (!Sized, where ! being syntax signifying lack of trait implementation).\nWhen storing an object on a heap, however, we can use it as a dyn object seamlessly.\nObligatory reading\n\n\nThe Book, chapter 15\n\n\nstd::borrow::Cow, a versatile copy-on-write smart pointer\n\n\nAdditional reading\n\nOn wrapped references\nDeref vs AsRef vs Borrow\n\nAssignment 5 (graded)\nCorporations\nDeadline: 13.11.2024 23:59\n","id":"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/","title":"Smart Pointers"},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"body":"Feedback\nConditional implementation\nimpl<const N: usize> Shape for SphereN<N> {\n type Volume = VolumeN<N>;\n fn volume(&self) -> Self::Volume {\n let mut volume: u32 = (f64::from(self.radius) * f64::from(self.radius) * PI) as u32;\n if N == 3 {\n volume = (f64::from(self.radius)\n * f64::from(self.radius)\n * f64::from(self.radius)\n * PI\n * 4.0_f64\n / 3.0_f64) as u32;\n }\n Self::Volume::new(volume)\n }\n}\n\nInstead of checking N == 3, you can provide different impls for SphereN<2> and\nSphereN<3> (as they are different types).\nu32 and u64\nThey are different types, but because you can easily cast one to another,\nit was not sufficient to make the implementation type-safe.\n","id":"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/","title":"Feedback #2"},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"body":"Parallelism vs Concurrency\nConcurrency is when tasks can make progress independently of each other.\nParallelism is when multiple tasks make progress at the same time.\nConcurrency models in Rust\nThreads\nNothing unusual here.\nThreads can be created with the thread::spawn function docs - please read them!.\nThis method returns a JoinHandle<T> which can be used to wait for the thread to finish. T is the type of the thread's return value.\nAnother way to spawn threads is using scope. Threads created in such way are mandatorily joined at the end of the scope, which guarantees that they will borrow items for no longer that the lifetime of the scope. Hence, they can borrow non-'static items!\nPropagating panics\nIn Rust a panic of one thread doesn't affect the other threads (similar to how Java handles exceptions in threads).\nClosures\nClosures which are used to create threads must take ownership of any values they use. It can be forced with the move keyword.\nuse std::thread;\n\nfn main() {\n let v = vec![1, 2, 3];\n\n let handle = thread::spawn(move || {\n println!(\"Here's a vector: {:?}\", v);\n });\n\n handle.join().unwrap();\n}\n\nNormal ownership rules still apply. It means that we cannot mutate the vector in the spawned thread from the main thread!\nBut what if we need to share some state?\nSend and Sync\nThey are marker traits used to indicate that a type or a reference to it can be used across threads. See the nomicon for more information.\n\n\nA type is Send if it is safe to move it (send it) to another thread.\nA type is Sync if it is safe to share (sync) between threads (T is Sync if and only if &T is Send).\n\n\nThis makes sense, because Sync is about sharing object between threads, and & is the shared reference.\nThere is also a great answer on Rust forum, listing + explaining example types that are !Send or !Sync.\nFor more convenient analysis, examples are listed here:\nSend + !Sync:\n\nUnsafeCell (=> Cell, RefCell);\n\n!Send + !Sync:\n\nRc\n*const T, *mut T (raw pointers)\n\n!Send + Sync:\n\nMutexGuard (hint: !Send for POSIX reasons)\n\nExercise for the reader: explain reasons for all limitations of the above types.\nSharing state between threads\nMessage passing\nOne possible way is to use message passing. We can use a blocking queue (called mpsc - \"multi producer single consumer FIFO queue\") to do it.\nWe talked about blocking queues in the Concurrent programming class. In Rust, they are strongly-typed. Sending and receiving ends have different types.\nMutexes\nIn Rust, a mutex wraps a value and makes it thread-safe.\nBecause it becomes a part of the type, it's impossible to access the underlying value in an unsynchronized manner. It is conceptually similar to the RefCell type.\nArc is a smart pointer like Rc but it can be shared between threads.\nPlease read more about them in the book.\nThe docs also mention poisoning.\nRwLocks\nRwLocks are similar to mutexes, but they distinguish between read and write locks.\nAtomic types\nAtomic types are described in the docs.\nuse std::sync::Arc;\nuse std::sync::atomic::{AtomicUsize, Ordering};\nuse std::{hint, thread};\n\nfn main() {\n let spinlock = Arc::new(AtomicUsize::new(1));\n\n let spinlock_clone = Arc::clone(&spinlock);\n let thread = thread::spawn(move|| {\n spinlock_clone.store(0, Ordering::SeqCst);\n });\n\n // Wait for the other thread to release the lock\n while spinlock.load(Ordering::SeqCst) != 0 {\n hint::spin_loop();\n }\n\n if let Err(panic) = thread.join() {\n println!(\"Thread had an error: {:?}\", panic);\n }\n}\n\nNote that atomic values don't have to be wrapped in a mutex when shared across threads.\nWait...\nIf most types are Sync + Send, then what stops us from using a standard, non-atomic integer in the example above?\nlet spinlock = Arc::new(1);\n\nlet spinlock_clone = Arc::clone(&spinlock);\nlet thread = thread::spawn(move|| {\n *spinlock_clone += 1;\n});\n\nwhile *spinlock != 0 {\n hint::spin_loop();\n}\n\nerror[E0594]: cannot assign to data in an `Arc`\n --> src/main.rs:9:9\n |\n9 | *spinlock_clone += 1;\n | ^^^^^^^^^^^^^^^^^^^^ cannot assign\n |\n = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `Arc<i32>`\n\n...so we would have to use a RefCell to be able to modify the value through a shared reference...\nlet spinlock = Arc::new(RefCell::new(1));\n\nlet spinlock_clone = Arc::clone(&spinlock);\nlet thread = thread::spawn(move|| {\n *spinlock_clone.borrow_mut() += 1;\n});\n\n// Wait for the other thread to release the lock\nwhile *spinlock.borrow() != 0 {\n hint::spin_loop();\n}\n\n...but RefCell isn't Sync:\nerror[E0277]: `RefCell<i32>` cannot be shared between threads safely\n --> src/main.rs:9:18\n |\n9 | let thread = thread::spawn(move|| {\n | ^^^^^^^^^^^^^ `RefCell<i32>` cannot be shared between threads safely\n |\n = help: the trait `Sync` is not implemented for `RefCell<i32>`\n = note: required because of the requirements on the impl of `Send` for `Arc<RefCell<i32>>`\n = note: required because it appears within the type `[closure@src/main.rs:9:32: 11:6]`\nnote: required by a bound in `spawn`\n\nAnd that bound mentioned in the last line looks like this:\npub fn spawn<F, T>(f: F) -> JoinHandle<T> where\n F: FnOnce() -> T,\n F: Send + 'static,\n T: Send + 'static,\n\nExercise for the reader\nWhy is it impossible to share a reference to a Mutex between threads spawned with std::thread::spawn?\nData parallelism with Rayon\nRayon is a library for parallelization of data processing.\nIt can be used to parallelize the execution of functions over a collection of data by switching the standard Iterator to a ParallelIterator.\nIt works very similar to Java's parallel streams.\nWhy do that? Because thread synchronization is hard! Rust prevents data races, but logical races and deadlocks are impossible to prevent!!\nRayon's FAQ is worth reading.\nReading\n\nThe Book\nSafely writing code that isn't thread-safe\n\nNo assignment this week\nPlease work on the first iteration of the big project instead.\n","id":"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/","title":"Fearless concurrency"},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"body":"Object-oriented programming and Rust\nThe book has a chapter dedicated to it.\nEspecially the \"typestate\" pattern is very interesting.\nYou can read more about it here.\nHow to build a good library\nThese guidelines have been created by the Rust library team.\nHow to handle errors\nThis post is from 2020, but the libraries it mentions (anyhow and thiserror) are still the most popular.\nSerde\nSerde is the most popular serialization library for Rust.\nAssignment\nThis week's assignment is to write a \"distributed\" calculator.\nYou should base your solution on the final project from the book.\n","id":"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/","title":"Design patterns"},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"body":"Tokio\nWe'll use the Tokio tutorial (chapters Overview-Channels).\nCommon Rust Lifetime Misconceptions\nPlease read this blogpost.\nAssignment 6 (graded)\nCalculator\nDeadline: 04.12.2024 23:59\n","id":"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/","title":"Async: Part 1"},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"body":"Project feedback\nUnwrapping options/results\nAlways ask yourself twice if you really need to unwrap. In most cases, you don't have to. Use pattern matching instead,\nas it provides a static guarantee that the value is present.\nPattern matching prevents you from writing code like this:\nfn main() {\n let x: Option<i32> = some_function();\n\n if x.is_some() {\n println!(\"x is {}\", x.unwrap());\n }\n\n // Let's say this line was added later and/or you forgot to put it in the if statement.\n do_something(x.unwrap()); // this will blow up if x == None!\n}\n\nInstead, you can write:\nfn main() {\n let x: Option<i32> = some_function();\n\n if let Some(x) = x {\n println!(\"x is {}\", x);\n do_something(x);\n }\n}\n\nQuestion mark operator\nIn methods that return Result or Option, you can use the question mark operator to return early if the value is None or Err.\nSee: https://doc.rust-lang.org/rust-by-example/std/result/question_mark.html\nLogging\nYou can use the log crate to log messages. It's better than println! because it\ncan be easily turned off. It also allows you to use different severity levels (e.g. info, warn, error) and only\nlog messages above a certain level.\n&String vs &str\nSee https://doc.rust-lang.org/book/ch04-03-slices.html#string-slices-as-parameters\nIn general, if you want to pass a reference to a string, use &str instead of &String.\nUse current versions of dependencies\nYou can use cargo upgrades to check for outdated dependencies.\nIf your project has separate binaries, use multiple binaries or a workspace\nYou can have multiple binaries in a single cargo project. Simply place them in the src/bin directory.\nYou can run them with cargo run --bin <name>. Alternatively, you can setup a\nworkspace.\nRun clippy & cargo fmt\nThis should have become a habit by now. You can disable clippy warnings for a single item with #[allow(clippy::...)],\nbut in most cases you shouldn't do that.\nIf you need to escape characters in a string, use raw strings\nSee https://doc.rust-lang.org/reference/tokens.html#raw-string-literals\nHow to handle errors?\nShort: https://kerkour.com/rust-error-handling\nLong: https://www.lpalmieri.com/posts/error-handling-rust/\nDon't pass around locked mutex's contents\nIf you have a mutex, you can use lock() to get a guard that will unlock the mutex when it goes out of scope.\nBut don't pass the contents of the guard to functions that can block (unless the mutex must be locked for\nthe entire duration of the function).\nInstead of:\nuse std::sync::Mutex;\nuse std::thread;\nuse std::time::Duration;\nuse std::time::Instant;\n\nfn handle_function(counter: &mut i32) {\n thread::sleep(Duration::from_secs(1));\n *counter += 1;\n thread::sleep(Duration::from_secs(1));\n}\n\nfn main() {\n let counter = Mutex::new(1);\n\n thread::scope(|s| {\n for i in 0..10 {\n let counter = &counter;\n s.spawn(move || {\n println!(\"Thread {i} started\");\n let now = Instant::now();\n let mut counter = counter.lock().unwrap();\n handle_function(&mut counter); // lock is held for 2 seconds\n println!(\"Thread {i} finished after {}s\", now.elapsed().as_secs());\n });\n }\n })\n}\n\nYou should do this:\nuse std::sync::Mutex;\nuse std::thread;\nuse std::time::Duration;\nuse std::time::Instant;\n\nfn handle_function(counter: &Mutex<i32>) { // <-- changed\n thread::sleep(Duration::from_secs(1));\n {\n let mut counter = counter.lock().unwrap(); // <-- changed\n *counter += 1;\n // lock is held only for the duration of the block\n // it is important to create a new scope here, otherwise the lock would be held for another second\n }\n thread::sleep(Duration::from_secs(1));\n}\n\nfn main() {\n let counter = Mutex::new(1);\n\n thread::scope(|s| {\n for i in 0..10 {\n let counter = &counter;\n s.spawn(move || {\n println!(\"Thread {i} started\");\n let now = Instant::now();\n handle_function(counter); // <-- changed! we don't lock here\n println!(\"Thread {i} finished after {}s\", now.elapsed().as_secs());\n });\n }\n })\n}\n\n\nCompare the output of the two programs. The first one will take 20 seconds to finish, while the second one will take 2 seconds.\nFirst one:\nThread 1 started\nThread 0 started\nThread 2 started\nThread 3 started\nThread 4 started\nThread 5 started\nThread 6 started\nThread 7 started\nThread 8 started\nThread 9 started\nThread 1 finished after 2s\nThread 0 finished after 4s\nThread 2 finished after 6s\nThread 3 finished after 8s\nThread 4 finished after 10s\nThread 5 finished after 12s\nThread 6 finished after 14s\nThread 7 finished after 16s\nThread 8 finished after 18s\nThread 9 finished after 20s\n\n\nSecond one:\nThread 0 started\nThread 2 started\nThread 1 started\nThread 3 started\nThread 4 started\nThread 5 started\nThread 6 started\nThread 7 started\nThread 8 started\nThread 9 started\nThread 1 finished after 2s\nThread 2 finished after 2s\nThread 0 finished after 2s\nThread 3 finished after 2s\nThread 4 finished after 2s\nThread 5 finished after 2s\nThread 6 finished after 2s\nThread 7 finished after 2s\nThread 8 finished after 2s\nThread 9 finished after 2s\n\n","id":"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/","title":"Project feedback"},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"body":"Reinventing futures\nWe recently got our feet wet with the async/await functionality of Rust by using the Tokio library. With this basic understanding of what we expect out of futures, let's try to come up with their details ourselves.\nWe know that, when asked, a future can either give us a ready value or still be waiting for it. Asking about the future's result is called polling. Our future could look something like this:\ntrait SimpleFuture {\n type Output;\n fn poll(&mut self) -> Poll<Self::Output>;\n}\n\nenum Poll<T> {\n Ready(T),\n Pending,\n}\n\nThe poll method can be called to check for the result of the future. There is a flaw in this however - whatever is coordinating our future-based computations will have to constantly poll each of them in hope they are ready to do some work.\ntrait SimpleFuture {\n type Output;\n fn poll(&mut self, wake: fn()) -> Poll<Self::Output>;\n}\n\n\nWe can solve this by attaching a callback to our polling. The wake function passed to poll can be used to notify whoever issued the poll that the future is ready to make some progress and should be polled.\nLet's picture a quick example of how our SimpleFuture could be used.\npub struct SocketRead<'a> {\n socket: &'a Socket,\n}\n\nimpl SimpleFuture for SocketRead<'_> {\n type Output = Vec<u8>;\n\n fn poll(&mut self, wake: fn()) -> Poll<Self::Output> {\n if self.socket.has_data_to_read() {\n // The socket has data -- read it into a buffer and return it.\n Poll::Ready(self.socket.read_buf())\n } else {\n // The socket does not yet have data.\n //\n // Arrange for `wake` to be called once data is available.\n // When data becomes available, `wake` will be called, and the\n // user of this `Future` will know to call `poll` again and\n // receive data.\n self.socket.set_readable_callback(wake);\n Poll::Pending\n }\n }\n}\n\nCombining futures\nWith the SimpleFuture at our disposal we can easily model more advanced concurrent computations.\n/// Concurrency is achieved via the fact that calls to `poll` each future\n/// may be interleaved, allowing each future to advance itself at its own pace.\npub struct Join<FutureA, FutureB> {\n // Each field may contain a future that should be run to completion.\n // If the future has already completed, the field is set to `None`.\n // This prevents us from polling a future after it has completed, which\n // would violate the contract of the `Future` trait.\n a: Option<FutureA>,\n b: Option<FutureB>,\n}\n\nimpl<FutureA, FutureB> SimpleFuture for Join<FutureA, FutureB>\nwhere\n FutureA: SimpleFuture<Output = ()>,\n FutureB: SimpleFuture<Output = ()>,\n{\n type Output = ();\n fn poll(&mut self, wake: fn()) -> Poll<Self::Output> {\n // Attempt to complete future `a`.\n if let Some(a) = &mut self.a {\n if let Poll::Ready(()) = a.poll(wake) {\n self.a.take();\n }\n }\n\n // Attempt to complete future `b`.\n if let Some(b) = &mut self.b {\n if let Poll::Ready(()) = b.poll(wake) {\n self.b.take();\n }\n }\n\n if self.a.is_none() && self.b.is_none() {\n // Both futures have completed -- we can return successfully\n Poll::Ready(())\n } else {\n // One or both futures returned `Poll::Pending` and still have\n // work to do. They will call `wake()` when progress can be made.\n Poll::Pending\n }\n }\n}\n\nWe can also queue futures like this:\npub struct AndThenFut<FutureA, FutureB> {\n first: Option<FutureA>,\n second: FutureB,\n}\n\nimpl<FutureA, FutureB> SimpleFuture for AndThenFut<FutureA, FutureB>\nwhere\n FutureA: SimpleFuture<Output = ()>,\n FutureB: SimpleFuture<Output = ()>,\n{\n type Output = ();\n fn poll(&mut self, wake: fn()) -> Poll<Self::Output> {\n if let Some(first) = &mut self.first {\n match first.poll(wake) {\n // We've completed the first future -- remove it and start on\n // the second!\n Poll::Ready(()) => self.first.take(),\n // We couldn't yet complete the first future.\n Poll::Pending => return Poll::Pending,\n };\n }\n // Now that the first future is done, attempt to complete the second.\n self.second.poll(wake)\n }\n}\n\nExercise\nThe last example assumes that both futures are already constructed. In practice, however, we often want to chain futures that use the results of their predecessors, like this - get_breakfast().and_then(|food| eat(food));. Try implementing this behavior by adding a new method to the SimpleFuture trait called and_then and something that models this sequential computation (like the previous AndThenFut future).\nThe real deal\nWe weren't far from the actual way Rust's futures are structured. The Future trait looks as follows:\ntrait Future {\n type Output;\n fn poll(\n // Note the change from `&mut self` to `Pin<&mut Self>`:\n self: Pin<&mut Self>,\n // and the change from `wake: fn()` to `cx: &mut Context<'_>`:\n cx: &mut Context<'_>,\n ) -> Poll<Self::Output>;\n}\n\nThere are two differences here. Firstly, we use a context instead of a standalone wake method. Since this callback was just a simple function pointer, there was no way for it to hold any data pertaining to which future called it.\nSecondly, we take self as a Pin<>. This enables us to create immovable futures - we will go into it later.\nCoordinating futures - waker & executor\nUsing wakers and context\nWe will follow the steps in the book to make a future that runs a separate thread that sleeps for a given duration and only then returns a result.\nExecutor\nWe will follow the steps in the book to create our own executor to run our futures on.\nObligatory reading\n\nPinning in detail\nPinning in even more detail\nAsync in depth\n\nAdditional reading\n\nWhat color is your function\nPin and suffering\nUnderstanding Rust futures by going way too deep\nDesugaring and assembly of Rust async/await\n\nAssignment 7 (graded)\nCalculator\nDeadline: 18.12.2024 23:59\n","id":"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/","title":"Async: Part 2"},"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"body":"Reading\n\n\nThe Book, Chapter 19.5\n\n\nLittle Book of Macros\n\n\nMacro Workshop\n\n\n","id":"https://mimuw-jnp2-rust.github.io/lessons/14-macros/","title":"Macros"},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"body":"(Some) projects from the previous semester\nChat App\nGitHub\nBartłomiej Sadlej (GitHub: @barteksad email: sadlejbartek@gmail.com)\n\"Chat app written in Rust with Postgress db. Allows users to create new accounts and channels and communicate within channel. All unseed messages from last login are delivered once logged in again.\nBy default server stats with one user named ADMIN with password ADMIN\"\ntokio, serde, anyhow, thiserror, dashmap\nAlgorithm Visualizer\nGitHub\nMikołaj Piróg (mikolajpirog@gmail.com, GitHub: @aetn23), Mikołaj Wasiak (wasiak.mikolaj1@gmail.com, GitHub: @RudyMis)\nGraph editor with algorithms visualization. Create and modify the graph using GUI, move it around using WSAD. To see an algorithm being run, simply click on a node, and select the desired algorithm. See video and/or GitHub page for further details.\nPetgraph, egui-tetra, dyn_partial_eq\n\n\nRustal Combat\nGitHub\nKamil Bugała (GiHub: @Emilo77)\nSimple game in the style of Mortal Combat. Two players fight each other by using dashes. It is the 1 v 1 version, so far it is possible to play on a one computer.\nBevy\nRusty dungeon\nGitHub\nBarbara Rosiak (GitHub: @barosiak, email basiarosiak.7@gmail.com), Tomasz Kubica (GitHub: @Tomasz-Kubica, email: tomaszkubica4@gmail.com), Dawid Mędrek (GitHub: @dawidmd)\nA 2D game written using Rust and Bevy Game Engine, in which the player has to shoot and defeat enemies on their way to the final boss, inspired by the Binding of Isaac.\nBevy\n\nMarioMIM\nGitHub\nKatarzyna Kloc (GitHub: @KatKlo, email: kk429317@students.mimuw.edu.pl, linkedin: https://www.linkedin.com/in/katarzyna-kloc-7a7503209/),\nPatryk Bundyra (GitHub: PBundyra, email: pb429159@students.mimuw.edu.pl, linkedin: https://www.linkedin.com/in/pbundyra/)\nSince the moment CLion has shown us the first segfaults, we wanted to create a computer game inspired by the student’s adventure of pursuing a Computer Science degree. MarioMIM is a platform game whose main goal is to... get a degree. We’ve implemented a game inspired by Super Mario Bros, but in the special University of Warsaw edition. In order to overcome bugs, the student can strengthen himself by drinking coffee or learning the best programming language in the world - Rust.\nBevy, Rapier, Kira\n\n\nSendino\nGitHub\nGrzegorz Nowakowski (Github: @grzenow4, email: g.nowakowski@student.uw.edu.pl) with @izmael7 on Github\nOne room chat application with client-server model of communication. Many users can communicate at one time.\nTokio, serde, crossterm\nChatter\nGitHub\nKacper Kramarz-Fernandez (GitHub: @kfernandez31, email: kacper.fernandez@gmail.com),\nJan Zembowicz (GitHub: @JWZ1996, email: janzembowicz@gmail.com)\nChatter is a simple multi-room command-line chat application that uses a two-protocol (HTTP + WS) communication style for high-efficiency.\nTokio, Warp, Serde, Hyper, among others\n","id":"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/","title":"2021L Project showcase"}},"docInfo":{"https://mimuw-jnp2-rust.github.io/":{"body":37,"title":3},"https://mimuw-jnp2-rust.github.io/lessons/":{"body":0,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/00-organizational/":{"body":128,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/01-introduction/":{"body":866,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/02-ownership/":{"body":1511,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/03-data-types/":{"body":1424,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/04-feedback-1/":{"body":182,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/05-types-reasoning/":{"body":2292,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/06-closures-iterators/":{"body":840,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/07-smart-pointers/":{"body":523,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/08-feedback-2/":{"body":57,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/09-concurrency/":{"body":530,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/10-design-patterns/":{"body":50,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/11-async-1/":{"body":22,"title":3},"https://mimuw-jnp2-rust.github.io/lessons/12-project-feedback/":{"body":484,"title":2},"https://mimuw-jnp2-rust.github.io/lessons/13-async-2/":{"body":491,"title":3},"https://mimuw-jnp2-rust.github.io/lessons/14-macros/":{"body":9,"title":1},"https://mimuw-jnp2-rust.github.io/lessons/project-showcase/":{"body":297,"title":3}},"length":18},"lang":"English"};
\ No newline at end of file
diff --git a/sitemap.xml b/sitemap.xml
new file mode 100644
index 0000000..5bf2e47
--- /dev/null
+++ b/sitemap.xml
@@ -0,0 +1,209 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 2021L Project showcase
++ 2022-10-17 (last edit: 2022-10-17) +
+(Some) projects from the previous semester
+Chat App
+ +Bartłomiej Sadlej (GitHub: @barteksad email: sadlejbartek@gmail.com)
+"Chat app written in Rust with Postgress db. Allows users to create new accounts and channels and communicate within channel. All unseed messages from last login are delivered once logged in again.
+By default server stats with one user named ADMIN with password ADMIN"
+tokio, serde, anyhow, thiserror, dashmap
+Algorithm Visualizer
+ +Mikołaj Piróg (mikolajpirog@gmail.com, GitHub: @aetn23), Mikołaj Wasiak (wasiak.mikolaj1@gmail.com, GitHub: @RudyMis)
+Graph editor with algorithms visualization. Create and modify the graph using GUI, move it around using WSAD. To see an algorithm being run, simply click on a node, and select the desired algorithm. See video and/or GitHub page for further details.
+Petgraph, egui-tetra, dyn_partial_eq
+ +Rustal Combat
+ +Kamil Bugała (GiHub: @Emilo77)
+Simple game in the style of Mortal Combat. Two players fight each other by using dashes. It is the 1 v 1 version, so far it is possible to play on a one computer.
+Bevy
+Rusty dungeon
+ +Barbara Rosiak (GitHub: @barosiak, email basiarosiak.7@gmail.com), Tomasz Kubica (GitHub: @Tomasz-Kubica, email: tomaszkubica4@gmail.com), Dawid Mędrek (GitHub: @dawidmd)
+A 2D game written using Rust and Bevy Game Engine, in which the player has to shoot and defeat enemies on their way to the final boss, inspired by the Binding of Isaac.
+Bevy
+
MarioMIM
+ +Katarzyna Kloc (GitHub: @KatKlo, email: kk429317@students.mimuw.edu.pl, linkedin: https://www.linkedin.com/in/katarzyna-kloc-7a7503209/), +Patryk Bundyra (GitHub: PBundyra, email: pb429159@students.mimuw.edu.pl, linkedin: https://www.linkedin.com/in/pbundyra/)
+Since the moment CLion has shown us the first segfaults, we wanted to create a computer game inspired by the student’s adventure of pursuing a Computer Science degree. MarioMIM is a platform game whose main goal is to... get a degree. We’ve implemented a game inspired by Super Mario Bros, but in the special University of Warsaw edition. In order to overcome bugs, the student can strengthen himself by drinking coffee or learning the best programming language in the world - Rust.
+Bevy, Rapier, Kira
+
+
Sendino
+ +Grzegorz Nowakowski (Github: @grzenow4, email: g.nowakowski@student.uw.edu.pl) with @izmael7 on Github
+One room chat application with client-server model of communication. Many users can communicate at one time.
+Tokio, serde, crossterm
+Chatter
+ +Kacper Kramarz-Fernandez (GitHub: @kfernandez31, email: kacper.fernandez@gmail.com), +Jan Zembowicz (GitHub: @JWZ1996, email: janzembowicz@gmail.com)
+Chatter is a simple multi-room command-line chat application that uses a two-protocol (HTTP + WS) communication style for high-efficiency.
+Tokio, Warp, Serde, Hyper, among others
+ + +
+
+
+
+
+
+