Rust 1.0.0-alpha 即将释出

2015/01/07 17:14
阅读数 900

Rust 1.0.0-alpha 即将释出


Version 1.0.0-alpha (January 2015)


  * ~2300 changes, numerous bugfixes

  * Highlights

    * The language itself is considered feature complete for 1.0,

      though there is a significant amount of cleanup and bugfixes


    * Nearly 50% of the public API surface of the standard library has

      been declared 'stable'. Those interfaces will not change.

    * Most crates that are not `std` have been moved out of the Rust

      distribution into the Cargo ecosystem so they can evolve

      separately and don't need to be stabilized as quickly, including

      'time', 'getopts', 'num', 'regex', and 'term'.

    * Documentation continues to be expanded with more guides, more

      API coverage and more examples.

    * All official Rust binary installers now come with [Cargo], the

      Rust package manager.

* Language

    * Closures have been [completely redesigned][unboxed] to be

      implemented in terms of traits, can now be used as generic type

      bounds and thus monomorphized and inlined, or via an opaque

      pointer (boxed) as in the old system. The new system is often

      referred to as 'unboxed' closures.

    * Enum variants are [namespaced by their type names][enum].

    * [`where` clauses][where] provide a more versatile and attractive

      syntax for specifying generic bounds, though the previous syntax

      remains valid.

    * Rust again picks a [fallback] (either i32 or f64) for uninferred

      numeric types.

    * Rust [no longer has a runtime][rt] of any description, and only

      supports OS threads, not green threads.

    * At long last, Rust has been overhauled for 'dynamically-sized

      types' ([DST]), which integrates 'fat pointers' (object types,

      arrays, and `str`) more deeply into the type system, making it

      more consistent.

    * Rust now has a general [range syntax][range], `i..j`, `i..`, and

      `..j` that produce range types and which, when combined with the

      `Index` operator and multitispatch, leads to a convenient slice

      notation, `[i..j]`.

    * The new range syntax revealed an ambiguity in the fixed-length

      array syntax, so now fixed length arrays [are written `[T;


    * The `Copy` trait is no longer implemented automatically. Unsafe

      pointers no longer implement `Sync` and `Send` so types

      containing them don't automatically either. `Sync` and `Send`

      are now 'unsafe traits' so one can "forcibly" implement them via

      `unsafe impl` if a type confirms to the requirements for them

      even though the internals do not (e.g. structs containing unsafe

      pointers like `Arc`). These changes are intended to prevent some

      footguns and are collectively known as [opt-in built-in

      traits][oibit] (though `Sync` and `Share` will soon become pure

      library types unknown to the compiler).

    * Operator traits now take their operands [by value][ops], and

      comparison traits can use multidispatch to compare one type

      against multiple other types, allowing e.g. `String` to be

      compared with `&str`.

    * `if let` and `while let` are no longer feature-gated.

    * Rust has adopted a more [uniform syntax for escaping unicode


    * `macro_rules!` [has been declared stable][mac]. Though it is a

      flawed system it is sufficiently popular that it must be usable

      for 1.0. Effort has gone into future-proofing it in ways that

      will allow other macro systems to be developed in parallel, and

      won't otherwise impact the evolution of the language.

    * The prelude has been [pared back significantly][prelude] such

      that it is the minimum necessary to support the most pervasive

      code patterns, and through [generalized where clauses][where]

      many of the prelude extension traits have been consolidated.

    * Rust's rudimentary reflection [has been removed][refl], as it

      incurred too much code generation for little benefit.

    * [Struct variants][structvars] are no longer feature-gated.

    * Trait bounds can be [polymorphic over lifetimes][hrtb]. Also

      known as 'higher-ranked trait bounds', this crucially allows

      unboxed closures to work.

    * Macros invocations surrounded by parens or square brackets and

      not terminated by a semicolon are [parsed as

      expressions][macros], which makes expressions like `vec![1i32,

      2, 3].len()` work as expected.

    * Trait objects now implement their traits automatically.

    * Automatically deriving traits is now done with `#[derive(...)]`

      not `#[deriving(...)]` for [consistency with other naming


    * Importing the containing module at the same time as items it

      contains is [now done with `self` instead of `mod`][self], as in

      use `foo::{self, bar}`

* Libraries

    * A [series][coll1] of [efforts][coll2] to establish

      [conventions][coll3] for collections types has resulted in API

      improvements throughout the standard library.

    * New [APIs for error handling][err] provide ergonomic interop

      between error types, and [new conventions][err-conv] describe

      more clearly the recommended error handling strategies in Rust.

    * The `fail!` macro has been renamed to [`panic!`][panic] so that

      it is easier to discuss failure in the context of error handling

      without making clarifications as to whether you are referring to

      the 'fail' macro or failure more generally.

    * On Linux, `OsRng` prefers the new, more reliable `getrandom'

      syscall when available.

    * The 'serialize' crate has been renamed 'rustc-serialize' and

      moved out of the distribution to Cargo. Although it is widely

      used now, it is expected to be superceded in the near future.

    * The `Show` formatter, typically implemented with

      `#[derive(Show)]` is [now requested with the `{:?}`

      specifier][show] and is intended for use by all types, for uses

      such as `println!` debugging. The new `String` formatter must be

      implemented by hand, uses the `{}` specifier, and is intended

      for full-fidelity conversions of things that can logically be

      represented as strings.

* Tooling

    * [Flexible target specification][flex] allows rustc's code

      generation to be configured to support otherwise-unsupported


    * Rust comes with rust-gdb and rust-lldb scripts that launch their

      respective debuggers with Rust-appropriate pretty-printing.

    * The Windows installation of Rust is distributed with the the

      MinGW components currently required to link binaries on that


* Misc

    * Nullable enum optimizations have been extended to more types so

      that e.g. `Option<Vec<T>>` and `Option<String>` take up no more

      space than the inner types themselves.

    * Work has begun on supporting AArch64.





























Version 0.12.0 (October 2014)




0 收藏
2 评论
0 收藏