ರಸ್ಟ್ 1.63 ಸಾಮಾನ್ಯ-ಉದ್ದೇಶದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಬಿಡುಗಡೆಯನ್ನು ಮೊಜಿಲ್ಲಾ ಯೋಜನೆಯಿಂದ ಸ್ಥಾಪಿಸಲಾಗಿದೆ, ಆದರೆ ಈಗ ಸ್ವತಂತ್ರ ಲಾಭೋದ್ದೇಶವಿಲ್ಲದ ಸಂಸ್ಥೆ ರಸ್ಟ್ ಫೌಂಡೇಶನ್ ಆಶ್ರಯದಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ. ಭಾಷೆ ಮೆಮೊರಿ ಸುರಕ್ಷತೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಕಸ ಸಂಗ್ರಾಹಕ ಮತ್ತು ರನ್ಟೈಮ್ ಬಳಕೆಯನ್ನು ತಪ್ಪಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಹೆಚ್ಚಿನ ಕೆಲಸದ ಸಮಾನಾಂತರತೆಯನ್ನು ಸಾಧಿಸಲು ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ (ರನ್ಟೈಮ್ ಅನ್ನು ಮೂಲ ಪ್ರಾರಂಭ ಮತ್ತು ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯದ ನಿರ್ವಹಣೆಗೆ ಕಡಿಮೆ ಮಾಡಲಾಗಿದೆ).
ರಸ್ಟ್ನ ಮೆಮೊರಿ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ವಿಧಾನಗಳು ಪಾಯಿಂಟರ್ಗಳನ್ನು ಮ್ಯಾನಿಪ್ಯುಲೇಟ್ ಮಾಡುವಾಗ ಡೆವಲಪರ್ ಅನ್ನು ದೋಷಗಳಿಂದ ಉಳಿಸುತ್ತದೆ ಮತ್ತು ಕಡಿಮೆ-ಹಂತದ ಮೆಮೊರಿ ಹ್ಯಾಂಡ್ಲಿಂಗ್ನಿಂದ ಉಂಟಾಗುವ ಸಮಸ್ಯೆಗಳಿಂದ ರಕ್ಷಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಮೆಮೊರಿ ಪ್ರದೇಶವನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ನಂತರ ಪ್ರವೇಶಿಸುವುದು, ಶೂನ್ಯ ಪಾಯಿಂಟರ್ಗಳನ್ನು ಡಿಫರೆನ್ಸಿಂಗ್ ಮಾಡುವುದು, ಬಫರ್ ಓವರ್ರನ್ಗಳು ಇತ್ಯಾದಿ. ಗ್ರಂಥಾಲಯಗಳನ್ನು ವಿತರಿಸಲು, ನಿರ್ಮಾಣಗಳನ್ನು ಒದಗಿಸಲು ಮತ್ತು ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು, ಯೋಜನೆಯು ಕಾರ್ಗೋ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತದೆ. ಲೈಬ್ರರಿಗಳನ್ನು ಹೋಸ್ಟ್ ಮಾಡಲು crates.io ರೆಪೊಸಿಟರಿಯನ್ನು ಬೆಂಬಲಿಸಲಾಗುತ್ತದೆ.
ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಮೆಮೊರಿ ಸುರಕ್ಷತೆಯನ್ನು ಒದಗಿಸಲಾಗುತ್ತದೆ, ಆಬ್ಜೆಕ್ಟ್ ಮಾಲೀಕತ್ವವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು, ಆಬ್ಜೆಕ್ಟ್ ಜೀವಿತಾವಧಿಯನ್ನು (ಸ್ಕೋಪ್ಗಳು) ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು ಮತ್ತು ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯದಲ್ಲಿ ಮೆಮೊರಿ ಪ್ರವೇಶದ ಸರಿಯಾದತೆಯನ್ನು ನಿರ್ಣಯಿಸುವುದು. ರಸ್ಟ್ ಪೂರ್ಣಾಂಕದ ಉಕ್ಕಿ ಹರಿಯುವಿಕೆಯಿಂದ ರಕ್ಷಣೆ ನೀಡುತ್ತದೆ, ಬಳಕೆಗೆ ಮೊದಲು ವೇರಿಯಬಲ್ ಮೌಲ್ಯಗಳ ಕಡ್ಡಾಯ ಆರಂಭದ ಅಗತ್ಯವಿರುತ್ತದೆ, ಪ್ರಮಾಣಿತ ಗ್ರಂಥಾಲಯದಲ್ಲಿ ದೋಷಗಳನ್ನು ಉತ್ತಮವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬದಲಾಗದ ಉಲ್ಲೇಖಗಳು ಮತ್ತು ವೇರಿಯೇಬಲ್ಗಳ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ, ತಾರ್ಕಿಕ ದೋಷಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಬಲವಾದ ಸ್ಥಿರ ಟೈಪಿಂಗ್ ಅನ್ನು ನೀಡುತ್ತದೆ.
ಮುಖ್ಯ ಆವಿಷ್ಕಾರಗಳು:
- std::thread::scope API ಅನ್ನು ಸೇರಿಸಲಾಗಿದೆ, ಇದು ನಿಮಗೆ ಸ್ಕೋಪ್ಡ್ ಥ್ರೆಡ್ಗಳನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಈ ಹಿಂದೆ ಲಭ್ಯವಿರುವ ಥ್ರೆಡ್ಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಹೊಸ std::thread::scope API ಎರವಲು ಸ್ಥಿರವಲ್ಲದ ಡೇಟಾವನ್ನು ರವಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಕ್ಲಾಸಿಕ್ std::thread::spawn API ಅನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಲಾದ ಥ್ರೆಡ್ಗಳು ಪಾಸ್ ಮಾಡಿದ ಎಲ್ಲಾ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳನ್ನು ಹೊಂದಲು ಅಗತ್ಯವಿದೆ ಮತ್ತು ಸ್ವೀಕರಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ಎರವಲು ಪಡೆದ ಅಸ್ಥಿರ. std::thread::scope API ಡೇಟಾವನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೊದಲು ಯಾವುದೇ ಮೊಟ್ಟೆಯಿಟ್ಟ ಥ್ರೆಡ್ಗಳನ್ನು ಕೊನೆಗೊಳಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು ಎರವಲು ಕಾರ್ಯವಿಧಾನಕ್ಕೆ ಸಾಕಷ್ಟು ಭದ್ರತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
- ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ಗಳಿಗಾಗಿ ಹೊಸ ಹೊದಿಕೆಯ ಪ್ರಕಾರಗಳನ್ನು ಪ್ರಸ್ತಾಪಿಸಲಾಗಿದೆ - BorrowedFd ಮತ್ತು OwnedFd, ಇದು ಎರವಲು ಮತ್ತು ಮಾಲೀಕತ್ವವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಪ್ರಕಾರಗಳನ್ನು "#[repr(ಪಾರದರ್ಶಕ)]" ಎಂದು ಗುರುತಿಸಲಾಗಿದೆ, ಅವುಗಳನ್ನು ಮಾಲೀಕತ್ವ-ಅರಿವಿನ ರೀತಿಯಲ್ಲಿ ಬಾಹ್ಯ C ಬೈಂಡಿಂಗ್ಗಳಲ್ಲಿ ನೇರವಾಗಿ ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ.
- Lazy_static ಪ್ಯಾಕೇಜುಗಳನ್ನು ಬಳಸದೆಯೇ ಜಾಗತಿಕ ಸ್ಥಿರ Mutex, RwLock ಮತ್ತು Condvar ಮೌಲ್ಯಗಳನ್ನು ರಚಿಸಲು Condvar ::new, Mutex::new ಮತ್ತು RwLock::ಹೊಸದಾಗಿ ಕರೆ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸಲಾಗಿದೆ.
- fn foo ನಂತಹ ಕಾರ್ಯಗಳಿಗಾಗಿ (ಮೌಲ್ಯ: T, f: impl ನಕಲು) "foo::" ನಂತಹ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಅನುಮತಿಸಲಾಗಿದೆ (32, 3)”, ಸ್ಪಷ್ಟವಾಗಿ ಜೆನೆರಿಕ್ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುತ್ತದೆ.
- ಎರವಲು ವೇರಿಯಬಲ್ಗಳೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಲು NLL (ನಾನ್-ಲೆಕ್ಸಿಕಲ್ ಲೈಫ್ಟೈಮ್ಸ್) ತಂತ್ರವನ್ನು ಬಳಸುವ ಪರಿವರ್ತನೆಯು ಪೂರ್ಣಗೊಂಡಿದೆ. ಎಕ್ಸಿಕ್ಯೂಶನ್ ಫ್ಲೋ ಗ್ರಾಫ್ನಲ್ಲಿನ ಪಾಯಿಂಟರ್ಗಳ ಗುಂಪಿನ ಮಟ್ಟದಲ್ಲಿ ಎನ್ಎಲ್ಎಲ್ ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಇದು ಎರವಲು ವೇರಿಯೇಬಲ್ಗಳಿಗೆ ಚೆಕ್ನ ಗುಣಮಟ್ಟವನ್ನು ಹೆಚ್ಚಿಸಲು (ಎರವಲು ಪರೀಕ್ಷಕ) ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ ಮತ್ತು ಕೆಲವು ರೀತಿಯ ಸರಿಯಾದ ಕೋಡ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಹಿಂದೆ ದೋಷಕ್ಕೆ ಕಾರಣವಾಯಿತು. ಲೆಕ್ಸಿಕಲ್-ಲೆವೆಲ್ ಲೈಫ್ಟೈಮ್ ಬೈಂಡಿಂಗ್ ಅನ್ನು ಬಳಸಿದ ಹಳೆಯ ಕಾರ್ಯವಿಧಾನದ ಬೆಂಬಲವನ್ನು ಈಗ ಸಂಪೂರ್ಣವಾಗಿ rustc ನಿಂದ ತೆಗೆದುಹಾಕಲಾಗಿದೆ ಮತ್ತು ಹೊಸ NLL ನ ಬಳಕೆಯನ್ನು ಪೂರ್ತಿಯಾಗಿ ಅಳವಡಿಸಲಾಗಿದೆ.
- API ಯ ಹೊಸ ಭಾಗವನ್ನು ಸ್ಥಿರತೆಯ ವರ್ಗಕ್ಕೆ ಸರಿಸಲಾಗಿದೆ, ಇದರಲ್ಲಿ ವಿಧಾನಗಳು ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳ ಅನುಷ್ಠಾನಗಳನ್ನು ಸ್ಥಿರಗೊಳಿಸಲಾಗಿದೆ:
- ರಚನೆ:: from_fn
- ಬಾಕ್ಸ್::ಇನ್ಟು_ಪಿನ್
- BinaryHeap :: try_reserve
- BinaryHeap :: try_reserve_exact
- OsString:: try_reserve
- OsString:: try_reserve_exact
- PathBuf:: try_reserve
- PathBuf:: try_reserve_exact
- ಮಾರ್ಗ:: ಪ್ರಯತ್ನಿಸಿ_ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ
- ಉಲ್ಲೇಖ::filter_map
- RefMut::filter_map
- NonNull::<[T]>::len
- ಮಾಲೀಕತ್ವದ::clone_into
- Ipv6Addr::to_ipv4_mapped
- unix::io::AsFd
- unix::io::BorrowedFd<'fd>
- unix::io::OwnedFd
- windows::io::AsHandle
- windows::io::BorrowedHandle
ಮೂಲ: opennet.ru
