રસ્ટ 1.35

રસ્ટ ડેવલપમેન્ટ ટીમ તેમની ભાષાના નવા સંસ્કરણની જાહેરાત કરીને ખુશ છે: 1.35. રસ્ટ એ એક પ્રોગ્રામિંગ ભાષા છે જે તમને વિશ્વસનીય અને કાર્યક્ષમ પ્રોગ્રામ લખવા દે છે.

જો તમારી પાસે રસ્ટઅપ દ્વારા પહેલાથી જ રસ્ટ ઇન્સ્ટોલ કરેલ છે, તો તમે આદેશ સાથે અપડેટ કરી શકો છો:
$ rustup અપડેટ સ્થિર

અપડેટમાં મુખ્ય વસ્તુ અનુક્રમે Box, Box, Box માટે બંધ લક્ષણો Fn, FnOnce, FnMut નો અમલ છે. અસુરક્ષિત કાર્યો માટે પોઇન્ટર પર ક્લોઝર કાસ્ટ કરવાની ક્ષમતા ઉમેરવાનું, dbg!() મેક્રોને કૉલ કરવું હવે દલીલો વિના શક્ય છે, અને પ્રમાણભૂત લાઇબ્રેરીને સ્થિર કરવામાં આવી છે.

વિગતો માટે:

• નવા સંસ્કરણમાં, Fn, FnOnce, FnMut લક્ષણોના અમલીકરણો અનુક્રમે Box, Box, Box માટે ઉમેરવામાં આવ્યા છે.
  હવે આ કોડ કામ કરશે:
  fn foo(x: Box u8>) -> Vec {
  vec![1, 2, 3, 4].into_iter().map(x).collect()
  }

  તમે Box થી સીધું ક્લોઝર પણ કૉલ કરી શકો છો:
  fn foo(x: Box) {
  x()
  }

• બંધ હવે અસુરક્ષિત એફએનના નિર્દેશકો પર કાસ્ટ કરી શકાય છે.
  હવે આ કોડ માન્ય છે:
  /// સેફ્ટી ઇનવેરિઅન્ટ્સ એ પાસ કરેલ `અસુરક્ષિત fn` પોઇન્ટર છે.
  unsafe fn call_unsafe_fn_ptr(f: unsafe fn()) {
  f()
  }

  fn main() {
  // સલામતી: ત્યાં કોઈ અનિવાર્ય નથી.
  // બંધને સ્થિર રીતે અસુરક્ષિત વસ્તુઓ કરવાથી અટકાવવામાં આવે છે.
  અસુરક્ષિત {
  call_unsafe_fn_ptr(|| {
  dbg!();
  });
  }
  }

• દલીલો વિના dbg!() મેક્રોને કૉલ કરવાની ક્ષમતા ઉમેરી.
  જો તમે આ મેક્રોમાં અમુક અભિવ્યક્તિ પસાર કરો છો, તો મેક્રો તેનું પરિણામ છાપશે. ઉદાહરણ:
  fn main() {
  ચાલો mut x = 0;

  જો dbg!(x == 1) {
  x += 1;
  }

  dbg!(x);
  }

  જ્યારે તમે આ કોડ ચલાવો છો ત્યારે તમે જોશો:
  [src/main.rs:4] x == 1 = ખોટા
  [src/main.rs:8] x = 0

  હવે તમે આના જેવું લખી શકો છો:
  fn main() {
  let condition = true;

  જો સ્થિતિ {
  dbg!();
  }
  }

  જ્યારે તમે આ કોડ ચલાવો છો ત્યારે તમે જોશો:
  [src/main.rs:5]
  

• પ્રમાણભૂત પુસ્તકાલયના કેટલાક ભાગોને સ્થિર કરવામાં આવ્યા છે
  • f32 અને f64 માટે નવી પદ્ધતિઓ:
    • f32::copysign
    • f64::copysign

    વાસ્તવમાં, ફંક્શન્સ બીજા નંબરના ચિહ્નની નકલ કરે છે. ઉદાહરણ:
    fn main() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • શ્રેણી પ્રકારો માટે નવી પદ્ધતિઓ ઉમેરી
    • શ્રેણી:: સમાવે છે
    • RangeFrom:: સમાવે છે
    • RangeTo:: સમાવે છે
    • RangeInclusive:: સમાવે છે
    • RangeToInclusive:: સમાવે છે

    આ પદ્ધતિઓ દ્વારા તમે સરળતાથી ચકાસી શકો છો કે કોઈ ચોક્કસ મૂલ્ય અનુક્રમમાં છે કે નહીં:
    fn main() {
    જો (0..=10). સમાવે છે(&5) {
    println!("શૂન્યથી દસમાં પાંચનો સમાવેશ થાય છે.");
    }
    }

  • તમે સ્થિર API ની સંપૂર્ણ સૂચિ શોધી શકો છો અહીં
• આ અપડેટમાં, ક્લિપ્પી (આ એક પ્રોગ્રામ છે જે તમારા કોડને ઘણી ભૂલો માટે તપાસે છે) એ ડ્રોપ_બાઉન્ડ્સ માટે એક નવો ચેક ઉમેર્યો છે. જ્યારે તમે કોઈ અવરોધ સેટ કરો છો ત્યારે આ ચેક કામ કરે છે: T: ડ્રોપ - સામાન્યકૃત કાર્યો માટે:
  fn foo(x: T) {}

  T: ડ્રોપ પ્રતિબંધ મોટાભાગે ભૂલ છે, કારણ કે કેટલાક પ્રકારોને તરત જ બાકાત રાખવામાં આવે છે, જેમ કે u8. (તમે આ વિશે વધુ વાંચી શકો છો. અહીં)

• કાર્ગો (ભાષા પેકેજ મેનેજર) માં ઘણા બધા સુધારા અને સુધારાઓ, ફેરફારોની સંપૂર્ણ સૂચિ

સોર્સ: linux.org.ru