本文将汇总 Rust 1.0 之后各版本在语法和部分库函数方面的更新,略过编译器和标准库的性能优化,工具链和文档的改进等内容.
2015 - 05 - 15 Rust 1.0 2015 - 06 - 25 Rust 1.1 New std: :fs APIs.2015 - 08 - 06 Rust 1.2 Rc < [T] > is fully usable.2015 - 09 - 17 Rust 1.3 new Duration API and enhancements to Error and Hash / Hasher.'static variables may now be recursive .
2015-10-29 Rust 1.4
When reading 'lines ' to treat both \n and \r\n as a valid line-ending.
2015-12-10 Rust 1.5
Arc and Rc are covariant with respect to T instead of invariant .
Default is implemented for mutable slices .
There are now From conversions between floating point types where the conversions are lossless.
Thera are now From conversions between integer types where the conversions are lossless.
The parse method accepts a leading "+" when parsing integers .
2016-01-21 Rust 1.6
The core library is stable, as are most of its APIs. Rust's standard library is two - tiered: there 's a small core library, libcore, and the full standard library, libstd, that builds on top of it. libcore is completely platform agnostic, and requires only a handful of external symbols to be defined. Rust's libstd builds on top of libcore,
adding support
for memory allocation,
I / O,
and concurrency.Applications using Rust in the embedded space,
as well as those writing operating systems,
often eschew libstd,
using only libcore.The`# [图片上传失败... (image - f4d162 - 1516015456023)].2016 - 03 - 02 Rust 1.7 support
for custom hash algorithms in the standard library 's HashMap<K, V> type.
2016-04-14 Rust 1.8
"operator equals" operators, such as += and -=, are now overloadable via coresponding traits.
struct with no fields can have curly braces:
struct Foo; // works
struct Bar { } // also works
2016-05-26 Rust 1.9
The #[deprecated] attribute when applied to an API will generate warnings when used. The warnings may be suppressed with
# [allow(deprecated)]
.
stabilization of the std::panic module.
2016-07-07 Rust 1.10
Single-variant enums support the #[repr(..)\] attribute.
panic! can be converted to a runtime abort with the -C panic=abort flag .
Add a new crate type, 'cdylib ' . cdylibs are dynamic libraries suitable for loading by non-Rust hosts.
2016-08-18 Rust 1.11
Macros can be expanded inside of trait definitions
support for cdylibs has landed in Cargo ! By adding this to your Cargo.toml:
crate - type = ["cdylib"]
2016-09-29 Rust 1.12
rustc translates code to LLVM IR via its own "middle" IR (MIR) .
rustc presents a new, more readable error format, along with machine-readable JSON error output for use by IDEs .
The format! macro and friends now allow a single argument to be formatted in multiple styles
Option implements From for its contained type
2016-11-10 Rust 1.13
new operator, ?, for error handling, a solid ergonomic improvement to the old try! macro.
fn read_username_from_file() -> Result<String, io::Error> {
let mut f = File::open("username.txt")?;
let mut s = String::new();
f.read_to_string(&mut s)?;
Ok(s)
}
Macros can now be used in type position ( RFC 873 ).
Attributes can be applied to statements ( RFC 16 ).
2016-12-22 Rust 1.14
rustup is the recommended Rust installation method
experimental support for webAssembly , via the
wasm32 - unknown - emscripten
target.
println!(), with no arguments, prints newline . Previously, an empty string was required to achieve the same.
.. matches multiple tuple fields in enum variants, structs and tuples . RFC 1492 .
struct Point(i32, i32, i32);
let p = Point(0, 1, 2);
// Previously you could ignore all three elements:
match p {
Point(..) = >println ! ("found a point"),
}
// Now you could only ignore parts of the tuple:
match p {
Point(x, ..) = >println ! ("x is {}", x),
}
2017-02-02 Rust 1.15
The Rust build system is now re-written in Rust, using Cargo .
?Sized can be used in where clauses .
Basic procedural macros allowing custom #[derive], aka "macros 1.1". This allows popular code-generating crates like Serde and Diesel to work ergonomically. RFC 1681 .
Tuple structs may be empty. Unary and empty tuple structs may be instantiated with curly braces . Part of RFC 1506 .
2017-03-16 Rust 1.16
All public types in std implement Debug
writeln! now has a single-argument form , just like println!, writing a newline.
Self may appear in impl headers and in struct expressions
2017-04-27 Rust 1.17
The 'staticlifetime is now assumed in statics and consts.
// old
const NAME: &'static str = "Ferris";
static NAME: &'static str = "Ferris";
const NAMES: &'static [&'static str;
2] = &["Ferris", "Bors"];
// new
const NAME: &str = "Ferris";
static NAME: &str = "Ferris";
const NAMES: &[ & str; 2] = &["Ferris", "Bors"];
Fields of structs may be initialized without duplicating the field / variable names.RFC 1682 let x = 5;
let y = 6;
let p = Point {
x,
y
};
Self may be included in the where clause of impls.RFC 1647 Static variables may contain references to other statics Documentation is rendered with mdbook instead of the obsolete,
in-tree rustbook rustup installs documentation by
default 2017 - 06 - 08 Rust 1.18 pub has gained a new form: pub(crate) bar;
pub( in a: :b: :c) foo;`# [图片上传失败... (image - 32849c - 1516015456023)].# ! [windows_subsystem = "console"]# ! [windows_subsystem = "windows"] 0e + 10 is now a valid floating point literal 2017 - 07 - 20 Rust 1.19 C compatible unions are now available.RFC 1444 union MyUnion {
f1: u32,
f2: f32,
}
let u = MyUnion {
f1: 1
};
unsafe {
u.f1 = 5
};
let value = unsafe {
u.f1
};
Enums have a "tag"that stores which variant is the correct one at runtime;
unions elide this tag.So reading or writing a union 's field is unsafe. One major use-case is interoperability with C.
loops can now break with a value :
let x = loop { break 7; };
closures that do not capture an environment can now be coerced to a function pointer :
let f: fn(i32) - >i32 = |x | x + 1;
Numeric fields can now be used for creating tuple structs. RFC 1506
struct Point(u32, u32);
let x = Point { 0: 7, 1: 0 };
eprint! and eprintln! macros . These work exactly the same as print! and println! but instead write to standard error.
2017-08-31 Rust 1.20
Define "associated constants" on traits, structs, and enums.
struct Struct;
impl Struct {
// associated constant
const ID: u32 = 0;
// associated function
fn foo() {
println ! ("foo is called");
}
}
fn main() {
Struct: :foo();
println ! ("the ID of Struct is: {}", Struct: :ID);
}
allow messages in the unimplemented!() macro. ie.
unimplemented ! ("Waiting for 1.21 to be stable")
Upgrade to Unicode 10.0.0
2017-10-12 Rust 1.21
You can now use static references for literals.
fn main() {
let x: &'static u32 = &0;
let y = &5;
thread: :spawn(move || {
println ! ("{}", y);
});
}
'
Iterator::for_each has been stabilized.
(0..10).for_each( | i | println ! ("{}", i));
Generate builtin impls for Clone for all arrays and tuples that are T: Clone
2017-11-22 Rust 1.22
can use ? with Option
Types that implement Drop are now allowed in const and static items .
T op= &T now works for primitive types , which is a fancy way of saying:
let mut x = 2;
let y = &8;
// Previously, you'd have needed to write x += *y x += y;Now accepts underscores in unicode escapes 2018 - 01 - 04 Rust 1.23 AsciiExt methods are now defined directly on u8, char, [u8], and str types, so you no longer need to import the trait.The various std: :sync: :atomic types now implement From their non - atomic types.
来源: http://www.jianshu.com/p/159823959005