રસ્ટ 1.51 પ્રોગ્રામિંગ લેંગ્વેજ રિલીઝ

સિસ્ટમ પ્રોગ્રામિંગ લેંગ્વેજ રસ્ટ 1.51, મોઝિલા પ્રોજેક્ટ દ્વારા સ્થપાયેલી, પરંતુ હવે સ્વતંત્ર બિન-લાભકારી સંસ્થા રસ્ટ ફાઉન્ડેશનના આશ્રય હેઠળ વિકસિત, પ્રકાશિત કરવામાં આવી છે. ભાષા મેમરી સલામતી પર ધ્યાન કેન્દ્રિત કરે છે, સ્વચાલિત મેમરી મેનેજમેન્ટ પ્રદાન કરે છે, અને ગાર્બેજ કલેક્ટર અથવા રનટાઈમનો ઉપયોગ કર્યા વિના ઉચ્ચ કાર્ય સમાનતા પ્રાપ્ત કરવાના માધ્યમો પૂરા પાડે છે (રનટાઇમ મૂળભૂત પ્રારંભ અને પ્રમાણભૂત લાઇબ્રેરીની જાળવણી માટે ઘટાડવામાં આવે છે).

રસ્ટનું ઓટોમેટિક મેમરી મેનેજમેન્ટ પોઈન્ટર્સની હેરફેર કરતી વખતે ભૂલોને દૂર કરે છે અને લો-લેવલ મેમરી મેનીપ્યુલેશનથી ઊભી થતી સમસ્યાઓ સામે રક્ષણ આપે છે, જેમ કે મેમરી રિજનને મુક્ત કર્યા પછી એક્સેસ કરવું, નલ પોઈન્ટર ડિરેફરન્સ, બફર ઓવરરન્સ વગેરે. લાઇબ્રેરીઓનું વિતરણ કરવા, એસેમ્બલીની ખાતરી કરવા અને નિર્ભરતાઓનું સંચાલન કરવા માટે, પ્રોજેક્ટ કાર્ગો પેકેજ મેનેજર વિકસાવી રહ્યો છે. crates.io રીપોઝીટરી હોસ્ટિંગ લાઈબ્રેરીઓ માટે આધારભૂત છે.

મુખ્ય નવીનતાઓ:

• કોન્સ્ટ જેનેરિક્સના ઉપયોગ સાથે સંકળાયેલ કાર્યક્ષમતાને લઘુત્તમ વ્યવહારુ ઉત્પાદન (MVP) તરીકે નિયુક્ત કરવામાં આવી છે, જે વ્યાપક સ્વીકાર માટે લીલી ઝંડી આપે છે. કોન્સ્ટ જેનેરિક સ્થિર મૂલ્યો માટે પ્રકારોના સામાન્યીકરણની મંજૂરી આપે છે, એટલે કે, પ્રકારો અથવા જીવનકાળને બદલે સ્થિર મૂલ્યોની શ્રેણી સુધી મર્યાદિત સામાન્ય દલીલોનો ઉપયોગ. આ ક્ષમતા કોઈપણ કદના એરે માટે લક્ષણો બનાવતી વખતે પૂર્ણાંક-પરિમાણિત પ્રકારો અને અમૂર્તતાનો ઉપયોગ સક્ષમ કરે છે, માન્ય શ્રેણી ઓળંગાઈ ન જાય તેની ખાતરી કરવા માટે માન્ય મૂલ્યોની દરેક શ્રેણી માટે અલગ પ્રકાર બનાવવાની જરૂર વગર.

  વર્તમાન પ્રકાશનથી શરૂ કરીને, "[T; N]" પ્રકારના એરે (પ્રકાર T અને કદ N) હવે કોઈપણ પૂર્ણાંક, બુલિયન અથવા અક્ષર પ્રકારોના મૂલ્યોનો ઉપયોગ કરીને પ્રકાર અને કદને અમૂર્ત કરવાની ક્ષમતા ધરાવે છે (સ્ટ્રક્ટ અને એનમ પ્રકારો હજુ સુધી સમર્થિત નથી). કોન્સ્ટ જેનેરિક્સ લાઇબ્રેરી વિકાસને નોંધપાત્ર રીતે સરળ બનાવે છે; ઉદાહરણ તરીકે, ચોક્કસ પ્રકાર અને કદ સાથે જોડાયેલા ન હોય તેવા એરેનો ઉપયોગ કરવા માટે, તમે સ્પષ્ટ કરી શકો છો: સ્ટ્રક્ટ એરે { // ^^^^^^^^^^^^^^^^^^^^ અચળ સામાન્ય યાદીની વ્યાખ્યા: [T; LENGTH] // ^^^^^^^ તેનો ઉપયોગ }

  જ્યારે ખરેખર આ વ્યાખ્યા સાથે ઉપયોગ થાય છે, ત્યારે "એરે" " કમ્પાઇલર એરેનું મોનોમોર્ફિક વર્ઝન જનરેટ કરશે: સ્ટ્રક્ટ એરે { યાદી: [u8; 32] }

• સતત જેનેરિક્સ પર આધારિત std::array::IntoIter API ને સ્થિર કરવામાં આવ્યું છે. તેની મદદથી, તમે કોઈપણ એરે માટે મૂલ્ય દ્વારા ઇટરેટર્સ બનાવી શકો છો: fn main() { let array = [1, 2, 3, 4, 5]; // પહેલાં, મૂલ્ય પર પુનરાવર્તન કરવા માટે, તમારે array.iter().copied() માં આઇટમ માટે .iter() પદ્ધતિને કૉલ કરવી પડતી હતી { println!(«{}», item); } // હવે તમે std::array::IntoIter::new(array) માં આઇટમ માટે સ્પષ્ટ કરી શકો છો { println!(«{}», item); } }
• કાર્ગો પેકેજ મેનેજર હવે Cargo.toml માં એક નવા રિઝોલ્વર ફીલ્ડને સપોર્ટ કરે છે, જેનો ઉપયોગ ફીચર રિઝોલ્વરના બીજા વર્ઝનને સક્ષમ કરવા માટે થઈ શકે છે. આ નવું રિઝોલ્વર "[સુવિધાઓ]" વિભાગમાં સૂચિબદ્ધ ડિપેન્ડન્સી સુવિધાઓને મર્જ કરવાનું ટાળે છે જ્યારે આમ કરવું અયોગ્ય હોય, જેમ કે જ્યારે ડિપેન્ડન્સીનો સમાવેશ થાય છે જેને બિલ્ડ સ્ક્રિપ્ટ્સ અને મેક્રોમાં સ્ટાન્ડર્ડ ફીચરની જરૂર હોય છે, પરંતુ ફાઇનલ એક્ઝિક્યુટેબલમાં નોન-સ્ટાન્ડર્ડ ફીચરનો ઉપયોગ કરે છે.

  પહેલાં, ડિપેન્ડન્સી ગ્રાફમાં ઘણી વખત ઉલ્લેખિત પેકેજની ક્ષમતાઓ મર્જ કરવામાં આવતી હતી. ઉદાહરણ તરીકે, જો કોઈ પ્રોજેક્ટમાં ડિપેન્ડન્સી foo શામેલ હોય જે ક્ષમતાઓ A અને B ને વ્યાખ્યાયિત કરે છે, અને આ પેકેજનો ઉપયોગ અન્ય પેકેજો બાર અને બાઝમાં થતો હતો, અને બાર ક્ષમતા A સાથે foo પર આધારિત હતો, અને બાઝ ક્ષમતા B સાથે foo પર આધારિત હતો, તો કાર્ગો આ ​​ક્ષમતાઓને મર્જ કરશે અને foo ને A અને B સક્ષમ ક્ષમતાઓ સાથે કમ્પાઇલ કરશે. આ પદ્ધતિના પરિણામે ડિપેન્ડન્સી લક્ષ્ય સિસ્ટમ સાથે અસંગત હોવાથી સક્ષમ ક્ષમતામાં પરિણમી શકે છે જેના માટે અંતિમ બિલ્ડ કરવામાં આવ્યું હતું. ઉદાહરણ તરીકે, જ્યારે "#![no_std]" સાથેના foo ના સંસ્કરણનો ઉપયોગ "#![no_std]" સાથેના એક્ઝિક્યુટેબલમાં કરવો જરૂરી હતો, અને build.rs માં બિલ્ડ દરમિયાન "std" સાથે foo નો ઉપયોગ કરવો જરૂરી હતો. Cargo.toml માં resolver="2" નો ઉલ્લેખ કરીને, પેકેજ મેનેજર હવે આ સંઘર્ષને યોગ્ય રીતે હેન્ડલ કરવાનો પ્રયાસ કરશે, dev, host અને target ડિપેન્ડન્સીને અલગ કરશે.

• કાર્ગો "[પ્રોફાઇલ]" વિભાગમાં ઉલ્લેખિત સ્પ્લિટ-ડિબગઇન્ફો વિકલ્પ અને rustc માં અનુરૂપ "-Csplit-debuginfo=unpacked" ફ્લેગ લાગુ કરે છે, જે ડિબગ માહિતી સાચવવા માટે એક નવી પદ્ધતિના અમલીકરણની ઓફર કરે છે, જે dsymutil ઉપયોગિતાને કૉલ કરવાની જરૂરિયાતને દૂર કરે છે અને ડિબગ માહિતી સાથે બિલ્ડ પ્રક્રિયાને નોંધપાત્ર રીતે ઝડપી બનાવે છે. macOS.
• "ptr::addr_of!" અને "ptr::addr_of_mut!" મેક્રો સ્થિર કરવામાં આવ્યા છે, જે અસંરેખિત ક્ષેત્રોમાં કાચા પોઇન્ટર બનાવવાની મંજૂરી આપે છે. std::ptr નો ઉપયોગ કરો; #[repr(packed)] struct Packed { f1: u8, f2: u16, } let packed = Packed { f1: 1, f2: 2 }; // &packed.f2 એક અસંરેખિત પોઇન્ટર બનાવશે, જે અવ્યાખ્યાયિત વર્તન તરફ દોરી જશે let raw_f2 = ptr::addr_of!(packed.f2); assert_eq!(unsafe { raw_f2.read_unaligned() }, 2);
• API ના એક નવા ભાગને સ્થિર શ્રેણીમાં સ્થાનાંતરિત કરવામાં આવ્યો છે, જેમાં નીચેની પદ્ધતિઓનો સમાવેશ કરીને સ્થિર કરવામાં આવી છે:
  • આર્ક:: ઘટાડો_શક્તિ_ગણતરી
  • આર્ક::વૃદ્ધિ_મજબૂત_ગણતરી
  • એકવાર::call_once_force
  • જોઈ શકાય તેવું::આગળ_જો_eq
  • જોઈ શકાય તેવું::આગળ_જો
  • શોધો::સ્ટ્રીમ_પોઝિશન
  • એરે::ઇનટુઇટર
  • ગભરાટ::ગભરાટ_કોઈપણ
  • ગુણાંક::સંબંધ_નો!
  • ગુણ::મટનો_સંબંધ!
  • સ્લાઇસ::ભરો_સાથે
  • સ્લાઇસ::સ્પ્લિટ_ઇન્ક્લુઝિવ_મ્યુટ
  • સ્લાઇસ::સ્પ્લિટ_ઇન્ક્લુઝિવ
  • સ્લાઇસ::સ્ટ્રીપ_પ્રીફિક્સ
  • સ્લાઇસ::સ્ટ્રીપ_પ્રત્યય
  • str::split_inclusive
  • સમન્વયન::એકવાર રાજ્ય
  • કાર્ય::જાગો
• i386-unknown-linux-gnu, i486-unknown-linux-gnu, aarch64_be-unknown-linux-gnu, aarch64-unknown-linux-gnu_ilp32, અને aarch64_be-unknown-linux-gnu_ilp32 પ્લેટફોર્મ માટે લેવલ 3 સપોર્ટ લાગુ કરવામાં આવ્યો છે. લેવલ 3 મૂળભૂત સપોર્ટ પૂરો પાડે છે, પરંતુ ઓટોમેટેડ ટેસ્ટિંગ, ઓફિશિયલ બિલ્ડ્સ અથવા બિલ્ડ વેરિફિકેશન વિના.

સોર્સ: opennet.ru