Oxido. Verificador de préstamos a través de iteradores

Prefacio

Iterador

    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. obtener explícitamente el iterador en el vector (`iter ()`)
2. en la función predicado, por alguna razón, desreferenciamos el puntero dos veces
3. llame a `collect ()`
4. también dio como resultado un vector de tipos de referencia Vec <& i32>, y no ints ordinarios

Verificador de préstamos

1. Para evitar situaciones en las que varios punteros apuntan a la misma área de memoria, lo que le permite cambiarla. Esa es una condición de carrera.
2. Para no desasignar la misma memoria varias veces.

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

Punteros

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

Iteradores

1. Absorción, préstamo, mudanza.
2. Enlace
3. Enlace mutable

1. IntoIter absorbe objetos de la colección original.
2. Iter se ejecuta en enlaces de objetos
3. IterMut se ejecuta en referencias de objetos 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,

Continuación

• cómo y cuándo ocurre la desasignación de memoria
• enlace de por vida
• programación asincrónica
• escribiendo un pequeño servicio web, incluso puedes ofrecer API

Enlaces

• libro de óxido
• Debido al concepto de propiedad, la implementación de cosas básicas como, por ejemplo, una lista vinculada ya no es trivial. Aquí hay varias formas de implementarlas.