Rouille. Emprunter le vérificateur via des itérateurs

Préface

Itérateur

    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. obtenir explicitement l'itérateur sur le vecteur (`iter ()`)
2. dans la fonction prédicat, pour une raison quelconque, nous déréférencer le pointeur deux fois
3. appelez `collect ()`
4. cela a également donné lieu à un vecteur de types de référence Vec <& i32>, et non à des nombres ordinaires

Vérificateur d'emprunt

1. Pour éviter les situations où plusieurs pointeurs pointent vers la même zone mémoire, ce qui vous permet de la modifier. C'est une condition de course.
2. Afin de ne pas désallouer plusieurs fois la même mémoire.

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

Pointeurs

#[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;
}

Itérateurs

1. Absorption, emprunt, déménagement
2. Lien
3. Lien mutable

1. IntoIter absorbe les objets de la collection originale
2. Iter s'exécute sur des liens d'objet
3. IterMut s'exécute sur des références d'objets mutables

#[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,

Continuation

• comment et quand la désallocation de mémoire se produit
• durée de vie du lien
• programmation asynchrone
• écrire un petit service web, vous pouvez même proposer des api

Liens

• livre de rouille
• En raison du concept de propriété, la mise en œuvre d'éléments de base tels que, par exemple, une liste chaînée n'est plus anodine. Voici plusieurs façons de les implémenter.