Merge branch 'master' into elixir-casing

1 files changed, 19 insertions, 18 deletions

diff --git a/el-gr/rust-gr.html.markdown b/el-gr/rust-gr.html.markdown
index 4da75b1d..d28e3c2c 100644
--- a/el-gr/rust-gr.html.markdown
+++ b/el-gr/rust-gr.html.markdown
@@ -62,7 +62,7 @@ fn add2(x: i32, y: i32) -> i32 {
 fn main() {
     // Αριθμοί //
 
-    // Αμετάβλητη σύνδεση
+    // Αμετάβλητη δέσμευση (η τιμή που αντιστοιχεί στο όνομα "x" δεν μπορεί να αλλάξει)
     let x: i32 = 1;
 
     // Καταλήξεις integer/float
@@ -80,7 +80,8 @@ fn main() {
     // Πράξεις
     let sum = x + y + 13;
 
-    // Μη-αμετάβλητη αξία (με την έννοια ότι μπορεί να αλλάξει)
+    // Μεταβλητές (με την έννοια των προστακτικών γλωσσών προγραμματισμού).
+    // Στη Rust η αμετάβλητη δέσμευση είναι στάνταρ. Το mut δηλώνει μεταβλητότητα.
     let mut mutable = 1;
     mutable = 4;
     mutable += 2;
@@ -96,7 +97,7 @@ fn main() {
     // A `String` – a heap-allocated string
     let s: String = "καλημέρα κόσμε".to_string();
 
-    // Ένα κομμάτι αλφαριθμητικού (string slice) – μια μη-μεταβλητή οπτική γωνία προς ένα άλλο αλφαριθμητικό
+    // Ένα κομμάτι αλφαριθμητικού (string slice) – μια αμετάβλητη οπτική γωνία προς ένα άλλο αλφαριθμητικό
     // Το αλφαριθμητικό μπορεί να είναι στατικό όπως τα σταθερά αλφαριθμητικά, ή να περιλαμβάνεται σε ένα άλλο,
     // δυναμικό αντικείμενο (σε αυτή την περίπτωση τη μεταβλητή `s`)
     let s_slice: &str = &s;
@@ -112,7 +113,7 @@ fn main() {
     let mut vector: Vec<i32> = vec![1, 2, 3, 4];
     vector.push(5);
 
-    // Ένα κομμάτι – μια μη-μεταβλητή οπτική γωνία προς ένα διάνυσμα ή πίνακα
+    // Ένα κομμάτι – μια αμετάβλητη οπτική γωνία προς ένα διάνυσμα ή πίνακα
     // Είναι παρόμοιο με το κομμάτι αλφαριθμητικού που είδαμε προηγουμένως
     let slice: &[i32] = &vector;
 
@@ -121,10 +122,10 @@ fn main() {
 
     // Tuples (πλειάδες) //
 
-    // Ένα tuple είναι μια σταθερού μεγέθους σειρά από αξίες (πιθανά διαφορετικού τύπου)
+    // Ένα tuple είναι μια σταθερού μεγέθους σειρά από τιμές (πιθανά διαφορετικού τύπου)
     let x: (i32, &str, f64) = (1, "καλημέρα", 3.4);
 
-    // Μπορούμε να χρησιμοποιήσουμε το `let` και ένα tuple για να δώσουμε πολλές αξίες σε πολλές μεταβλητές ταυτόχρονα
+    // Μπορούμε να χρησιμοποιήσουμε το `let` και ένα tuple για να δώσουμε πολλές τιμές σε πολλές μεταβλητές ταυτόχρονα
     // (destructuring `let`)
     let (a, b, c) = x;
     println!("{} {} {}", a, b, c); // 1 καλημέρα 3.4
@@ -185,7 +186,7 @@ fn main() {
         fn bar(&self) -> &T { // Δανειζόμαστε το self
             &self.bar
         }
-        fn bar_mut(&mut self) -> &mut T { // Δανειζόμαστε το self ως μη-αμετάβλητη αξία
+        fn bar_mut(&mut self) -> &mut T { // Γίνεται "μεταβλητός δανεισμός" του self (μπορούμε να το τροποποιήσουμε)
             &mut self.bar
         }
         fn into_bar(self) -> T { // Εδώ το self καταναλώνεται
@@ -240,7 +241,7 @@ fn main() {
     // 4. Έλεγχος ροής //
     /////////////////////
 
-    // Βρόγχοι `for`
+    // Βρόχοι `for`
     let array = [1, 2, 3];
     for i in array {
         println!("{}", i);
@@ -253,7 +254,7 @@ fn main() {
     println!("");
     // Τυπώνει `0 1 2 3 4 5 6 7 8 9 `
 
-    // Βρόγχοι `if`
+    // `if` (υπό συνθήκη διακλάδωση)
     if 1 == 1 {
         println!("Τα μαθηματικά δουλεύουν!");
     } else {
@@ -267,17 +268,17 @@ fn main() {
         "κακό"
     };
 
-    // Βρόγχοι `while`
+    // Βρόχοι `while`
     while 1 == 1 {
         println!("Το σύμπαν λειτουργεί κανονικά.");
-        // Μπορούμε να βγούμε από το βρόγχο με το `break`
+        // Μπορούμε να βγούμε από το βρόχο με το `break`
         break
     }
 
-    // Ατέρμονος βρόχγος
+    // Ατέρμονος βρόχος
     loop {
         println!("Καλημέρα!");
-        // Μπορούμε να βγούμε από το βρόγχο με το `break`
+        // Μπορούμε να βγούμε από το βρόχο με το `break`
         break
     }
 
@@ -294,11 +295,11 @@ fn main() {
     *now_its_mine += 2;
 
     println!("{}", now_its_mine); // 7
-    // println!("{}", mine); // Αυτό παράγει λάθος κατά τη μεταγλώττιση διότι τώρα ο δείκτης ανοίκει στο `now_its_mine`
+    // println!("{}", mine); // Αυτό παράγει λάθος κατά τη μεταγλώττιση διότι τώρα ο δείκτης ανήκει στο `now_its_mine`
 
     // Reference (αναφορά) – ένας αμετάβλητος δείκτης που αναφέρεται σε άλλα δεδομένα
-    // Όταν μια αναφορά δίνεται σε μια αξία, λέμε πως η αξία έχει "δανειστεί".
-    // Όταν μια αξία δανείζεται αμετάβλητα, δεν μπορεί να είναι mutated (να μεταβληθεί) ή να μετακινηθεί.
+    // Όταν μια αναφορά δίνεται σε μια τιμή, λέμε πως η τιμή έχει "δανειστεί".
+    // Όταν μια τιμή δανείζεται αμετάβλητα, δεν μπορεί να είναι mutated (να μεταβληθεί) ή να μετακινηθεί.
     // Ένας "δανεισμός" παραμένει ενεργός μέχρι την τελευταία χρήση της μεταβλητής που δανείζεται.
     let mut var = 4;
     var = 3;
@@ -313,13 +314,13 @@ fn main() {
     var = 2; // Η `ref_var` δεν χρησιμοποιείται από εδώ και στο εξής, άρα ο "δανεισμός" τελειώνει
 
     // Μεταβλητή αναφορά
-    // Όσο μια αξία είναι μεταβλητά δανεισμένη, παραμένει τελείως απροσβάσιμη.
+    // Όσο μια τιμή είναι μεταβλητά δανεισμένη, παραμένει τελείως απροσβάσιμη.
     let mut var2 = 4;
     let ref_var2: &mut i32 = &mut var2;
     *ref_var2 += 2; // Ο αστερίσκος (*) χρησιμοποιείται ως δείκτης προς την μεταβλητά δανεισμένη `var2`
 
     println!("{}", *ref_var2); // 6 , // Αν είχαμε `var2` εδώ θα προκαλούνταν λάθος μεταγλώττισης.
-    // O τύπος της `ref_var2` είναι &mut i32, άρα αποθηκεύει μια αναφορά προς μια αξία i32, όχι την αξία την ίδια.
+    // O τύπος της `ref_var2` είναι &mut i32, άρα αποθηκεύει μια αναφορά προς μια τιμή i32, όχι την τιμή την ίδια.
     // var2 = 2; // Λάθος μεταγλώττισης, γιατί η `var2` είναι δανεισμένη.
     ref_var2; // Εντολή no-op (τίποτα δεν εκτελείται από τον επεξεργαστή), η οποία όμως μετράει ως χρήση και κρατά τον
               // "δανεισμό" ενεργό