మొజిల్లా ప్రాజెక్ట్ ద్వారా స్థాపించబడిన రస్ట్ 1.78 సాధారణ-ప్రయోజన ప్రోగ్రామింగ్ లాంగ్వేజ్ విడుదల, కానీ ఇప్పుడు స్వతంత్ర లాభాపేక్ష లేని సంస్థ రస్ట్ ఫౌండేషన్ ఆధ్వర్యంలో అభివృద్ధి చేయబడింది, ప్రచురించబడింది. భాష మెమరీ భద్రతపై దృష్టి పెడుతుంది మరియు చెత్త సేకరించేవాడు మరియు రన్టైమ్ (ప్రామాణిక లైబ్రరీ యొక్క ప్రాథమిక ప్రారంభ మరియు నిర్వహణకు రన్టైమ్ తగ్గించబడింది) వినియోగాన్ని నివారించేటప్పుడు అధిక ఉద్యోగ సమాంతరతను సాధించడానికి మార్గాలను అందిస్తుంది.
రస్ట్ యొక్క మెమరీ హ్యాండ్లింగ్ పద్ధతులు పాయింటర్లను మానిప్యులేట్ చేసేటప్పుడు డెవలపర్ను లోపాల నుండి కాపాడతాయి మరియు తక్కువ-స్థాయి మెమరీ హ్యాండ్లింగ్ కారణంగా తలెత్తే సమస్యల నుండి రక్షిస్తాయి, అనగా మెమరీ ప్రాంతాన్ని విడుదల చేసిన తర్వాత యాక్సెస్ చేయడం, శూన్య పాయింటర్లను డిఫెరెన్సింగ్ చేయడం, బఫర్ ఓవర్రన్లు మొదలైనవి. లైబ్రరీలను పంపిణీ చేయడానికి, బిల్డ్లను అందించడానికి మరియు డిపెండెన్సీలను నిర్వహించడానికి, ప్రాజెక్ట్ కార్గో ప్యాకేజీ మేనేజర్ను అభివృద్ధి చేస్తుంది. లైబ్రరీలను హోస్ట్ చేయడానికి crates.io రిపోజిటరీకి మద్దతు ఉంది.
రిఫరెన్స్ చెకింగ్, ఆబ్జెక్ట్ యాజమాన్యాన్ని ట్రాక్ చేయడం, ఆబ్జెక్ట్ జీవితకాలాన్ని (స్కోప్లు) ట్రాక్ చేయడం మరియు కోడ్ అమలు సమయంలో మెమరీ యాక్సెస్ యొక్క ఖచ్చితత్వాన్ని అంచనా వేయడం ద్వారా కంపైల్ సమయంలో రస్ట్లో మెమరీ భద్రత అందించబడుతుంది. రస్ట్ పూర్ణాంకాల ఓవర్ఫ్లోల నుండి రక్షణను కూడా అందిస్తుంది, ఉపయోగించే ముందు వేరియబుల్ విలువలను తప్పనిసరిగా ప్రారంభించడం అవసరం, ప్రామాణిక లైబ్రరీలో లోపాలను మెరుగ్గా నిర్వహిస్తుంది, డిఫాల్ట్గా మార్పులేని సూచనలు మరియు వేరియబుల్స్ భావనను వర్తింపజేస్తుంది, లాజికల్ లోపాలను తగ్గించడానికి బలమైన స్టాటిక్ టైపింగ్ను అందిస్తుంది.
ప్రధాన ఆవిష్కరణలు:
- కంపైలర్ ద్వారా ఉత్పత్తి చేయబడిన దోష సందేశాలను ప్రభావితం చేయడానికి ఒక కొత్త అట్రిబ్యూట్ నేమ్స్పేస్ "#[డయాగ్నస్టిక్]" ప్రతిపాదించబడింది. కొత్త స్థలంలో మొదటిది "#[డయాగ్నస్టిక్::on_unimplemented]" లక్షణం, ఇది మీరు రకం కోసం అమలు చేయని లక్షణాన్ని ఉపయోగించాల్సిన పరిస్థితిలో విసిరిన దోష సందేశాలను అనుకూలీకరించడానికి ఉపయోగించవచ్చు. #[diagnostic::on_unimplemented( message = "`ImportantTrait<{A}>` కోసం నా సందేశం `{Self}`" కోసం అమలు చేయబడలేదు, label = "నా లేబుల్", గమనిక = "గమనిక 1", గమనిక = "గమనిక 2" )] లక్షణం ImportantTrait {} fn use_my_trait(_: impl ImportantTrait ) {} fn ప్రధాన() {use_my_trait(స్ట్రింగ్::new()); } లోపం[E32]: `ముఖ్యమైన లక్షణం కోసం నా సందేశం `స్ట్రింగ్` కోసం అమలు చేయబడలేదు —> src/main.rs:0277:32 | 12 | use_my_trait(స్ట్రింగ్:: కొత్త()); | ———— ^^^^^^^^^^^^^^ నా లేబుల్ | | | ఈ కాల్ ద్వారా పరిచయం చేయబడిన బౌండ్ ద్వారా అవసరం | = సహాయం: లక్షణం `ముఖ్యమైన లక్షణం `స్ట్రింగ్` = గమనిక కోసం ` అమలు చేయబడలేదు: గమనిక 18 = గమనిక: గమనిక 12
- "#[cfg(debug_assertions)]" మోడ్లో ప్రామాణిక లైబ్రరీని నిర్మించాల్సిన అవసరం లేకుండానే ఈ తనిఖీలను నిర్వహించడానికి అనుమతించడం ద్వారా అసురక్షిత ఫంక్షన్లకు వర్తించే ముందస్తు-నిర్ధారణ తనిఖీలు ఇప్పుడు కోడ్ ఉత్పత్తి వరకు వాయిదా వేయబడతాయి. తనిఖీలను ట్రిగ్గర్ చేయడానికి, మీ కోడ్ యొక్క పరీక్ష లేదా డీబగ్ బిల్డ్ల కోసం డీబగ్ నిర్థారణలను ప్రారంభించడం ఇప్పుడు సరిపోతుంది.
- పాయింటర్లు మరియు స్లైస్ల అమరికను ప్రభావితం చేసే ప్రామాణిక లైబ్రరీలోని ఫంక్షన్ల ప్రవర్తన ఇప్పుడు రన్టైమ్లో ఊహించదగినది మరియు ఇన్పుట్ డేటాపై ఆధారపడి ఉంటుంది. ఫంక్షన్ పాయింటర్::align_offset, పాయింటర్ను సమలేఖనం చేయడానికి ఆఫ్సెట్ను గణిస్తుంది, ఇప్పుడు ఆపరేషన్ విఫలమైతే మాత్రమే usize::MAXని అందిస్తుంది. ఫంక్షన్ల స్లైస్::align_to మరియు స్లైస్::align_to_mut రెండూ, సమలేఖనం చేయబడిన మిడిల్ స్లైస్ మరియు అసలు ప్రారంభ మరియు ముగింపు స్లైస్లతో స్లైస్లను ప్రాతినిధ్యంగా మారుస్తాయి, ఇప్పుడు ఎల్లప్పుడూ అతిపెద్ద మధ్య భాగాన్ని తిరిగి అందిస్తాయి.
- కిందివి స్థిరమైన వర్గానికి బదిలీ చేయబడ్డాయి:
- Impl &Stdin కోసం చదవండి
- కొన్ని std::error::ఎర్రర్-సంబంధిత అమలుల కోసం నాన్-స్టాటిక్ (నాన్-స్టాటిక్) జీవితకాలాన్ని ఉపయోగించడానికి అనుమతించండి.
- ఇంప్లిమెంట్ అమలు ?పరిమాణ విలువ అనుమతించబడుతుంది.
- నుండి impl io కోసం:: లోపం
- అవరోధం ::new() ఫంక్షన్ స్థిరాంకాలకి బదులుగా ఏదైనా సందర్భంలో "const" లక్షణంతో ఉపయోగించబడుతుంది.
- టార్గెట్ ప్లాట్ఫారమ్ల కోసం x86_64-pc-windows-msvc, i686-pc-windows-msvc, x86_64-pc-windows-gnu, i686-pc-windows-gnu, x86_64-pc-windows-gnull-mc మరియు-gnullvc ఇప్పుడు కనీసం Windows 686 వెర్షన్ అవసరం.
- మూడవ స్థాయి మద్దతు wasm32-wasip2, arm64ec-pc-windows-msvc, armv8r-none-eabihf మరియు loongarch64-unknown-linux-musl ప్లాట్ఫారమ్ల కోసం అమలు చేయబడింది. మూడవ స్థాయి ప్రాథమిక మద్దతును కలిగి ఉంటుంది, అయితే ఆటోమేటెడ్ టెస్టింగ్ లేకుండా, అధికారిక బిల్డ్లను ప్రచురించడం లేదా కోడ్ని నిర్మించవచ్చో లేదో తనిఖీ చేయడం.
- టార్గెట్ ప్లాట్ఫారమ్ Add wasm32-wasip1 కోసం రెండవ స్థాయి మద్దతు అమలు చేయబడింది. రెండవ స్థాయి మద్దతు అసెంబ్లీ హామీని కలిగి ఉంటుంది.
- ప్లాట్ఫారమ్ wasm32-wasi-preview1-threads పేరు wasm32-wasip1-థ్రెడ్లుగా మార్చబడింది.
- కంపైలర్ LLVM 18ని ఉపయోగించడానికి మార్చబడింది. x18-86 మరియు x32-86 ఆర్కిటెక్చర్ల కోసం LLVM 64ని ఉపయోగిస్తున్నప్పుడు, u128 మరియు i128 రకాలతో అనుబంధించబడిన ABI మార్చబడింది.
- కార్గో ప్యాక్ట్ మేనేజర్లో, లాక్ ఫైల్ల వెర్షన్ 4 (లాక్ఫైల్ v4) స్థిరీకరించబడింది.
- కార్గో తాజా డేటా వినియోగం గురించిన సమాచారంతో స్థిరీకరించబడిన గ్లోబల్ కాష్ని కలిగి ఉంది. కాష్ SQLiteని ఉపయోగించి $CARGO_HOME/.global-cacheలో హోస్ట్ చేయబడింది మరియు ఇండెక్స్, క్రేట్ ఫైల్, కోడ్ డైరెక్టరీ, git క్లోన్ మరియు git చెక్అవుట్లో తాజా మార్పులను ప్రతిబింబించేలా స్వయంచాలకంగా నవీకరించబడుతుంది.
అదనంగా, బోర్గో ప్రోగ్రామింగ్ లాంగ్వేజ్ గో లాంగ్వేజ్ కంటే ఎక్కువ ఎక్స్ప్రెసివ్గా ఉండటానికి ప్రయత్నిస్తుంది, కానీ రస్ట్ లాంగ్వేజ్ కంటే తక్కువ క్లిష్టంగా ఉంటుంది. బోర్గో గో మరియు రస్ట్ యొక్క ఉత్తమ లక్షణాలను మిళితం చేస్తుంది, ప్రతి భాషలోని లోపాలను భర్తీ చేస్తుంది. ఉదాహరణకు, గో అనేది సరళమైనది మరియు సూటిగా ఉంటుంది, కానీ అధునాతన రకం భద్రతా లక్షణాలను అందించదు. రస్ట్ భాష సురక్షితమైన ప్రోగ్రామింగ్ కోసం సాధనాలను అందిస్తుంది, కానీ చాలా క్లిష్టంగా ఉంటుంది. ది సింపుల్ హాస్కెల్ హ్యాండ్బుక్ రచయిత మరియు క్వాడ్ CI కంటిన్యూస్ ఇంటిగ్రేషన్ సిస్టమ్ డెవలపర్ అయిన మార్కో శాంపెల్లెగ్రిని ప్రాజెక్ట్ను అభివృద్ధి చేస్తున్నారు.
బోర్గో స్టాటిక్ టైపింగ్, గో లాంటి రకాలు మరియు రస్ట్ లాంటి సింటాక్స్ని ఉపయోగిస్తుంది. బోర్గో కోడ్లోని పంక్తుల చివర సెమికోలన్లు ఐచ్ఛికం. Borgo కోడ్ ఇప్పటికే ఉన్న Go ప్యాకేజీలతో పూర్తిగా అనుకూలంగా ఉండే Go ప్రాతినిధ్యంగా కంపైల్ చేయబడింది. కంపైలర్ కోడ్ రస్ట్లో వ్రాయబడింది మరియు ISC లైసెన్స్ క్రింద పంపిణీ చేయబడుతుంది. fmt enum నెట్వర్క్స్టేట్ని ఉపయోగించండి { లోడ్ అవుతోంది, విఫలమైంది(int), సక్సెస్(T), } struct Response { title: string, duration: int, } fn main() {let res = Response { title: “Hello world”, duration: 0, } లెట్ స్టేట్ = NetworkState.Success(res) let msg = మ్యాచ్ స్థితి {NetworkState.Loading => “ఇప్పటికీ లోడ్ అవుతోంది”, NetworkState.Failed(code) => fmt.Sprintf(“ఎర్రర్ కోడ్ వచ్చింది: %d”, కోడ్), NetworkState.Success (res) => res.title, } fmt.Println(msg)}
మూలం: opennet.ru
