Rust 1.51 ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਰੀਲੀਜ਼

ਸਿਸਟਮ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ Rust 1.51 ਦੀ ਰਿਲੀਜ਼, ਜੋ ਕਿ ਮੋਜ਼ੀਲਾ ਪ੍ਰੋਜੈਕਟ ਦੁਆਰਾ ਸਥਾਪਿਤ ਕੀਤੀ ਗਈ ਸੀ, ਪਰ ਹੁਣ ਸੁਤੰਤਰ ਗੈਰ-ਲਾਭਕਾਰੀ ਸੰਸਥਾ ਰਸਟ ਫਾਊਂਡੇਸ਼ਨ ਦੀ ਸਰਪ੍ਰਸਤੀ ਹੇਠ ਵਿਕਸਤ ਕੀਤੀ ਗਈ ਹੈ, ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਗਈ ਹੈ। ਭਾਸ਼ਾ ਮੈਮੋਰੀ ਸੁਰੱਖਿਆ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੀ ਹੈ, ਆਟੋਮੈਟਿਕ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ, ਅਤੇ ਕੂੜਾ ਇਕੱਠਾ ਕਰਨ ਵਾਲੇ ਜਾਂ ਰਨਟਾਈਮ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ ਉੱਚ ਕਾਰਜ ਸਮਾਨਤਾ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਸਾਧਨ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ (ਰਨਟਾਈਮ ਨੂੰ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਮੁੱਢਲੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਰੱਖ-ਰਖਾਅ ਤੱਕ ਘਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ)।

ਜੰਗਾਲ ਦਾ ਆਟੋਮੈਟਿਕ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਪੁਆਇੰਟਰਾਂ ਦੀ ਹੇਰਾਫੇਰੀ ਕਰਦੇ ਸਮੇਂ ਗਲਤੀਆਂ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ ਅਤੇ ਘੱਟ-ਪੱਧਰੀ ਮੈਮੋਰੀ ਹੇਰਾਫੇਰੀ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੀਆਂ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਮੈਮੋਰੀ ਖੇਤਰ ਨੂੰ ਖਾਲੀ ਹੋਣ ਤੋਂ ਬਾਅਦ ਐਕਸੈਸ ਕਰਨਾ, ਨਲ ਪੁਆਇੰਟਰ ਡੀਰੇਫਰੈਂਸ, ਬਫਰ ਓਵਰਰਨ, ਆਦਿ। ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਵੰਡਣ, ਅਸੈਂਬਲੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਅਤੇ ਨਿਰਭਰਤਾ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ, ਪ੍ਰੋਜੈਕਟ ਕਾਰਗੋ ਪੈਕੇਜ ਮੈਨੇਜਰ ਨੂੰ ਵਿਕਸਤ ਕਰ ਰਿਹਾ ਹੈ। crates.io ਰਿਪੋਜ਼ਟਰੀ ਹੋਸਟਿੰਗ ਲਾਇਬ੍ਰੇਰੀਆਂ ਲਈ ਸਮਰਥਿਤ ਹੈ।

ਮੁੱਖ ਨਵੀਨਤਾਵਾਂ:

• ਨਿਰੰਤਰ ਜੈਨਰਿਕਸ ਦੀ ਵਰਤੋਂ ਨਾਲ ਜੁੜੀ ਕਾਰਜਸ਼ੀਲਤਾ ਨੇ ਵਿਆਪਕ ਵਰਤੋਂ ਲਈ ਹਰੀ ਰੋਸ਼ਨੀ ਦਿੰਦੇ ਹੋਏ, ਘੱਟੋ-ਘੱਟ ਵਿਹਾਰਕ ਉਤਪਾਦ (MVP) ਦਾ ਦਰਜਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਹੈ। Const generics ਕਿਸਮਾਂ ਨੂੰ ਸਥਿਰ ਮੁੱਲਾਂ ਲਈ ਸਧਾਰਣ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਸਥਾਈ ਮੁੱਲਾਂ ਦੀ ਇੱਕ ਸੀਮਾ ਤੱਕ ਸੀਮਿਤ ਆਮ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਕਿਸਮਾਂ ਜਾਂ ਜੀਵਨ ਕਾਲਾਂ ਦੀ ਨਹੀਂ। ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਤੁਹਾਨੂੰ ਪੂਰਨ ਅੰਕ-ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਕਿਸਮਾਂ ਅਤੇ ਐਬਸਟ੍ਰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ ਜਦੋਂ ਕਿਸੇ ਵੀ ਆਕਾਰ ਦੇ ਐਰੇ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾ ਬਣਾਉਂਦੇ ਸਮੇਂ ਵੈਧ ਮੁੱਲਾਂ ਦੀ ਹਰੇਕ ਰੇਂਜ ਲਈ ਇੱਕ ਵੱਖਰੀ ਕਿਸਮ ਬਣਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਤਾਂ ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕੇ ਕਿ ਕੋਈ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਦੀਆਂ ਘਟਨਾਵਾਂ ਨਹੀਂ ਹਨ।

  ਮੌਜੂਦਾ ਰੀਲੀਜ਼ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, ਕਿਸਮ “[T; N]" (ਟਾਈਪ T ਅਤੇ ਆਕਾਰ N) ਕਿਸੇ ਵੀ ਪੂਰਨ ਅੰਕ, ਬੂਲੀਅਨ ਅਤੇ ਅੱਖਰ ਕਿਸਮਾਂ ਦੇ ਨਾਲ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਮੂਰਤ ਕਿਸਮ ਅਤੇ ਆਕਾਰ ਦੀ ਯੋਗਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (ਸਟ੍ਰਕਚਰ ਅਤੇ ਐਨਮ ਕਿਸਮਾਂ ਅਜੇ ਸਮਰਥਿਤ ਨਹੀਂ ਹਨ)। ਸਥਿਰ ਜੈਨਰਿਕ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਵਿਕਾਸ ਨੂੰ ਬਹੁਤ ਸਰਲ ਬਣਾਉਂਦੇ ਹਨ; ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਐਰੇ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਜੋ ਕਿਸੇ ਖਾਸ ਕਿਸਮ ਅਤੇ ਆਕਾਰ ਨਾਲ ਨਹੀਂ ਜੁੜਿਆ ਹੋਇਆ ਹੈ, ਤੁਸੀਂ ਨਿਸ਼ਚਿਤ ਕਰ ਸਕਦੇ ਹੋ: struct ਐਰੇ { // ^^^^^^^^^^^^^^^^^^^^ ਇੱਕ ਸਥਿਰ ਆਮ ਸੂਚੀ ਦੀ ਪਰਿਭਾਸ਼ਾ: [ਟੀ; ਲੰਬਾਈ] // ^^^^^^ ਇਸਦੀ ਵਰਤੋਂ }

  ਜਦੋਂ ਅਸਲ ਵਿੱਚ "ਐਰੇ" ਦੀ ਇਸ ਪਰਿਭਾਸ਼ਾ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ » ਕੰਪਾਈਲਰ ਐਰੇ ਦਾ ਮੋਨੋਮੋਰਫਿਕ ਸੰਸਕਰਣ ਤਿਆਰ ਕਰੇਗਾ: struct ਐਰੇ {ਸੂਚੀ: [u8; 32] }

• std::array::IntoIter API, ਸਥਿਰ ਜੈਨਰਿਕਸ ਦੇ ਅਧਾਰ ਤੇ, ਸਥਿਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਐਰੇ ਲਈ ਮੁੱਲ ਦੁਆਰਾ ਦੁਹਰਾਓ ਬਣਾ ਸਕਦੇ ਹੋ: fn main() { let array = [1, 2, 3, 4, 5] ; // ਪਹਿਲਾਂ, ਕਿਸੇ ਮੁੱਲ ਨੂੰ ਦੁਹਰਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ array.iter().copied() { println!("{}", item) ਵਿੱਚ ਆਈਟਮ ਲਈ .iter() ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਨਾ ਪੈਂਦਾ ਸੀ; } // ਹੁਣ ਤੁਸੀਂ std::array::IntoIter::new(array) { println!("{}", item) ਵਿੱਚ ਆਈਟਮ ਲਈ ਨਿਰਧਾਰਿਤ ਕਰ ਸਕਦੇ ਹੋ; } }
• ਕਾਰਗੋ ਪੈਕੇਜ ਮੈਨੇਜਰ ਹੁਣ Cargo.toml ਵਿੱਚ ਇੱਕ ਨਵੇਂ ਰੈਜ਼ੋਲਵਰ ਫੀਲਡ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਜਿਸਦੀ ਵਰਤੋਂ ਵਿਸ਼ੇਸ਼ਤਾ ਰੈਜ਼ੋਲਵਰ ਦੇ ਦੂਜੇ ਸੰਸਕਰਣ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਡਿਫਾਈਨਰ ਦਾ ਨਵਾਂ ਸੰਸਕਰਣ "[ਵਿਸ਼ੇਸ਼ਤਾ]" ਭਾਗ ਵਿੱਚ ਸੂਚੀਬੱਧ ਨਿਰਭਰਤਾ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋੜਨ ਤੋਂ ਬਚਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਅਣਉਚਿਤ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ ਇੱਕ ਨਿਰਭਰਤਾ ਸ਼ਾਮਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੋ ਬਿਲਡ ਸਕ੍ਰਿਪਟਾਂ ਅਤੇ ਮੈਕਰੋਜ਼ ਵਿੱਚ ਕੁਝ ਮਿਆਰੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਬੇਨਤੀ ਕਰਦੀ ਹੈ, ਪਰ ਜਦੋਂ ਇੱਕ ਗੈਰ-ਮਿਆਰੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਨਤੀਜੇ ਵਜੋਂ ਚੱਲਣਯੋਗ ਫਾਈਲ ਵਿੱਚ .

  ਹੁਣ ਤੱਕ, ਨਿਰਭਰਤਾ ਗ੍ਰਾਫ ਵਿੱਚ ਕਈ ਵਾਰ ਜ਼ਿਕਰ ਕੀਤੇ ਪੈਕੇਜ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਜੋੜਿਆ ਗਿਆ ਸੀ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਇੱਕ ਨਿਰਭਰਤਾ foo ਸ਼ਾਮਲ ਹੈ ਜੋ ਸਮਰੱਥਾ A ਅਤੇ B ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਹ ਪੈਕੇਜ ਦੂਜੇ ਪੈਕੇਜ ਬਾਰ ਅਤੇ baz ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਬਾਰ ਵਿਸ਼ੇਸ਼ਤਾ A ਵਾਲੇ foo 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਅਤੇ baz ਵਿਸ਼ੇਸ਼ਤਾ B ਵਾਲੇ foo 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਫਿਰ ਨਤੀਜਾ ਇਹ ਹੋਵੇਗਾ ਕਿ ਕਾਰਗੋ ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋੜ ਦੇਵੇਗਾ ਅਤੇ foo ਨੂੰ A ਅਤੇ B ਸ਼ਾਮਲ ਕੀਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਨਾਲ ਕੰਪਾਇਲ ਕਰੇਗਾ। ਇਸ ਵਿਧੀ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਹੋ ਸਕਦੀ ਹੈ ਜੋ ਕਿ ਕੁਝ ਨਿਰਭਰਤਾ ਟਾਰਗੇਟ ਸਿਸਟਮ ਨਾਲ ਅਸੰਗਤ ਹੋਣ ਕਾਰਨ ਸਮਰੱਥ ਹੈ ਜਿਸ ਲਈ ਨਤੀਜਾ ਬਿਲਡ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ ਤੁਸੀਂ "#![no_std]" ਨਾਲ ਬਣੇ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਵਿੱਚ "#![no_std]" ਦੇ ਨਾਲ foo ਦਾ ਵਰਜਨ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ ਉਸੇ ਸਮੇਂ ਬਿਲਡ ਇਨ ਬਿਲਡ ਦੌਰਾਨ "std" ਨਾਲ foo ਦੀ ਵਰਤੋਂ ਕਰੋ। ਰੁਪਏ ਜਦੋਂ Cargo.toml ਵਿੱਚ solver="2" ਨੂੰ ਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਪੈਕੇਜ ਮੈਨੇਜਰ ਹੁਣ dev, ਹੋਸਟ ਅਤੇ ਟਾਰਗੇਟ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਵੱਖ ਕਰਦੇ ਹੋਏ, ਇਸ ਅਪਵਾਦ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੇਗਾ।

• ਕਾਰਗੋ ਸਪਲਿਟ-ਡੀਬਗਿਨਫੋ ਵਿਕਲਪ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਜੋ “[ਪ੍ਰੋਫਾਈਲ]” ਭਾਗ ਵਿੱਚ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ rustc ਵਿੱਚ ਸੰਬੰਧਿਤ ਫਲੈਗ “-Csplit-debuginfo=unpacked”, ਡੀਬਗਿੰਗ ਜਾਣਕਾਰੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਇੱਕ ਨਵੀਂ ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਲੋੜ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ। dsymutil ਉਪਯੋਗਤਾ ਨੂੰ ਕਾਲ ਕਰੋ ਅਤੇ macOS 'ਤੇ ਡੀਬੱਗਿੰਗ ਜਾਣਕਾਰੀ ਨਾਲ ਬਿਲਡ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਤੇਜ਼ ਕਰਦਾ ਹੈ।
• ਸਥਿਰ makos "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 ਇੱਕ ਅਣ-ਅਲਾਈਨ ਪੁਆਇੰਟਰ ਬਣਾਵੇਗਾ ਜੋ ਅਣ-ਪ੍ਰਭਾਸ਼ਿਤ ਵਿਵਹਾਰ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ raw_f2 = ptr::addr_of!(packed.f2); assert_eq!(ਅਸੁਰੱਖਿਅਤ { raw_f2.read_unaligned() }, 2);
• API ਦੇ ਇੱਕ ਨਵੇਂ ਹਿੱਸੇ ਨੂੰ ਸਥਿਰ ਸ਼੍ਰੇਣੀ ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਜਿਸ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਵਿਧੀਆਂ ਨੂੰ ਸਥਿਰ ਕੀਤਾ ਗਿਆ ਹੈ:
  • Arc::decrement_strong_count
  • Arc::increment_strong_count
  • ਇੱਕ ਵਾਰ::call_one_force
  • ਦੇਖਣਯੋਗ::next_if_eq
  • Peekable::next_if
  • ਖੋਜੋ::stream_position
  • ਐਰੇ::IntoIter
  • panic::panic_any
  • ptr::addr_of!
  • ptr::addr_of_mut!
  • ਟੁਕੜਾ::ਫਿਲ_ਵਿਥ
  • ਟੁਕੜਾ::split_inclusive_mut
  • slice::split_inclusive
  • slice::strip_prefix
  • ਟੁਕੜਾ::ਸਟ੍ਰਿਪ_ਸਫਿਕਸ
  • 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 ਪਲੇਟਫਾਰਮਾਂ ਲਈ ਸਮਰਥਨ ਦਾ ਤੀਜਾ ਪੱਧਰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ। . ਤੀਜੇ ਪੱਧਰ ਵਿੱਚ ਬੁਨਿਆਦੀ ਸਹਾਇਤਾ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ, ਪਰ ਸਵੈਚਲਿਤ ਜਾਂਚ ਤੋਂ ਬਿਨਾਂ, ਅਧਿਕਾਰਤ ਬਿਲਡਾਂ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨਾ, ਜਾਂ ਇਹ ਜਾਂਚ ਕਰਨਾ ਕਿ ਕੀ ਕੋਡ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

ਸਰੋਤ: opennet.ru