जंग। Iterators के माध्यम से उधारकर्ता चेक

प्रस्तावना

इटरेटर

    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. स्पष्ट रूप से वेक्टर पर पुनरावृत्ति प्राप्त करें (`iter ()`)
2. किसी कार्य के लिए, किसी कारण से, हम सूचक को दो बार रोकते हैं
3. कॉल `इकट्ठा ()`
4. यह संदर्भ प्रकार Vec <& i32> के वेक्टर के परिणामस्वरूप हुआ, न कि साधारण इन्ट्स में

उधार चेक करने वाला

1. स्थितियों से बचने के लिए जब कई पॉइंटर्स एक ही मेमोरी क्षेत्र की ओर इशारा करते हैं, तो आप इसे बदल सकते हैं। यह एक दौड़ की स्थिति है।
2. आदेश में एक ही स्मृति को कई बार डील करने के लिए नहीं।

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

संकेत

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

iterators

1. अवशोषण, उधार, चलती है
2. संपर्क
3. परस्पर लिंक

1. IntoIter मूल संग्रह से वस्तुओं को अवशोषित करता है
2. Iter ऑब्जेक्ट लिंक पर चलता है
3. IterMut उत्परिवर्तनीय वस्तु संदर्भों पर चलता है

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

विस्तार

• मेमोरी डीलोकेशन कैसे और कब होता है
• लिंक जीवन भर
• अतुल्यकालिक प्रोग्रामिंग
• एक छोटी सी वेब सेवा लिखना, आप एपीआई भी प्रदान कर सकते हैं

लिंक

• जंग की किताब
• स्वामित्व की अवधारणा के कारण, इस तरह की बुनियादी चीजों के कार्यान्वयन, उदाहरण के लिए, एक लिंक की गई सूची अब तुच्छ नहीं है। उन्हें लागू करने के कई तरीके यहां दिए गए हैं ।