diff --git a/ro-RO/assets/CNAME b/ro-RO/assets/CNAME
new file mode 100644
index 000000000..c6cd02a9d
--- /dev/null
+++ b/ro-RO/assets/CNAME
@@ -0,0 +1 @@
+practice.rs
\ No newline at end of file
diff --git a/ro-RO/assets/custom3.js b/ro-RO/assets/custom3.js
new file mode 100644
index 000000000..3f70daa4e
--- /dev/null
+++ b/ro-RO/assets/custom3.js
@@ -0,0 +1,156 @@
+var initAll = function () {
+ var path = window.location.pathname;
+ if (path.endsWith("/print.html")) {
+ return;
+ }
+
+ var images = document.querySelectorAll("main img")
+ Array.prototype.forEach.call(images, function (img) {
+ img.addEventListener("click", function () {
+ BigPicture({
+ el: img,
+ });
+ });
+ });
+
+ // Un-active everything when you click it
+ Array.prototype.forEach.call(document.getElementsByClassName("pagetoc")[0].children, function (el) {
+ el.addEventHandler("click", function () {
+ Array.prototype.forEach.call(document.getElementsByClassName("pagetoc")[0].children, function (el) {
+ el.classList.remove("active");
+ });
+ el.classList.add("active");
+ });
+ });
+
+ var updateFunction = function () {
+ var id = null;
+ var elements = document.getElementsByClassName("header");
+ Array.prototype.forEach.call(elements, function (el) {
+ if (window.pageYOffset >= el.offsetTop) {
+ id = el;
+ }
+ });
+
+ Array.prototype.forEach.call(document.getElementsByClassName("pagetoc")[0].children, function (el) {
+ el.classList.remove("active");
+ });
+
+ Array.prototype.forEach.call(document.getElementsByClassName("pagetoc")[0].children, function (el) {
+ if (id == null) {
+ return;
+ }
+ if (id.href.localeCompare(el.href) == 0) {
+ el.classList.add("active");
+ }
+ });
+ };
+
+ var pagetoc = document.getElementsByClassName("pagetoc")[0];
+ var elements = document.getElementsByClassName("header");
+ Array.prototype.forEach.call(elements, function (el) {
+ var link = document.createElement("a");
+
+ // Indent shows hierarchy
+ var indent = "";
+ switch (el.parentElement.tagName) {
+ case "H1":
+ return;
+ case "H3":
+ indent = "20px";
+ break;
+ case "H4":
+ indent = "40px";
+ break;
+ default:
+ break;
+ }
+
+ link.appendChild(document.createTextNode(el.text));
+ link.style.paddingLeft = indent;
+ link.href = el.href;
+ pagetoc.appendChild(link);
+ });
+ updateFunction.call();
+
+ // Handle active elements on scroll
+ window.addEventListener("scroll", updateFunction);
+
+ document.getElementById("theme-list").addEventListener("click", function (e) {
+ var iframe = document.querySelector('.giscus-frame');
+ if (!iframe) return;
+ var theme;
+ if (e.target.className === "theme") {
+ theme = e.target.id;
+ } else {
+ return;
+ }
+
+ // 若当前 mdbook 主题不是 Light 或 Rust ，则将 giscuz 主题设置为 transparent_dark
+ var giscusTheme = "light"
+ if (theme != "light" && theme != "rust") {
+ giscusTheme = "transparent_dark";
+ }
+
+ var msg = {
+ setConfig: {
+ theme: giscusTheme
+ }
+ };
+ iframe.contentWindow.postMessage({ giscus: msg }, 'https://giscus.app');
+ });
+
+ pagePath = pagePath.replace("index.md", "");
+ pagePath = pagePath.replace(".md", "");
+ if (pagePath.length > 0) {
+ if (pagePath.charAt(pagePath.length-1) == "/"){
+ pagePath = pagePath.substring(0, pagePath.length-1)
+ }
+ }else {
+ pagePath = "index"
+ }
+
+ // add visitors count
+ var ele = document.createElement("div");
+ ele.setAttribute("align","center");
+ var count = document.createElement("img")
+ // count.setAttribute("src", "https://visitor-badge.glitch.me/badge?page_id=practice/en/" + path);
+ count.setAttribute("src", "https://api.visitorbadge.io/api/visitors?labelColor=%23595959&countColor=%230d81c3&style=flat-square&path=practice/en/" + path);
+ ele.appendChild(count);
+ var divider =document.createElement("hr")
+
+ document.getElementById("giscus-container").appendChild(ele);
+ document.getElementById("giscus-container").appendChild(divider);
+
+ // 选取浏览器默认使用的语言
+ const lang = navigator.language || navigator.userLanguage
+
+ // 若当前 mdbook 主题为 Light 或 Rust ，则将 giscuz 主题设置为 light
+ var theme = "transparent_dark";
+ const themeClass = document.getElementsByTagName("html")[0].className;
+ if (themeClass.indexOf("light") != -1 || themeClass.indexOf("rust") != -1) {
+ theme = "light"
+ }
+
+ var script = document.createElement("script")
+ script.type = "text/javascript";
+ script.src = "https://giscus.app/client.js";
+ script.async = true;
+ script.crossOrigin = "anonymous";
+ script.setAttribute("data-repo", "sunface/rust-by-practice");
+ script.setAttribute("data-repo-id", "MDEwOlJlcG9zaXRvcnkxMjk5OTAzOTY=");
+ script.setAttribute("data-category", "Book Comments");
+ script.setAttribute("data-category-id", "DIC_kwDOB79-_M4COQmx");
+ script.setAttribute("data-mapping", "specific");
+ script.setAttribute("data-term", pagePath);
+ script.setAttribute("data-reactions-enabled", "1");
+ script.setAttribute("data-emit-metadata", "0");
+ script.setAttribute("data-input-position", "top");
+ script.setAttribute("data-theme", theme);
+ script.setAttribute("data-lang", lang == 'en-US' ? 'en' : lang);
+ // 预先加载评论会更好，这样用户读到那边时，评论就加载好了
+ // script.setAttribute("data-loading", "lazy");
+ document.getElementById("giscus-container").appendChild(script);
+};
+
+window.addEventListener('load', initAll);
\ No newline at end of file
diff --git a/ro-RO/assets/header.jpg b/ro-RO/assets/header.jpg
new file mode 100644
index 000000000..7a18c7a45
Binary files /dev/null and b/ro-RO/assets/header.jpg differ
diff --git a/ro-RO/assets/header1.png b/ro-RO/assets/header1.png
new file mode 100644
index 000000000..259779c32
Binary files /dev/null and b/ro-RO/assets/header1.png differ
diff --git a/ro-RO/assets/lang.js b/ro-RO/assets/lang.js
new file mode 100644
index 000000000..061d37586
--- /dev/null
+++ b/ro-RO/assets/lang.js
@@ -0,0 +1,26 @@
+(function () {
+ var path = window.location.pathname;
+ var link = "https://practice.rs" + path;
+ var word = "English";
+ var lang = "zh-CN";
+ var changeLang = "切换到英语";
+
+ if (window.location.href.indexOf("zh.") == -1) {
+ link = "https://zh.practice.rs" + path;
+ word = "简体中文";
+ lang = "en";
+ changeLang = "Switch to Chinese"
+ }
+
+ var lang_node = '';
+ if (link != '') {
+ lang_node = ' ' + word + '';
+ }
+
+ console.log(lang_node)
+ var insertNode = document.getElementsByClassName('right-buttons');
+ if (insertNode.length > 0) {
+ var html = insertNode[0].innerHTML;
+ insertNode[0].innerHTML = html + lang_node;
+ }
+ })()
\ No newline at end of file
diff --git a/ro-RO/assets/logo.png b/ro-RO/assets/logo.png
new file mode 100644
index 000000000..bb2ac3ca3
Binary files /dev/null and b/ro-RO/assets/logo.png differ
diff --git a/ro-RO/assets/temp.md b/ro-RO/assets/temp.md
new file mode 100644
index 000000000..090250fba
--- /dev/null
+++ b/ro-RO/assets/temp.md
@@ -0,0 +1,87 @@
+# 字符、布尔、单元类型
+
+### 字符
+🌟
+```rust
+
+use std::mem::size_of_val;
+fn main() {
+ let c1 = 'a';
+ assert_eq!(size_of_val(&c1),1);
+
+ let c2 = '中';
+ assert_eq!(size_of_val(&c2),3);
+}
+```
+
+🌟
+```rust
+
+fn main() {
+ let c1 = "中";
+ print_char(c1);
+}
+
+fn print_char(c : char) {
+ println!("{}", c);
+}
+```
+
+### 布尔
+🌟
+```rust
+
+// 让 println! 工作
+fn main() {
+ let _f: bool = false;
+
+ let t = true;
+ if !t {
+ println!("hello, world");
+ }
+}
+```
+
+🌟
+```rust
+
+fn main() {
+ let f = true;
+ let t = true && false;
+ assert_eq!(t, f);
+}
+```
+
+
+### 单元类型
+🌟🌟
+```rust
+
+// 让代码工作，但不要修改 `implicitly_ret_unit` !
+fn main() {
+ let _v: () = ();
+
+ let v = (2, 3);
+ assert_eq!(v, implicitly_ret_unit())
+}
+
+fn implicitly_ret_unit() {
+ println!("I will returen a ()")
+}
+
+// 不要使用下面的函数，它只用于演示！
+fn explicitly_ret_unit() -> () {
+ println!("I will returen a ()")
+}
+```
+
+🌟🌟 单元类型占用的内存大小是多少？
+```rust
+
+// 让代码工作：修改 `assert!` 中的 `4`
+use std::mem::size_of_val;
+fn main() {
+ let unit: () = ();
+ assert!(size_of_val(&unit) == 4);
+}
+```
\ No newline at end of file
diff --git a/ro-RO/book.toml b/ro-RO/book.toml
new file mode 100644
index 000000000..98fe5ccaa
--- /dev/null
+++ b/ro-RO/book.toml
@@ -0,0 +1,22 @@
+[book]
+title = "Rust prin practică"
+description = "Learn Rust with Example, Exercise and real Practice, written with ❤️ by https://course.rs team"
+authors = ["sunface, https://im.dev"]
+language = "en"
+
+[output.html.playpen]
+editable = true
+editor = "ace"
+
+[output.html.fold]
+enable = true
+level = 1
+
+[output.html]
+additional-css = ["theme/style1.css"]
+additional-js = ["assets/custom3.js","assets/lang.js"]
+git-repository-url = "https://github.com/sunface/rust-by-practice"
+edit-url-template = "https://github.com/sunface/rust-by-practice/edit/master/ro-RO/{path}"
+
+[rust]
+edition = "2021"
\ No newline at end of file
diff --git a/ro-RO/deploy.sh b/ro-RO/deploy.sh
new file mode 100644
index 000000000..880ab5cef
--- /dev/null
+++ b/ro-RO/deploy.sh
@@ -0,0 +1,23 @@
+## this script deploys the static website of course.rs to github pages
+
+## build static website for book
+mdbook build
+## copy CNAME info to book dir
+cp ./assets/CNAME ./book/
+
+## init git repo
+cd book
+git init
+git config user.name "sunface"
+git config user.email "cto@188.com"
+git add .
+git commit -m 'deploy'
+git branch -M gh-pages
+git remote add origin https://github.com/sunface/rust-by-practice
+
+## push to github pages
+git push -u -f origin gh-pages
+
+## deploy zh-CN
+cd ../../zh-CN
+./deploy
\ No newline at end of file
diff --git a/ro-RO/src/.gitignore b/ro-RO/src/.gitignore
new file mode 100644
index 000000000..e9c072897
--- /dev/null
+++ b/ro-RO/src/.gitignore
@@ -0,0 +1 @@
+book
\ No newline at end of file
diff --git a/ro-RO/src/SUMMARY.md b/ro-RO/src/SUMMARY.md
new file mode 100644
index 000000000..14bf0d894
--- /dev/null
+++ b/ro-RO/src/SUMMARY.md
@@ -0,0 +1,94 @@
+# Summary
+
+- [Rust By Practice](why-exercise.md)
+- [Small projects with Elegant code](elegant-code-base.md)
+- [Variables](variables.md)
+- [Basic Types](basic-types/intro.md)
+ - [Numbers](basic-types/numbers.md)
+ - [Char, Bool and Unit](basic-types/char-bool-unit.md)
+ - [Statements and Expressions](basic-types/statements-expressions.md)
+ - [Functions](basic-types/functions.md)
+- [Ownership and Borrowing](ownership/intro.md)
+ - [Ownership](ownership/ownership.md)
+ - [Reference and Borrowing](ownership/borrowing.md)
+- [Compound Types](compound-types/intro.md)
+ - [string](compound-types/string.md)
+ - [Array](compound-types/array.md)
+ - [Slice](compound-types/slice.md)
+ - [Tuple](compound-types/tuple.md)
+ - [Struct](compound-types/struct.md)
+ - [Enum](compound-types/enum.md)
+- [Flow Control](flow-control.md)
+- [Pattern Match](pattern-match/intro.md)
+ - [match, matches! and if let](pattern-match/match-iflet.md)
+ - [Patterns](pattern-match/patterns.md)
+- [Method & Associated function](method.md)
+- [Generics and Traits](generics-traits/intro.md)
+ - [Generics](generics-traits/generics.md)
+ - [Const Generics](generics-traits/const-generics.md)
+ - [Traits](generics-traits/traits.md)
+ - [Trait Object](generics-traits/trait-object.md)
+ - [Advanced Traits](generics-traits/advanced-traits.md)
+- [Collection Types](collections/intro.md)
+ - [String](collections/string.md)
+ - [Vector](collections/vector.md)
+ - [HashMap](collections/hashmap.md)
+- [Type Conversion](type-conversions/intro.md)
+ - [as](type-conversions/as.md)
+ - [From/Into](type-conversions/from-into.md)
+ - [Others](type-conversions/others.md)
+- [Result and panic](result-panic/intro.md)
+ - [panic!](result-panic/panic.md)
+ - [Result and ?](result-panic/result.md)
+- [Crate and Module](crate-module/intro.md)
+ - [Package and Crate](crate-module/crate.md)
+ - [Module](crate-module/module.md)
+ - [Advanced use and pub](crate-module/use-pub.md)
+- [Comments and Docs](comments-docs.md)
+- [Formatted output](formatted-output/intro.md)
+ - [println! and format!](formatted-output/println.md)
+ - [Debug and Display](formatted-output/debug-display.md)
+ - [formating](formatted-output/formatting.md)
+- [Lifetime](lifetime/intro.md)
+ - [basic](lifetime/basic.md)
+ - [&'static and T: 'static](lifetime/static.md)
+ - [advanced](lifetime/advance.md)
+- [Functional programing](functional-programing/intro.md)
+ - [Closure](functional-programing/closure.md)
+ - [Iterator](functional-programing/iterator.md)
+- [newtype and DST](newtype-sized.md)
+- [Smart pointers TODO](smart-pointers/intro.md)
+ - [Box](smart-pointers/box.md)
+ - [Deref](smart-pointers/deref.md)
+ - [Drop](smart-pointers/drop.md)
+ - [Rc and Arc](smart-pointers/rc-arc.md)
+ - [Cell and RefCell](smart-pointers/cell-refcell.md)
+- [Weak and Circle reference TODO](weak.md)
+- [Self referential TODO](self-referential.md)
+- [Threads TODO](threads/intro.md)
+ - [Basic using](threads/basic-using.md)
+ - [Message passing](threads/message-passing.md)
+ - [Sync](threads/sync.md)
+ - [Atomic](threads/atomic.md)
+ - [Send and Sync](threads/send-sync.md)
+- [Global variables TODO](global-variables.md)
+- [Errors TODO](errors.md)
+- [Unsafe doing](unsafe/intro.md)
+ - [Inline assembly](unsafe/inline-asm.md)
+- [Macro TODO](macro.md)
+- [Tests TODO](tests/intro.md)
+ - [Write Tests](tests/write-tests.md)
+ - [Benchmark](tests/benchmark.md)
+ - [Unit and Integration](tests/unit-integration.md)
+ - [Assertions](tests/assertions.md)
+- [Async/Await TODO](async/intro.md)
+ - [async and await!](async/async-await.md)
+ - [Future](async/future.md)
+ - [Pin and Unpin](async/pin-unpin.md)
+ - [Stream](async/stream.md)
+
+- [Standard Library TODO](std/intro.md)
+ - [String](std/String.md)
+
+- [Fighting with Compiler](fight-compiler/intro.md)
+ - [Borrowing](fight-compiler/borrowing.md)
\ No newline at end of file
diff --git a/ro-RO/src/about.md b/ro-RO/src/about.md
new file mode 100644
index 000000000..65054b7d8
--- /dev/null
+++ b/ro-RO/src/about.md
@@ -0,0 +1 @@
+# Rust By Practice
diff --git a/ro-RO/src/async/async-await.md b/ro-RO/src/async/async-await.md
new file mode 100644
index 000000000..a20c0b854
--- /dev/null
+++ b/ro-RO/src/async/async-await.md
@@ -0,0 +1 @@
+# async and await!
diff --git a/ro-RO/src/async/future.md b/ro-RO/src/async/future.md
new file mode 100644
index 000000000..5f24b0e0a
--- /dev/null
+++ b/ro-RO/src/async/future.md
@@ -0,0 +1 @@
+# Future
diff --git a/ro-RO/src/async/intro.md b/ro-RO/src/async/intro.md
new file mode 100644
index 000000000..70bdb9f49
--- /dev/null
+++ b/ro-RO/src/async/intro.md
@@ -0,0 +1 @@
+# Async/Await
diff --git a/ro-RO/src/async/pin-unpin.md b/ro-RO/src/async/pin-unpin.md
new file mode 100644
index 000000000..8655bd18d
--- /dev/null
+++ b/ro-RO/src/async/pin-unpin.md
@@ -0,0 +1 @@
+# Pin and Unpin
diff --git a/ro-RO/src/async/stream.md b/ro-RO/src/async/stream.md
new file mode 100644
index 000000000..867bd88c3
--- /dev/null
+++ b/ro-RO/src/async/stream.md
@@ -0,0 +1 @@
+# Stream
diff --git a/ro-RO/src/basic-types/char-bool-unit.md b/ro-RO/src/basic-types/char-bool-unit.md
new file mode 100644
index 000000000..1192fb7b7
--- /dev/null
+++ b/ro-RO/src/basic-types/char-bool-unit.md
@@ -0,0 +1,100 @@
+# Char, Bool and Unit
+
+### Char
+1. 🌟
+```rust,editable
+
+// Faceți să funcționeze
+use std::mem::size_of_val;
+fn main() {
+ let c1 = 'a';
+ assert_eq!(size_of_val(&c1),1);
+
+ let c2 = '中';
+ assert_eq!(size_of_val(&c2),3);
+
+ println!("Success!");
+}
+```
+
+2. 🌟
+```rust,editable
+
+// Faceți să funcționeze
+fn main() {
+ let c1 = "中";
+ print_char(c1);
+}
+
+fn print_char(c : char) {
+ println!("{}", c);
+}
+```
+
+### Bool
+3. 🌟
+```rust,editable
+
+// Faceți println! să funcționeze
+fn main() {
+ let _f: bool = false;
+
+ let t = true;
+ if !t {
+ println!("Success!");
+ }
+}
+```
+
+4. 🌟
+```rust,editable
+
+// Faceți să funcționeze
+fn main() {
+ let f = true;
+ let t = true && false;
+ assert_eq!(t, f);
+
+ println!("Success!");
+}
+```
+
+
+### Unit type
+5. 🌟🌟
+```rust,editable
+
+// Faceți să funcționeze fără a modifica `implicitly_ret_unit` !
+fn main() {
+ let _v: () = ();
+
+ let v = (2, 3);
+ assert_eq!(v, implicitly_ret_unit());
+
+ println!("Success!");
+}
+
+fn implicitly_ret_unit() {
+ println!("I will return a ()");
+}
+
+// Nu folosiți asta
+fn explicitly_ret_unit() -> () {
+ println!("I will return a ()");
+}
+```
+
+6. 🌟🌟 What's the size of the unit type?
+```rust,editable
+
+// Modificați `4` in 'assert' pentru a face să funcționeze
+use std::mem::size_of_val;
+fn main() {
+ let unit: () = ();
+ assert!(size_of_val(&unit) == 4);
+
+ println!("Success!");
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice)(sub calea soluțiilor), dar utilizați-le doar atunci când aveți nevoie.
diff --git a/ro-RO/src/basic-types/functions.md b/ro-RO/src/basic-types/functions.md
new file mode 100644
index 000000000..5b7aa8174
--- /dev/null
+++ b/ro-RO/src/basic-types/functions.md
@@ -0,0 +1,101 @@
+# Functions
+1. 🌟🌟🌟
+```rust,editable
+
+fn main() {
+ // Nu modificați următoarele două linii!
+ let (x, y) = (1, 2);
+ let s = sum(x, y);
+
+ assert_eq!(s, 3);
+
+ println!("Success!");
+}
+
+fn sum(x, y: i32) {
+ x + y;
+}
+```
+
+
+2. 🌟
+```rust,editable
+fn main() {
+ print();
+}
+
+// Inlocuiți i32 cu un alt tip de date
+fn print() -> i32 {
+ println!("Success!");
+}
+```
+
+
+3. 🌟🌟🌟
+
+```rust,editable
+// Rezolvați in două moduri
+// NU lăsați `println!` să ruleze
+fn main() {
+ never_return();
+
+ println!("Failed!");
+}
+
+fn never_return() -> ! {
+ // Implementați această funcție, nu modificați semnăturile funcției
+
+}
+```
+
+### Diverging functions
+Funcțiile divergente nu se întorc niciodată la apelant, astfel că pot fi folosite în locuri unde se așteaptă o valoare de orice tip.
+
+4. 🌟🌟
+```rust,editable
+
+fn main() {
+ println!("Success!");
+}
+
+fn get_option(tp: u8) -> Option {
+ match tp {
+ 1 => {
+ // TODO
+ }
+ _ => {
+ // TODO
+ }
+ };
+
+ // În loc să returnăm un "None", folosim în schimb o funcție divergentă.
+ never_return_fn()
+}
+
+// IMPLMENTAȚI această funcție în TREI moduri
+fn never_return_fn() -> ! {
+
+}
+```
+
+5. 🌟🌟
+```rust,editable
+
+fn main() {
+ // COMPLETEAZĂ spațiul liber
+ let b = __;
+
+ let _v = match b {
+ true => 1,
+ // Funcțiile divergente pot fi, de asemenea, utilizate în expresii match pentru a înlocui o valoare de orice tip.
+ false => {
+ println!("Success!");
+ panic!("we have no value for `false`, but we can panic");
+ }
+ };
+
+ println!("Exercise Failed if printing out this line!");
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice)(sub calea soluțiilor), dar utilizați-le doar atunci când aveți nevoie.
diff --git a/ro-RO/src/basic-types/intro.md b/ro-RO/src/basic-types/intro.md
new file mode 100644
index 000000000..ec0b69e5f
--- /dev/null
+++ b/ro-RO/src/basic-types/intro.md
@@ -0,0 +1,5 @@
+# Tipuri de bază
+Resurse de învățare:
+- Engleză: [Rust Book 3.2 and 3.3](https://doc.rust-lang.org/book/ch03-02-data-types.html)
+- Chineză simplificată: [Rust语言圣经 - 基本类型](https://course.rs/basic/base-type/index.html)
+- Română: []
diff --git a/ro-RO/src/basic-types/numbers.md b/ro-RO/src/basic-types/numbers.md
new file mode 100644
index 000000000..c433f6d80
--- /dev/null
+++ b/ro-RO/src/basic-types/numbers.md
@@ -0,0 +1,187 @@
+# Numere
+
+### Numere întregi
+
+1. 🌟
+
+> Sfat: Dacă nu atribuim explicit un tip unei variabile, compilatorul îl va deduce pentru noi.
+
+```rust,editable
+
+// Eliminați ceva pentru a face să funcționeze
+fn main() {
+ let x: i32 = 5;
+ let mut y: u32 = 5;
+
+ y = x;
+
+ let z = 10; // Ce tip are z ?
+
+ println!("Success!");
+}
+```
+
+2. 🌟
+```rust,editable
+
+// Umple spațiul liber
+fn main() {
+ let v: u16 = 38_u8 as __;
+
+ println!("Success!");
+}
+```
+
+3. 🌟🌟🌟
+
+> Sfat: Dacă nu atribuim explicit un tip unei variabile, compilatorul îl va deduce pentru noi.
+
+```rust,editable
+
+// Modificați `assert_eq!` pentru a face să funcționeze
+fn main() {
+ let x = 5;
+ assert_eq!("u32".to_string(), type_of(&x));
+
+ println!("Success!");
+}
+
+// Obțineți tipul variabilei date, returnați o reprezentare sub formă de șir a tipului, de exemplu "i8", "u8", "i32", "u32".
+fn type_of(_: &T) -> String {
+ format!("{}", std::any::type_name::())
+}
+```
+
+4. 🌟🌟
+```rust,editable
+
+// Completați spațiile goale pentru a face să funcționeze
+fn main() {
+ assert_eq!(i8::MAX, __);
+ assert_eq!(u8::MAX, __);
+
+ println!("Success!");
+}
+```
+
+5. 🌟🌟
+```rust,editable
+
+// Remediați erorile și panicele pentru a face să funcționeze.
+fn main() {
+ let v1 = 251_u8 + 8;
+ let v2 = i8::checked_add(251, 8).unwrap();
+ println!("{},{}",v1,v2);
+}
+```
+
+6. 🌟🌟
+```rust,editable
+
+// Modificați `assert!` pentru a face să funcționeze
+fn main() {
+ let v = 1_024 + 0xff + 0o77 + 0b1111_1111;
+ assert!(v == 1579);
+
+ println!("Success!");
+}
+```
+
+
+### Floating-Point
+7. 🌟
+
+```rust,editable
+
+// Completați spațiul gol pentru a face să funcționeze
+
+fn main() {
+ let x = 1_000.000_1; // ?
+ let y: f32 = 0.12; // f32
+ let z = 0.01_f64; // f64
+
+ assert_eq!(type_of(&x), "__".to_string());
+ println!("Success!");
+}
+
+fn type_of(_: &T) -> String {
+ format!("{}", std::any::type_name::())
+}
+```
+
+8. 🌟🌟 Faceți să funcționeze în două moduri distincte.
+
+```rust,editable
+
+fn main() {
+ assert!(0.1+0.2==0.3);
+
+ println!("Success!");
+}
+```
+
+### Range
+9. 🌟🌟 Două obiective: 1. Modificați `assert!` pentru a face codul să funcționeze 2. Faceți `println!` să afișeze: 97 - 122
+
+```rust,editable
+fn main() {
+ let mut sum = 0;
+ for i in -3..2 {
+ sum += i
+ }
+
+ assert!(sum == -3);
+
+ for c in 'a'..='z' {
+ println!("{}",c);
+ }
+}
+```
+
+10. 🌟🌟
+```rust,editable
+
+// Umpleți spațiile goale
+use std::ops::{Range, RangeInclusive};
+fn main() {
+ assert_eq!((1..__), Range{ start: 1, end: 5 });
+ assert_eq!((1..__), RangeInclusive::new(1, 5));
+
+ println!("Success!");
+}
+```
+
+### Computations
+
+11. 🌟
+```rust,editable
+
+// Umpleți spațiile goale și rezolvați erorile
+fn main() {
+ // Adunarea numerelor întregi
+ assert!(1u32 + 2 == __);
+
+ // Scăderea numerelor întregi
+ assert!(1i32 - 2 == __);
+ assert!(1u8 - 2 == -1);
+
+ assert!(3 * 50 == __);
+
+ assert!(9.6 / 3.2 == 3.0); // asigură-te că 9.6 împărțit la 3.2 este egal cu 3.0; // eroare! fă-l să funcționeze
+
+ assert!(24 % 5 == __);
+ // Logica booleană cu scurtcircuitare
+ assert!(true && false == __);
+ assert!(true || false == __);
+ assert!(!true == __);
+
+ // Operații pe biți
+ println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101);
+ println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101);
+ println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101);
+ println!("1 << 5 is {}", 1u32 << 5);
+ println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2);
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice)(sub calea soluțiilor), dar utilizați-le doar atunci când aveți nevoie.
diff --git a/ro-RO/src/basic-types/statements-expressions.md b/ro-RO/src/basic-types/statements-expressions.md
new file mode 100644
index 000000000..afa4addb2
--- /dev/null
+++ b/ro-RO/src/basic-types/statements-expressions.md
@@ -0,0 +1,71 @@
+# Instrucțiuni și Expresii
+
+### Exemple
+```rust,editable
+fn main() {
+ let x = 5u32;
+
+ let y = {
+ let x_squared = x * x;
+ let x_cube = x_squared * x;
+
+ // Această expresie va fi asignată variabilei y
+ x_cube + x_squared + x
+ };
+
+ let z = {
+
+ // Punctul și virgulă suprimă această expresie și () este asignat variabilei z
+ 2 * x;
+ };
+
+ println!("x is {:?}", x);
+ println!("y is {:?}", y);
+ println!("z is {:?}", z);
+}
+```
+
+### Exercises
+1. 🌟🌟
+```rust,editable
+// Faceți să funcționeze în două moduri
+fn main() {
+ let v = {
+ let mut x = 1;
+ x += 2
+ };
+
+ assert_eq!(v, 3);
+
+ println!("Success!");
+}
+```
+
+2. 🌟
+```rust,editable
+
+fn main() {
+ let v = (let x = 3);
+
+ assert!(v == 3);
+
+ println!("Success!");
+}
+```
+
+3. 🌟
+```rust,editable
+
+fn main() {
+ let s = sum(1 , 2);
+ assert_eq!(s, 3);
+
+ println!("Success!");
+}
+
+fn sum(x: i32, y: i32) -> i32 {
+ x + y;
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice)(sub calea soluțiilor), dar utilizați-le doar atunci când aveți nevoie.
\ No newline at end of file
diff --git a/ro-RO/src/circle-reference/intro.md b/ro-RO/src/circle-reference/intro.md
new file mode 100644
index 000000000..4f99ca561
--- /dev/null
+++ b/ro-RO/src/circle-reference/intro.md
@@ -0,0 +1 @@
+# Circle reference and Self referential
diff --git a/ro-RO/src/collections/hashmap.md b/ro-RO/src/collections/hashmap.md
new file mode 100644
index 000000000..2eef9357a
--- /dev/null
+++ b/ro-RO/src/collections/hashmap.md
@@ -0,0 +1,225 @@
+# HashMap
+În timp ce vectorii stochează valori printr-un index întreg, HashMaps stochează valori prin intermediul unei chei. Este o hartă de tip hash implementată cu sondaj pătratic și căutare SIMD. În mod implicit, HashMap utilizează un algoritm de hash selectat pentru a oferi rezistență împotriva atacurilor HashDoS.
+
+Algoritmul implicit de hash este în prezent SipHash 1-3, cu toate că acest lucru poate suferi modificări în orice moment în viitor. În timp ce performanța sa este foarte competitivă pentru chei de dimensiuni medii, alte algoritme de hash îl vor depăși pentru chei mici, cum ar fi cele întregi, precum și pentru chei mari, cum ar fi șiruri lungi, deși aceste algoritme nu vor oferi, de obicei, protecție împotriva atacurilor precum HashDoS.
+
+Implementarea tabelului de hash este o adaptare Rust a SwissTable de la Google. Versiunea originală în C++ a SwissTable poate fi găsită aici, iar acest discurs CppCon oferă o prezentare a modului în care funcționează algoritmul.
+
+
+### Operații de bază
+1. 🌟🌟
+
+```rust,editable
+
+// UMPLEȚI spațiile goale si REZOLVAȚI erorile
+use std::collections::HashMap;
+fn main() {
+ let mut scores = HashMap::new();
+ scores.insert("Sunface", 98);
+ scores.insert("Daniel", 95);
+ scores.insert("Ashley", 69.0);
+ scores.insert("Katie", "58");
+
+ // `Get` întoarce Option<&V>
+ let score = scores.get("Sunface");
+ assert_eq!(score, Some(98));
+
+ if scores.contains_key("Daniel") {
+ // Indexarea returnează o valoare V
+ let score = scores["Daniel"];
+ assert_eq!(score, __);
+ scores.remove("Daniel");
+ }
+
+ assert_eq!(scores.len(), __);
+
+ for (name, score) in scores {
+ println!("The score of {} is {}", name, score);
+ }
+}
+```
+
+2. 🌟🌟
+```rust,editable
+
+use std::collections::HashMap;
+fn main() {
+ let teams = [
+ ("Chinese Team", 100),
+ ("American Team", 10),
+ ("France Team", 50),
+ ];
+
+ let mut teams_map1 = HashMap::new();
+ for team in &teams {
+ teams_map1.insert(team.0, team.1);
+ }
+
+ // IMPLEMENTAȚI team_map2 in două moduri
+ // Sfat: o posibilă abordare ar fi folosirea metodei `collect`
+ let teams_map2...
+
+ assert_eq!(teams_map1, teams_map2);
+
+ println!("Success!");
+}
+```
+
+3. 🌟🌟
+```rust,editable
+
+// UMPLEȚI spațiile goale
+use std::collections::HashMap;
+fn main() {
+ // Inferența de tip ne permite să omitem o semnătură explicită de tip
+ // (care ar fi HashMap<&str, u8> în acest exemplu).
+ let mut player_stats = HashMap::new();
+
+ // Introduce o cheie doar dacă aceasta nu există deja.
+ player_stats.entry("health").or_insert(100);
+
+ assert_eq!(player_stats["health"], __);
+
+ // Introduce o cheie folosind o funcție care furnizează o valoare nouă
+ // doar dacă aceasta nu există deja.
+ player_stats.entry("health").or_insert_with(random_stat_buff);
+ assert_eq!(player_stats["health"], __);
+
+ // Se asigură că o valoare este în intrare prin introducerea valorii implicite dacă este goală
+ // și returnează o referință mutabilă la valoarea din intrare.
+ let health = player_stats.entry("health").or_insert(50);
+ assert_eq!(health, __);
+ *health -= 50;
+ assert_eq!(*health, __);
+
+ println!("Success!");
+}
+
+fn random_stat_buff() -> u8 {
+ // Ar putea returna efectiv o valoare aleatoare aici
+ // să returnăm pur și simplu o valoare fixă pentru moment.
+ 42
+}
+```
+
+### Cerințe pentru cheile HashMap
+Orice tip care implementează trăsăturile Eq și Hash poate fi o cheie în HashMap. Aceasta include:
+
+- bool (deși nu foarte util deoarece există doar două chei posibile)
+- int, uint și toate variațiile acestora
+- String și &str (sugestie: poți avea o HashMap indexată cu String și apela .get() cu un &str)
+
+Observați că f32 și f64 nu implementează Hash, probabil din cauza problemelor de precizie cu numere în virgulă mobilă care ar face folosirea lor ca chei într-o hartă hash extrem de predispusă la erori.
+
+Toate clasele de colecții implementează Eq și Hash dacă tipul lor conținut implementează, de asemenea, Eq și Hash. De exemplu, Vec va implementa Hash dacă T implementează Hash.
+
+4. 🌟🌟
+```rust,editable
+
+// CORECTEAZĂ erorile
+// Sfaturi: derive este de obicei o modalitate bună de a implementa unele trăsături folosite frecvent
+use std::collections::HashMap;
+
+struct Viking {
+ name: String,
+ country: String,
+}
+
+impl Viking {
+ /// Creates a new Viking.
+ fn new(name: &str, country: &str) -> Viking {
+ Viking {
+ name: name.to_string(),
+ country: country.to_string(),
+ }
+ }
+}
+
+fn main() {
+ // Folosește o HashMap pentru a stoca punctele de viață ale vikingilor.
+ let vikings = HashMap::from([
+ (Viking::new("Einar", "Norway"), 25),
+ (Viking::new("Olaf", "Denmark"), 24),
+ (Viking::new("Harald", "Iceland"), 12),
+ ]);
+
+ // Folosește implementarea derivată pentru a afișa starea vikingilor.
+ for (viking, health) in &vikings {
+ println!("{:?} has {} hp", viking, health);
+ }
+}
+```
+
+### Capacitate
+La fel ca vectorii, HashMaps sunt extensibili, dar acestea se pot și micșora atunci când au spațiu în exces. Puteți crea un HashMap cu o anumită capacitate inițială folosind HashMap::with_capacity(uint), sau puteți utiliza HashMap::new() pentru a obține un HashMap cu o capacitate inițială implicită (recomandată).
+
+#### Exemplu
+```rust,editable
+
+use std::collections::HashMap;
+fn main() {
+ let mut map: HashMap = HashMap::with_capacity(100);
+ map.insert(1, 2);
+ map.insert(3, 4);
+ // Într-adevăr, capacitatea HashMap nu este 100, așa că nu putem compara egalitatea aici.
+ assert!(map.capacity() >= 100);
+
+ // Micșorează capacitatea hărții cu o limită inferioară.
+ // Nu va scădea mai jos decât limita furnizată, păstrând în același timp regulile interne
+ // și, posibil, lăsând spațiu conform politicii de redimensionare.
+
+ map.shrink_to(50);
+ assert!(map.capacity() >= 50);
+
+ // Micșorează capacitatea hărții cât mai mult posibil.
+ // Va scădea cât mai mult posibil, păstrând în același timp regulile interne
+ // și, posibil, lăsând spațiu conform politicii de redimensionare.
+ map.shrink_to_fit();
+ assert!(map.capacity() >= 2);
+ println!("Success!");
+}
+```
+
+### Proprietate (Ownership)
+Pentru tipuri care implementează trăsătura Copy, cum ar fi i32, valorile sunt copiate în HashMap. Pentru valorile deținute precum String, valorile vor fi mutate, iar HashMap va deveni proprietarul acestora.
+
+5. 🌟🌟
+```rust,editable
+
+// CORECTEAZĂ erorile cu cel mai mic număr de modificări
+// NU șterge nicio linie de cod
+use std::collections::HashMap;
+fn main() {
+ let v1 = 10;
+ let mut m1 = HashMap::new();
+ m1.insert(v1, v1);
+ println!("v1 is still usable after inserting to hashmap : {}", v1);
+
+ let v2 = "hello".to_string();
+ let mut m2 = HashMap::new();
+ // Proprietate (Ownership) mutată aici
+ m2.insert(v2, v1);
+
+ assert_eq!(v2, "hello");
+
+ println!("Success!");
+}
+```
+
+### Biblioteci Hash terțe
+Dacă performanța lui SipHash 1-3 nu îndeplinește cerințele dvs., puteți găsi înlocuitori pe crates.io sau github.com.
+
+Utilizarea unei funcționalități de hash terțe arată în felul următor:
+```rust
+use std::hash::BuildHasherDefault;
+use std::collections::HashMap;
+
+// Introdu o funcție de hash terță parte
+use twox_hash::XxHash64;
+
+
+let mut hash: HashMap<_, _, BuildHasherDefault> = Default::default();
+hash.insert(42, "the answer");
+assert_eq!(hash.get(&42), Some(&"the answer"));
+```
+
diff --git a/ro-RO/src/collections/intro.md b/ro-RO/src/collections/intro.md
new file mode 100644
index 000000000..408e9b584
--- /dev/null
+++ b/ro-RO/src/collections/intro.md
@@ -0,0 +1,6 @@
+# Tipuri de colecții
+Resurse de învățare:
+- Engleză: [Rust Book Chapter 8](https://doc.rust-lang.org/book/ch08-00-common-collections.html)
+- Chineză simplificată: [Rust语言圣经 - 集合类型](https://course.rs/basic/collections/intro.html)
+
+
diff --git a/ro-RO/src/collections/string.md b/ro-RO/src/collections/string.md
new file mode 100644
index 000000000..32917035a
--- /dev/null
+++ b/ro-RO/src/collections/string.md
@@ -0,0 +1,206 @@
+# String
+`std::string::String` este un șir extensibil codificat în UTF-8. Este cel mai comun tip de șir folosit în dezvoltarea zilnică și are proprietatea conținutului șirului.
+
+### Operații de bază
+1. 🌟🌟
+```rust,editable
+
+// COMPLETAȚI spațiile goale și CORECTAȚI erorile
+// 1. Nu utilizați to_string()
+// 2. Nu adăugați/eliminați nicio linie de cod
+fn main() {
+ let mut s: String = "hello, ";
+ s.push_str("world".to_string());
+ s.push(__);
+
+ move_ownership(s);
+
+ assert_eq!(s, "hello, world!");
+
+ println!("Success!");
+}
+
+fn move_ownership(s: String) {
+ println!("ownership of \"{}\" is moved here!", s)
+}
+```
+
+### String și &str
+Un String este stocat sub formă de vector de octeți (Vec), dar este întotdeauna garantat să fie o secvență UTF-8 validă. String este alocat pe heap, poate crește dinamic și nu este terminat cu null.
+
+&str este o felie (&[u8]) care indică întotdeauna către o secvență UTF-8 validă și poate fi utilizat pentru a vizualiza conținutul unui String, la fel cum &[T] este o vedere într-un Vec.
+
+2. 🌟🌟
+```rust,editable
+// COMPLETAȚI spațiile goale
+fn main() {
+ let mut s = String::from("hello, world");
+
+ let slice1: &str = __; // În două moduri
+ assert_eq!(slice1, "hello, world");
+
+ let slice2 = __;
+ assert_eq!(slice2, "hello");
+
+ let slice3: __ = __;
+ slice3.push('!');
+ assert_eq!(slice3, "hello, world!");
+
+ println!("Success!");
+}
+```
+
+3. 🌟🌟
+```rust,editable
+
+// Întrebare: câte alocări de heap au loc aici?
+// Răspunsul tău:
+fn main() {
+ // Creează un tip String bazat pe &str
+ // Tipul literalurilor de șir este &str
+ let s: String = String::from("hello, world!");
+
+ // Creează un `slice` care indică către String-ul s
+ let slice: &str = &s;
+
+
+ // Creează un tip String bazat pe `slice`-ul creat recent
+ let s: String = slice.to_string();
+
+ assert_eq!(s, "hello, world!");
+
+ println!("Success!");
+}
+```
+
+### UTF-8 și Indexare
+Șirurile sunt întotdeauna formate din UTF-8 valid. Acest lucru are câteva implicații:
+
+Prima dintre acestea este că, dacă aveți nevoie de un șir non-UTF-8, luați în considerare [OsString](https://doc.rust-lang.org/stable/std/ffi/struct.OsString.html). Este similar, dar fără constrângerea UTF-8.
+A doua implicație este că nu puteți indexa într-un String.
+Indexarea este menită să fie o operație cu timp constant, dar encodarea UTF-8 nu ne permite să facem acest lucru. În plus, nu este clar ce fel de informație ar trebui să returneze indexul: un octet, un punct de cod sau un cluster grafemic. Metodele bytes și chars returnează iteratori peste primele două, respectiv.
+
+4. 🌟🌟🌟 Nu puteți folosi indexul pentru a accesa un caracter într-un șir, dar puteți utiliza felișea &s1[start..end].
+
+```rust,editable
+
+// COMPLETAȚI spațiile goale și CORECTAȚI erorile
+fn main() {
+ let s = String::from("hello, 世界");
+ let slice1 = s[0]; // Sfaturi: h ocupă doar 1 byte în formatul UTF-8
+ assert_eq!(slice1, "h");
+
+ let slice2 = &s[3..5]; // Sfaturi: 中 ocupă 3 octeți în formatul UTF-8
+ assert_eq!(slice2, "世");
+
+ // Parcurgeți toate caracterele din s
+ for (i, c) in s.__ {
+ if i == 7 {
+ assert_eq!(c, '世')
+ }
+ }
+
+ println!("Success!");
+}
+```
+
+
+#### UTF8_slice
+Puteți utiliza [utf8_slice](https://docs.rs/utf8_slice/1.0.0/utf8_slice/fn.slice.html) pentru a felia un șir UTF8, acesta poate indexa caractere în loc de octeți.
+
+**Exemplu**
+```rust
+use utf8_slice;
+fn main() {
+ let s = "The 🚀 goes to the 🌑!";
+
+ let rocket = utf8_slice::slice(s, 4, 5);
+ // Va fi egal cu "🚀"
+}
+```
+
+
+5. 🌟🌟🌟
+> Sfat: poate aveți nevoie de metoda from_utf8
+
+```rust,editable
+
+// COMPLETAȚI spațiile goale
+fn main() {
+ let mut s = String::new();
+ __;
+
+ // Niste octeți într-un vector.
+ let v = vec![104, 101, 108, 108, 111];
+
+ // Transformă un vector de octeți într-un șir de caractere (String)
+ let s1 = __;
+
+
+ assert_eq!(s, s1);
+
+ println!("Success!");
+}
+```
+
+### Reprezentare
+Un șir de caractere (String) este compus din trei componente: un pointer către niște octeți, o lungime și o capacitate.
+
+Pointer-ul arată către un buffer intern pe care String îl folosește pentru a stoca datele sale. Lungimea reprezintă numărul de octeți stocați în prezent în buffer (întotdeauna stocați în heap), iar capacitatea este dimensiunea buffer-ului în octeți. Prin urmare, lungimea va fi întotdeauna mai mică sau egală cu capacitatea.
+
+6. 🌟🌟 Dacă un String are suficientă capacitate, adăugarea de elemente la el nu va realoca memorie.
+```rust,editable
+
+// Modificați codul de mai jos pentru a afișa
+// 25
+// 25
+// 25
+// Aici nu este nevoie să alocăm mai multă memorie în interiorul buclei.
+fn main() {
+ let mut s = String::new();
+
+ println!("{}", s.capacity());
+
+ for _ in 0..2 {
+ s.push_str("hello");
+ println!("{}", s.capacity());
+ }
+
+ println!("Success!");
+}
+```
+
+7. 🌟🌟🌟
+```rust,editable
+
+// UMPLEȚI spațiile goale
+use std::mem;
+
+fn main() {
+ let story = String::from("Rust By Practice");
+
+ // Împiedică eliminarea automată a datelor din String
+ let mut story = mem::ManuallyDrop::new(story);
+
+ let ptr = story.__();
+ let len = story.__();
+ let capacity = story.__();
+
+ assert_eq!(16, len);
+
+ // Putem reconstrui un String folosind ptr, len și capacity.
+ // Totul este nesigur, deoarece suntem responsabili să ne asigurăm că
+ // componentele sunt valide:
+ let s = unsafe { String::from_raw_parts(ptr, len, capacity) };
+
+ assert_eq!(*story, s);
+
+ println!("Success!");
+}
+```
+
+
+### Metode comune
+Mai multe exerciții despre metodele String pot fi găsite [aici](../std/String.md).
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie.
\ No newline at end of file
diff --git a/ro-RO/src/collections/vector.md b/ro-RO/src/collections/vector.md
new file mode 100644
index 000000000..0029f35f5
--- /dev/null
+++ b/ro-RO/src/collections/vector.md
@@ -0,0 +1,244 @@
+# Vector
+Vectorii sunt tablouri redimensionabile. La fel ca și slice-urile, dimensiunea lor nu este cunoscută în timpul compilării, dar pot să crească sau să scadă în orice moment.
+
+
+### Operații de bază
+1. 🌟🌟🌟
+```rust,editable
+
+fn main() {
+ let arr: [u8; 3] = [1, 2, 3];
+
+ let v = Vec::from(arr);
+ is_vec(&v);
+
+ let v = vec![1, 2, 3];
+ is_vec(&v);
+
+ // vec!(..) și vec![..] sunt aceleași macrocomenzi, deci
+ let v = vec!(1, 2, 3);
+ is_vec(&v);
+
+ // În cod-ul de mai jos, v este Vec<[u8; 3]>, nu Vec
+ // FOLOSIȚI Vec::new și `for` pentru a rescrie codul de mai jos
+ let v1 = vec!(arr);
+ is_vec(&v1);
+
+ assert_eq!(v, v1);
+
+ println!("Success!");
+}
+
+fn is_vec(v: &Vec) {}
+```
+
+
+
+2. 🌟🌟 Un vector poate fi extins cu metoda `extend`
+```rust,editable
+
+// UMPLEȚI spațiile goale
+fn main() {
+ let mut v1 = Vec::from([1, 2, 4]);
+ v1.pop();
+ v1.push(3);
+
+ let mut v2 = Vec::new();
+ v2.__;
+
+ assert_eq!(v1, v2);
+
+ println!("Success!");
+}
+```
+
+### Transformați X în Vec
+3. 🌟🌟🌟
+```rust,editable
+
+// UMPLEȚI spațiile goale
+fn main() {
+ // Array -> Vec
+ // impl From<[T; N]> pentru Vec
+ let arr = [1, 2, 3];
+ let v1 = __(arr);
+ let v2: Vec = arr.__();
+
+ assert_eq!(v1, v2);
+
+
+ // String -> Vec
+ // impl From pentru Vec
+ let s = "hello".to_string();
+ let v1: Vec = s.__();
+
+ let s = "hello".to_string();
+ let v2 = s.into_bytes();
+ assert_eq!(v1, v2);
+
+ // impl<'_> From<&'_ str> pentru Vec
+ let s = "hello";
+ let v3 = Vec::__(s);
+ assert_eq!(v2, v3);
+
+ // Iteratoarele pot fi colectate în vectori
+ let v4: Vec = [0; 10].into_iter().collect();
+ assert_eq!(v4, vec![0; 10]);
+
+ println!("Success!");
+ }
+```
+
+### Indexarea
+4. 🌟🌟🌟
+```rust,editable
+
+// REZOLVAȚI erorile și IMPLEMENTAȚI codul
+fn main() {
+ let mut v = Vec::from([1, 2, 3]);
+ for i in 0..5 {
+ println!("{:?}", v[i])
+ }
+
+ for i in 0..5 {
+ // IMPLEMENTAȚI codul aici...
+ }
+
+ assert_eq!(v, vec![2, 3, 4, 5, 6]);
+
+ println!("Success!");
+}
+```
+
+
+### Felii (Slicing)
+Un Vec poate fi mutabil. Pe de altă parte, slice-urile sunt obiecte doar pentru citire. Pentru a obține un slice, folosiți &.
+
+În Rust, este mai obișnuit să se transmită slice-uri ca argumente în loc de vectori atunci când doriți doar să furnizați acces de citire. Același lucru este valabil pentru String și &str.
+
+5. 🌟🌟
+```rust,editable
+
+// REZOLVAȚI erorile
+fn main() {
+ let mut v = vec![1, 2, 3];
+
+ let slice1 = &v[..];
+ // Accesul în afara limitelor va cauza o panică
+ // Trebuie să utilizați v.len aici
+ let slice2 = &v[0..4];
+
+ assert_eq!(slice1, slice2);
+
+ // Slice-urile sunt doar pentru citire
+ // Notă: slice-urile și &Vec sunt diferite
+ let vec_ref: &mut Vec = &mut v;
+ (*vec_ref).push(4);
+ let slice3 = &mut v[0..3];
+ slice3.push(4);
+
+ assert_eq!(slice3, &[1, 2, 3, 4]);
+
+ println!("Success!");
+}
+```
+### Capacitate
+Capacitatea unui vector reprezintă spațiul alocat pentru orice elemente viitoare care vor fi adăugate la vector. Aceasta nu trebuie confundată cu lungimea unui vector, care specifică numărul real de elemente din vector. Dacă lungimea unui vector depășește capacitatea sa, capacitatea acestuia va fi crescută automat, dar elementele vor trebui să fie realocate.
+
+De exemplu, un vector cu o capacitate de 10 și o lungime de 0 ar fi un vector gol cu spațiu pentru încă 10 elemente. Adăugarea a 10 sau mai puține elemente în vector nu va schimba capacitatea sau nu va provoca realocare. Cu toate acestea, dacă lungimea vectorului este crescută la 11, va trebui să fie realocat, ceea ce poate fi lent. Din acest motiv, se recomandă utilizarea Vec::with_capacity ori de câte ori este posibil pentru a specifica cât de mare se așteaptă să devină vectorul.
+
+6. 🌟🌟
+```rust,editable
+// REZOLVAȚI erorile
+fn main() {
+ let mut vec = Vec::with_capacity(10);
+
+ // Vectorul nu conține niciun element, chiar dacă are capacitate pentru mai multe.
+ assert_eq!(vec.len(), __);
+ assert_eq!(vec.capacity(), 10);
+
+ // Toate acestea se fac fără a realoca memorie...
+ for i in 0..10 {
+ vec.push(i);
+ }
+ assert_eq!(vec.len(), __);
+ assert_eq!(vec.capacity(), __);
+
+ // ...dar acest lucru ar putea determina vectorul să realoce memorie.
+ vec.push(11);
+ assert_eq!(vec.len(), 11);
+ assert!(vec.capacity() >= 11);
+
+ // Completați cu o valoare potrivită pentru a face ca bucla for să se execute fără alocare suplimentară de memorie
+ let mut vec = Vec::with_capacity(__);
+ for i in 0..100 {
+ vec.push(i);
+ }
+
+ assert_eq!(vec.len(), __);
+ assert_eq!(vec.capacity(), __);
+
+ println!("Success!");
+}
+```
+
+### Stocarea de tipuri distincte într-un Vector
+Elementele dintr-un vector trebuie să fie de același tip. De exemplu, codul de mai jos va genera o eroare:
+```rust
+fn main() {
+ let v = vec![1, 2.0, 3];
+}
+```
+
+Dar putem folosi enum-uri sau obiecte de tip trait pentru a stoca tipuri distincte.
+
+7. 🌟🌟
+```rust,editable
+#[derive(Debug)]
+enum IpAddr {
+ V4(String),
+ V6(String),
+}
+fn main() {
+ // COMPLETAȚI spațiul liber
+ let v : Vec= __;
+
+ // Pentru a compara două enum-uri, este necesar să derivăm traitul PartialEq.
+ assert_eq!(v[0], IpAddr::V4("127.0.0.1".to_string()));
+ assert_eq!(v[1], IpAddr::V6("::1".to_string()));
+
+ println!("Success!");
+}
+```
+
+8. 🌟🌟
+```rust,editable
+trait IpAddr {
+ fn display(&self);
+}
+
+struct V4(String);
+impl IpAddr for V4 {
+ fn display(&self) {
+ println!("ipv4: {:?}",self.0)
+ }
+}
+struct V6(String);
+impl IpAddr for V6 {
+ fn display(&self) {
+ println!("ipv6: {:?}",self.0)
+ }
+}
+
+fn main() {
+ // COMPLETAȚI spațiul liber
+ let v: __= vec![
+ Box::new(V4("127.0.0.1".to_string())),
+ Box::new(V6("::1".to_string())),
+ ];
+
+ for ip in v {
+ ip.display();
+ }
+}
+```
diff --git a/ro-RO/src/comments-docs.md b/ro-RO/src/comments-docs.md
new file mode 100644
index 000000000..afef0fa10
--- /dev/null
+++ b/ro-RO/src/comments-docs.md
@@ -0,0 +1,295 @@
+# Comments and Docs
+Every program requires comments:
+
+
+## Comments
+- Regular comments which are ignored by the compiler:
+ - `// Line comment, which goes to the end of the line`
+ - `/* Block comment, which goes to the end of the closing delimiter */`
+
+
+### Examples
+```rust
+fn main() {
+ // This is an example of a line comment
+ // There are two slashes at the beginning of the line
+ // And nothing written inside these will be read by the compiler
+
+ // println!("Hello, world!");
+
+ // Run it. See? Now try deleting the two slashes, and run it again.
+
+ /*
+ * This is another type of comment, a block comment. In general,
+ * line comments are the recommended comment style. But
+ * block comments are extremely useful for temporarily disabling
+ * chunks of code. /* Block comments can be /* nested, */ */
+ * so it takes only a few keystrokes to comment out everything
+ * in this main() function. /*/*/* Try it yourself! */*/*/
+ */
+
+ /*
+ Note: The previous column of `*` was entirely for style. There's
+ no actual need for it.
+ */
+}
+```
+
+### Exercises
+1. 🌟🌟
+```rust,editable
+
+/* Make it work, only using comments! */
+fn main() {
+ todo!();
+ unimplemented!();
+
+ assert_eq!(6, 5 + 3 + 2 + 1 )
+}
+```
+
+
+## Doc Comments
+- Doc comments which are parsed into HTML and supported `Markdown`
+ - `/// Generate library docs for the following item`
+ - `//! Generate library docs for the eclosing item`
+
+Before starting, we need to create a new package for practice: `cargo new --lib doc-comments`.
+
+
+### Line doc comments `///`
+Add docs for function `add_one`
+```rust
+// in lib.rs
+
+/// Add one to the given value and return the value
+///
+/// # Examples
+///
+/// ```
+/// let arg = 5;
+/// let answer = my_crate::add_one(arg);
+///
+/// assert_eq!(6, answer);
+/// ```
+pub fn add_one(x: i32) -> i32 {
+ x + 1
+}
+```
+
+### Cargo doc
+We can use `cargo doc --open` to generate html files and open them in the browser.
+
+### Block doc comments `/** ... */`
+Add docs for function `add_two`:
+```rust
+/** Add two to the given value and return a new value
+
+# Examples
+
+let arg = 5;
+let answer = my_crate::add_two(arg);
+
+assert_eq!(7, answer);
+
+*/
+pub fn add_two(x: i32) -> i32 {
+ x + 2
+}
+```
+
+### Doc comments for crate and module
+We can also add doc comments for our crates and modules.
+
+Firstly, let's add some doc comments for our library crate:
+
+> Note: We must place crates and module comments at the top of crate root or module file.
+```rust
+//! # Doc comments
+//!
+//! A library for showing how to use doc comments
+
+// in lib.rs
+pub mod compute;
+```
+
+You can also use block comments to achieve this:
+```rust
+/*! # Doc comments
+
+ A library for showing how to use doc comments */
+```
+
+Next, create a new module file `src/compute.rs`, and add following comments to it:
+```rust
+//! //! Do some complicated arithmetic that you can't do by yourself
+
+// in compute.rs
+```
+
+Then run `cargo doc --open` and see the results.
+
+
+### Doc tests
+The doc comments of `add_one` and `add_two` contain two example code blocks.
+
+The examples can not only demonstrate how to use your library, but also running as test with `cargo test` command.
+
+2. 🌟🌟 But there are errors in the two examples, please fix them, and running with `cargo test` to get following result:
+```shell
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+ Doc-tests doc-comments
+
+running 2 tests
+test src/lib.rs - add_one (line 11) ... ok
+test src/lib.rs - add_two (line 26) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.55s
+```
+
+3. 🌟🌟 Sometimes we expect an example to be panic, add following code to `src/compute.rs` and make the `cargo test` passed.
+
+> You can only modify the comments, DON'T modify `fn div`
+
+```rust
+// in src/compute.rs
+
+/// # Panics
+///
+/// The function panics if the second argument is zero.
+///
+/// ```rust,should_panic
+/// // panics on division by zero
+/// doc_comments::compute::div(10, 0);
+/// ```
+pub fn div(a: i32, b: i32) -> i32 {
+ if b == 0 {
+ panic!("Divide-by-zero error");
+ }
+
+ a / b
+}
+```
+
+4. 🌟🌟 Sometimes we want to hide the doc comments, but keep the doc tests.
+
+Add following code to `src/compute.rs` ,
+
+```rust
+// in src/compute.rs
+
+/// ```
+/// # fn try_main() -> Result<(), String> {
+/// # let res = doc_comments::compute::try_div(10, 0)?;
+/// # Ok(()) // returning from try_main
+/// # }
+/// # fn main() {
+/// # try_main().unwrap();
+/// #
+/// # }
+/// ```
+pub fn try_div(a: i32, b: i32) -> Result {
+ if b == 0 {
+ Err(String::from("Divide-by-zero"))
+ } else {
+ Ok(a / b)
+ }
+}
+```
+
+and modify this code to achieve two goals:
+
+- The doc comments must not be presented in html files generated by `cargo doc --open`
+- run the tests, you should see results as below:
+
+```shell
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+ Doc-tests doc-comments
+
+running 4 tests
+test src/compute.rs - compute::div (line 7) ... ok
+test src/lib.rs - add_two (line 27) ... ok
+test src/lib.rs - add_one (line 11) ... ok
+test src/compute.rs - compute::try_div (line 20) ... ok
+
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.51s
+```
+
+### Code navigation
+Rust provide a very powerful feature for us, that is code navigation in doc comments.
+
+Add following code to `src/lib.rs`:
+```rust
+// in lib.rs
+
+/// Add three to the given value and return a [`Option`] type
+pub fn add_three(x: i32) -> Option {
+ Some(x + 3)
+}
+```
+
+Besides jump into the standard library, you can also jump to another module in the package.
+
+```rust
+// in lib.rs
+
+mod a {
+ /// Add four to the given value and return a [`Option`] type
+ /// [`crate::MySpecialFormatter`]
+ pub fn add_four(x: i32) -> Option {
+ Some(x + 4)
+ }
+}
+
+struct MySpecialFormatter;
+```
+
+### Doc attributes
+Below are a few examples of the most common `#[doc]` attributes used with `rustdoc`.
+
+### `inline`
+
+Used to inline docs, instead of linking out to separate page.
+
+```rust,ignore
+#[doc(inline)]
+pub use bar::Bar;
+
+/// bar docs
+mod bar {
+ /// the docs for Bar
+ pub struct Bar;
+}
+```
+
+### `no_inline`
+
+Used to prevent linking out to separate page or anywhere.
+
+```rust,ignore
+// Example from libcore/prelude
+#[doc(no_inline)]
+pub use crate::mem::drop;
+```
+
+### `hidden`
+
+Using this tells `rustdoc` not to include this in documentation:
+
+```rust,editable,ignore
+// Example from the futures-rs library
+#[doc(hidden)]
+pub use self::async_await::*;
+```
+
+For documentation, `rustdoc` is widely used by the community. It's what is used to generate the [std library docs](https://doc.rust-lang.org/std/).
+
+
+### Full Code
+The full code of package `doc-comments` is [here](https://github.com/sunface/rust-by-practice/tree/master/practices/doc-comments).
diff --git a/ro-RO/src/compound-types/array.md b/ro-RO/src/compound-types/array.md
new file mode 100644
index 000000000..eacdff74a
--- /dev/null
+++ b/ro-RO/src/compound-types/array.md
@@ -0,0 +1,102 @@
+# Tablou (Array)
+Tipul de tablou este [T; Lungime], așa cum poți observa, lungimea tabloului este parte a semnăturii lor de tip. Prin urmare, lungimea lor trebuie să fie cunoscută în timpul compilării.
+
+De exemplu, nu poți inițializa un tablou în felul următor:
+```rust
+fn init_arr(n: i32) {
+ let arr = [1; n];
+}
+```
+
+Acest lucru va provoca o eroare, deoarece compilatorul nu are nicio idee despre dimensiunea exactă a tabloului în timpul compilării.
+
+1. 🌟
+```rust,editable
+
+fn main() {
+ // Completează spațiul gol cu tipul de tablou potrivit
+ let arr: __ = [1, 2, 3, 4, 5];
+
+ // Modifică codul de mai jos pentru a-l face funcțional
+ assert!(arr.len() == 4);
+
+ println!("Success!");
+}
+```
+
+2. 🌟🌟
+```rust,editable
+
+fn main() {
+ // Putem să ignorăm părți ale tipului de tablou sau chiar întregul tip, să lăsăm compilatorul să-l deducă pentru noi
+ let arr0 = [1, 2, 3];
+ let arr: [_; 3] = ['a', 'b', 'c'];
+
+ // Completează spațiul gol
+ // Tablourile sunt alocate pe stivă, std::mem::size_of_val returnează numărul de octeți pe care îi ocupă un tablou
+ // Un caracter în Rust ocupă 4 octeți: caracter Unicode
+ assert!(std::mem::size_of_val(&arr) == __);
+
+ println!("Success!");
+}
+```
+
+3. 🌟 Toate elementele dintr-un tablou pot fi inițializate la aceeași valoare în același timp.
+
+```rust,editable
+
+fn main() {
+ // Completează spațiul gol
+ let list: [i32; 100] = __ ;
+
+ assert!(list[0] == 1);
+ assert!(list.len() == 100);
+
+ println!("Success!");
+}
+```
+
+4. 🌟 Toate elementele dintr-un tablou trebuie să fie de același tip.
+```rust,editable
+
+fn main() {
+ // Remediază eroarea
+ let _arr = [1, 2, '3'];
+
+ println!("Success!");
+}
+```
+
+5. 🌟 Indexarea începe de la 0.
+```rust,editable
+
+fn main() {
+ let arr = ['a', 'b', 'c'];
+
+ let ele = arr[1]; // Modifică doar această linie pentru a face ca codul să funcționeze!
+
+ assert!(ele == 'a');
+
+ println!("Success!");
+}
+```
+
+6. 🌟 Out of bounds indexing causes `panic`.
+```rust,editable
+
+// Remediază eroarea
+fn main() {
+ let names = [String::from("Sunfei"), "Sunface".to_string()];
+
+ // Get returnează un Option, este sigur să-l folosești
+ let name0 = names.get(0).unwrap();
+
+ // Dar indexarea nu este sigură
+ let _name1 = &names[2];
+
+ println!("Success!");
+}
+
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie.
\ No newline at end of file
diff --git a/ro-RO/src/compound-types/enum.md b/ro-RO/src/compound-types/enum.md
new file mode 100644
index 000000000..5b8dbcbb5
--- /dev/null
+++ b/ro-RO/src/compound-types/enum.md
@@ -0,0 +1,209 @@
+# Enum
+1. 🌟🌟 Enum-urile pot fi create cu un discriminator explicit.
+
+```rust,editable
+
+// Rezolvați erorile
+enum Number {
+ Zero,
+ One,
+ Two,
+}
+
+enum Number1 {
+ Zero = 0,
+ One,
+ Two,
+}
+
+// Enum de tip C
+enum Number2 {
+ Zero = 0.0,
+ One = 1.0,
+ Two = 2.0,
+}
+
+
+fn main() {
+ // O variantă enum poate fi convertită la un întreg folosind as
+ assert_eq!(Number::One, Number1::One);
+ assert_eq!(Number1::One, Number2::One);
+
+ println!("Success!");
+}
+```
+
+2. 🌟 Fiecare variantă de enum poate deține propriile sale date.
+```rust,editable
+
+// Completați spațiul liber
+enum Message {
+ Quit,
+ Move { x: i32, y: i32 },
+ Write(String),
+ ChangeColor(i32, i32, i32),
+}
+
+fn main() {
+ let msg1 = Message::Move{__}; // Instanțiere cu x = 1, y = 2
+ let msg2 = Message::Write(__); // Instanțiere cu "hello, world!"
+
+ println!("Success!");
+}
+```
+
+3. 🌟🌟 Putem obține datele pe care o variantă enum le deține prin potrivirea de modele.
+```rust,editable
+
+// Completați spațiul liber și remediați eroarea
+enum Message {
+ Quit,
+ Move { x: i32, y: i32 },
+ Write(String),
+ ChangeColor(i32, i32, i32),
+}
+
+fn main() {
+ let msg = Message::Move{x: 1, y: 2};
+
+ if let Message::Move{__} = msg {
+ assert_eq!(a, b);
+ } else {
+ panic!("NEVER LET THIS RUN！");
+ }
+
+ println!("Success!");
+}
+```
+
+4. 🌟🌟
+
+```rust,editable
+
+// Completați spațiul liber și remediați erorile
+enum Message {
+ Quit,
+ Move { x: i32, y: i32 },
+ Write(String),
+ ChangeColor(i32, i32, i32),
+}
+
+fn main() {
+ let msgs: __ = [
+ Message::Quit,
+ Message::Move{x:1, y:3},
+ Message::ChangeColor(255,255,0)
+ ];
+
+ for msg in msgs {
+ show_message(msg)
+ }
+}
+
+fn show_message(msg: Message) {
+ println!("{}", msg);
+}
+```
+
+5. 🌟🌟 Deoarece nu există null în Rust, trebuie să folosim enum-ul Option pentru a gestiona cazurile în care valoarea lipsește.
+```rust,editable
+
+// Completați spațiul liber pentru a face funcționarea println.
+// Adăugați, de asemenea, un cod pentru a preveni rularea panic.
+fn main() {
+ let five = Some(5);
+ let six = plus_one(five);
+ let none = plus_one(None);
+
+ if let __ = six {
+ println!("{}", n);
+
+ println!("Success!");
+ }
+
+ panic!("NEVER LET THIS RUN！");
+}
+
+fn plus_one(x: Option) -> Option {
+ match x {
+ __ => None,
+ __ => Some(i + 1),
+ }
+}
+```
+
+
+6. 🌟🌟🌟🌟 Implementați o `linked list`` prin intermediul enum-urilor.
+
+```rust,editable
+
+use crate::List::*;
+
+enum List {
+ // Cons: Structură tuplu care înconjoară un element și un pointer către următorul nod
+ Cons(u32, Box),
+ // Nil: Un nod care semnifică sfârșitul listei legate
+ Nil,
+}
+
+// Metodele pot fi atașate unui enum
+impl List {
+ // Creați o listă goală
+ fn new() -> List {
+ // `Nil` are tipul `List`
+ Nil
+ }
+
+ // Consumați o listă și returnați aceeași listă cu un element nou la începutul ei
+ fn prepend(self, elem: u32) -> __ {
+ // Cons are, de asemenea, tipul List
+ Cons(elem, Box::new(self))
+ }
+
+ // Returnați lungimea listei
+ fn len(&self) -> u32 {
+ // self trebuie potrivit, deoarece comportamentul acestei metode depinde de variantă self
+ // self are tipul &List, și *self are tipul List, potrivirea pe un tip concret T este preferată față de o potrivire pe o referință &T
+ // După Rust 2018, puteți utiliza self aici și tail (fără ref) mai jos, de asemenea,
+ // Rust va deduce &-urile și ref-ul pentru voi.
+ // Vezi https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/default-match-bindings.html
+ match *self {
+ // Nu putem prelua proprietatea cozii, deoarece self este împrumutat;
+ // În schimb, preluați o referință la coadă
+ Cons(_, ref tail) => 1 + tail.len(),
+ // Caz de bază: O listă goală are lungimea zero
+ Nil => 0
+ }
+ }
+
+ // Returnați reprezentarea listei ca un șir (alocat pe heap)
+ fn stringify(&self) -> String {
+ match *self {
+ Cons(head, __ tail) => {
+ // format! este similar cu print!, dar
+ // returnează un șir alocat pe heap în loc să imprime la consolă
+ format!("{}, {}", head, tail.__())
+ },
+ Nil => {
+ format!("Nil")
+ },
+ }
+ }
+}
+
+fn main() {
+ // Creează o listă simplu înlănțuită goală
+ let mut list = List::new();
+
+ // Adaugă elemente înainte (la începutul listei)
+ list = list.prepend(1);
+ list = list.prepend(2);
+ list = list.prepend(3);
+
+ // Afișează starea finală a listei
+ println!("linked list has length: {}", list.len());
+ println!("{}", list.stringify());
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie.
\ No newline at end of file
diff --git a/ro-RO/src/compound-types/intro.md b/ro-RO/src/compound-types/intro.md
new file mode 100644
index 000000000..3f986ca2a
--- /dev/null
+++ b/ro-RO/src/compound-types/intro.md
@@ -0,0 +1,6 @@
+# Tipuri compuse
+Resurse de învățare:
+- Engleză:: [Rust Book 4.3, 5.1, 6.1, 8.2](https://doc.rust-lang.org/book/ch04-03-slices.html)
+- Chineză simplificată: [Rust语言圣经 - 复合类型](https://course.rs/basic/compound-type/intro.html)
+
+
diff --git a/ro-RO/src/compound-types/slice.md b/ro-RO/src/compound-types/slice.md
new file mode 100644
index 000000000..260bd7c0a
--- /dev/null
+++ b/ro-RO/src/compound-types/slice.md
@@ -0,0 +1,100 @@
+# Felie (Slice)
+Feliile sunt similare cu tablourile, dar lungimea lor nu este cunoscută în timpul compilării, așa că nu poți utiliza feliile direct.
+
+1. 🌟🌟 Aici, atât [i32] cât și str sunt tipuri de felii, dar utilizarea directă va provoca erori. Trebuie să folosiți referința feliei în schimb: &[i32], &str.
+```rust,editable
+
+// Remediază erorile, NU adăuga noi linii!
+fn main() {
+ let arr = [1, 2, 3];
+ let s1: [i32] = arr[0..2];
+
+ let s2: str = "hello, world" as str;
+
+ println!("Success!");
+}
+```
+
+O referință la o felie este un obiect format din două cuvinte, din motive de simplitate, de acum înainte vom folosi doar "felia" în loc de "referința la felie". Primul cuvânt este un pointer către date, iar al doilea cuvânt este lungimea feliei. Dimensiunea cuvântului este aceeași cu usize, determinată de arhitectura procesorului, de exemplu, 64 de biți pe un x86-64. Feliile pot fi utilizate pentru a împrumuta o secțiune a unui tablou și au semnătura de tip &[T].
+
+2. 🌟🌟🌟
+```rust,editable
+
+fn main() {
+ let arr: [char; 3] = ['中', '国', '人'];
+
+ let slice = &arr[..2];
+
+ // Modifică '8' pentru a face codul să funcționeze
+ // SFAT: slice (referința la feliu) NU ESTE un tablou, dacă ar fi un tablou, atunci assert! ar fi trecut: Fiecare dintre cele două caractere '中' și '国' ocupă 4 octeți, 2 * 4 = 8
+ assert!(std::mem::size_of_val(&slice) == 8);
+
+ println!("Success!");
+}
+```
+
+3. 🌟🌟
+```rust,editable
+
+fn main() {
+ let arr: [i32; 5] = [1, 2, 3, 4, 5];
+ // Completează spațiile goale pentru a face codul să funcționeze
+ let slice: __ = __;
+ assert_eq!(slice, &[2, 3, 4]);
+
+ println!("Success!");
+}
+```
+
+### Feliile de șiruri (String slices)
+4. 🌟
+```rust,editable
+
+fn main() {
+ let s = String::from("hello");
+
+ let slice1 = &s[0..2];
+ // Completează spațiul gol pentru a face codul să funcționeze, NU FOLOSI 0..2 din nou
+ let slice2 = &s[__];
+
+ assert_eq!(slice1, slice2);
+
+ println!("Success!");
+}
+```
+
+5. 🌟
+```rust,editable
+
+fn main() {
+ let s = "你好，世界";
+ // Modifică această linie pentru a face codul să funcționeze
+ let slice = &s[0..2];
+
+ assert!(slice == "你");
+
+ println!("Success!");
+}
+```
+
+6. 🌟🌟 `&String` can be implicitly converted into `&str`.
+```rust,editable
+
+// Remediază erorile
+fn main() {
+ let mut s = String::from("hello world");
+
+ // Aici, &s are tipul &String, dar first_word necesită un tip &str.
+ // Funcționează deoarece &String poate fi convertit implicit la &str. Dacă vrei să afli mai multe, acest lucru se numește "coerciție Deref".
+ let word = first_word(&s);
+
+ s.clear(); // eroare!
+
+ println!("the first word is: {}", word);
+}
+fn first_word(s: &str) -> &str {
+ &s[..1]
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie.
\ No newline at end of file
diff --git a/ro-RO/src/compound-types/string.md b/ro-RO/src/compound-types/string.md
new file mode 100644
index 000000000..be0df71aa
--- /dev/null
+++ b/ro-RO/src/compound-types/string.md
@@ -0,0 +1,268 @@
+# Șir de caractere (String)
+Tipul literalului de șir "hello, world" este &str, de exemplu let s: &str = "hello, world".
+
+
+### Str și &str
+1. 🌟 Nu putem utiliza tipul str în moduri normale, dar putem utiliza &str.
+
+```rust,editable
+
+// Remedierează eroarea fără a adăuga noi linii
+fn main() {
+ let s: str = "hello, world";
+
+ println!("Success!");
+}
+```
+
+
+2. 🌟🌟 Putem utiliza doar str prin împachetarea acestuia, & poate fi folosit pentru a converti Box în &str.
+
+```rust,editable
+
+// Remediază eroarea cu cel puțin două soluții
+fn main() {
+ let s: Box = "hello, world".into();
+ greetings(s)
+}
+
+fn greetings(s: &str) {
+ println!("{}",s)
+}
+```
+
+### String
+Tipul String este definit în std și stocat ca un vector de octeți (Vec), dar este întotdeauna garantat să fie o secvență UTF-8 validă. String este alocat pe stivă, poate crește și nu este terminat cu null.
+
+3. 🌟
+```rust,editable
+
+// Completează spațiul gol
+fn main() {
+ let mut s = __;
+ s.push_str("hello, world");
+ s.push('!');
+
+ assert_eq!(s, "hello, world!");
+
+ println!("Success!");
+}
+```
+
+4. 🌟🌟🌟
+```rust,editable
+
+// Remediază toate erorile fără a adăuga linii noi
+fn main() {
+ let s = String::from("hello");
+ s.push(',');
+ s.push(" world");
+ s += "!".to_string();
+
+ println!("{}", s);
+}
+```
+
+5. 🌟🌟 Funcția replace poate fi folosită pentru a înlocui o subșir.
+```rust,editable
+
+// Completează spațiul gol
+fn main() {
+ let s = String::from("I like dogs");
+ // Alocă memorie nouă și stochează șirul modificat acolo
+ let s1 = s.__("dogs", "cats");
+
+ assert_eq!(s1, "I like cats");
+
+ println!("Success!");
+}
+```
+
+Mai multe metode pentru tipul String pot fi găsite în cadrul modulului [String](https://doc.rust-lang.org/std/string/struct.String.html).
+
+6. 🌟🌟 Poți concatena doar un String cu un &str, iar proprietatea String-ului poate fi transferată către o altă variabilă.
+
+```rust,editable
+
+// Remediază erorile fără a elimina nicio linie
+fn main() {
+ let s1 = String::from("hello,");
+ let s2 = String::from("world!");
+ let s3 = s1 + s2;
+ assert_eq!(s3, "hello,world!");
+ println!("{}", s1);
+}
+```
+
+### &str și String
+Contrar utilizării rare a tipului str, &str și String sunt folosite pretutindeni!
+
+7. 🌟🌟 &str poate fi convertit la String în două moduri:
+```rust,editable
+
+// Remedierează eroarea cu cel puțin două soluții
+fn main() {
+ let s = "hello, world";
+ greetings(s)
+}
+
+fn greetings(s: String) {
+ println!("{}", s)
+}
+```
+
+8. 🌟🌟 Putem folosi String::from sau to_string pentru a converti un &str la String.
+
+```rust,editable
+
+// Folosește două abordări pentru a remedia eroarea și fără a adăuga o linie nouă
+fn main() {
+ let s = "hello, world".to_string();
+ let s1: &str = s;
+
+ println!("Success!");
+}
+```
+
+### Escapări pentru șiruri (String escapes)
+9. 🌟
+```rust,editable
+fn main() {
+ // Poți utiliza caractere de escape pentru a scrie octeți folosind valorile lor hexadecimale
+ // Completează spațiul gol de mai jos pentru a afișa "I'm writing Rust"
+ let byte_escape = "I'm writing Ru\x73__!";
+ println!("What are you doing\x3F (\\x3F means ?) {}", byte_escape);
+
+ // ...sau puncte de cod Unicode.
+ let unicode_codepoint = "\u{211D}";
+ let character_name = "\"DOUBLE-STRUCK CAPITAL R\"";
+
+ println!("Unicode character {} (U+211D) is called {}",
+ unicode_codepoint, character_name );
+
+ let long_string = "String literals
+ can span multiple lines.
+ The linebreak and indentation here \
+ can be escaped too!";
+ println!("{}", long_string);
+}
+```
+
+10. 🌟🌟🌟 Uneori există prea multe caractere care trebuie evitate sau este mult mai convenabil să scrii un șir așa cum este. Aici intervin literalurile brute de șiruri (raw string literals).
+
+```rust,editable
+
+/* Completează spațiul gol și remediază erorile */
+fn main() {
+ let raw_str = r"Escapes don't work here: \x3F \u{211D}";
+ // Modifică linia de mai sus pentru a face codul să funcționeze
+ assert_eq!(raw_str, "Escapes don't work here: ? ℝ");
+
+ // Dacă ai nevoie de ghilimele într-un șir brut, adaugă o pereche de #
+ let quotes = r#"And then I said: "There is no escape!""#;
+ println!("{}", quotes);
+
+ // Dacă ai nevoie de "# în șirul tău, folosește mai multe # în delimitator.
+ // Poți folosi până la 65535 de #.
+ let delimiter = r###"A string with "# in it. And even "##!"###;
+ println!("{}", delimiter);
+
+ // Completează spațiul gol
+ let long_delimiter = __;
+ assert_eq!(long_delimiter, "Hello, \"##\"");
+
+ println!("Success!");
+}
+```
+
+### Șir de octeți (Byte string)
+Vrei un șir care nu este UTF-8? (Ține minte, str și String trebuie să fie UTF-8 valide). Sau poate vrei un tablou de octeți care este în mare parte text? Șirurile de octeți te ajută!
+
+**Exemplu**:
+```rust,editable
+use std::str;
+
+fn main() {
+ // Reține că aceasta nu este de fapt un &str.
+ let bytestring: &[u8; 21] = b"this is a byte string";
+
+ // Tablourile de octeți nu au trăsătura Display, așa că afișarea lor este puțin limitată
+ println!("A byte string: {:?}", bytestring);
+
+ // Șirurile de octeți pot avea caractere de escape pentru octeți...
+ let escaped = b"\x52\x75\x73\x74 as bytes";
+ // ...Dar fără caractere de escape Unicode
+ // let escaped = b"\u{211D} Nu este permis";
+ println!("Some escaped bytes: {:?}", escaped);
+
+
+ // Șirurile brute de octeți funcționează la fel ca și șirurile brute
+ let raw_bytestring = br"\u{211D} is not escaped here";
+ println!("{:?}", raw_bytestring);
+
+ // Conversia unui tablou de octeți la str poate eșua
+ if let Ok(my_str) = str::from_utf8(raw_bytestring) {
+ println!("And the same as text: '{}'", my_str);
+ }
+
+ let _quotes = br#"You can also use "fancier" formatting, \
+ like with normal raw strings"#;
+
+ // Șirurile de octeți nu trebuie să fie UTF-8
+ let shift_jis = b"\x82\xe6\x82\xa8\x82\xb1\x82\xbb"; // "ようこそ" In SHIFT-JIS
+
+ // Dar nu pot fi mereu convertite in `str`
+ match str::from_utf8(shift_jis) {
+ Ok(my_str) => println!("Conversion successful: '{}'", my_str),
+ Err(e) => println!("Conversion failed: {:?}", e),
+ };
+}
+```
+
+O detaliere mai amplă a modalităților de a scrie literale de șir și caractere de escape este dată în [capitolul 'Jetoane'](https://doc.rust-lang.org/reference/tokens.html)
+a Referinței Rust.
+
+### Index de șiruri
+11. 🌟🌟🌟 Nu puteți folosi index pentru a accesa un caracter dintr-un șir, dar puteți folosi slice `&s1[start..end]`.
+
+```rust,editable
+
+fn main() {
+ let s1 = String::from("hi,中国");
+ let h = s1[0]; // Modificați această linie pentru a remedia eroarea, sfaturi: `h` ia doar 1 octet în format UTF8
+ assert_eq!(h, "h");
+
+ let h1 = &s1[3..5]; // Modificați această linie pentru a remedia eroarea, sfaturi: `中` are 3 octeți în format UTF8
+ assert_eq!(h1, "中");
+
+ println!("Success!");
+}
+```
+
+### Operați pe șir UTF8
+12. 🌟
+```rust,editable
+
+fn main() {
+ // Completați spațiul liber pentru a imprima fiecare caracter din „你好，世界”
+ for c in "你好，世界".__ {
+ println!("{}", c)
+ }
+}
+```
+
+#### utf8_slice
+Puteți folosi [utf8_slice](https://docs.rs/utf8_slice/1.0.0/utf8_slice/fn.slice.html) pentru a tăia șirul UTF8. Poate indexa caractere în loc de octeți.
+
+**Exemplu**
+```rust
+use utf8_slice;
+fn main() {
+ let s = "The 🚀 goes to the 🌑!";
+
+ let rocket = utf8_slice::slice(s, 4, 5);
+ // Va fi egal cu „🚀”
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie.
diff --git a/ro-RO/src/compound-types/struct.md b/ro-RO/src/compound-types/struct.md
new file mode 100644
index 000000000..2c9435334
--- /dev/null
+++ b/ro-RO/src/compound-types/struct.md
@@ -0,0 +1,230 @@
+# Struct
+
+### Tipurile de structuri
+1. 🌟 Trebuie să precizăm valori concrete pentru fiecare dintre câmpurile din struct.
+```rust,editable
+
+// Remediați eroarea
+struct Person {
+ name: String,
+ age: u8,
+ hobby: String
+}
+fn main() {
+ let age = 30;
+ let p = Person {
+ name: String::from("sunface"),
+ age,
+ };
+
+ println!("Success!");
+}
+```
+
+2. 🌟 Structura unității nu are câmpuri. Poate fi util atunci când trebuie să implementați o trăsătură pe un anumit tip, dar nu aveți date pe care doriți să le stocați în tipul în sine.
+```rust,editable
+
+struct Unit;
+trait SomeTrait {
+ // ...Unele comportamente definite aici.
+}
+
+// Nu ne pasă de ce câmpuri sunt în Unitate, dar ne pasă de comportamentele acesteia.
+// Așadar, folosim o structură fără câmpuri și implementăm unele comportamente pentru aceasta
+impl SomeTrait for Unit { }
+fn main() {
+ let u = Unit;
+ do_something_with_unit(u);
+
+ println!("Success!");
+}
+
+// Completați spațiul liber pentru a face codul să funcționeze
+fn do_something_with_unit(u: __) { }
+```
+
+3. 🌟🌟🌟 Structura tuplurilor arată similar cu tuplurile, are un sens adăugat pe care numele structurii o oferă, dar nu are câmpuri denumite. Este util atunci când vrei să dai un nume întregului tuplu, dar nu-ți pasă de numele câmpurilor.
+
+```rust,editable
+
+// Remediați eroarea și completați spațiile libere
+struct Color(i32, i32, i32);
+struct Point(i32, i32, i32);
+fn main() {
+ let v = Point(__, __, __);
+ check_color(v);
+
+ println!("Success!");
+}
+
+fn check_color(p: Color) {
+ let (x, _, _) = p;
+ assert_eq!(x, 0);
+ assert_eq!(p.1, 127);
+ assert_eq!(__, 255);
+ }
+```
+
+### Operarea pe structuri
+
+4. 🌟 Puteți face un întreg struct mutabil atunci când îl instanțiați, dar Rust nu ne permite să marchem doar anumite câmpuri ca mutabile.
+
+```rust,editable
+
+// Completați spațiul liber și remediați eroarea fără a adăuga/elimina o nouă linie
+struct Person {
+ name: String,
+ age: u8,
+}
+fn main() {
+ let age = 18;
+ let p = Person {
+ name: String::from("sunface"),
+ age,
+ };
+
+ // Cum poți să crezi că fața solară are doar 18 ani?
+ p.age = 30;
+
+ // Completați spațiul liber
+ __ = String::from("sunfei");
+
+ println!("Success!");
+}
+```
+
+5. 🌟 Folosind *field init sintaxa scurtă* pentru a reduce repetițiile.
+```rust,editable
+
+// Completați spațiul liber
+struct Person {
+ name: String,
+ age: u8,
+}
+fn main() {
+ println!("Success!");
+}
+
+fn build_person(name: String, age: u8) -> Person {
+ Person {
+ age,
+ __
+ }
+}
+```
+
+6. 🌟 Puteți crea instanță dintr-o altă instanță cu *sintaxă de actualizare a structurii*
+```rust,editable
+
+// Completați spațiul liber pentru ca codul să funcționez
+struct User {
+ active: bool,
+ username: String,
+ email: String,
+ sign_in_count: u64,
+}
+fn main() {
+ let u1 = User {
+ email: String::from("someone@example.com"),
+ username: String::from("sunface"),
+ active: true,
+ sign_in_count: 1,
+ };
+
+ let u2 = set_email(u1);
+
+ println!("Success!");
+}
+
+fn set_email(u: User) -> User {
+ User {
+ email: String::from("contact@im.dev"),
+ __
+ }
+}
+```
+
+### Afișați structurile
+7. 🌟🌟 Putem folosi `#[derive(Debug)]` pentru a [face un struct imprimabil](https://doc.rust-lang.org/book/ch05-02-example-structs.html?highlight= %23%5Bderive(Debug)%5D#adding-useful-functionality-with-derived-traits).
+
+```rust,editable
+
+// Completați spațiile libere pentru ca codul să funcționeze
+#[__]
+struct Rectangle {
+ width: u32,
+ height: u32,
+}
+
+fn main() {
+ let scale = 2;
+ let rect1 = Rectangle {
+ width: dbg!(30 * scale), // Imprimați informațiile de depanare în stderr și atribuiți valoarea `30 * scale` la `width`
+ height: 50,
+ };
+
+ dbg!(&rect1); // Imprimă informațiile de depanare în stderr
+
+ println!(__, rect1); // Imprimă informațiile de depanare în stdout
+}
+```
+
+### Mutare parțială
+În cadrul destructurarii unei singure variabile, pot fi utilizate în același timp atât legările de model prin mutare, cât și prin referință. Acest lucru va duce la o mutare parțială a variabilei, ceea ce înseamnă că părți ale variabilei vor fi mutate în timp ce celelalte părți rămân. Într-un astfel de caz, variabila părinte nu poate fi utilizată ulterior ca un întreg, totuși părțile care sunt doar referite (și nu sunt mutate) pot fi încă folosite.
+
+#### Exemplu
+```rust,editable
+
+fn main() {
+ #[derive(Debug)]
+ struct Person {
+ name: String,
+ age: Box,
+ }
+
+ let person = Person {
+ name: String::from("Alice"),
+ age: Box::new(20),
+ };
+
+ // „name” este mutat din persoană, dar se face referire la „age”.
+ let Person { name, ref age } = person;
+
+ println!("The person's age is {}", age);
+
+ println!("The person's name is {}", name);
+
+ // Eroare! împrumut de valoare parțial mutată: se produce mutarea parțială a variabilei „person”.
+ //println!("The person struct is {:?}", person);
+
+ // `person` nu poate fi folosit, dar `person.age` poate fi folosit deoarece nu este mutat
+ println!("The person's age from person struct is {}", person.age);
+}
+```
+
+
+#### Exerciții
+
+8. 🌟🌟
+```rust,editable
+
+// Remediați erorile pentru ca acest cod să funcționeze
+#[derive(Debug)]
+struct File {
+ name: String,
+ data: String,
+}
+fn main() {
+ let f = File {
+ name: String::from("readme.md"),
+ data: "Rust By Practice".to_string()
+ };
+
+ let _name = f.name;
+
+ // modifică NUMAI această linie
+ println!("{}, {}, {:?}",f.name, f.data, f);
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie.
\ No newline at end of file
diff --git a/ro-RO/src/compound-types/tuple.md b/ro-RO/src/compound-types/tuple.md
new file mode 100644
index 000000000..f5fa5f52d
--- /dev/null
+++ b/ro-RO/src/compound-types/tuple.md
@@ -0,0 +1,89 @@
+# Tuplu
+1. 🌟 Elementele dintr-un tuplu pot avea diferite tipuri. Semnătura de tip tuplu este `(T1, T2, ...)`, unde `T1`, `T2` sunt tipurile de membri ai tuplului.
+```rust,editable
+
+fn main() {
+ let _t0: (u8,i16) = (0, -1);
+ // Tuples can be tuple's members
+ let _t1: (u8, (i16, u32)) = (0, (-1, 1));
+ // Fill the blanks to make the code work
+ let t: (u8, __, i64, __, __) = (1u8, 2u16, 3i64, "hello", String::from(", world"));
+
+ println!("Success!");
+}
+```
+
+2. 🌟 Membrii pot fi extrași din tuplu folosind indexare.
+```rust,editable
+
+// Faceți să funcționeze
+fn main() {
+ let t = ("i", "am", "sunface");
+ assert_eq!(t.1, "sunface");
+
+ println!("Success!");
+}
+```
+
+3. 🌟 Tuplurile lungi nu pot fi imprimate
+```rust,editable
+
+// Remediați eroarea
+fn main() {
+ let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
+ println!("too long tuple: {:?}", too_long_tuple);
+}
+```
+
+4. 🌟 Destructurarea tuplului cu model.
+```rust,editable
+
+fn main() {
+ let tup = (1, 6.4, "hello");
+
+ // Completați spațiul liber pentru ca codul să funcționeze
+ let __ = tup;
+
+ assert_eq!(x, 1);
+ assert_eq!(y, "hello");
+ assert_eq!(z, 6.4);
+
+ println!("Success!");
+}
+```
+
+5. 🌟🌟 Destructurați sarcinile.
+```rust,editable
+fn main() {
+ let (x, y, z);
+
+ // Completați spațiul liber
+ __ = (1, 2, 3);
+
+ assert_eq!(x, 3);
+ assert_eq!(y, 1);
+ assert_eq!(z, 2);
+
+ println!("Success!");
+}
+```
+
+6. 🌟🌟 Tuplurile pot fi folosite ca argumente de funcție și valori returnate
+```rust,editable
+
+fn main() {
+ // Completați spațiul liber, aveți nevoie de câteva calcule aici.
+ let (x, y) = sum_multiply(__);
+
+ assert_eq!(x, 5);
+ assert_eq!(y, 6);
+
+ println!("Success!");
+}
+
+fn sum_multiply(nums: (i32, i32)) -> (i32, i32) {
+ (nums.0 + nums.1, nums.0 * nums.1)
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie.
diff --git a/ro-RO/src/crate-module/crate.md b/ro-RO/src/crate-module/crate.md
new file mode 100644
index 000000000..e3a6aa942
--- /dev/null
+++ b/ro-RO/src/crate-module/crate.md
@@ -0,0 +1,109 @@
+# Pachet și ladă (crate)
+Un pachet este un proiect pe care il creăm cu "cargo" (in general). Pachetul conține un fișier 'Cargo.toml'.
+
+1. 🌟 Creați un pachet cu ierarhia de mai jos
+```shell
+.
+├── Cargo.toml
+└── src
+ └── main.rs
+
+1 directory, 2 files
+```
+
+```toml
+# in Cargo.toml
+[package]
+name = "hello-package"
+version = "0.1.0"
+edition = "2021"
+```
+
+> În acest pachet vom lucra pe parcursul întregului capitol!
+
+2. 🌟 Creați un pachet cu ierarhia de mai jos
+```shell
+.
+├── Cargo.toml
+└── src
+ └── lib.rs
+
+1 directory, 2 files
+```
+
+```toml
+# in Cargo.toml
+[package]
+name = "hello-package1"
+version = "0.1.0"
+edition = "2021"
+```
+
+> Acest pachet poate fi șters datorită existenței primului.
+
+3. 🌟
+```rust,editable
+/* Întrebare: */
+
+// Î: Care este diferența dintre cele două pachete?
+// R: __
+```
+
+
+## Crate
+O ladă este un fișier binar sau o bibliotecă. Rădăcina lăzii este un fișier sursă de unde începe compilatorul Rust și formează modulul rădăcină al lăzii.
+
+În pachetul hello-package, există o ladă binară cu același nume ca și pachetul: hello-package, iar src/main.rs este rădăcina lăzii acestei lăzi binare.
+
+Similar cu 'hello-package', 'hello-package1' are, de asemenea, o ladă în el, însă acest pachet nu conține o ladă binară, ci o ladă de bibliotecă, iar src/lib.rs este rădăcina lăzii.
+
+4. 🌟
+```rust,editable
+/* Întrebare: */
+
+// Î: Care este numele lăzii de bibliotecă în pachetul hello-package1?
+// R: __
+```
+
+
+5. 🌟🌟 Adaugă o cutie de bibliotecă pentru 'hello-package' și descrie structura sa de fișiere mai jos:
+```shell,editable
+# COMPLETEAZĂ spațiile libere
+.
+├── Cargo.lock
+├── Cargo.toml
+├── src
+│ ├── __
+│ └── __
+```
+
+După acest pas, în pachetul hello-package ar trebui să existe două cutii: o cutie binară și o cutie de bibliotecă, ambele având același nume ca și pachetul.
+
+6. 🌟🌟🌟 Un pachet poate conține cel mult o cutie de bibliotecă, dar poate conține oricâte cutii binare dorești plasând fișiere în directorul src/bin: fiecare fișier va fi o cutie binară separată cu același nume ca și fișierul.
+
+```shell,editable
+# Creează un pachet care conține
+# 1. trei cutii binare: hello-package, main1 și main2
+# 2. o cutie de bibliotecă
+# descrie structura directorului mai jos
+.
+├── Cargo.toml
+├── Cargo.lock
+├── src
+│ ├── __
+│ ├── __
+│ └── __
+│ └── __
+│ └── __
+├── tests # director pentru fișierele de teste integrate
+│ └── some_integration_tests.rs
+├── benches # director pentru fișierele de referință de performanță
+│ └── simple_bench.rs
+└── examples # director pentru fișierele de exemplu
+ └── simple_example.rs
+```
+
+Așa cum poți observa, structura pachetului de mai sus este foarte standard și este folosită pe scară largă în multe proiecte Rust.
+
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
\ No newline at end of file
diff --git a/ro-RO/src/crate-module/intro.md b/ro-RO/src/crate-module/intro.md
new file mode 100644
index 000000000..5e32401f1
--- /dev/null
+++ b/ro-RO/src/crate-module/intro.md
@@ -0,0 +1,5 @@
+# Crate și Module
+Resurse de învățare:
+- Engleză: [Rust Book Chapter 7](https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html)
+- Chineză simplificată: [Rust语言圣经 - 包和模块](https://course.rs/basic/crate-module/intro.html)
+
diff --git a/ro-RO/src/crate-module/module.md b/ro-RO/src/crate-module/module.md
new file mode 100644
index 000000000..a1a337c27
--- /dev/null
+++ b/ro-RO/src/crate-module/module.md
@@ -0,0 +1,195 @@
+# Module
+Modulele ne permit să organizăm codul într-o cutie în grupuri pentru lizibilitate și ușurință în reutilizare. Modulele controlează, de asemenea, confidențialitatea elementelor, adică dacă un element poate fi văzut de codul extern (public) sau este doar o implementare internă și nu este disponibil pentru codul extern (privat).
+
+
+Am creat un pachet numit hello-package în capitolul anterior și arată așa:
+```shell
+.
+├── Cargo.toml
+├── src
+│ ├── lib.rs
+│ └── main.rs
+```
+
+Acum este momentul să creăm câteva module în cutia de bibliotecă și să le utilizăm în cutia binară, să începem.
+
+1. 🌟🌟 Implementează modulul front_of_house bazat pe arborele de module de mai jos:
+```shell
+library crate root
+ └── front_of_house
+ ├── hosting
+ │ ├── add_to_waitlist
+ │ └── seat_at_table
+ └── serving
+ ├── take_order
+ ├── serve_order
+ ├── take_payment
+ └── complain
+```
+
+```rust,editable
+// COMPLETEAZĂ spațiile libere
+// în __.rs
+
+mod front_of_house {
+ // IMPLEMENTEAZĂ acest modul...
+}
+```
+
+
+2. 🌟🌟 Să apelăm add_to_waitlist dintr-o funcție eat_at_restaurant care se află în rădăcina cutiei de bibliotecă.
+
+```rust,editable
+// În lib.rs
+
+// COMPLETEAZĂ spațiile libere și CORECTEAZĂ erorile
+// Trebuie să faci ceva public cu pub pentru a asigura accesibilitatea pentru codul extern fn eat_at_restaurant()
+mod front_of_house {
+ /* ...snip... */
+}
+
+pub fn eat_at_restaurant() {
+ // Apelează 'add_to_waitlist' cu **cale absolută**:
+ __.add_to_waitlist();
+
+ // Apelează cu **cale relativă**
+ __.add_to_waitlist();
+}
+```
+
+3. 🌟🌟 Poți folosi 'super' pentru a importa elemente în cadrul modulului părinte
+```rust,editable
+// În lib.rs
+
+mod back_of_house {
+ fn fix_incorrect_order() {
+ cook_order();
+ // COMPLETEAZĂ spațiul liber în trei moduri
+ // 1. folosind cuvântul cheie 'super'
+ // 2. folosind calea absolută
+ __.serve_order();
+ }
+
+ fn cook_order() {}
+}
+```
+
+
+### Separarea modulelor în fișiere diferite
+```rust,editable
+// În lib.rs
+pub mod front_of_house {
+ pub mod hosting {
+ pub fn add_to_waitlist() {}
+
+ pub fn seat_at_table() -> String {
+ String::from("sit down please")
+ }
+ }
+
+ pub mod serving {
+ pub fn take_order() {}
+
+ pub fn serve_order() {}
+
+ pub fn take_payment() {}
+
+ // Poate nu vrei ca oaspeții să audă plângerile tale despre ei
+ // Așa că fă-le private
+ fn complain() {}
+ }
+}
+
+pub fn eat_at_restaurant() -> String {
+ front_of_house::hosting::add_to_waitlist();
+
+ back_of_house::cook_order();
+
+ String::from("yummy yummy!")
+}
+
+pub mod back_of_house {
+ pub fn fix_incorrect_order() {
+ cook_order();
+ crate::front_of_house::serving::serve_order();
+ }
+
+ pub fn cook_order() {}
+}
+```
+
+4. 🌟🌟🌟🌟 Te rog să separi modulele și codurile de mai sus în fișiere aflate în arborele de directoare de mai jos:
+```shell
+.
+├── Cargo.toml
+├── src
+│ ├── back_of_house.rs
+│ ├── front_of_house
+│ │ ├── hosting.rs
+│ │ ├── mod.rs
+│ │ └── serving.rs
+│ ├── lib.rs
+│ └── main.rs
+```
+
+```rust,editable
+// În src/lib.rs
+
+// IMPLEMENTEAZĂ...
+```
+
+```rust,editable
+// În src/back_of_house.rs
+
+// IMPLEMENTEAZĂ...
+```
+
+
+```rust,editable
+// În src/front_of_house/mod.rs
+
+// IMPLEMENTEAZĂ...
+```
+
+```rust,editable
+// În src/front_of_house/hosting.rs
+
+// IMPLEMENTEAZĂ...
+```
+
+```rust,editable
+// În src/front_of_house/serving.rs
+
+// IMPLEMENTEAZĂ...
+```
+
+### Accesarea codului în cutia de bibliotecă din cutia binară
+**Te rog să te asiguri că ai finalizat a patra exercițiu înainte de a face progrese suplimentare.**
+
+Ar trebui să ai structurile de mai jos și codurile corespunzătoare în ele când ajungi aici:
+```shell
+.
+├── Cargo.toml
+├── src
+│ ├── back_of_house.rs
+│ ├── front_of_house
+│ │ ├── hosting.rs
+│ │ ├── mod.rs
+│ │ └── serving.rs
+│ ├── lib.rs
+│ └── main.rs
+```
+
+5. 🌟🌟🌟 Acum vom apela câteva funcții de bibliotecă din cutia binară.
+
+```rust,editable
+// În src/main.rs
+
+// COMPLETEAZĂ spațiul liber și CORECTEAZĂ erorile
+fn main() {
+ assert_eq!(__, "sit down please");
+ assert_eq!(__,"yummy yummy!");
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
diff --git a/ro-RO/src/crate-module/use-pub.md b/ro-RO/src/crate-module/use-pub.md
new file mode 100644
index 000000000..391eb8a76
--- /dev/null
+++ b/ro-RO/src/crate-module/use-pub.md
@@ -0,0 +1,69 @@
+# Folosire și publicare
+1. 🌟 Putem aduce două tipuri cu același nume în același domeniu cu 'use', dar avem nevoie de cuvântul cheie 'as'.
+
+```rust,editable
+use std::fmt::Result;
+use std::io::Result;
+
+fn main() {}
+```
+
+2. 🌟🌟 Dacă folosim mai multe elemente definite în aceeași creație sau modul, atunci listarea fiecărui element pe linie proprie va ocupa prea mult spațiu vertical.
+
+```rust,editable
+
+// COMPLETEAZĂ spațiul liber în două moduri
+// NU adăuga linii noi de cod
+use std::collections::__;
+
+fn main() {
+ let _c1:HashMap<&str, i32> = HashMap::new();
+ let mut c2 = BTreeMap::new();
+ c2.insert(1, "a");
+ let _c3: HashSet = HashSet::new();
+}
+```
+
+### Re-exportarea numelor cu 'pub use'
+3. 🌟🌟🌟 În pachetul nostru creat recent, hello-package, adaugă ceva pentru a face codul de mai jos să funcționeze.
+```rust,editable
+fn main() {
+ assert_eq!(hello_package::hosting::seat_at_table(), "sit down please");
+ assert_eq!(hello_package::eat_at_restaurant(),"yummy yummy!");
+}
+```
+
+
+### Pub(in Crate)
+Uneori dorim ca un element să fie public doar pentru o anumită creație. Pentru asta putem folosi sintaxa pub(in Crate).
+
+#### Exemplu
+```rust,editable
+pub mod a {
+ pub const I: i32 = 3;
+
+ fn semisecret(x: i32) -> i32 {
+ use self::b::c::J;
+ x + J
+ }
+
+ pub fn bar(z: i32) -> i32 {
+ semisecret(I) * z
+ }
+ pub fn foo(y: i32) -> i32 {
+ semisecret(I) + y
+ }
+
+ mod b {
+ pub(in crate::a) mod c {
+ pub(in crate::a) const J: i32 = 4;
+ }
+ }
+}
+```
+
+### Cod Complet
+Codul complet al hello-package se află [aici](https://github.com/sunface/rust-by-practice/tree/master/practices/hello-package).
+
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
\ No newline at end of file
diff --git a/ro-RO/src/elegant-code-base.md b/ro-RO/src/elegant-code-base.md
new file mode 100644
index 000000000..3384ff752
--- /dev/null
+++ b/ro-RO/src/elegant-code-base.md
@@ -0,0 +1,48 @@
+# Small projects with Elegant code base
+Following questions come up weekly in online Rust discussions:
+
+- I just finished reading The Book, what should I do next ?
+- What projects would you recommend to a Rust beginner?
+- Looking for small projects with an elegant code base
+- Codes that is easy to read and learn
+
+The answers to these questions are always **Practice**: doing some exercises, and then reading some small and excellent Rust projects.
+
+This is precisely the goal of this book, so, collecting relative resourses and representing in _Rust By Practice_ seems not a bad idea.
+
+### 1. Ripgrep
+
+Answers for above questions usually came with [`ripgrep`](https://github.com/BurntSushi/ripgrep), though I don't think it is a **small** project, but yes, go for it if you are not afraid to delve deep a bit.
+
+### 2. Building a text editor
+Tutorial [`https://www.flenker.blog/hecto/`](https://www.flenker.blog/hecto/) will lead you to build a text editor from scratch.
+
+### 3. Ncspot
+[Ncspot](https://github.com/hrkfdn/ncspot), a terminal Spotify client. Small, simple, well organized and async, it's good for learning.
+
+### 4. Command Line Rust
+[This project](https://github.com/kyclark/command-line-rust) is for the book `Command-Line Rust(O'Reily)`, it will show you how to write small CLIs (clones of `head`, `cat`, `ls`).
+
+### 5. pngme book
+[This book](https://picklenerd.github.io/pngme_book/) will guide you to make a command line program that lets you hide secret messages in PNG files. The primary goal here is to get you writing code. The secondary goal is to get you reading documentation.
+
+### 6. Writing an OS in Rust
+
+[This blog series](https://os.phil-opp.com) creates a small operating system in the Rust programming language. Each post is a small tutorial and includes all needed code, so you can follow along if you like. The source code is also available in the corresponding [Github repository](https://github.com/phil-opp/blog_os).
+
+
+### 7. CodeCrafters.io: Build your own Git, Docker, SQLite, or Redis
+
+On [CodeCrafters](https://codecrafters.io/for/rust), you can recreate your favorite developer tools from scratch. It's a hands-on, minimally-guided approach to master Rust, while appreciating the internals and documentation of popular technology that we use every day.
+
+### 8. mini-redis
+[mini-redis](https://github.com/tokio-rs/mini-redis) is an incomplete Redis client and server implementation using tokio, it has decent code base and detail explanations, very suitable for learning Rust and asynchronous programming.
+
+### 9. Writing Interpreters in Rust
+
+[This online book](https://github.com/rust-hosted-langs/book) will walk through the basics of interpreted language implementation in Rust with a focus on the challenges that are specific to using Rust.
+
+---
+
+
+**To be continued...**
diff --git a/ro-RO/src/errors.md b/ro-RO/src/errors.md
new file mode 100644
index 000000000..165d08c36
--- /dev/null
+++ b/ro-RO/src/errors.md
@@ -0,0 +1 @@
+# Errors
diff --git a/ro-RO/src/fight-compiler/borrowing.md b/ro-RO/src/fight-compiler/borrowing.md
new file mode 100644
index 000000000..a9306f5ea
--- /dev/null
+++ b/ro-RO/src/fight-compiler/borrowing.md
@@ -0,0 +1,30 @@
+# Împrumut (Borrowing)
+
+1. 🌟🌟
+```rust,editable
+// REZOLVĂ eroarea fără a elimina nicio linie de cod:
+struct test {
+ list: Vec,
+ a: i32
+}
+
+impl test {
+ pub fn new() -> Self {
+ test { list:vec![1,2,3,4,5,6,7], a:0 }
+ }
+
+ pub fn run(&mut self) {
+ for i in self.list.iter() {
+ self.do_something(*i)
+ }
+
+ }
+
+ pub fn do_something(&mut self, n: i32) {
+ self.a = n;
+ }
+}
+
+fn main() {}
+```
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
diff --git a/ro-RO/src/fight-compiler/intro.md b/ro-RO/src/fight-compiler/intro.md
new file mode 100644
index 000000000..f414cbab3
--- /dev/null
+++ b/ro-RO/src/fight-compiler/intro.md
@@ -0,0 +1,4 @@
+# Lupta cu Compilatorul
+Lupta cu compilatorul este foarte obișnuită în programarea noastră zilnică, în special pentru cei care nu sunt familiarizați cu limbajul Rust.
+
+Acest capitol va oferi câteva exerciții pentru a ne ajuta să evităm astfel de situații și să reducem curbura de învățare abruptă.
\ No newline at end of file
diff --git a/ro-RO/src/flow-control.md b/ro-RO/src/flow-control.md
new file mode 100644
index 000000000..a24961007
--- /dev/null
+++ b/ro-RO/src/flow-control.md
@@ -0,0 +1,259 @@
+# Flow control
+
+### If/else
+1. 🌟
+```rust,editable
+
+// Fill in the blanks
+fn main() {
+ let n = 5;
+
+ if n < 0 {
+ println!("{} is negative", n);
+ } __ n > 0 {
+ println!("{} is positive", n);
+ } __ {
+ println!("{} is zero", n);
+ }
+}
+```
+
+2. 🌟🌟 `If/else` expression can be used in assignments.
+```rust,editable
+
+// Fix the errors
+fn main() {
+ let n = 5;
+
+ let big_n =
+ if n < 10 && n > -10 {
+ println!(", and is a small number, increase ten-fold");
+
+ 10 * n
+ } else {
+ println!(", and is a big number, halve the number");
+
+ n / 2.0 ;
+ }
+
+ println!("{} -> {}", n, big_n);
+}
+```
+
+### For
+3. 🌟 The `for in` construct can be used to iterate through an Iterator, e.g a range `a..b`.
+
+```rust,editable
+
+fn main() {
+ for n in 1..=100 { // modify this line to make the code work
+ if n == 100 {
+ panic!("NEVER LET THIS RUN")
+ }
+ }
+
+ println!("Success!");
+}
+```
+
+
+4. 🌟🌟
+```rust,editable
+
+// Fix the errors without adding or removing lines
+fn main() {
+ let names = [String::from("liming"),String::from("hanmeimei")];
+ for name in names {
+ // Do something with name...
+ }
+
+ println!("{:?}", names);
+
+ let numbers = [1, 2, 3];
+ // The elements in numbers are Copy，so there is no move here
+ for n in numbers {
+ // Do something with n...
+ }
+
+ println!("{:?}", numbers);
+}
+```
+
+5. 🌟
+```rust,editable
+fn main() {
+ let a = [4, 3, 2, 1];
+
+ // Iterate the indexing and value in 'a'
+ for (i,v) in a.__ {
+ println!("The {}th element is {}",i+1,v);
+ }
+}
+```
+
+### While
+6. 🌟🌟 The `while` keyword can be used to run a loop when a condition is true.
+
+```rust,editable
+
+// Fill in the blanks to make the last println! work !
+fn main() {
+ // A counter variable
+ let mut n = 1;
+
+ // Loop while the condition is true
+ while n __ 10 {
+ if n % 15 == 0 {
+ println!("fizzbuzz");
+ } else if n % 3 == 0 {
+ println!("fizz");
+ } else if n % 5 == 0 {
+ println!("buzz");
+ } else {
+ println!("{}", n);
+ }
+
+
+ __;
+ }
+
+ println!("n reached {}, so loop is over",n);
+}
+```
+
+### Continue and break
+7. 🌟 Use `break` to break the loop.
+```rust,editable
+
+// Fill in the blank
+fn main() {
+ let mut n = 0;
+ for i in 0..=100 {
+ if n == 66 {
+ __
+ }
+ n += 1;
+ }
+
+ assert_eq!(n, 66);
+
+ println!("Success!");
+}
+```
+
+8. 🌟🌟 `continue` will skip over the remaining code in current iteration and go to the next iteration.
+```rust,editable
+
+// Fill in the blanks
+fn main() {
+ let mut n = 0;
+ for i in 0..=100 {
+ if n != 66 {
+ n+=1;
+ __;
+ }
+
+ __
+ }
+
+ assert_eq!(n, 66);
+
+ println!("Success!");
+}
+```
+
+### Loop
+
+9. 🌟🌟 Loop is usually used together with `break` or `continue`.
+
+```rust,editable
+
+// Fill in the blanks
+fn main() {
+ let mut count = 0u32;
+
+ println!("Let's count until infinity!");
+
+ // Infinite loop
+ loop {
+ count += 1;
+
+ if count == 3 {
+ println!("three");
+
+ // Skip the rest of this iteration
+ __;
+ }
+
+ println!("{}", count);
+
+ if count == 5 {
+ println!("OK, that's enough");
+
+ __;
+ }
+ }
+
+ assert_eq!(count, 5);
+
+ println!("Success!");
+}
+```
+
+10. 🌟🌟 Loop is an expression, so we can use it with `break` to return a value
+```rust,editable
+
+// Fill in the blank
+fn main() {
+ let mut counter = 0;
+
+ let result = loop {
+ counter += 1;
+
+ if counter == 10 {
+ __;
+ }
+ };
+
+ assert_eq!(result, 20);
+
+ println!("Success!");
+}
+```
+
+11. 🌟🌟🌟 It's possible to break or continue outer loops when dealing with nested loops. In these cases, the loops must be annotated with some 'label, and the label must be passed to the break/continue statement.
+
+```rust,editable
+
+// Fill in the blank
+fn main() {
+ let mut count = 0;
+ 'outer: loop {
+ 'inner1: loop {
+ if count >= 20 {
+ // This would break only the inner1 loop
+ break 'inner1; // `break` is also works.
+ }
+ count += 2;
+ }
+
+ count += 5;
+
+ 'inner2: loop {
+ if count >= 30 {
+ // This breaks the outer loop
+ break 'outer;
+ }
+
+ // This will continue the outer loop
+ continue 'outer;
+ }
+ }
+
+ assert!(count == __);
+
+ println!("Success!");
+}
+```
+
+> You can find the solutions [here](https://github.com/sunface/rust-by-practice)(under the solutions path), but only use it when you need it
\ No newline at end of file
diff --git a/ro-RO/src/formatted-output/debug-display.md b/ro-RO/src/formatted-output/debug-display.md
new file mode 100644
index 000000000..32e317d37
--- /dev/null
+++ b/ro-RO/src/formatted-output/debug-display.md
@@ -0,0 +1,156 @@
+# Debug și Display
+
+Toate tipurile care doresc să fie afișate trebuie să implementeze trăsătura de formatare `std::fmt`: `std::fmt::Debug` sau `std::fmt::Display`.
+
+Implementările automate sunt furnizate doar pentru tipuri precum cele din biblioteca `std`. Celelalte trebuie implementate manual.
+
+## Debug
+Implementarea `Debug` este foarte simplă: Toate tipurile pot deriva implementarea `std::fmt::Debug`. Aceasta nu este valabilă pentru `std::fmt::Display`, care trebuie implementată manual.
+
+`{:?}` trebuie folosit pentru a afișa tipul care a implementat trăsătura `Debug`.
+
+```rust
+// Această structură nu poate fi tipărită nici cu `fmt::Display` nici cu
+// `fmt::Debug`.
+struct UnPrintable(i32);
+
+// Pentru a face această structură imprimabilă cu `fmt::Debug`, putem deriva implementările automate furnizate de Rust
+#[derive(Debug)]
+struct DebugPrintable(i32);
+```
+
+1. 🌟
+```rust,editable
+
+/* Completați spațiile libere și remediați erorile */
+struct Structure(i32);
+
+fn main() {
+ // Tipurile din std și Rust au implementată trăsătura fmt::Debug
+ println!("__ months in a year.", 12);
+
+ println!("Now __ will print!", Structure(3));
+}
+```
+
+2. 🌟🌟 Deci, fmt::Debug cu siguranță face un tip imprimabil, dar sacrifică puțină eleganță. Poate putem obține ceva mai elegant înlocuind {:?} cu altceva (dar nu și {}!)
+```rust,editable
+#[derive(Debug)]
+struct Person {
+ name: String,
+ age: u8
+}
+
+fn main() {
+ let person = Person { name: "Sunface".to_string(), age: 18 };
+
+ /* Faceți să afișeze:
+ Person {
+ name: "Sunface",
+ age: 18,
+ }
+ */
+ println!("{:?}", person);
+}
+```
+
+3. 🌟🌟 Putem implementa și manual trăsătura Debug pentru tipurile noastre
+```rust,editable
+
+#[derive(Debug)]
+struct Structure(i32);
+
+#[derive(Debug)]
+struct Deep(Structure);
+
+
+fn main() {
+ // Problema cu `derive` este că nu există control asupra modului
+ // în care arată rezultatele. Ce se întâmplă dacă vreau să afișez doar un `7`?
+
+ /* Faceți să afișeze: Acum 7 va fi tipărit! */
+ println!("Now {:?} will print!", Deep(Structure(7)));
+}
+```
+
+## Display
+Da, Debug este simplu și ușor de folosit. Dar uneori vrem să personalizăm aspectul de ieșire al tipului nostru. Aici intervine Display.
+
+Spre deosebire de Debug, nu există nici o modalitate de a deriva implementarea trăsăturii Display, trebuie să o implementăm manual.
+
+Un alt lucru de remarcat: locul de substituire pentru Display este {}, nu {:?}.
+
+4. 🌟🌟
+```rust,editable
+
+/* Faceți să funcționeze*/
+use std::fmt;
+
+struct Point2D {
+ x: f64,
+ y: f64,
+}
+
+impl fmt::Display for Point2D {
+ /* Implementați.. */
+}
+
+impl fmt::Debug for Point2D {
+ /* Implementați.. */
+}
+
+fn main() {
+ let point = Point2D { x: 3.3, y: 7.2 };
+ assert_eq!(format!("{}",point), "Display: 3.3 + 7.2i");
+ assert_eq!(format!("{:?}",point), "Debug: Complex { real: 3.3, imag: 7.2 }");
+
+ println!("Success!");
+}
+```
+
+
+### Operatorul '?'
+
+Implementarea 'fmt::Display' pentru o structură a cărei elemente trebuie gestionate separat este dificilă. Problema este că fiecare 'write!' generează un 'fmt::Result' care trebuie gestionat în același loc.
+
+În mod fericit, Rust oferă operatorul '?' pentru a ne ajuta să eliminăm unele coduri inutile pentru tratarea rezultatului 'fmt::Result.'
+
+5. 🌟🌟
+```rust,editable
+
+/* Faceți să funcționeze */
+use std::fmt;
+
+struct List(Vec);
+
+impl fmt::Display for List {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ // Extrageți valoarea folosind indexarea tuplului,
+ // și creați o referință la `vec`.
+ let vec = &self.0;
+
+ write!(f, "[")?;
+
+ // Iterați peste `v` în `vec` în timp ce enumerați iterația
+ // numărul în `count`.
+ for (count, v) in vec.iter().enumerate() {
+ // Pentru fiecare element în afară de primul, adăugați o virgulă.
+ // Utilizați operatorul ? pentru a reveni la erori.
+ if count != 0 { write!(f, ", ")?; }
+ write!(f, "{}", v)?;
+ }
+
+ // Închideți paranteza deschisă și returnați o valoare fmt::Result.
+ write!(f, "]")
+ }
+}
+
+fn main() {
+ let v = List(vec![1, 2, 3]);
+ assert_eq!(format!("{}",v), "[0: 1, 1: 2, 2: 3]");
+ println!("Success!");
+}
+```
+
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
diff --git a/ro-RO/src/formatted-output/formatting.md b/ro-RO/src/formatted-output/formatting.md
new file mode 100644
index 000000000..2832381f0
--- /dev/null
+++ b/ro-RO/src/formatted-output/formatting.md
@@ -0,0 +1,184 @@
+# Formatare
+
+## Argumente poziționale
+
+1.🌟🌟
+```rust,editable
+/* Completați spațiile libere */
+fn main() {
+ println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob"); // => Alice, this is Bob. Bob, this is Alice
+ assert_eq!(format!("{1}{0}", 1, 2), __);
+ assert_eq!(format!(__, 1, 2), "2112");
+ println!("Success!");
+}
+```
+
+## Argumente numite
+
+2.🌟🌟
+```rust,editable
+fn main() {
+ println!("{argument}", argument = "test"); // => "test"
+
+ /* Completați spațiile libere */
+ assert_eq!(format!("{name}{}", 1, __), "21");
+ assert_eq!(format!(__,a = "a", b = 'b', c = 3 ), "a 3 b");
+
+ /* Remediați eroarea */
+ // Argumentul numit trebuie plasat după celelalte argumente
+ println!("{abc} {1}", abc = "def", 2);
+
+ println!("Success!");
+}
+```
+
+## Umplerea cu spații a șirului (Padding cu string-uri)
+
+3.🌟🌟 În mod implicit, puteți umple șirul cu spații
+```rust,editable
+fn main() {
+ // Următoarele două umplu cu 5 spații
+ println!("Hello {:5}!", "x"); // => "Hello x !"
+ println!("Hello {:1$}!", "x", 5); // => "Hello x !"
+
+ /* Completați spațiile libere */
+ assert_eq!(format!("Hello __!", 5, "x"), "Hello x !");
+ assert_eq!(format!("Hello __!", "x", width = 5), "Hello x !");
+
+ println!("Success!");
+}
+```
+
+4.🌟🌟🌟 Aliniere la stânga, dreapta, umplere cu caractere specificate.
+```rust,editable
+fn main() {
+ // Aliniere la stânga
+ println!("Hello {:<5}!", "x"); // => Hello x !
+ // Aliniere la dreapta
+ assert_eq!(format!("Hello __!", "x"), "Hello x!");
+ // Aliniere la centru
+ assert_eq!(format!("Hello __!", "x"), "Hello x !");
+
+ // Aliniere la stânga, umplere cu '&'
+ assert_eq!(format!("Hello {:&<5}!", "x"), __);
+
+ println!("Success!");
+}
+```
+
+5.🌟🌟 Puteți umple numerele cu zerouri suplimentare.
+```rust,editable
+fn main() {
+ println!("Hello {:5}!", 5); // => Hello 5!
+ println!("Hello {:+}!", 5); // => Hello +5!
+ println!("Hello {:05}!", 5); // => Hello 00005!
+ println!("Hello {:05}!", -5); // => Hello -0005!
+
+ /* Completați spațiile libere */
+ assert!(format!("{number:0>width$}", number=1, width=6) == __);
+
+ println!("Success!")
+;}
+```
+
+## Precizie
+6.🌟🌟 Precizie pentru virgulă mobilă
+```rust,editable
+
+/* Completați spațiile libere */
+fn main() {
+ let v = 3.1415926;
+
+ println!("{:.1$}", v, 4); // same as {:.4} => 3.1416
+
+ assert_eq!(format!("__", v), "3.14");
+ assert_eq!(format!("__", v), "+3.14");
+ assert_eq!(format!("__", v), "3");
+
+ println!("Success!");
+}
+```
+
+7.🌟🌟🌟 Lungimea șirului
+```rust,editable
+fn main() {
+ let s = "Hello, world!";
+
+ println!("{0:.5}", s); // => Hello
+
+ assert_eq!(format!("Hello __!", 3, "abcdefg"), "Hello abc!");
+
+ println!("Success!");
+}
+```
+
+## Binare, octale, hexazecimale
+
+- format!("{}", foo) -> "3735928559"
+- format!("0x{:X}", foo) -> "0xDEADBEEF"
+- format!("0o{:o}", foo) -> "0o33653337357"
+
+8.🌟🌟
+```rust,editable
+fn main() {
+ assert_eq!(format!("__", 27), "0b11011");
+ assert_eq!(format!("__", 27), "0o33");
+ assert_eq!(format!("__", 27), "0x1b");
+ assert_eq!(format!("__", 27), "0x1B");
+
+ println!("{:x}!", 27); // Hex fără prefix => 1b
+
+ println!("{:#010b}", 27); // Padding binar cu 0, lățime = 10, => 0b00011011
+
+ println!("Success!");
+}
+```
+
+## Capturarea mediului
+9.🌟🌟🌟
+```rust,editable
+fn get_person() -> String {
+ String::from("sunface")
+}
+
+fn get_format() -> (usize, usize) {
+ (4, 1)
+}
+
+
+fn main() {
+ let person = get_person();
+ println!("Hello, {person}!");
+
+ let (width, precision) = get_format();
+ let scores = [("sunface", 99.12), ("jack", 60.34)];
+ /* Faceți-l să afișeze:
+ sunface: 99.1
+ jack: 60.3
+ */
+ for (name, score) in scores {
+ println!("{name}: __");
+ }
+}
+```
+
+
+## Altele
+
+**Exemplu**
+```rust,editable
+fn main() {
+ // Exponent
+ println!("{:2e}", 1000000000); // => 1e9
+ println!("{:2E}", 1000000000); // => 1E9
+
+ // Adresa pointerului
+ let v= vec![1, 2, 3];
+ println!("{:p}", v.as_ptr()); // => 0x600002324050
+
+ // Escape
+ println!("Hello {{}}"); // => Hello {}
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
diff --git a/ro-RO/src/formatted-output/intro.md b/ro-RO/src/formatted-output/intro.md
new file mode 100644
index 000000000..8b530e7d7
--- /dev/null
+++ b/ro-RO/src/formatted-output/intro.md
@@ -0,0 +1,63 @@
+# Formatarea ieșirilor
+
+```rust,editable,ignore,mdbook-runnable
+fn main() {
+ // În general, `{}` va fi înlocuit automat cu orice argumente.
+ // Acestea vor fi transformate în șiruri de caractere.
+ println!("{} days", 31);
+
+ // Fără un sufix, 31 devine un i32. Puteți schimba tipul lui 31
+ // furnizând un sufix. Numărul 31i64, de exemplu, are tipul i64.
+
+ // Există diverse modele opționale cu care acest lucru funcționează.
+ // Pot fi utilizate argumente poziționale.
+ println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob");
+
+ // La fel de bine pot fi folosite argumente denumite.
+ println!("{subject} {verb} {object}",
+ object="the lazy dog",
+ subject="the quick brown fox",
+ verb="jumps over");
+
+ // Se pot specifica formate speciale după un `:`.
+ println!("{} of {:b} people know binary, the other half doesn't", 1, 2);
+
+ // Se poate alinia textul la dreapta cu o lățime specificată.
+ // Acesta va afișa " 1". 5 spații albe și un "1".
+ println!("{number:>width$}", number=1, width=6);
+
+ // Se pot adăuga zerouri suplimentare la numere.
+ // Acesta va afișa "000001".
+ println!("{number:0>width$}", number=1, width=6);
+
+ // Rust se asigură chiar și că se folosește numărul corect de argumente.
+ println!("My name is {0}, {1} {0}", "Bond");
+ // FIXME ^ Adăugați argumentul lipsă: "James"
+
+ // Creați o structură numită `Structure` care conține un `i32`.
+ #[allow(dead_code)]
+ struct Structure(i32);
+
+ // Cu toate acestea, tipurile personalizate, cum ar fi această structură, necesită manipulări mai complicate.
+ // Acest lucru nu va funcționa.
+ println!("This struct `{}` won't print...", Structure(3));
+ // FIXME ^ Comentați această linie.
+
+ // Începând cu Rust 1.58 și mai sus, puteți captura direct argumentul din
+ // variabila înconjurătoare. La fel ca în exemplul de mai sus, acesta va afișa
+ // " 1". 5 spații albe și un "1".
+ let number: f64 = 1.0;
+ let width: usize = 6;
+ println!("{number:>width$}");
+}
+```
+
+[std::fmt][fmt] conține multe [traits][traits] care guvernează afișarea
+textului. Forma de bază a două dintre cele mai importante este prezentată mai jos:
+
+* fmt::Debug: Utilizează marcajul {:?}. Formatează textul în scopuri de depanare.
+* fmt::Display: Utilizează marcajul {}. Formatează textul într-un mod mai elegant și prietenos pentru utilizator.
+
+Aici, am folosit fmt::Display deoarece biblioteca standard oferă implementări pentru aceste tipuri. Pentru a tipări text pentru tipuri personalizate, sunt necesari mai mulți pași.
+
+Implementarea trait-ului fmt::Display implementează automat trait-ul [ToString], care ne permite să [convertim] tipul în [String][string].
diff --git a/ro-RO/src/formatted-output/println.md b/ro-RO/src/formatted-output/println.md
new file mode 100644
index 000000000..a19a8b590
--- /dev/null
+++ b/ro-RO/src/formatted-output/println.md
@@ -0,0 +1,40 @@
+# 'println!' și 'format!'
+Afișarea este gestionată de o serie de ['macro-uri'][macros] definite în ['std::fmt'][fmt],
+Printre acestea se numără:
+
+* format!: scrie text formatat într-un [String][string]
+* print!: la fel ca format!, dar textul este tipărit pe consolă (io::stdout).
+* println!: la fel ca print!, dar se adaugă o linie nouă.
+* eprint!: la fel ca format!, dar textul este tipărit pe eroarea standard (io::stderr).
+* eprintln!: la fel ca eprint!, dar se adaugă o linie nouă.
+
+Toate parsează textul în același mod. În plus, Rust verifică corectitudinea formatului la momentul compilării.
+
+## `format!`
+1.🌟
+```rust,editable
+
+fn main() {
+ let s1 = "hello";
+ /* Completează spațiul liber */
+ let s = format!(__);
+ assert_eq!(s, "hello, world!");
+}
+```
+
+## `print!`, `println!`
+2.🌟
+```rust,editable
+
+fn main() {
+ /* Completați spațiile libere pentru a afișa:
+ Hello world, I am
+ Sunface!
+ */
+ __("hello world, ");
+ __("I am");
+ __("Sunface!");
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
diff --git a/ro-RO/src/functional-programing/closure.md b/ro-RO/src/functional-programing/closure.md
new file mode 100644
index 000000000..0e6a3d204
--- /dev/null
+++ b/ro-RO/src/functional-programing/closure.md
@@ -0,0 +1,437 @@
+# Closure
+Închideri (Closures) pot captura mediile înconjurate. De exemplu, putem captura variabila 'x':
+```rust
+fn main() {
+ let x = 1;
+ let closure = |val| val + x;
+ assert_eq!(closure(2), 3);
+}
+```
+
+Din sintaxă, putem observa că închiderile sunt foarte convenabile pentru utilizarea pe loc. Spre deosebire de funcții, atât tipurile de intrare, cât și cele de ieșire ale unei închideri pot fi inferate de compilator.
+
+```rust
+fn main() {
+ // Incrementare prin închideri și funcții.
+ fn function(i: i32) -> i32 { i + 1 }
+
+ // Închiderile sunt anonime, aici le legăm la referințe
+ //
+ // Aceste funcții fără nume sunt atribuite unor variabile cu denumiri corespunzătoare.
+ let closure_annotated = |i: i32| -> i32 { i + 1 };
+ let closure_inferred = |i | i + 1 ;
+
+ let i = 1;
+ // Apelăm funcția și închiderile.
+ println!("function: {}", function(i));
+ println!("closure_annotated: {}", closure_annotated(i));
+ println!("closure_inferred: {}", closure_inferred(i));
+
+ // O închidere care nu primește argumente și returnează un `i32`.
+ // Tipul de returnare este inferat.
+ let one = || 1;
+ println!("closure returning one: {}", one());
+
+}
+```
+
+## Capturarea
+Închiderile pot captura variabile prin împrumut sau mutare. Dar ele preferă să captureze prin împrumut și să treacă la mutare doar când este necesar:
+
+- Prin referință: '&T'
+- Prin referință mutabilă: '&mut T'
+- Prin valoare: 'T'
+
+
+1. 🌟
+
+```rust,editable
+/* Faceți să funcționeze cu cel mai mic număr de modificări posibile */
+fn main() {
+ let color = String::from("green");
+
+ let print = move || println!("`color`: {}", color);
+
+ print();
+ print();
+
+ // `color` poate fi împrumutat imutabil din nou, deoarece închiderea deține doar
+ // o referință imutabilă la `color`.
+ let _reborrow = &color;
+
+ println!("{}",color);
+}
+```
+
+
+2. 🌟🌟
+
+```rust,editable
+/* Faceți să funcționeze
+- Nu utilizați `_reborrow` și `_count_reborrowed`
+- Nu modificați `assert_eq`
+*/
+fn main() {
+ let mut count = 0;
+
+ let mut inc = || {
+ count += 1;
+ println!("`count`: {}", count);
+ };
+
+ inc();
+
+
+ let _reborrow = &count;
+
+ inc();
+
+ // Închiderea nu mai are nevoie să împrumute `&mut count`. Prin urmare, este
+ // posibil să se facă un împrumut din nou fără eroare
+ let _count_reborrowed = &mut count;
+
+ assert_eq!(count, 0);
+}
+```
+
+
+3. 🌟🌟
+
+```rust,editable
+/* Faceți să funcționeze în două moduri, niciunul dintre ele nu
+este să eliminați `take(movable)` din cod */
+fn main() {
+ let movable = Box::new(3);
+
+ let consume = || {
+ println!("`movable`: {:?}", movable);
+ take(movable);
+ };
+
+ consume();
+ consume();
+}
+
+fn take(_v: T) {}
+```
+
+În comparație, următorul cod nu are eroare:
+```rust
+fn main() {
+ let movable = Box::new(3);
+
+ let consume = move || {
+ println!("`movable`: {:?}", movable);
+ };
+
+ consume();
+ consume();
+}
+```
+
+## Tipul inferat
+Următoarele patru închideri nu au diferențe în tipurile de intrare și ieșire.
+
+```rust
+fn add_one_v1 (x: u32) -> u32 { x + 1 }
+let add_one_v2 = |x: u32| -> u32 { x + 1 };
+let add_one_v3 = |x| { x + 1 };
+let add_one_v4 = |x| x + 1 ;
+```
+
+
+4. 🌟
+
+```rust,editable
+fn main() {
+ let example_closure = |x| x;
+
+ let s = example_closure(String::from("hello"));
+
+ /* Faceți să funcționeze, schimbând doar următoarea linie */
+ let n = example_closure(5);
+}
+```
+
+## Fn, FnMut, FnOnce
+Atunci când se preia o închidere ca parametru de intrare, tipul complet al închiderii trebuie să fie adnotat folosind una dintre următoarele trăsături:
+
+- Fn: închiderea folosește valoarea capturată prin referință (&T)
+- FnMut: închiderea folosește valoarea capturată prin referință mutabilă (&mut T)
+- FnOnce: închiderea folosește valoarea capturată prin valoare (T)
+
+
+5. 🌟🌟
+
+```rust,editable
+/* Faceți să funcționeze schimbând bound-ul trăsăturii, în două feluri*/
+fn fn_once(func: F)
+where
+ F: FnOnce(usize) -> bool,
+{
+ println!("{}", func(3));
+ println!("{}", func(4));
+}
+
+fn main() {
+ let x = vec![1, 2, 3];
+ fn_once(|z|{z == x.len()})
+}
+```
+
+6. 🌟🌟
+```rust,editable
+fn main() {
+ let mut s = String::new();
+
+ let update_string = |str| s.push_str(str);
+
+ exec(update_string);
+
+ println!("{:?}",s);
+}
+
+/* Completați spațiile libere */
+fn exec<'a, F: __>(mut f: F) {
+ f("hello")
+}
+```
+
+#### Pe care trăsătură preferă compilatorul să o folosească?
+- Fn: închiderea folosește valoarea capturată prin referință (&T)
+- FnMut: închiderea folosește valoarea capturată prin referință mutabilă (&mut T)
+- FnOnce: închiderea folosește valoarea capturată prin valoare (T)
+
+În mod individual pentru fiecare variabilă, compilatorul va captura variabilele în cel mai puțin restrictiv mod posibil.
+
+De exemplu, să luăm în considerare un parametru notat ca FnOnce. Acest lucru specifică că închiderea poate captura prin '&T', '&mut T' sau 'T', dar compilatorul va alege în funcție de modul în care variabilele capturate sunt utilizate în închidere.
+Trăsătura de utilizare este determinată de ceea ce face închiderea cu valorile capturate.
+
+Acest lucru se întâmplă pentru că dacă o mutare este posibilă, atunci orice tip de împrumut ar trebui să fie, de asemenea, posibil. Observați că inversul nu este adevărat. Dacă parametrul este notat ca Fn, atunci capturarea variabilelor prin '&mut T' sau 'T' nu este permisă.
+
+
+7. 🌟🌟
+
+```rust,editable
+/* Completați spațiile libere */
+
+// O funcție care primește o închidere ca argument și o apelează.
+// indică faptul că F este un "Parametru de tip generic"
+fn apply(f: F) where
+ // Închiderea nu primește niciun argument și nu returnează nimic.
+ F: __ {
+
+ f();
+}
+
+// O funcție care primește o închidere și returnează un `i32`.
+fn apply_to_3(f: F) -> i32 where
+ // Închiderea primește un `i32` și returnează un `i32`.
+ F: Fn(i32) -> i32 {
+
+ f(3)
+}
+
+fn main() {
+ use std::mem;
+
+ let greeting = "hello";
+ // Un tip care nu se copiază.
+ // `to_owned` creează date deținute din cele împrumutate
+ let mut farewell = "goodbye".to_owned();
+
+ // Capturăm 2 variabile: `greeting` prin referință și
+ // `farewell` prin valoare.
+ let diary = || {
+ // `greeting` este prin referință: necesită `Fn`.
+ println!("I said {}.", greeting);
+
+ // Mutarea forțează `farewell` să fie capturat
+ // prin referință mutabilă. Acum necesită `FnMut`.
+ farewell.push_str("!!!");
+ println!("Then I screamed {}.", farewell);
+ println!("Now I can sleep. zzzzz");
+
+ // Apelăm manual drop pentru a forța `farewell` să fie
+ // capturat prin valoare. Acum necesită `FnOnce`.
+ mem::drop(farewell);
+ };
+
+ // Apelăm funcția care aplică închiderea.
+ apply(diary);
+
+ // `double` satisface condiția de trăsătură a lui `apply_to_3`
+ let double = |x| 2 * x;
+
+ println!("3 doubled: {}", apply_to_3(double));
+}
+```
+
+Închiderile care mută pot implementa în continuare 'Fn' sau 'FnMut', chiar dacă capturează variabile prin mutare. Acest lucru se datorează faptului că trăsăturile implementate de un tip de închidere sunt determinate de ceea ce face închiderea cu valorile capturate, nu cum le capturează. Cuvântul cheie 'move' specifică doar ultimul aspect.
+
+```rust
+fn main() {
+ let s = String::new();
+
+ let update_string = move || println!("{}",s);
+
+ exec(update_string);
+}
+
+fn exec(f: F) {
+ f()
+}
+```
+
+Următorul cod nu are nicio eroare:
+```rust
+fn main() {
+ let s = String::new();
+
+ let update_string = move || println!("{}",s);
+
+ exec(update_string);
+}
+
+fn exec(f: F) {
+ f()
+}
+```
+
+
+8. 🌟🌟
+
+```rust,editable
+/* Completați spațiile libere */
+fn main() {
+ let mut s = String::new();
+
+ let update_string = |str| -> String {s.push_str(str); s };
+
+ exec(update_string);
+}
+
+fn exec<'a, F: __>(mut f: F) {
+ f("hello");
+}
+```
+
+
+## Funcții de intrare
+Deoarece închiderile pot fi utilizate ca argumente, poate vă întrebați dacă putem utiliza și funcții ca argumente? Și cu siguranță că putem.
+
+
+9. 🌟🌟
+
+```rust,editable
+
+/* Implementați `call_me` pentru a funcționa */
+fn call_me {
+ f();
+}
+
+fn function() {
+ println!("I'm a function!");
+}
+
+fn main() {
+ let closure = || println!("I'm a closure!");
+
+ call_me(closure);
+ call_me(function);
+}
+```
+
+## Închiderea ca tipuri de returnare
+Returnarea unei închideri este mult mai dificilă decât ai fi crezut.
+
+
+10. 🌟🌟
+
+```rust,editable
+/* Completați spațiul liber folosind două abordări,
+și rezolvați eroarea */
+fn create_fn() -> __ {
+ let num = 5;
+
+ // Cum capturează închiderea următoarea variabilă de mediu `num`
+ // &T, &mut T, T ?
+ |x| x + num
+}
+
+
+fn main() {
+ let fn_plain = create_fn();
+ fn_plain(1);
+}
+```
+
+
+11. 🌟🌟
+
+```rust,editable
+/* Completați spațiul liber și rezolvați eroarea*/
+fn factory(x:i32) -> __ {
+
+ let num = 5;
+
+ if x > 1{
+ move |x| x + num
+ } else {
+ move |x| x + num
+ }
+}
+```
+
+
+## Închideri în structuri
+
+**Exemplu**
+```rust
+struct Cacher
+where
+ T: Fn(E) -> E,
+ E: Copy
+{
+ query: T,
+ value: Option,
+}
+
+impl Cacher
+where
+ T: Fn(E) -> E,
+ E: Copy
+{
+ fn new(query: T) -> Cacher {
+ Cacher {
+ query,
+ value: None,
+ }
+ }
+
+ fn value(&mut self, arg: E) -> E {
+ match self.value {
+ Some(v) => v,
+ None => {
+ let v = (self.query)(arg);
+ self.value = Some(v);
+ v
+ }
+ }
+ }
+}
+fn main() {
+
+}
+
+#[test]
+fn call_with_different_values() {
+ let mut c = Cacher::new(|a| a);
+
+ let v1 = c.value(1);
+ let v2 = c.value(2);
+
+ assert_eq!(v2, 1);
+}
+```
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
diff --git a/ro-RO/src/functional-programing/intro.md b/ro-RO/src/functional-programing/intro.md
new file mode 100644
index 000000000..d8b3c14f1
--- /dev/null
+++ b/ro-RO/src/functional-programing/intro.md
@@ -0,0 +1,5 @@
+# Programarea funcțională (Functional Programming)
+Resurse de învățare:
+- Engleză: [Rust Book 13](https://doc.rust-lang.org/book/ch13-00-functional-features.html)
+- Chineză simplificată: [Rust语言圣经 - 函数式编程：闭包和迭代器](https://course.rs/advance/functional-programing/intro.html)
+
diff --git a/ro-RO/src/functional-programing/iterator.md b/ro-RO/src/functional-programing/iterator.md
new file mode 100644
index 000000000..b8816c7f7
--- /dev/null
+++ b/ro-RO/src/functional-programing/iterator.md
@@ -0,0 +1,354 @@
+# Iterator
+Modelul iterator permite efectuarea unor sarcini pe o secvență de elemente pe rând. Un iterator este responsabil pentru logica iterării prin fiecare element și determinarea momentului în care secvența s-a încheiat.
+
+## 'for' și iterator
+```rust
+fn main() {
+ let v = vec![1, 2, 3];
+ for x in v {
+ println!("{}",x)
+ }
+}
+```
+
+În codul de mai sus, puteți considera for ca un simplu ciclu, dar de fapt acesta iterează printr-un iterator.
+
+În mod implicit, 'for' va aplica 'into_iter' la colecție, transformând-o într-un iterator. Ca rezultat, codul de mai jos este echivalent cu cel anterior:
+```rust
+fn main() {
+ let v = vec![1, 2, 3];
+ for x in v.into_iter() {
+ println!("{}",x)
+ }
+}
+```
+
+
+1. 🌟
+
+```rust,editable
+/* Refactorizați următorul cod folosind iteratori */
+fn main() {
+ let arr = [0; 10];
+ for i in 0..arr.len() {
+ println!("{}",arr[i]);
+ }
+}
+```
+
+2. 🌟 Una dintre cele mai simple modalități de a crea un iterator este utilizarea notației de interval: 'a..b'.
+```rust,editable
+/* Completați spațiul liber */
+fn main() {
+ let mut v = Vec::new();
+ for n in __ {
+ v.push(n);
+ }
+
+ assert_eq!(v.len(), 100);
+}
+```
+
+## Metoda next
+Toate iteratoarele implementează un trăsătura numită 'Iterator' definită în biblioteca standard:
+```rust
+pub trait Iterator {
+ type Item;
+
+ fn next(&mut self) -> Option;
+
+ // Metode cu implementări implicite eliberate
+}
+```
+
+Și putem apela metoda 'next' direct pe iteratoare.
+
+
+3. 🌟🌟
+
+```rust,editable
+/* Completați spațiile libere și rezolvați erorile.
+Folosiți două modalități dacă este posibil */
+fn main() {
+ let v1 = vec![1, 2];
+
+ assert_eq!(v1.next(), __);
+ assert_eq!(v1.next(), __);
+ assert_eq!(v1.next(), __);
+}
+```
+
+## 'into_iter', 'iter' și 'iter_mut'
+
+În secțiunea anterioară, am menționat că 'for' va aplica 'into_iter' la colecție și o va transforma într-un iterator. Cu toate acestea, aceasta nu este singura modalitate de a converti colecțiile în iteratoare.
+
+- 'into_iter', 'iter' și 'iter_mut', toate acestea pot converti o colecție într-un iterator, dar în moduri diferite.
+
+- 'into_iter' consumă colecția; o dată ce colecția a fost consumată, nu mai este disponibilă pentru reutilizare, deoarece stăpânirea sa a fost mutată în cadrul buclei.
+- 'iter' împrumută fiecare element al colecției prin fiecare iterație, lăsând astfel colecția neatinsă și disponibilă pentru reutilizare după buclă.
+- 'iter_mut' împrumută mutabil fiecare element al colecției, permițând modificarea colecției pe loc.
+
+
+4. 🌟
+
+```rust,editable
+/* Faceți-l să funcționeze */
+fn main() {
+ let arr = vec![0; 10];
+ for i in arr {
+ println!("{}", i);
+ }
+
+ println!("{:?}",arr);
+}
+```
+
+
+5. 🌟
+
+```rust,editable
+/* Completați spațiul liber */
+fn main() {
+ let mut names = vec!["Bob", "Frank", "Ferris"];
+
+ for name in names.__{
+ *name = match name {
+ &mut "Ferris" => "There is a rustacean among us!",
+ _ => "Hello",
+ }
+ }
+
+ println!("names: {:?}", names);
+}
+```
+
+
+6. 🌟🌟
+
+```rust,editable
+/* Completați spațiul liber */
+fn main() {
+ let mut values = vec![1, 2, 3];
+ let mut values_iter = values.__;
+
+ if let Some(v) = values_iter.__{
+ __
+ }
+
+ assert_eq!(values, vec![0, 2, 3]);
+}
+```
+
+
+## Crearea propriilor noștri iteratori
+Nu putem doar crea iteratori din tipurile de colecție, ci și putem crea iteratori prin implementarea trăsăturii 'Iterator' pe propriile noastre tipuri.
+
+**Exemplu**
+```rust
+struct Counter {
+ count: u32,
+}
+
+impl Counter {
+ fn new() -> Counter {
+ Counter { count: 0 }
+ }
+}
+
+impl Iterator for Counter {
+ type Item = u32;
+
+ fn next(&mut self) -> Option {
+ if self.count < 5 {
+ self.count += 1;
+ Some(self.count)
+ } else {
+ None
+ }
+ }
+}
+
+fn main() {
+ let mut counter = Counter::new();
+
+ assert_eq!(counter.next(), Some(1));
+ assert_eq!(counter.next(), Some(2));
+ assert_eq!(counter.next(), Some(3));
+ assert_eq!(counter.next(), Some(4));
+ assert_eq!(counter.next(), Some(5));
+ assert_eq!(counter.next(), None);
+}
+```
+
+
+7. 🌟🌟🌟
+
+```rust,editable
+struct Fibonacci {
+ curr: u32,
+ next: u32,
+}
+
+// Implementați `Iterator` pentru `Fibonacci`.
+// Trăsătura `Iterator` necesită doar definirea unei metode pentru elementul `next`.
+impl Iterator for Fibonacci {
+ // Putem să ne referim la acest tip folosind Self::Item
+ type Item = u32;
+
+ /* Implementați metoda next */
+ fn next(&mut self)
+}
+
+// Returnează un generator de secvență Fibonacci
+fn fibonacci() -> Fibonacci {
+ Fibonacci { curr: 0, next: 1 }
+}
+
+fn main() {
+ let mut fib = fibonacci();
+ assert_eq!(fib.next(), Some(1));
+ assert_eq!(fib.next(), Some(1));
+ assert_eq!(fib.next(), Some(2));
+ assert_eq!(fib.next(), Some(3));
+ assert_eq!(fib.next(), Some(5));
+}
+```
+
+## Metode care consumă iteratorul
+Trăsătura Iterator are un număr de metode cu implementări implicite furnizate de biblioteca standard.
+
+### Adaptoare de consum
+Unele dintre aceste metode apelează metoda next pentru a utiliza iteratorul, astfel sunt numite adaptoare de consum.
+
+
+8. 🌟🌟
+
+```rust,edtiable
+
+/* Completați spațiul liber și rezolvați erorile */
+fn main() {
+ let v1 = vec![1, 2, 3];
+
+ let v1_iter = v1.iter();
+
+ // Metoda sum va lua stăpânirea iteratorului și va trece prin elemente apelând repetat metoda next
+ let total = v1_iter.sum();
+
+ assert_eq!(total, __);
+
+ println!("{:?}, {:?}",v1, v1_iter);
+}
+```
+
+
+#### Colectare
+În afară de conversia unei colecții într-un iterator, putem de asemenea să collectăm valorile rezultate într-o colecție, collect va consuma iteratorul.
+
+
+9. 🌟🌟
+
+```rust,editable
+/* Faceți-l să funcționeze */
+use std::collections::HashMap;
+fn main() {
+ let names = [("sunface",18), ("sunfei",18)];
+ let folks: HashMap<_, _> = names.into_iter().collect();
+
+ println!("{:?}",folks);
+
+ let v1: Vec = vec![1, 2, 3];
+
+ let v2 = v1.iter().collect();
+
+ assert_eq!(v2, vec![1, 2, 3]);
+}
+```
+
+
+### Adaptoare de iterator
+Metodele care vă permit să schimbați un iterator în alt iterator sunt cunoscute sub numele de *adaptoare de iterator*. Puteți concatena mai multe adaptoare de iterator pentru a efectua acțiuni complexe într-un mod lizibil.
+
+Dar deoarece **toate iteratoarele sunt leneșe**, trebuie să apelați unul dintre adaptoarele de consum pentru a obține rezultate din apelurile la adaptoarele de iterator.
+
+
+10. 🌟🌟
+
+```rust,editable
+/* Completați spațiile libere */
+fn main() {
+ let v1: Vec = vec![1, 2, 3];
+
+ let v2: Vec<_> = v1.iter().__.__;
+
+ assert_eq!(v2, vec![2, 3, 4]);
+}
+```
+
+
+11. 🌟🌟
+
+```rust
+/* Completați spațiile libere */
+use std::collections::HashMap;
+fn main() {
+ let names = ["sunface", "sunfei"];
+ let ages = [18, 18];
+ let folks: HashMap<_, _> = names.into_iter().__.collect();
+
+ println!("{:?}",folks);
+}
+```
+
+
+#### Utilizarea închiderilor în adaptoarele de iterator
+
+
+12. 🌟🌟
+
+```rust
+/* Completați spațiile libere */
+#[derive(PartialEq, Debug)]
+struct Shoe {
+ size: u32,
+ style: String,
+}
+
+fn shoes_in_size(shoes: Vec, shoe_size: u32) -> Vec {
+ shoes.into_iter().__.collect()
+}
+
+fn main() {
+ let shoes = vec![
+ Shoe {
+ size: 10,
+ style: String::from("sneaker"),
+ },
+ Shoe {
+ size: 13,
+ style: String::from("sandal"),
+ },
+ Shoe {
+ size: 10,
+ style: String::from("boot"),
+ },
+ ];
+
+ let in_my_size = shoes_in_size(shoes, 10);
+
+ assert_eq!(
+ in_my_size,
+ vec![
+ Shoe {
+ size: 10,
+ style: String::from("sneaker")
+ },
+ Shoe {
+ size: 10,
+ style: String::from("boot")
+ },
+ ]
+ );
+}
+```
+
+> Puteți găsi soluțiile [aici](https://github.com/sunface/rust-by-practice) (în cadrul căii soluțiilor), dar folosiți-le doar atunci când aveți nevoie. :)
diff --git a/ro-RO/src/generics-traits/advanced-traits.md b/ro-RO/src/generics-traits/advanced-traits.md
new file mode 100644
index 000000000..2fb2bf4ca
--- /dev/null
+++ b/ro-RO/src/generics-traits/advanced-traits.md
@@ -0,0 +1,279 @@
+# Trăsături Avansate
+
+## Tipuri asociate
+Utilizarea "Tipurilor asociate" îmbunătățește în mod general citibilitatea codului prin mutarea tipurilor interne local într-o trăsătură ca tipuri de ieșire. De exemplu:
+```rust
+pub trait CacheableItem: Clone + Default + fmt::Debug + Decodable + Encodable {
+ type Address: AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash;
+ fn is_null(&self) -> bool;
+}
+```
+
+Utilizarea tipului Adresa este mult mai clară și mai convenabilă decât 'AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash'.
+
+1. 🌟🌟🌟
+```rust,editable
+
+struct Container(i32, i32);
+
+// UTILIZAREA tipurilor asociate pentru a reimplementa trăsătura Contine.
+// trăsătură Contine {
+// tip A;
+// tip B;
+
+trait Contains {
+ fn contains(&self, _: &A, _: &B) -> bool;
+ fn first(&self) -> i32;
+ fn last(&self) -> i32;
+}
+
+impl Contains for Container {
+ fn contains(&self, number_1: &i32, number_2: &i32) -> bool {
+ (&self.0 == number_1) && (&self.1 == number_2)
+ }
+ // Preia primul număr.
+ fn first(&self) -> i32 { self.0 }
+
+ // Preia ultimul număr.
+ fn last(&self) -> i32 { self.1 }
+}
+
+fn difference>(container: &C) -> i32 {
+ container.last() - container.first()
+}
+
+fn main() {
+ let number_1 = 3;
+ let number_2 = 10;
+
+ let container = Container(number_1, number_2);
+
+ println!("Does container contain {} and {}: {}",
+ &number_1, &number_2,
+ container.contains(&number_1, &number_2));
+ println!("First number: {}", container.first());
+ println!("Last number: {}", container.last());
+
+ println!("The difference is: {}", difference(&container));
+}
+```
+
+## Parametri de Tip Generic Implicit
+Atunci când utilizăm parametri de tip generic, putem specifica un tip concret implicit pentru tipul generic. Acest lucru elimină necesitatea ca implementatorii trăsăturii să specifice un tip concret dacă tipul implicit funcționează.
+
+2. 🌟🌟
+```rust,editable
+
+use std::ops::Sub;
+
+#[derive(Debug, PartialEq)]
+struct Point {
+ x: T,
+ y: T,
+}
+
+// COMPLETAȚI spațiile libere în trei moduri: două dintre ele folosesc parametrii de tip generic implicit, cealaltă nu.
+// Observați că implementarea folosește tipul asociat `Output`.
+impl __ {
+ type Output = Self;
+
+ fn sub(self, other: Self) -> Self::Output {
+ Point {
+ x: self.x - other.x,
+ y: self.y - other.y,
+ }
+ }
+}
+
+fn main() {
+ assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 },
+ Point { x: 1, y: 3 });
+
+ println!("Success!");
+}
+```
+
+## Sintaxă Complet Calificată
+Nimic în Rust nu împiedică o trăsătură să aibă o metodă cu același nume ca o altă metodă a unei alte trăsături, iar Rust nu vă împiedică să implementați ambele trăsături pe un singur tip. De asemenea, este posibil să implementați o metodă direct pe tip cu același nume ca metodele din trăsături.
+
+Atunci când apelăm metode cu același nume, trebuie să folosim Sintaxa Complet Calificată.
+
+#### Exemplu
+```rust,editable
+trait UsernameWidget {
+ // Preia numele de utilizator selectat din acest widget
+ fn get(&self) -> String;
+}
+
+trait AgeWidget {
+ // Preia vârsta selectată din acest widget
+ fn get(&self) -> u8;
+}
+
+// O formă cu un WidgetNumeUtilizator(UsernameWidget), cât și un WidgetVârstă(AgeWidget).
+struct Form {
+ username: String,
+ age: u8,
+}
+
+impl UsernameWidget for Form {
+ fn get(&self) -> String {
+ self.username.clone()
+ }
+}
+
+impl AgeWidget for Form {
+ fn get(&self) -> u8 {
+ self.age
+ }
+}
+
+fn main() {
+ let form = Form{
+ username: "rustacean".to_owned(),
+ age: 28,
+ };
+
+ // Dacă decomentați această linie, veți primi o eroare care spune
+ // "s-au găsit multiple `get`". Pentru că, în cele din urmă, există mai multe metode
+ // denumite `get`.
+ // println!("{}", form.get());
+
+ let username = UsernameWidget::get(&form);
+ assert_eq!("rustacean".to_owned(), username);
+ let age = AgeWidget::get(&form); // Puteți folosi și `