Rost. Checker über Iteratoren ausleihen

Vorwort

Iterator

    val vec = Vector(1,2,3,4)
    val result = vec.filter(e => e % 2 == 0)

  private[scala] def filterImpl(p: A => Boolean, isFlipped: Boolean): Repr = {
    val b = newBuilder
    for (x <- this)
      if (p(x) != isFlipped) b += x

    b.result
  }

    let v: Vec<i32> = vec![1, 2, 3, 4];
    let result: Vec<&i32> = v.iter().filter(|e| **e % 2 == 0).collect();

1. Holen Sie sich explizit den Iterator auf den Vektor (`iter ()`)
2. In der Prädikatfunktion dereferenzieren wir aus irgendeinem Grund den Zeiger zweimal
3. Rufen Sie `collect ()` auf
4. es ergab sich auch ein Vektor der Referenztypen Vec <& i32> und nicht gewöhnlicher Ints

Checker ausleihen

1. Um Situationen zu vermeiden, in denen mehrere Zeiger auf denselben Speicherbereich zeigen, können Sie ihn ändern. Das ist eine Rennbedingung.
2. Um den Speicher nicht mehrmals freizugeben.

struct X; // 

fn test_borrow_checker () -> X {
    let first = X; //  
    let second = first; //  
    let third = first; //   ,   first   
//    value used here after move

    return third;
}

fn test_borrow_checker () -> i32 {
    let first = 32;
    let second = first; 
    let third = first; 

    return third;
}

let coll_1 = vec![1,2,3];
let coll_2: Vec<i32> = coll_1.into_iter().collect();
//coll_1 doesn't exists anymore

Zeiger

#[derive(Debug)]
struct Y; // 

fn test_borrow_checker() -> Y {
    let first = Y; //  
    let second: &Y = &first; //   ,     
    let third = &first; //    

// 
    println!("{:?}", second);
    println!("{:?}", third);

    return first;
}

// 
struct X {
    x: i32,
} 

fn test_borrow_checker() -> X {
    let mut first = X { x: 20 }; //  
    let second: &mut X = &mut first; //   
    let third: &mut X = &mut first; //    .        `second`        - .
//    second.x = 33;  //    ,             ,    
    third.x = 33;

    return first;
}

Iteratoren

1. Absorption, Ausleihe, Bewegung
2. Verknüpfung
3. Veränderliche Verbindung

1. IntoIter absorbiert Objekte aus der Originalsammlung
2. Iter läuft auf Objektverknüpfungen
3. IterMut wird auf veränderlichen Objektreferenzen ausgeführt

#[derive(PartialEq, Eq)]
enum Sex {
    Male,
    Female
}

struct Scholar {
    name: String,
    age: i32,
    sex: Sex
}

let scholars: Vec<Scholar> = ...;

fn bad_idea() {
    let scholars: Vec<Scholar> = Vec::new();
    let girls_c = scholars
        .into_iter()
        .filter(|s| (*s).sex == Sex::Female)
        .count();

    let boys_c = scholars 
        .into_iter()
        .filter(|s| (*s).sex == Sex::Male)
        .count();
}

fn good_idea() {
    let scholars: Vec<Scholar> = Vec::new();
    let girls_c = scholars.iter().filter(|s| (**s).sex == Sex::Female).count();
    let boys_c = scholars.iter().filter(|s| (**s).sex == Sex::Male).count();
}

fn very_good_idea() {
    let mut scholars: Vec<Scholar> = Vec::new();
    scholars.iter_mut().for_each(|s| (*s).sex = Sex::Male);
}

impl Scholar {
    fn to_soldier(self) -> Soldier {
        Soldier { forgotten_name: self.name, number: some_random_number_generator() }
    }
}

struct Soldier {
    forgotten_name: String,
    number: i32
}

fn good_bright_future() {
    let mut scholars: Vec<Scholar> = Vec::new();
    scholars.iter_mut().for_each(|s| (*s).sex = Sex::Male);
    let soldiers: Vec<Soldier> = scholars.into_iter().map(|s| s.to_soldier()).collect();
    //   scholars,    
}

    fn filter<P>(self, predicate: P) -> Filter<Self, P> where
        Self: Sized, P: FnMut(&Self::Item) -> bool,

Fortsetzung

• wie und wann Speicherfreigabe erfolgt
• Link-Lebensdauer
• asynchrone Programmierung
• Wenn Sie einen kleinen Webdienst schreiben, können Sie sogar API anbieten

Links

• Rostbuch
• Aufgrund des Eigentumskonzepts ist die Implementierung grundlegender Dinge wie beispielsweise einer verknüpften Liste nicht mehr trivial. Hier sind verschiedene Möglichkeiten, wie Sie sie implementieren können.