From 69405ff52d3aa2a1072b9e11eec660fad6097c55 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Thu, 26 Jan 2023 03:53:31 +0200 Subject: [PATCH 01/11] translated about half of the file --- lessons/ro/chapter_8.yaml | 340 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 340 insertions(+) create mode 100644 lessons/ro/chapter_8.yaml diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml new file mode 100644 index 000000000..f335e1775 --- /dev/null +++ b/lessons/ro/chapter_8.yaml @@ -0,0 +1,340 @@ +- title: Capitolul 8 - Smart Pointerii + content_markdown: > + În acest capitol vom demistifica smart pointerii. Haideți să explorăm aceste + structuri de date care ne permit să interacționăm cu cel mai de jos nivel al memoriei. + + + Ferris spune: "Nu vă simțiți copleșit de acest capitol dacă nu credeți că puteți scrie + propriul cod de gestionare a memoriei dintr-o singură lectură scurtă. + + Acest capitol are în principal rolul de a vă prezenta câteva unelte utile + și de a vă oferi o perspectivă asupra felului în care acestea funcționează!" +- title: Referințe revizuite + content_markdown: > + O referință este, în principiu, doar un număr care reprezintă poziția de început + a unor octeți din memorie. + + Singurul său scop este reprezentarea locației în care există date de un anumit tip. + + Ceea ce face ca o referință să fie diferită de un simplu număr este faptul că Rust va verifica + dacă durata de viață a referințelor nu este mai mare decât cea a datelor pe care le referențiază + + (altfel vom primi o eroare atunci când le folosim!). +- title: Pointeri bruți + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20a%20%3D%2042%3B%0A%20%20%20%20let%20locatie_din_memorie%20%3D%20%26a%20as%20*const%20i32%20as%20usize%3B%0A%20%20%20%20println!(%22Aici%20se%20afla%20date%20%7B%7D%22%2C%20locatie_din_memorie)%3B%0A%7D%0A + content_markdown: > + Referințele pot fi convertite într-un tip mai primitiv numit pointer brut (în engleză *raw pointer*). + La fel ca un număr, acesta poate fi copiat și mutat fără prea multe restricții. + + Rust nu oferă nicio garanție privind validitatea locației de memorie către care pointează. + + + Există două tipuri de pointeri bruți: + + + * `*const T` - Un pointer brut la date de tip T care nu trebuie să se modifice niciodată. + + * `*mut T` - Un pointer brut către date de tip T care se pot modifica. + + + Pointerii bruți pot fi convertiți în și din numere (exemplu: `usize`). + + + Pointerii bruți pot accesa date cu cod *nesigur* (mai multe despre acest lucru mai târziu). + + + Detalii despre memorie: + + * O referință în Rust este foarte asemănătoare cu un pointer în C din punct de vedere al utilizării, dar cu mult + mai multe restricții la momentul compilării asupra modul în care poate fi stocată și transmisă către alte funcții. + + * Un pointer brut în Rust este similar cu un pointer în C, în sensul că reprezintă un număr care poate fi copiat + sau transmis și chiar transformat în tipuri numerice unde poate fi modificat pentru a efectua aritmetică cu pointeri. +- title: Dereferențiere + content_markdown: | + Procesul de accesare/manipulare a datelor referențiate printr-o *referință* (adică `&i32`) se numește *dereferențiere*. + + Referințele sunt utilizate pentru a accesa/manipula datele în două moduri: + + * Accesul la datele referențiate în timpul atribuirii variabilelor. + * Accesul la câmpuri sau metode ale datelor referențiate. + + Rust dispune de câțiva operatori puternici care ne permit să facem acest lucru. +- title: Operatorul * + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20a%3A%20i32%20%3D%2042%3B%0A%20%20%20%20let%20ref_ref_ref_a%3A%20%26%26%26i32%20%3D%20%26%26%26a%3B%0A%20%20%20%20let%20ref_a%3A%20%26i32%20%3D%20**ref_ref_ref_a%3B%0A%20%20%20%20let%20b%3A%20i32%20%3D%20*ref_a%3B%0A%20%20%20%20println!(%22%7B%7D%22%2C%20b)%0A%7D + content_markdown: > + Operatorul `*` este o modalitate explicită de a dereferenția o referință. + + + ```rust + + let a: i32 = 42; + + let ref_ref_ref_a: &&&i32 = &&&a; + + let ref_a: &i32 = **ref_ref_ref_a; + + let b: i32 = *ref_a; + + ``` + + + Detaliu de memorie: + + - Deoarece i32 este un tip primitiv care implementează trăsătura `Copy`, + octeții variabilei `a` de pe stivă sunt copiați în octeții variabilei `b`. +- title: Operatorul . + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=struct%20Foo%20%7B%0A%20%20%20%20value%3A%20i32%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20f%20%3D%20Foo%20%7B%20value%3A%2042%20%7D%3B%0A%20%20%20%20let%20ref_ref_ref_f%20%3D%20%26%26%26f%3B%0A%20%20%20%20println!(%22%7B%7D%22%2C%20ref_ref_ref_f.value)%3B%0A%7D + content_markdown: > + Operatorul `.` este utilizat pentru a accesa câmpurile și metodele unei referințe. + Acesta funcționează într-un mod puțin mai subtil. + + + ```rust + + let f = Foo { value: 42 }; + + let ref_ref_ref_f = &&&f; + + println!("{}", ref_ref_ref_f.value); + + ``` + + Whoa, de ce nu a fost nevoie să adăugăm `***` înainte de `ref_ref_ref_ref_f`? Acest lucru se + întâmplă deoarece operatorul `.` dereferențiază automat o secvență de referințe. + + Această ultimă linie este transformată în următoarea de către compilator, în mod automat: + + + ```rust + + println!("{}", (***ref_ref_ref_f).value); + + ``` +- title: Smart Pointerii + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Aops%3A%3ADeref%3B%0Astruct%20Paraciosul%3CT%3E%20%7B%0A%20%20%20%20valoare%3A%20T%2C%0A%7D%0Aimpl%3CT%3E%20Deref%20for%20Paraciosul%3CT%3E%20%7B%0A%20%20%20%20type%20Target%20%3D%20T%3B%0A%20%20%20%20fn%20deref(%26self)%20-%3E%20%26T%20%7B%0A%20%20%20%20%20%20%20%20println!(%22%7B%7D%20a%20fost%20folosit!%22%2C%20std%3A%3Aany%3A%3Atype_name%3A%3A%3CT%3E())%3B%0A%20%20%20%20%20%20%20%20%26self.valoare%0A%20%20%20%20%7D%0A%7D%0Afn%20main()%20%7B%0A%20%20%20%20let%20foo%20%3D%20Paraciosul%20%7B%0A%20%20%20%20%20%20%20%20valoare%3A%20%22mesaj%20secret%22%2C%0A%20%20%20%20%7D%3B%0A%20%20%20%20%2F%2F%20dereferentierea%20se%20intampla%20aici%20imediat%0A%20%20%20%20%2F%2F%20dupa%20ce%20foo%20est%20auto-referentiat%20pentru%0A%20%20%20%20%2F%2F%20functia%20%60len%60%0A%20%20%20%20println!(%22%7B%7D%22%2C%20foo.len())%3B%0A%7D%0A + content_markdown: > + Pe lângă abilitatea de a crea referințe la datele tipizate deja existente folosind + operatorul `&`, Rust ne oferă posibilitatea + + de a crea structuri asemănătoare referințelor, denumite **smart pointeri**. + + + Ne putem gândi la referințe la un nivel înalt ca la un tip care ne oferă acces la + un alt tip. Smart pointerii sunt diferiți în ceea ce privește + + comportament față de referințele normale, deoarece aceștia operează pe baza unei logici interne + scrisă de programator. Dumneavoastră - programatorul -sunteți partea *inteligentă*. + + + De obicei, smart pointerii implementează trăsăturile `Deref`, `DerefMut` și `Drop` pentru a + specifica logica a ceea ce ar trebui să se întâmple atunci când + + structura este dereferențiată cu operatorii `*` și `.`. +- title: Cod smart nesigur + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20a%3A%20%5Bu8%3B%204%5D%20%3D%20%5B86%2C%2014%2C%2073%2C%2064%5D%3B%0A%20%20%20%20%2F%2F%20acesta%20este%20un%20pointer%20brut.%20Obtinerea%20adresei%20de%20memorie%0A%20%20%20%20%2F%2F%20a%20unui%20numar%20este%20in%20totalitate%20sigur%0A%20%20%20%20let%20pointer_a%20%3D%20%26a%20as%20*const%20u8%20as%20usize%3B%0A%20%20%20%20println!(%22Locatia%20din%20memorie%20a%20datelor%3A%20%7B%7D%22%2C%20pointer_a)%3B%0A%20%20%20%20%2F%2F%20Transformarea%20numarului%20nostru%20intr-un%20pointer%20brut%20la%20un%20f32%0A%20%20%20%20%2F%2F%20este%20de%20asemenea%20sigur%0A%20%20%20%20let%20pointer_b%20%3D%20pointer_a%20as%20*const%20f32%3B%0A%20%20%20%20let%20b%20%3D%20unsafe%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20Acest%20lucru%20este%20nesigur%20deoarece%20ii%20spunem%20compilatorului%0A%20%20%20%20%20%20%20%20%2F%2F%20sa%20presupuna%20ca%20pointerul%20nostru%20este%20un%20f32%20valid%0A%20%20%20%20%20%20%20%20%2F%2F%20si%20sa%20ii%20dereferentieze%20valoarea%20intr-o%20variabila%20b.%0A%20%20%20%20%20%20%20%20%2F%2F%20Rust%20nu%20poate%20verifica%20daca%20aceasta%20presupunere%20este%20corecta.%0A%20%20%20%20%20%20%20%20*pointer_b%0A%20%20%20%20%7D%3B%0A%20%20%20%20println!(%22I%20swear%20this%20is%20a%20pie!%20%7B%7D%22%2C%20b)%3B%0A%20%20%20%20%20%20%20%20%2F%2F%20traducere%20gluma%3A%20%22jur%20ca%20asta%20este%20o%20placinta%22%0A%20%20%20%20%20%20%20%20%2F%2F%20%22pie%22%20suna%20asemenea%20%22pi%22%2C%20constanta%20matematica%0A%7D%0A + content_markdown: > + Smart pointerii tind să folosească destul de des cod *neigur*. Asa cum am menționat anterior, + sunt instrumente uzuale în interacțiunea cu cele mai joase niveluri de memorie. + + + Ce este un cod nesigur? Un cod nesigur se comportă exact ca un cod obișnuit, + cu excepția câtorva capabilități pe care compilatorul Rust nu le poate garanta. + + + O abilitate principală a codului nesigur este *dereferențierea unui pointer brut*. + Asta înseamnă să ducem un *pointer brut* la o poziție din memorie, să declarăm că + + "aici există o structură de date!" și să o transformăm într-o reprezentare a datelor + pe care să o putem folosi (exemplu: `*const u8` în `u8`). + + Rust nu are nicio modalitate de a ține evidența semnificației fiecărui octet care este scris în memorie. + Deoarece Rust nu poate fi sigur cu privire la ce se află la un număr arbitrar folosit ca *pointer brut*, + + el plasează dereferențierea într-un bloc `unsafe { ... }`. + + + Smart pointerii *dereferință pointerii bruți* în mod extensiv, dar ei sunt bine dovediți în ceea ce fac. +- title: Prieteni familiari + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Aalloc%3A%3A%7Balloc%2C%20Layout%7D%3B%0Ause%20std%3A%3Aops%3A%3ADeref%3B%0A%0A%2F%2F%20aceeasi%20gluma%20cu%20placinta%20(*pie*)%0Astruct%20Placinta%20%7B%0A%20%20%20%20reteta_secreta%3A%20usize%2C%0A%7D%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20new()%20-%3E%20Self%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20hai%20sa%20cerem%204%20bytes%0A%20%20%20%20%20%20%20%20let%20layout%20%3D%20Layout%3A%3Afrom_size_align(4%2C%201).unwrap()%3B%0A%0A%20%20%20%20%20%20%20%20unsafe%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20alocam%20si%20salvam%20locatia%20din%20memore%20ca%20un%20numar%0A%20%20%20%20%20%20%20%20%20%20%20%20let%20ptr%20%3D%20alloc(layout)%20as%20*mut%20u8%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20folosim%20aritmetica%20cu%20pointeri%20si%20scriem%20cateva%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20valori%20u8%20in%20memorie%0A%20%20%20%20%20%20%20%20%20%20%20%20ptr.write(86)%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20ptr.add(1).write(14)%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20ptr.add(2).write(73)%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20ptr.add(3).write(64)%3B%0A%0A%20%20%20%20%20%20%20%20%20%20%20%20Placinta%20%7B%20reteta_secreta%3A%20ptr%20as%20usize%20%7D%0A%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%7D%0A%7D%0Aimpl%20Deref%20for%20Placinta%20%7B%0A%20%20%20%20type%20Target%20%3D%20f32%3B%0A%20%20%20%20fn%20deref(%26self)%20-%3E%20%26f32%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20interpretam%20pointerul%20reteta_secreta%20ca%20un%20pointer%20brut%20f32%0A%20%20%20%20%20%20%20%20let%20pointer%20%3D%20self.reteta_secreta%20as%20*const%20f32%3B%0A%20%20%20%20%20%20%20%20%2F%2F%20il%20dereferentiem%20intr-o%20valoare%20de%20return%20%26f32%0A%20%20%20%20%20%20%20%20unsafe%20%7B%20%26*pointer%20%7D%0A%20%20%20%20%7D%0A%7D%0Afn%20main()%20%7B%0A%20%20%20%20let%20p%20%3D%20Placinta%3A%3Anew()%3B%0A%20%20%20%20%2F%2F%20%22facem%20o%20placinta%22%20dereferentiind%20smart%20pointerul%0A%20%20%20%20%2F%2Fnostru%20la%20structura%20Placinta%20%0A%20%20%20%20println!(%22%7B%3A%3F%7D%22%2C%20*p)%3B%0A%7D%0A + content_markdown: > + Luați în considerare niște smart pointeri pe care i-am văzut deja, cum ar fi `Vec` și `String`. + + + `Vec` este un smart pointer care doar deține o regiune de memorie cu octeți. Compilatorul Rust + nu are nicio idee despre ce se află în acești octeți. Smart pointer-ul interpretează ce înseamnă + + să preia elemente din regiunea de memorie pe care o gestionează, ține evidența locului unde încep + și se termină structurile de date din acești octeți și apoi, în cele din urmă, dereferențiază + + un pointer brut în structuri de date, într-o interfață ergonomică, clară, pe care să o putem utiliza + (de exemplu, `my_vec[3]`). + + + În mod similar, `String` ține evidența unei regiuni de memorie cu octeți, restricționează în mod + programatic conținutul scris în ea pentru a fi întotdeauna `utf-8` valid și ajută la dereferențierea + + acelei regiuni de memorie într-un tip `&str`. + + + Ambele structuri de date utilizează dereferențierea nesigură a pointerilor bruți pentru a-și face treaba. + + + Detalii despre memorie: + + * Rust are un echivalent al lui `malloc` din C folosind + [alloc](https://doc.rust-lang.org/std/alloc/fn.alloc.html) și + [Layout](https://doc.rust-lang.org/std/alloc/struct.Layout.html ) pentru + a obține propriile regiuni de memorie pe care să le gestionați. +- title: Memorie alocată pe heap + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=struct%20Placinta%3B%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20mananca(%26self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22are%20gust%20mai%20bun%20pe%20heap!%22)%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20placinta_de_pe_heap%20%3D%20Box%3A%3Anew(Placinta)%3B%0A%20%20%20%20placinta_de_pe_heap.mananca()%3B%0A%7D%0A + content_markdown: > + `Box` este un smart pointer care ne permite să mutăm datele de pe stivă în heap. + + + Dereferențierea acestuia ne permite să folosim datele alocate în heap în mod ergonomic, + ca și cum ar fi fost tipul original. +- title: Main-ul eșuabil revizuit + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Afmt%3A%3ADisplay%3B%0Ause%20std%3A%3Aerror%3A%3AError%3B%0A%0Astruct%20Placinta%3B%0A%0A%23%5Bderive(Debug)%5D%0Astruct%20EroareNuEProaspata%3B%0A%0Aimpl%20Display%20for%20EroareNuEProaspata%20%7B%0A%20%20%20%20fn%20fmt(%26self%2C%20f%3A%20%26mut%20std%3A%3Afmt%3A%3AFormatter%3C'_%3E)%20-%3E%20std%3A%3Afmt%3A%3AResult%20%7B%0A%20%20%20%20%20%20%20%20write!(f%2C%20%22Aceasta%20placinta%20nu%20e%20proaspata!%22)%0A%20%20%20%20%7D%0A%7D%0A%0Aimpl%20Error%20for%20EroareNuEProaspata%20%7B%7D%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20mananca(%26self)%20-%3E%20Result%3C()%2C%20Box%3Cdyn%20Error%3E%3E%20%7B%0A%20%20%20%20%20%20%20%20Err(Box%3A%3Anew(EroareNuEProaspata))%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20-%3E%20Result%3C()%2C%20Box%3Cdyn%20Error%3E%3E%20%7B%0A%20%20%20%20let%20placinta_de_pe_heap%20%3D%20Box%3A%3Anew(Placinta)%3B%0A%20%20%20%20placinta_de_pe_heap.mananca()%3F%3B%0A%20%20%20%20Ok(())%0A%7D%0A + content_markdown: > + Rust code may have a plethora of representations of errors, but the standard + library has + + a universal trait `std::error::Error` for describing errors. + + + Using a smart pointer `Box` we can use the type `Box` + as a common type for returning errors because it allows us to + + propagate up an error on the heap and interact with it at a high level + without having to know a specific type. + + + Early in Tour of Rust we learned that `main` can return an error. We can now + return + + a type capable of describing almost any kind of error that might occur in + our program + + so long as the error's data structure implements Rust's common `Error` + trait. + + + ```rust + + fn main() -> Result<(), Box> + + ``` +- title: Referencing Counting + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Arc%3A%3ARc%3B%0A%0Astruct%20Pie%3B%0A%0Aimpl%20Pie%20%7B%0A%20%20%20%20fn%20eat(%26self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22tastes%20better%20on%20the%20heap!%22)%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20heap_pie%20%3D%20Rc%3A%3Anew(Pie)%3B%0A%20%20%20%20let%20heap_pie2%20%3D%20heap_pie.clone()%3B%0A%20%20%20%20let%20heap_pie3%20%3D%20heap_pie2.clone()%3B%0A%0A%20%20%20%20heap_pie3.eat()%3B%0A%20%20%20%20heap_pie2.eat()%3B%0A%20%20%20%20heap_pie.eat()%3B%0A%0A%20%20%20%20%2F%2F%20all%20reference%20count%20smart%20pointers%20are%20dropped%20now%0A%20%20%20%20%2F%2F%20the%20heap%20data%20Pie%20finally%20deallocates%0A%7D%0A + content_markdown: > + `Rc` is a smart pointer that moves data from the stack onto the heap. It + allows us to + + clone other `Rc` smart pointers that all have the ability to immutably + borrow the data + + that was put on the heap. + + + Only when the last smart pointer is dropped does the data on the heap become + deallocated. +- title: Sharing Access + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Acell%3A%3ARefCell%3B%0A%0Astruct%20Pie%20%7B%0A%20%20%20%20slices%3A%20u8%0A%7D%0A%0Aimpl%20Pie%20%7B%0A%20%20%20%20fn%20eat(%26mut%20self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22tastes%20better%20on%20the%20heap!%22)%3B%0A%20%20%20%20%20%20%20%20self.slices%20-%3D%201%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20%2F%2F%20RefCell%20validates%20memory%20safety%20at%20runtime%0A%20%20%20%20%2F%2F%20notice%3A%20pie_cell%20is%20not%20mut!%0A%20%20%20%20let%20pie_cell%20%3D%20RefCell%3A%3Anew(Pie%7Bslices%3A8%7D)%3B%0A%20%20%20%20%0A%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20but%20we%20can%20borrow%20mutable%20references!%0A%20%20%20%20%20%20%20%20let%20mut%20mut_ref_pie%20%3D%20pie_cell.borrow_mut()%3B%0A%20%20%20%20%20%20%20%20mut_ref_pie.eat()%3B%0A%20%20%20%20%20%20%20%20mut_ref_pie.eat()%3B%0A%20%20%20%20%20%20%20%20%0A%20%20%20%20%20%20%20%20%2F%2F%20mut_ref_pie%20is%20dropped%20at%20end%20of%20scope%0A%20%20%20%20%7D%0A%20%20%20%20%0A%20%20%20%20%2F%2F%20now%20we%20can%20borrow%20immutably%20once%20our%20mutable%20reference%20drops%0A%20%20%20%20%20let%20ref_pie%20%3D%20pie_cell.borrow()%3B%0A%20%20%20%20%20println!(%22%7B%7D%20slices%20left%22%2Cref_pie.slices)%3B%0A%7D%0A + content_markdown: > + `RefCell` is a container data structure commonly held by smart pointers that + takes in data and lets us + + borrow mutable and immutable references to what's inside. It prevents + borrowing from + + being abused by enforcing Rust's memory safety rules at runtime when you ask + to borrow + + the data within: + + + **Only one mutable reference OR multiple immutable references, but not + both!** + + + If you violate these rules `RefCell` will panic. +- title: Sharing Across Threads + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Async%3A%3AMutex%3B%0A%0Astruct%20Pie%3B%0A%0Aimpl%20Pie%20%7B%0A%20%20%20%20fn%20eat(%26self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22only%20I%20eat%20the%20pie%20right%20now!%22)%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20mutex_pie%20%3D%20Mutex%3A%3Anew(Pie)%3B%0A%20%20%20%20%2F%2F%20let's%20borrow%20a%20locked%20immutable%20reference%20of%20pie%0A%20%20%20%20%2F%2F%20we%20have%20to%20unwrap%20the%20result%20of%20a%20lock%0A%20%20%20%20%2F%2F%20because%20it%20might%20fail%0A%20%20%20%20let%20ref_pie%20%3D%20mutex_pie.lock().unwrap()%3B%0A%20%20%20%20ref_pie.eat()%3B%0A%20%20%20%20%2F%2F%20locked%20reference%20drops%20here%2C%20and%20mutex%20protected%20value%20can%20be%20used%20by%20someone%20else%0A%7D%0A + content_markdown: > + `Mutex` is a container data structure commonly held by smart pointers that + takes in data and lets us borrow mutable + + and immutable references to the data within. This prevents borrowing from + being abused by + + having the operating system restrict only one CPU thread at time to have + access to the data, + + blocking other threads until that original thread is done with its locked + borrow. + + + Multithreading is beyond the scope of Tour of Rust, but `Mutex` is a + fundamental part of orchestrating + + multiple CPU threads accessing the same data. + + + There is a special smart pointer `Arc` which is identical to `Rc` except + uses thread-safe incrementing of reference counts. + + It's often used to have many references to the same `Mutex`. +- title: Combining Smart Pointers + code: >- + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Acell%3A%3ARefCell%3B%0Ause%20std%3A%3Arc%3A%3ARc%3B%0A%0Astruct%20Pie%20%7B%0A%20%20%20%20slices%3A%20u8%2C%0A%7D%0A%0Aimpl%20Pie%20%7B%0A%20%20%20%20fn%20eat_slice(%26mut%20self%2C%20name%3A%20%26str)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22%7B%7D%20took%20a%20slice!%22%2C%20name)%3B%0A%20%20%20%20%20%20%20%20self.slices%20-%3D%201%3B%0A%20%20%20%20%7D%0A%7D%0A%0Astruct%20SeaCreature%20%7B%0A%20%20%20%20name%3A%20String%2C%0A%20%20%20%20pie%3A%20Rc%3CRefCell%3CPie%3E%3E%2C%0A%7D%0A%0Aimpl%20SeaCreature%20%7B%0A%20%20%20%20fn%20eat(%26self)%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20use%20smart%20pointer%20to%20pie%20for%20a%20mutable%20borrow%0A%20%20%20%20%20%20%20%20let%20mut%20p%20%3D%20self.pie.borrow_mut()%3B%0A%20%20%20%20%20%20%20%20%2F%2F%20take%20a%20bite!%0A%20%20%20%20%20%20%20%20p.eat_slice(%26self.name)%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20pie%20%3D%20Rc%3A%3Anew(RefCell%3A%3Anew(Pie%20%7B%20slices%3A%208%20%7D))%3B%0A%20%20%20%20%2F%2F%20ferris%20and%20sarah%20are%20given%20clones%20of%20smart%20pointer%20to%20pie%0A%20%20%20%20let%20ferris%20%3D%20SeaCreature%20%7B%0A%20%20%20%20%20%20%20%20name%3A%20String%3A%3Afrom(%22ferris%22)%2C%0A%20%20%20%20%20%20%20%20pie%3A%20pie.clone()%2C%0A%20%20%20%20%7D%3B%0A%20%20%20%20let%20sarah%20%3D%20SeaCreature%20%7B%0A%20%20%20%20%20%20%20%20name%3A%20String%3A%3Afrom(%22sarah%22)%2C%0A%20%20%20%20%20%20%20%20pie%3A%20pie.clone()%2C%0A%20%20%20%20%7D%3B%0A%20%20%20%20ferris.eat()%3B%0A%20%20%20%20sarah.eat()%3B%0A%0A%20%20%20%20let%20p%20%3D%20pie.borrow()%3B%0A%20%20%20%20println!(%22%7B%7D%20slices%20left%22%2C%20p.slices)%3B%0A%7D%0A + content_markdown: > + Smart pointers might seem limited, but they can make some very powerful + combinations. + + + `Rc>` - Allow the cloning of multiple smart pointers that can + borrow the same vector of immutable data structures on the heap. + + + `Rc>` - Allow multiple smart pointers the ability to borrow + mutably/immutably the same struct `Foo` + + + `Arc>` - Allow multiple smart pointers the ability to lock + temporary mutable/immutable borrows in a CPU thread exclusive manner. + + + Memory detail: + + * You'll notice a theme with many of these combinations. The use of an + immutable data type (possibly owned by multiple smart pointers) to modify + internal data. This + is referred to as the "interior mutability" pattern in Rust. It is a pattern that lets us bend the rules of memory usage at runtime with the same level of safety as Rust's + compile-time checks. + +- title: Chapter 8 - Conclusion + content_markdown: > + Smart pointers are the idioms of Rust programming and let us not have to + re-create the + + very common patterns of memory usage. With them you are ready to tackle the + toughest of + + challenges! Now that we have the foundations of Rust, let's talk a bit about + how we make + + larger projects. In chapter 9 we break free of single page + + lines of code. From c74fcd372c8cc24031fe530a213766e5809c1080 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Thu, 26 Jan 2023 05:19:00 +0200 Subject: [PATCH 02/11] translated the other half of the file --- lessons/ro/chapter_8.yaml | 160 ++++++++++++++++---------------------- 1 file changed, 69 insertions(+), 91 deletions(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index f335e1775..db7db5824 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -205,27 +205,19 @@ code: >- https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Afmt%3A%3ADisplay%3B%0Ause%20std%3A%3Aerror%3A%3AError%3B%0A%0Astruct%20Placinta%3B%0A%0A%23%5Bderive(Debug)%5D%0Astruct%20EroareNuEProaspata%3B%0A%0Aimpl%20Display%20for%20EroareNuEProaspata%20%7B%0A%20%20%20%20fn%20fmt(%26self%2C%20f%3A%20%26mut%20std%3A%3Afmt%3A%3AFormatter%3C'_%3E)%20-%3E%20std%3A%3Afmt%3A%3AResult%20%7B%0A%20%20%20%20%20%20%20%20write!(f%2C%20%22Aceasta%20placinta%20nu%20e%20proaspata!%22)%0A%20%20%20%20%7D%0A%7D%0A%0Aimpl%20Error%20for%20EroareNuEProaspata%20%7B%7D%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20mananca(%26self)%20-%3E%20Result%3C()%2C%20Box%3Cdyn%20Error%3E%3E%20%7B%0A%20%20%20%20%20%20%20%20Err(Box%3A%3Anew(EroareNuEProaspata))%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20-%3E%20Result%3C()%2C%20Box%3Cdyn%20Error%3E%3E%20%7B%0A%20%20%20%20let%20placinta_de_pe_heap%20%3D%20Box%3A%3Anew(Placinta)%3B%0A%20%20%20%20placinta_de_pe_heap.mananca()%3F%3B%0A%20%20%20%20Ok(())%0A%7D%0A content_markdown: > - Rust code may have a plethora of representations of errors, but the standard - library has + Codul Rust poate avea o multitudine de reprezentări ale erorilor, dar biblioteca standard + are o trăsătură universală `std::error::Error` pentru a descrie erorile. - a universal trait `std::error::Error` for describing errors. + Utilizând un smart pointer `Box` putem folosi tipul `Box` ca un tip + comun pentru returnarea erorilor, deoarece ne permite să propagăm o eroare pe heap + + și să interacționăm cu ea la un nivel înalt fără a fi nevoie să cunoaștem un tip specific. - Using a smart pointer `Box` we can use the type `Box` - as a common type for returning errors because it allows us to - - propagate up an error on the heap and interact with it at a high level - without having to know a specific type. - - - Early in Tour of Rust we learned that `main` can return an error. We can now - return - - a type capable of describing almost any kind of error that might occur in - our program - - so long as the error's data structure implements Rust's common `Error` - trait. + La începutul Turului limbajului Rust am învățat că `main` poate returna o eroare. Acum putem + returna un tip capabil să descrie aproape orice fel de eroare care ar putea apărea în programul + + nostru, atâta timp cât structura de date a erorii implementează trăsătura comună `Error` din Rust. ```rust @@ -233,108 +225,94 @@ fn main() -> Result<(), Box> ``` -- title: Referencing Counting +- title: Numărarea referințelor code: >- - https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Arc%3A%3ARc%3B%0A%0Astruct%20Pie%3B%0A%0Aimpl%20Pie%20%7B%0A%20%20%20%20fn%20eat(%26self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22tastes%20better%20on%20the%20heap!%22)%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20heap_pie%20%3D%20Rc%3A%3Anew(Pie)%3B%0A%20%20%20%20let%20heap_pie2%20%3D%20heap_pie.clone()%3B%0A%20%20%20%20let%20heap_pie3%20%3D%20heap_pie2.clone()%3B%0A%0A%20%20%20%20heap_pie3.eat()%3B%0A%20%20%20%20heap_pie2.eat()%3B%0A%20%20%20%20heap_pie.eat()%3B%0A%0A%20%20%20%20%2F%2F%20all%20reference%20count%20smart%20pointers%20are%20dropped%20now%0A%20%20%20%20%2F%2F%20the%20heap%20data%20Pie%20finally%20deallocates%0A%7D%0A + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Arc%3A%3ARc%3B%0A%0Astruct%20Placinta%3B%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20mananca(%26self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22are%20gust%20mai%20bun%20pe%20heap!%22)%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20placinta_de_pe_heap%20%3D%20Rc%3A%3Anew(Placinta)%3B%0A%20%20%20%20let%20placinta_de_pe_heap2%20%3D%20placinta_de_pe_heap.clone()%3B%0A%20%20%20%20let%20placinta_de_pe_heap3%20%3D%20placinta_de_pe_heap2.clone()%3B%0A%0A%20%20%20%20placinta_de_pe_heap3.mananca()%3B%0A%20%20%20%20placinta_de_pe_heap2.mananca()%3B%0A%20%20%20%20placinta_de_pe_heap.mananca()%3B%0A%0A%20%20%20%20%2F%2F%20toti%20smart%20pointerii%20cu%20referinte%20numarate%20sunt%20acum%20eliminati%20(drop)%0A%20%20%20%20%2F%2F%20datele%20de%20pe%20heap%20sunt%20intr-un%20final%20dealocate%0A%7D%0A content_markdown: > - `Rc` is a smart pointer that moves data from the stack onto the heap. It - allows us to - - clone other `Rc` smart pointers that all have the ability to immutably - borrow the data - - that was put on the heap. + `Rc` este un smart pointer care mută datele de pe stivă în heap. Acesta + ne permite să clonăm alți smart pointeri `Rc`, care au toți capacitatea + + de a împrumuta, în mod imutabil, date care au fost puse pe heap. - Only when the last smart pointer is dropped does the data on the heap become - deallocated. -- title: Sharing Access + Doar atunci când ultimul smart pointer este eliminat (drop), datele de pe heap devin + dealocate. +- title: Partajarea accesului code: >- - https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Acell%3A%3ARefCell%3B%0A%0Astruct%20Pie%20%7B%0A%20%20%20%20slices%3A%20u8%0A%7D%0A%0Aimpl%20Pie%20%7B%0A%20%20%20%20fn%20eat(%26mut%20self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22tastes%20better%20on%20the%20heap!%22)%3B%0A%20%20%20%20%20%20%20%20self.slices%20-%3D%201%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20%2F%2F%20RefCell%20validates%20memory%20safety%20at%20runtime%0A%20%20%20%20%2F%2F%20notice%3A%20pie_cell%20is%20not%20mut!%0A%20%20%20%20let%20pie_cell%20%3D%20RefCell%3A%3Anew(Pie%7Bslices%3A8%7D)%3B%0A%20%20%20%20%0A%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20but%20we%20can%20borrow%20mutable%20references!%0A%20%20%20%20%20%20%20%20let%20mut%20mut_ref_pie%20%3D%20pie_cell.borrow_mut()%3B%0A%20%20%20%20%20%20%20%20mut_ref_pie.eat()%3B%0A%20%20%20%20%20%20%20%20mut_ref_pie.eat()%3B%0A%20%20%20%20%20%20%20%20%0A%20%20%20%20%20%20%20%20%2F%2F%20mut_ref_pie%20is%20dropped%20at%20end%20of%20scope%0A%20%20%20%20%7D%0A%20%20%20%20%0A%20%20%20%20%2F%2F%20now%20we%20can%20borrow%20immutably%20once%20our%20mutable%20reference%20drops%0A%20%20%20%20%20let%20ref_pie%20%3D%20pie_cell.borrow()%3B%0A%20%20%20%20%20println!(%22%7B%7D%20slices%20left%22%2Cref_pie.slices)%3B%0A%7D%0A + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Acell%3A%3ARefCell%3B%0A%0Astruct%20Placinta%20%7B%0A%20%20%20%20felii%3A%20u8%0A%7D%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20mananca(%26mut%20self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22are%20gust%20mai%20bun%20pe%20heap!%22)%3B%0A%20%20%20%20%20%20%20%20self.felii%20-%3D%201%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20%2F%2F%20RefCell%20valideaza%20siguranta%20memoriei%20la%20runtime%0A%20%20%20%20%2F%2F%20aviz%3A%20placinta_cell%20nu%20este%20mut!%0A%20%20%20%20let%20placinta_cell%20%3D%20RefCell%3A%3Anew(Placinta%7Bfelii%3A8%7D)%3B%0A%20%20%20%20%0A%20%20%20%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20dar%20putem%20imprumuta%20referinte%20mutabile!%0A%20%20%20%20%20%20%20%20let%20mut%20mut_ref_placinta%20%3D%20placinta_cell.borrow_mut()%3B%0A%20%20%20%20%20%20%20%20mut_ref_placinta.mananca()%3B%0A%20%20%20%20%20%20%20%20mut_ref_placinta.mananca()%3B%0A%20%20%20%20%20%20%20%20%0A%20%20%20%20%20%20%20%20%2F%2F%20mut_ref_placinta%20este%20eliminata%20(drop)%20la%20finalul%0A%20%20%20%20%20%20%20%20%2F%2F%20domeniului%20de%20vizibilitate%0A%20%20%20%20%7D%0A%20%20%20%20%0A%20%20%20%20%2F%2F%20acum%20putem%20imprumuta%20imutabil%20odata%20ce%20referinta%0A%20%20%20%20%2F%2F%20noastra%20mutabila%20este%20eliminata%20(drop)%0A%20%20%20%20%20let%20ref_placinta%20%3D%20placinta_cell.borrow()%3B%0A%20%20%20%20%20println!(%22%7B%7D%20felii%20ramase%22%2Cref_placinta.felii)%3B%0A%7D%0A content_markdown: > - `RefCell` is a container data structure commonly held by smart pointers that - takes in data and lets us + `RefCell` este o structură de date de tip container ținută în mod obișnuit + de smart pointeri care preia date și ne permite - borrow mutable and immutable references to what's inside. It prevents - borrowing from - - being abused by enforcing Rust's memory safety rules at runtime when you ask - to borrow - - the data within: + să împrumutăm referințe mutabile și imuabile la ceea ce se află în interior. + Aceasta previne abuzul de împrumut prin aplicarea regulilor de siguranță a memoriei + + din Rust în timpul execuției, atunci când cereți împrumutul datelor din interior: - **Only one mutable reference OR multiple immutable references, but not - both!** + **Doar o singură referință mutabilă SAU mai multe referințe imuabile, dar nu + ambele!** - If you violate these rules `RefCell` will panic. -- title: Sharing Across Threads + Dacă încălcați aceste reguli, `RefCell` se va panica. +- title: Partajarea între thread-uri code: >- - https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Async%3A%3AMutex%3B%0A%0Astruct%20Pie%3B%0A%0Aimpl%20Pie%20%7B%0A%20%20%20%20fn%20eat(%26self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22only%20I%20eat%20the%20pie%20right%20now!%22)%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20mutex_pie%20%3D%20Mutex%3A%3Anew(Pie)%3B%0A%20%20%20%20%2F%2F%20let's%20borrow%20a%20locked%20immutable%20reference%20of%20pie%0A%20%20%20%20%2F%2F%20we%20have%20to%20unwrap%20the%20result%20of%20a%20lock%0A%20%20%20%20%2F%2F%20because%20it%20might%20fail%0A%20%20%20%20let%20ref_pie%20%3D%20mutex_pie.lock().unwrap()%3B%0A%20%20%20%20ref_pie.eat()%3B%0A%20%20%20%20%2F%2F%20locked%20reference%20drops%20here%2C%20and%20mutex%20protected%20value%20can%20be%20used%20by%20someone%20else%0A%7D%0A + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Async%3A%3AMutex%3B%0A%0Astruct%20Placinta%3B%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20mananca(%26self)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22mananc%20placinta%20doar%20acum!%22)%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20mutex_placinta%20%3D%20Mutex%3A%3Anew(Placinta)%3B%0A%20%20%20%20%2F%2F%20haideti%20sa%20imprumutam%20o%20referinta%20imutabila%20a%20placintei%0A%20%20%20%20%2F%2F%20trebuie%20sa%20despachetam%20rezultatul%20lock-ului%0A%20%20%20%20%2F%2F%20caci%20ar%20putea%20esua%0A%20%20%20%20let%20ref_placinta%20%3D%20mutex_placinta.lock().unwrap()%3B%0A%20%20%20%20ref_placinta.mananca()%3B%0A%20%20%20%20%2F%2F%20referinta%20cu%20lock%20este%20eliminata%20(drop)%20aici%2C%0A%20%20%20%20%2F%2F%20iar%20valoarea%20protejata%20de%20mutex%20poate%20fi%20folosita%20de%20altcineva%0A%7D%0A content_markdown: > - `Mutex` is a container data structure commonly held by smart pointers that - takes in data and lets us borrow mutable + `Mutex` este o structură de date de tip container ținută în mod obișnuit + de smart pointeri care preia date și ne permite - and immutable references to the data within. This prevents borrowing from - being abused by - - having the operating system restrict only one CPU thread at time to have - access to the data, - - blocking other threads until that original thread is done with its locked - borrow. + să împrumutăm referințe mutabile și imuabile la ceea ce se află în interior. + Acesta previne abuzul de împrumut prin restricționarea, + + de către sistemul de operare, a accesului la date doar pentru un singur + thread al procesorului la un moment de timp, + blocând alte thread-uri până când thread-ul original a terminat cu împrumutul său cu lock. - Multithreading is beyond the scope of Tour of Rust, but `Mutex` is a - fundamental part of orchestrating - multiple CPU threads accessing the same data. + Multithreading-ul este dincolo de obiectivul Turului limbajului Rust, dar `Mutex` este o parte + fundamentală a orchestrării mai multor thread-uri ale procesorului ce accesează aceleași date. - There is a special smart pointer `Arc` which is identical to `Rc` except - uses thread-safe incrementing of reference counts. + Există un smart pointer special `Arc`, care este identic cu `Rc`, cu excepția faptului că + folosește o incrementare a numărului de referințe în condiții de siguranță pentru thread-uri. - It's often used to have many references to the same `Mutex`. -- title: Combining Smart Pointers + Este adesea utilizat pentru a avea mai multe referințe la același `Mutex`. +- title: Combinarea Smart Pointerilor code: >- - https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Acell%3A%3ARefCell%3B%0Ause%20std%3A%3Arc%3A%3ARc%3B%0A%0Astruct%20Pie%20%7B%0A%20%20%20%20slices%3A%20u8%2C%0A%7D%0A%0Aimpl%20Pie%20%7B%0A%20%20%20%20fn%20eat_slice(%26mut%20self%2C%20name%3A%20%26str)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22%7B%7D%20took%20a%20slice!%22%2C%20name)%3B%0A%20%20%20%20%20%20%20%20self.slices%20-%3D%201%3B%0A%20%20%20%20%7D%0A%7D%0A%0Astruct%20SeaCreature%20%7B%0A%20%20%20%20name%3A%20String%2C%0A%20%20%20%20pie%3A%20Rc%3CRefCell%3CPie%3E%3E%2C%0A%7D%0A%0Aimpl%20SeaCreature%20%7B%0A%20%20%20%20fn%20eat(%26self)%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20use%20smart%20pointer%20to%20pie%20for%20a%20mutable%20borrow%0A%20%20%20%20%20%20%20%20let%20mut%20p%20%3D%20self.pie.borrow_mut()%3B%0A%20%20%20%20%20%20%20%20%2F%2F%20take%20a%20bite!%0A%20%20%20%20%20%20%20%20p.eat_slice(%26self.name)%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20pie%20%3D%20Rc%3A%3Anew(RefCell%3A%3Anew(Pie%20%7B%20slices%3A%208%20%7D))%3B%0A%20%20%20%20%2F%2F%20ferris%20and%20sarah%20are%20given%20clones%20of%20smart%20pointer%20to%20pie%0A%20%20%20%20let%20ferris%20%3D%20SeaCreature%20%7B%0A%20%20%20%20%20%20%20%20name%3A%20String%3A%3Afrom(%22ferris%22)%2C%0A%20%20%20%20%20%20%20%20pie%3A%20pie.clone()%2C%0A%20%20%20%20%7D%3B%0A%20%20%20%20let%20sarah%20%3D%20SeaCreature%20%7B%0A%20%20%20%20%20%20%20%20name%3A%20String%3A%3Afrom(%22sarah%22)%2C%0A%20%20%20%20%20%20%20%20pie%3A%20pie.clone()%2C%0A%20%20%20%20%7D%3B%0A%20%20%20%20ferris.eat()%3B%0A%20%20%20%20sarah.eat()%3B%0A%0A%20%20%20%20let%20p%20%3D%20pie.borrow()%3B%0A%20%20%20%20println!(%22%7B%7D%20slices%20left%22%2C%20p.slices)%3B%0A%7D%0A + https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Acell%3A%3ARefCell%3B%0Ause%20std%3A%3Arc%3A%3ARc%3B%0A%0Astruct%20Placinta%20%7B%0A%20%20%20%20felii%3A%20u8%2C%0A%7D%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20mananca_felia(%26mut%20self%2C%20nume%3A%20%26str)%20%7B%0A%20%20%20%20%20%20%20%20println!(%22%7B%7D%20a%20luat%20o%20felie!%22%2C%20nume)%3B%0A%20%20%20%20%20%20%20%20self.felii%20-%3D%201%3B%0A%20%20%20%20%7D%0A%7D%0A%0Astruct%20CreaturaMaritima%20%7B%0A%20%20%20%20nume%3A%20String%2C%0A%20%20%20%20placinta%3A%20Rc%3CRefCell%3CPlacinta%3E%3E%2C%0A%7D%0A%0Aimpl%20CreaturaMaritima%20%7B%0A%20%20%20%20fn%20mananca(%26self)%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20folositi%20un%20smart%20pointer%20catre%20placinta%20pentru%20un%20imprumut%20mutabil%0A%20%20%20%20%20%20%20%20let%20mut%20p%20%3D%20self.placinta.borrow_mut()%3B%0A%20%20%20%20%20%20%20%20%2F%2F%20ia%20o%20muscatura!%0A%20%20%20%20%20%20%20%20p.mananca_felia(%26self.nume)%3B%0A%20%20%20%20%7D%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20let%20placinta%20%3D%20Rc%3A%3Anew(RefCell%3A%3Anew(Placinta%20%7B%20felii%3A%208%20%7D))%3B%0A%20%20%20%20%2F%2F%20ferris%20si%20sarah%20primesc%20clone%20de%20smart%20pointeri%20catre%20placinta%0A%20%20%20%20let%20ferris%20%3D%20CreaturaMaritima%20%7B%0A%20%20%20%20%20%20%20%20nume%3A%20String%3A%3Afrom(%22ferris%22)%2C%0A%20%20%20%20%20%20%20%20placinta%3A%20placinta.clone()%2C%0A%20%20%20%20%7D%3B%0A%20%20%20%20let%20sarah%20%3D%20CreaturaMaritima%20%7B%0A%20%20%20%20%20%20%20%20nume%3A%20String%3A%3Afrom(%22sarah%22)%2C%0A%20%20%20%20%20%20%20%20placinta%3A%20placinta.clone()%2C%0A%20%20%20%20%7D%3B%0A%20%20%20%20ferris.mananca()%3B%0A%20%20%20%20sarah.mananca()%3B%0A%0A%20%20%20%20let%20p%20%3D%20placinta.borrow()%3B%0A%20%20%20%20println!(%22%7B%7D%20felii%20ramase%22%2C%20p.felii)%3B%0A%7D%0A content_markdown: > - Smart pointers might seem limited, but they can make some very powerful - combinations. + Smart pointerii pot părea limitați, dar ei pot realiza niște combinații foarte puternice. - `Rc>` - Allow the cloning of multiple smart pointers that can - borrow the same vector of immutable data structures on the heap. + `Rc>` - Permite clonarea mai multor smart pointeri care pot împrumuta același + vector de structuri de date imuabile pe heap. - `Rc>` - Allow multiple smart pointers the ability to borrow - mutably/immutably the same struct `Foo` + `Rc>`` - Permite ca mai mulți smart pointeri să poată împrumuta în mod + mutabil/imutabil aceeași structură `Foo`. - `Arc>` - Allow multiple smart pointers the ability to lock - temporary mutable/immutable borrows in a CPU thread exclusive manner. + `Arc>`` - Permite mai multor smart pointeri să blocheze împrumuturi temporare + mutabile/imuabile într-o manieră exclusivă pentru thread-ul procesorului. - Memory detail: + Detalii cu privire la memorie: - * You'll notice a theme with many of these combinations. The use of an - immutable data type (possibly owned by multiple smart pointers) to modify - internal data. This - is referred to as the "interior mutability" pattern in Rust. It is a pattern that lets us bend the rules of memory usage at runtime with the same level of safety as Rust's - compile-time checks. - -- title: Chapter 8 - Conclusion + * Veți observa un aspect la multe dintre aceste combinații. Utilizarea unui tip de date imutabil + (posibil deținut de mai mulți smart pointeri) pentru a modifica date interne. Acest lucru este + + cunoscut sub numele de patternul de "mutabilitate interioară" în Rust. Acesta este un pattern care + ne permite să eludăm regulile de utilizare a memoriei la runtime cu același nivel de siguranță + + ca și verificările limbajului Rust la compilare. +- title: Capitolul 8 - Concluzie content_markdown: > - Smart pointers are the idioms of Rust programming and let us not have to - re-create the - - very common patterns of memory usage. With them you are ready to tackle the - toughest of - - challenges! Now that we have the foundations of Rust, let's talk a bit about - how we make - - larger projects. In chapter 9 we break free of single page - - lines of code. + Smart pointeriii sunt idiomurile limbajului de programare Rust și ne permit să nu trebuiască + să recreăm pattern-uri foarte comune de utilizare a memoriei. + + Cu ajutorul lor sunteți gata să abordați cele mai dificile provocări! + + Acum că avem bazele limbajului Rust, haideți să vorbim puțin despre cum facem proiecte mai mari. + În capitolul 9 ne desprindem de lucrul pe o singură pagină de linii de cod. From 2a2d4ee3470745e3346420a11159c4a04abbbc5d Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:07:46 +0200 Subject: [PATCH 03/11] Update lessons/ro/chapter_8.yaml Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index db7db5824..f6e9f1fd7 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -4,7 +4,7 @@ structuri de date care ne permit să interacționăm cu cel mai de jos nivel al memoriei. - Ferris spune: "Nu vă simțiți copleșit de acest capitol dacă nu credeți că puteți scrie + Ferris spune: "Nu vă simțiți copleșiți de acest capitol dacă nu credeți că puteți scrie propriul cod de gestionare a memoriei dintr-o singură lectură scurtă. Acest capitol are în principal rolul de a vă prezenta câteva unelte utile From 6a51e90ae48a366c28c883f964186b6b1f980798 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:08:04 +0200 Subject: [PATCH 04/11] Update lessons/ro/chapter_8.yaml Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index f6e9f1fd7..991412e63 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -5,7 +5,7 @@ Ferris spune: "Nu vă simțiți copleșiți de acest capitol dacă nu credeți că puteți scrie - propriul cod de gestionare a memoriei dintr-o singură lectură scurtă. + propriul cod de gestionare a memoriei după o singură lectură scurtă. Acest capitol are în principal rolul de a vă prezenta câteva unelte utile și de a vă oferi o perspectivă asupra felului în care acestea funcționează!" From 7fc6e9f6dc370c4f3559ac5f7de381192cd5fcf9 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:08:19 +0200 Subject: [PATCH 05/11] Update lessons/ro/chapter_8.yaml Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index 991412e63..c9902768a 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -47,7 +47,7 @@ Detalii despre memorie: * O referință în Rust este foarte asemănătoare cu un pointer în C din punct de vedere al utilizării, dar cu mult - mai multe restricții la momentul compilării asupra modul în care poate fi stocată și transmisă către alte funcții. + mai multe restricții la momentul compilării asupra modului în care poate fi stocată și transmisă către alte funcții. * Un pointer brut în Rust este similar cu un pointer în C, în sensul că reprezintă un număr care poate fi copiat sau transmis și chiar transformat în tipuri numerice unde poate fi modificat pentru a efectua aritmetică cu pointeri. From 6cf8574724278072728f6bc93b7bd203af656b82 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:08:30 +0200 Subject: [PATCH 06/11] Update lessons/ro/chapter_8.yaml Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index c9902768a..59253b74a 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -127,7 +127,7 @@ Ne putem gândi la referințe la un nivel înalt ca la un tip care ne oferă acces la un alt tip. Smart pointerii sunt diferiți în ceea ce privește - comportament față de referințele normale, deoarece aceștia operează pe baza unei logici interne + comportamentul față de referințele normale, deoarece aceștia operează pe baza unei logici interne scrisă de programator. Dumneavoastră - programatorul -sunteți partea *inteligentă*. From c58641b5cfb29262ce2d58dfe2e59dc4866e511d Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:08:39 +0200 Subject: [PATCH 07/11] Update lessons/ro/chapter_8.yaml Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index 59253b74a..a879f6c5e 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -128,7 +128,7 @@ un alt tip. Smart pointerii sunt diferiți în ceea ce privește comportamentul față de referințele normale, deoarece aceștia operează pe baza unei logici interne - scrisă de programator. Dumneavoastră - programatorul -sunteți partea *inteligentă*. + scrisă de programator. Dumneavoastră - programatorul - sunteți partea *inteligentă*. De obicei, smart pointerii implementează trăsăturile `Deref`, `DerefMut` și `Drop` pentru a From dd6d8b7bdcf08a3b27fbec1193f831a43daa0069 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:08:58 +0200 Subject: [PATCH 08/11] Update lessons/ro/chapter_8.yaml Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index a879f6c5e..e4217e5ee 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -139,7 +139,7 @@ code: >- https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20a%3A%20%5Bu8%3B%204%5D%20%3D%20%5B86%2C%2014%2C%2073%2C%2064%5D%3B%0A%20%20%20%20%2F%2F%20acesta%20este%20un%20pointer%20brut.%20Obtinerea%20adresei%20de%20memorie%0A%20%20%20%20%2F%2F%20a%20unui%20numar%20este%20in%20totalitate%20sigur%0A%20%20%20%20let%20pointer_a%20%3D%20%26a%20as%20*const%20u8%20as%20usize%3B%0A%20%20%20%20println!(%22Locatia%20din%20memorie%20a%20datelor%3A%20%7B%7D%22%2C%20pointer_a)%3B%0A%20%20%20%20%2F%2F%20Transformarea%20numarului%20nostru%20intr-un%20pointer%20brut%20la%20un%20f32%0A%20%20%20%20%2F%2F%20este%20de%20asemenea%20sigur%0A%20%20%20%20let%20pointer_b%20%3D%20pointer_a%20as%20*const%20f32%3B%0A%20%20%20%20let%20b%20%3D%20unsafe%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20Acest%20lucru%20este%20nesigur%20deoarece%20ii%20spunem%20compilatorului%0A%20%20%20%20%20%20%20%20%2F%2F%20sa%20presupuna%20ca%20pointerul%20nostru%20este%20un%20f32%20valid%0A%20%20%20%20%20%20%20%20%2F%2F%20si%20sa%20ii%20dereferentieze%20valoarea%20intr-o%20variabila%20b.%0A%20%20%20%20%20%20%20%20%2F%2F%20Rust%20nu%20poate%20verifica%20daca%20aceasta%20presupunere%20este%20corecta.%0A%20%20%20%20%20%20%20%20*pointer_b%0A%20%20%20%20%7D%3B%0A%20%20%20%20println!(%22I%20swear%20this%20is%20a%20pie!%20%7B%7D%22%2C%20b)%3B%0A%20%20%20%20%20%20%20%20%2F%2F%20traducere%20gluma%3A%20%22jur%20ca%20asta%20este%20o%20placinta%22%0A%20%20%20%20%20%20%20%20%2F%2F%20%22pie%22%20suna%20asemenea%20%22pi%22%2C%20constanta%20matematica%0A%7D%0A content_markdown: > - Smart pointerii tind să folosească destul de des cod *neigur*. Asa cum am menționat anterior, + Smart pointerii tind să folosească destul de des cod *nesigur*. Asa cum am menționat anterior, sunt instrumente uzuale în interacțiunea cu cele mai joase niveluri de memorie. From 3e5fab134ff247c8655e81a616192d37eb2ade89 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:09:56 +0200 Subject: [PATCH 09/11] Update lessons/ro/chapter_8.yaml Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index e4217e5ee..385f1701c 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -244,7 +244,7 @@ `RefCell` este o structură de date de tip container ținută în mod obișnuit de smart pointeri care preia date și ne permite - să împrumutăm referințe mutabile și imuabile la ceea ce se află în interior. + să împrumutăm referințe mutabile și imutabile la ceea ce se află în interior. Aceasta previne abuzul de împrumut prin aplicarea regulilor de siguranță a memoriei din Rust în timpul execuției, atunci când cereți împrumutul datelor din interior: From 7d8b6512df445db6da9f4ad9fb0a10b7fb94ce83 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:10:18 +0200 Subject: [PATCH 10/11] Update lessons/ro/chapter_8.yaml Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index 385f1701c..f462a5412 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -250,7 +250,7 @@ din Rust în timpul execuției, atunci când cereți împrumutul datelor din interior: - **Doar o singură referință mutabilă SAU mai multe referințe imuabile, dar nu + **Doar o singură referință mutabilă SAU mai multe referințe imutabile, dar nu ambele!** From de909d94bc47a254e21f0a338bebecf8c21a4972 Mon Sep 17 00:00:00 2001 From: Anne Onciulescu Date: Sun, 14 Jan 2024 23:12:00 +0200 Subject: [PATCH 11/11] last 8 comits were typos fixed as per review of andreigheta Co-authored-by: Gheta Andrei-Cristian <95760823+andreigheta@users.noreply.github.com> --- lessons/ro/chapter_8.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lessons/ro/chapter_8.yaml b/lessons/ro/chapter_8.yaml index f462a5412..4e6c61149 100644 --- a/lessons/ro/chapter_8.yaml +++ b/lessons/ro/chapter_8.yaml @@ -159,7 +159,7 @@ el plasează dereferențierea într-un bloc `unsafe { ... }`. - Smart pointerii *dereferință pointerii bruți* în mod extensiv, dar ei sunt bine dovediți în ceea ce fac. + Smart pointerii *dereferențiază pointerii bruți* în mod extensiv, dar ei sunt buni în ceea ce fac. - title: Prieteni familiari code: >- https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=use%20std%3A%3Aalloc%3A%3A%7Balloc%2C%20Layout%7D%3B%0Ause%20std%3A%3Aops%3A%3ADeref%3B%0A%0A%2F%2F%20aceeasi%20gluma%20cu%20placinta%20(*pie*)%0Astruct%20Placinta%20%7B%0A%20%20%20%20reteta_secreta%3A%20usize%2C%0A%7D%0A%0Aimpl%20Placinta%20%7B%0A%20%20%20%20fn%20new()%20-%3E%20Self%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20hai%20sa%20cerem%204%20bytes%0A%20%20%20%20%20%20%20%20let%20layout%20%3D%20Layout%3A%3Afrom_size_align(4%2C%201).unwrap()%3B%0A%0A%20%20%20%20%20%20%20%20unsafe%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20alocam%20si%20salvam%20locatia%20din%20memore%20ca%20un%20numar%0A%20%20%20%20%20%20%20%20%20%20%20%20let%20ptr%20%3D%20alloc(layout)%20as%20*mut%20u8%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20folosim%20aritmetica%20cu%20pointeri%20si%20scriem%20cateva%20%0A%20%20%20%20%20%20%20%20%20%20%20%20%2F%2F%20valori%20u8%20in%20memorie%0A%20%20%20%20%20%20%20%20%20%20%20%20ptr.write(86)%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20ptr.add(1).write(14)%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20ptr.add(2).write(73)%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20ptr.add(3).write(64)%3B%0A%0A%20%20%20%20%20%20%20%20%20%20%20%20Placinta%20%7B%20reteta_secreta%3A%20ptr%20as%20usize%20%7D%0A%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%7D%0A%7D%0Aimpl%20Deref%20for%20Placinta%20%7B%0A%20%20%20%20type%20Target%20%3D%20f32%3B%0A%20%20%20%20fn%20deref(%26self)%20-%3E%20%26f32%20%7B%0A%20%20%20%20%20%20%20%20%2F%2F%20interpretam%20pointerul%20reteta_secreta%20ca%20un%20pointer%20brut%20f32%0A%20%20%20%20%20%20%20%20let%20pointer%20%3D%20self.reteta_secreta%20as%20*const%20f32%3B%0A%20%20%20%20%20%20%20%20%2F%2F%20il%20dereferentiem%20intr-o%20valoare%20de%20return%20%26f32%0A%20%20%20%20%20%20%20%20unsafe%20%7B%20%26*pointer%20%7D%0A%20%20%20%20%7D%0A%7D%0Afn%20main()%20%7B%0A%20%20%20%20let%20p%20%3D%20Placinta%3A%3Anew()%3B%0A%20%20%20%20%2F%2F%20%22facem%20o%20placinta%22%20dereferentiind%20smart%20pointerul%0A%20%20%20%20%2F%2Fnostru%20la%20structura%20Placinta%20%0A%20%20%20%20println!(%22%7B%3A%3F%7D%22%2C%20*p)%3B%0A%7D%0A