തുരുമ്പ് 1.35

റസ്റ്റ് ഡെവലപ്‌മെന്റ് ടീം അവരുടെ ഭാഷയുടെ ഒരു പുതിയ പതിപ്പ് പ്രഖ്യാപിക്കുന്നതിൽ സന്തോഷിക്കുന്നു: 1.35. വിശ്വസനീയവും കാര്യക്ഷമവുമായ പ്രോഗ്രാമുകൾ എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയാണ് റസ്റ്റ്.

നിങ്ങൾ ഇതിനകം റസ്റ്റപ്പ് വഴി റസ്റ്റ് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് അപ്ഡേറ്റ് ചെയ്യാം:
$ റസ്റ്റപ്പ് അപ്ഡേറ്റ് സ്ഥിരതയുള്ളതാണ്

അപ്‌ഡേറ്റിലെ പ്രധാന കാര്യം ബോക്‌സിനായി Fn, FnOnce, FnMut, അടച്ചുപൂട്ടൽ സ്വഭാവസവിശേഷതകൾ നടപ്പിലാക്കുക എന്നതാണ്. ,പെട്ടി ,പെട്ടി , യഥാക്രമം. സുരക്ഷിതമല്ലാത്ത ഫംഗ്‌ഷനുകളിലേക്ക് പോയിന്ററുകളിലേക്ക് ക്ലോഷറുകൾ കാസ്‌റ്റുചെയ്യാനുള്ള കഴിവ് ചേർക്കുന്നു, dbg!() മാക്രോയിലേക്ക് വിളിക്കുന്നത് ഇപ്പോൾ ആർഗ്യുമെന്റുകളില്ലാതെ സാധ്യമാണ്, കൂടാതെ സ്റ്റാൻഡേർഡ് ലൈബ്രറി സുസ്ഥിരമാക്കിയിരിക്കുന്നു.

വിശദാംശങ്ങളിലേക്ക്:

• പുതിയ പതിപ്പിൽ, ബോക്സിനുള്ള Fn, FnOnce, FnMut സ്വഭാവസവിശേഷതകൾ ഞങ്ങൾ ചേർത്തു. ,പെട്ടി ,പെട്ടി , യഥാക്രമം.
  ഇപ്പോൾ ഈ കോഡ് പ്രവർത്തിക്കും:
  fn foo(x: ബോക്സ് u8>) -> വെക് {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  നിങ്ങൾക്ക് ബോക്സിൽ നിന്ന് നേരിട്ട് ഒരു ക്ലോഷർ വിളിക്കാനും കഴിയും :
  fn foo(x: ബോക്സ് ) {
  x()
  }

• സുരക്ഷിതമല്ലാത്ത fn-ലേക്കുള്ള പോയിന്ററുകളിലേക്ക് ഇപ്പോൾ അടച്ചുപൂട്ടലുകൾ കാസ്‌റ്റുചെയ്യാനാകും.
  ഇപ്പോൾ ഈ കോഡ് സാധുവാണ്:
  /// 'സുരക്ഷിതമല്ലാത്ത എഫ്എൻ' പോയിന്റർ പാസ്സാക്കിയവയാണ് സുരക്ഷാ വ്യത്യാസങ്ങൾ.
  സുരക്ഷിതമല്ലാത്ത fn call_unsafe_fn_ptr(f: സുരക്ഷിതമല്ലാത്ത fn()) {
  f()
  }

  fn പ്രധാന() {
  // സുരക്ഷ: മാറ്റങ്ങളൊന്നുമില്ല.
  // സുരക്ഷിതമല്ലാത്ത കാര്യങ്ങൾ ചെയ്യുന്നതിൽ നിന്ന് അടച്ചുപൂട്ടൽ സ്ഥിരമായി തടഞ്ഞിരിക്കുന്നു.
  സുരക്ഷിതമല്ല {
  call_unsafe_fn_ptr(|| {
  dbg!();
  });
  }
  }

• ആർഗ്യുമെന്റുകളില്ലാതെ dbg!() മാക്രോയെ വിളിക്കാനുള്ള കഴിവ് ചേർത്തു.
  നിങ്ങൾ ഈ മാക്രോയിലേക്ക് കുറച്ച് എക്സ്പ്രഷൻ നൽകിയാൽ, മാക്രോ അതിന്റെ ഫലം പ്രിന്റ് ചെയ്യും. ഉദാഹരണം:
  fn പ്രധാന() {
  മട്ട് x = 0 ആകട്ടെ;

  dbg ആണെങ്കിൽ!(x == 1) {
  x += 1;
  }

  dbg!(x);
  }

  നിങ്ങൾ ഈ കോഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ നിങ്ങൾ കാണും:
  [src/main.rs:4] x == 1 = തെറ്റ്
  [src/main.rs:8] x = 0

  ഇപ്പോൾ നിങ്ങൾക്ക് ഇങ്ങനെ എഴുതാം:
  fn പ്രധാന() {
  അവസ്ഥ അനുവദിക്കുക = true;

  വ്യവസ്ഥ {
  dbg!();
  }
  }

  നിങ്ങൾ ഈ കോഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ നിങ്ങൾ കാണും:
  [src/main.rs:5]
  

• സാധാരണ ലൈബ്രറിയുടെ ചില ഭാഗങ്ങൾ സുസ്ഥിരമാക്കി
  • f32, f64 എന്നിവയ്ക്കുള്ള പുതിയ രീതികൾ:
    • f32:: കോപ്പിസൈൻ
    • f64:: കോപ്പിസൈൻ

    യഥാർത്ഥത്തിൽ, ഫംഗ്‌ഷനുകൾ മറ്റൊരു സംഖ്യയുടെ അടയാളം പകർത്തുന്നു. ഉദാഹരണം:
    fn പ്രധാന() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • ശ്രേണി തരങ്ങൾക്കായി പുതിയ രീതികൾ ചേർത്തു
    • ശ്രേണി:: അടങ്ങിയിരിക്കുന്നു
    • ശ്രേണിയിൽ നിന്ന്:: അടങ്ങിയിരിക്കുന്നു
    • RangeTo:: അടങ്ങിയിരിക്കുന്നു
    • ശ്രേണി ഉൾപ്പെടെ:: അടങ്ങിയിരിക്കുന്നു
    • RangeToInclusive:: അടങ്ങിയിരിക്കുന്നു

    ഈ രീതികൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു നിശ്ചിത മൂല്യം ഒരു ക്രമത്തിലാണോ എന്ന് എളുപ്പത്തിൽ പരിശോധിക്കാൻ കഴിയും:
    fn പ്രധാന() {
    എങ്കിൽ (0..=10).(&5) അടങ്ങിയിരിക്കുന്നു {
    println!("പൂജ്യം മുതൽ പത്ത് വരെയുള്ളതിൽ അഞ്ച് ഉൾപ്പെടുന്നു.");
    }
    }

  • നിങ്ങൾക്ക് സ്ഥിരതയുള്ള API-കളുടെ പൂർണ്ണമായ ലിസ്റ്റ് കണ്ടെത്താം ഇവിടെ
• ഈ അപ്‌ഡേറ്റിൽ, Clippy (ഇത് നിരവധി പിശകുകൾക്കായി നിങ്ങളുടെ കോഡ് പരിശോധിക്കുന്ന ഒരു പ്രോഗ്രാമാണ്) drop_bounds-നായി ഒരു പുതിയ പരിശോധന ചേർത്തു. നിങ്ങൾ ഒരു നിയന്ത്രണം സജ്ജീകരിക്കുമ്പോൾ ഈ പരിശോധന പ്രവർത്തിക്കുന്നു: ടി: ഡ്രോപ്പ് - പൊതുവായ പ്രവർത്തനങ്ങൾക്കായി:
  fn foo (x:T){}

  u8 പോലെയുള്ള ചില തരങ്ങൾ ഉടനടി ഒഴിവാക്കിയതിനാൽ, ടി: ഡ്രോപ്പ് നിയന്ത്രണം പലപ്പോഴും ഒരു തെറ്റാണ്. (നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് കൂടുതൽ വായിക്കാം ഇവിടെ)

• കാർഗോയിൽ ധാരാളം മെച്ചപ്പെടുത്തലുകളും പരിഹാരങ്ങളും (ഭാഷാ പാക്കേജ് മാനേജർ), മാറ്റങ്ങളുടെ മുഴുവൻ പട്ടിക

അവലംബം: linux.org.ru