ತುಕ್ಕು 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: unsafe fn()) {
  f()
  }

  fn ಮುಖ್ಯ() {
  // ಸುರಕ್ಷತೆ: ಯಾವುದೇ ಬದಲಾವಣೆಗಳಿಲ್ಲ.
  // ಅಸುರಕ್ಷಿತ ಕೆಲಸಗಳನ್ನು ಮಾಡುವುದರಿಂದ ಮುಚ್ಚುವಿಕೆಯನ್ನು ಸ್ಥಿರವಾಗಿ ತಡೆಯಲಾಗಿದೆ.
  ಅಸುರಕ್ಷಿತ {
  ಕರೆ_ಅಸುರಕ್ಷಿತ_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 ಮುಖ್ಯ() {
  ಅವಕಾಶ ಸ್ಥಿತಿ = ನಿಜ;

  ಸ್ಥಿತಿ {
  dbg!();
  }
  }

  ನೀವು ಈ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡಿದಾಗ ನೀವು ನೋಡುತ್ತೀರಿ:
  [src/main.rs:5]
  

• ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯದ ಕೆಲವು ಭಾಗಗಳನ್ನು ಸ್ಥಿರಗೊಳಿಸಲಾಗಿದೆ
  • F32 ಮತ್ತು f64 ಗಾಗಿ ಹೊಸ ವಿಧಾನಗಳು:
    • f32 :: ನಕಲು ಚಿಹ್ನೆ
    • f64 :: ನಕಲು ಚಿಹ್ನೆ

    ವಾಸ್ತವವಾಗಿ, ಕಾರ್ಯಗಳು ಮತ್ತೊಂದು ಸಂಖ್ಯೆಯ ಚಿಹ್ನೆಯನ್ನು ನಕಲಿಸುತ್ತವೆ. ಉದಾಹರಣೆ:
    fn ಮುಖ್ಯ() {
    assert_eq!(3.5_f32.copysign(-0.42), -3.5);
    }

  • ಶ್ರೇಣಿಯ ಪ್ರಕಾರಗಳಿಗೆ ಹೊಸ ವಿಧಾನಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ
    • ಶ್ರೇಣಿ ::ಒಳಗೊಂಡಿದೆ
    • ಶ್ರೇಣಿಯಿಂದ:: ಒಳಗೊಂಡಿದೆ
    • ಶ್ರೇಣಿಗೆ:: ಒಳಗೊಂಡಿದೆ
    • ವ್ಯಾಪ್ತಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ:: ಒಳಗೊಂಡಿದೆ
    • RangeToInclusive::ಒಳಗೊಂಡಿದೆ

    ಈ ವಿಧಾನಗಳೊಂದಿಗೆ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವು ಅನುಕ್ರಮದಲ್ಲಿದೆಯೇ ಎಂದು ನೀವು ಸುಲಭವಾಗಿ ಪರಿಶೀಲಿಸಬಹುದು:
    fn ಮುಖ್ಯ() {
    (0..=10) ಹೊಂದಿದ್ದರೆ (&5) {
    println!("ಐದು ಸೊನ್ನೆಯಿಂದ ಹತ್ತರಲ್ಲಿ ಸೇರಿದೆ.");
    }
    }

  • ನೀವು ಸ್ಥಿರವಾದ API ಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಕಾಣಬಹುದು ಇಲ್ಲಿ
• ಈ ಅಪ್‌ಡೇಟ್‌ನಲ್ಲಿ, ಕ್ಲಿಪ್ಪಿ (ಇದು ಅನೇಕ ದೋಷಗಳಿಗಾಗಿ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವ ಪ್ರೋಗ್ರಾಂ) drop_bounds ಗಾಗಿ ಹೊಸ ಚೆಕ್ ಅನ್ನು ಸೇರಿಸಿದೆ. ನೀವು ನಿರ್ಬಂಧವನ್ನು ಹೊಂದಿಸಿದಾಗ ಈ ಚೆಕ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: T: ಡ್ರಾಪ್ - ಸಾಮಾನ್ಯೀಕರಿಸಿದ ಕಾರ್ಯಗಳಿಗಾಗಿ:
  fn foo (x:T){}

  u8 ನಂತಹ ಕೆಲವು ಪ್ರಕಾರಗಳನ್ನು ತಕ್ಷಣವೇ ಹೊರಗಿಡುವುದರಿಂದ T: ಡ್ರಾಪ್ ನಿರ್ಬಂಧವು ಹೆಚ್ಚಾಗಿ ತಪ್ಪಾಗಿದೆ. (ನೀವು ಇದರ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ಓದಬಹುದು ಇಲ್ಲಿ)

• ಕಾರ್ಗೋದಲ್ಲಿ ಬಹಳಷ್ಟು ಸುಧಾರಣೆಗಳು ಮತ್ತು ಪರಿಹಾರಗಳು (ಭಾಷಾ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್), ಬದಲಾವಣೆಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿ

ಮೂಲ: linux.org.ru