Version 0.8 (October 2013) -------------------------- * ~2100 changes, numerous bugfixes * Language * The `for` loop syntax has changed to work with the `Iterator` trait. * At long last, unwinding works on Windows. * Default methods are ready for use. * Many trait inheritance bugs fixed. * Owned and borrowed trait objects work more reliably. * `copy` is no longer a keyword. It has been replaced by the `Clone` trait. * rustc can omit emission of code for the `debug!` macro if it is passed `--cfg ndebug` * mod.rs is now "blessed". When loading `mod foo;`, rustc will now look for foo.rs, then foo/mod.rs, and will generate an error when both are present. * Strings no longer contain trailing nulls. The new `std::c_str` module provides new mechanisms for converting to C strings. * The type of foreign functions is now `extern "C" fn` instead of `*u8'. * The FFI has been overhauled such that foreign functions are called directly, instead of through a stack-switching wrapper. * Calling a foreign function must be done through a Rust function with the `#[fixed_stack_segment]` attribute. * The `externfn!` macro can be used to declare both a foreign function and a `#[fixed_stack_segment]` wrapper at once. * `pub` and `priv` modifiers on `extern` blocks are no longer parsed. * `unsafe` is no longer allowed on extern fns - they are all unsafe. * `priv` is disallowed everywhere except for struct fields and enum variants. * `&T` (besides `&'static T`) is no longer allowed in `@T`. * `ref` bindings in irrefutable patterns work correctly now. * `char` is now prevented from containing invalid code points. * Casting to `bool` is no longer allowed. * `yield` is a reserved keyword. * `typeof` is a reserved keyword. * Crates may be imported by URL with `extern mod foo = "url";`. * Explicit enum discriminants may be given as uints as in `enum E { V = 0u }` * Static vectors can be initialized with repeating elements, e.g. `static foo: [u8, .. 100]: [0, .. 100];`. * Static structs can be initialized with functional record update, e.g. `static foo: Foo = Foo { a: 5, .. bar };`. * `cfg!` can be used to conditionally execute code based on the crate configuration, similarly to `#[cfg(...)]`. * The `unnecessary_qualification` lint detects unneeded module prefixes (default: allow). * Arithmetic operations have been implemented on the SIMD types in `std::unstable::simd`. * Exchange allocation headers were removed, reducing memory usage. * `format!` implements a completely new, extensible, and higher-performance string formatting system. It will replace `fmt!`. * `print!` and `println!` write formatted strings (using the `format!` extension) to stdout. * `write!` and `writeln!` write formatted strings (using the `format!` extension) to the new Writers in `std::rt::io`. * The library section in which a function or static is placed may be specified with `#[link_section = "..."]`. * The `proto!` syntax extension for defining bounded message protocols was removed. * `macro_rules!` is hygienic for `let` declarations. * The `#[export_name]` attribute specifies the name of a symbol. * `unreachable!` can be used to indicate unreachable code, and fails if executed. * Libraries * std: Transitioned to the new runtime, written in Rust. * std: Added an experimental I/O library, `rt::io`, based on the new runtime. * std: A new generic `range` function was added to the prelude, replacing `uint::range` and friends. * std: `range_rev` no longer exists. Since range is an iterator it can be reversed with `range(lo, hi).invert()`. * std: The `chain` method on option renamed to `and_then`; `unwrap_or_default` renamed to `unwrap_or`. * std: The `iterator` module was renamed to `iter`. * std: Integral types now support the `checked_add`, `checked_sub`, and `checked_mul` operations for detecting overflow. * std: Many methods in `str`, `vec`, `option, `result` were renamed for consistency. * std: Methods are standardizing on conventions for casting methods: `to_foo` for copying, `into_foo` for moving, `as_foo` for temporary and cheap casts. * std: The `CString` type in `c_str` provides new ways to convert to and from C strings. * std: `DoubleEndedIterator` can yield elements in two directions. * std: The `mut_split` method on vectors partitions an `&mut [T]` into two splices. * std: `str::from_bytes` renamed to `str::from_utf8`. * std: `pop_opt` and `shift_opt` methods added to vectors. * std: The task-local data interface no longer uses @, and keys are no longer function pointers. * std: The `swap_unwrap` method of `Option` renamed to `take_unwrap`. * std: Added `SharedPort` to `comm`. * std: `Eq` has a default method for `ne`; only `eq` is required in implementations. * std: `Ord` has default methods for `le`, `gt` and `ge`; only `lt` is required in implementations. * std: `is_utf8` performance is improved, impacting many string functions. * std: `os::MemoryMap` provides cross-platform mmap. * std: `ptr::offset` is now unsafe, but also more optimized. Offsets that are not 'in-bounds' are considered undefined. * std: Many freestanding functions in `vec` removed in favor of methods. * std: Many freestanding functions on scalar types removed in favor of methods. * std: Many options to task builders were removed since they don't make sense in the new scheduler design. * std: More containers implement `FromIterator` so can be created by the `collect` method. * std: More complete atomic types in `unstable::atomics`. * std: `comm::PortSet` removed. * std: Mutating methods in the `Set` and `Map` traits have been moved into the `MutableSet` and `MutableMap` traits. `Container::is_empty`, `Map::contains_key`, `MutableMap::insert`, and `MutableMap::remove` have default implementations. * extra: `dlist`, the doubly-linked list was modernized. * extra: Added a `hex` module with `ToHex` and `FromHex` traits. * extra: Added `glob` module, replacing `std::os::glob`. * extra: `rope` was removed. * extra: `deque` was renamed to `ringbuf`. `RingBuf` implements `Deque`. * extra: `net`, and `timer` were removed. The experimental replacements are `std::rt::io::net` and `std::rt::io::timer`. * extra: Iterators implemented for `SmallIntMap`. * extra: Iterators implemented for `Bitv` and `BitvSet`. * extra: `SmallIntSet` removed. Use `BitvSet`. * extra: Performance of JSON parsing greatly improved. * extra: `semver` updated to SemVer 2.0.0. * extra: `term` handles more terminals correctly. * extra: `dbg` module removed. * Other * rustc's debug info generation (`-Z debug-info`) is greatly improved. * rustc accepts `--target-cpu` to compile to a specific CPU architecture, similarly to gcc's `--march` flag. * rustc's performance compiling small crates is much better. * rustpkg has received many improvements. * rustpkg supports git tags as package IDs. * rustpkg builds into target-specific directories so it can be used for cross-compiling. * The number of concurrent test tasks is controlled by the environment variable RUST_TEST_TASKS. * The test harness can now report metrics for benchmarks. * All tools have man pages. * Programs compiled with `--test` now support the `-h` and `--help` flags. * The runtime uses jemalloc for allocations. * Segmented stacks are temporarily disabled as part of the transition to the new runtime. Stack overflows are possible! * A new documentation backend, rustdoc_ng, is available for use. It is still invoked through the normal `rustdoc` command. Version 0.7 (July 2013) ----------------------- * ~2000 changes, numerous bugfixes * Language * `impl`s no longer accept a visibility qualifier. Put them on methods instead. * The borrow checker has been rewritten with flow-sensitivity, fixing many bugs and inconveniences. * The `self` parameter no longer implicitly means `&'self self`, and can be explicitly marked with a lifetime. * Overloadable compound operators (`+=`, etc.) have been temporarily removed due to bugs. * The `for` loop protocol now requires `for`-iterators to return `bool` so they compose better. * The `Durable` trait is replaced with the `'static` bounds. * Trait default methods work more often. * Structs with the `#[packed]` attribute have byte alignment and no padding between fields. * Type parameters bound by `Copy` must now be copied explicitly with the `copy` keyword. * It is now illegal to move out of a dereferenced unsafe pointer. * `Option<~T>` is now represented as a nullable pointer. * `@mut` does dynamic borrow checks correctly. * The `main` function is only detected at the topmost level of the crate. The `#[main]` attribute is still valid anywhere. * Struct fields may no longer be mutable. Use inherited mutability. * The `#[no_send]` attribute makes a type that would otherwise be `Send`, not. * The `#[no_freeze]` attribute makes a type that would otherwise be `Freeze`, not. * Unbounded recursion will abort the process after reaching the limit specified by the `RUST_MAX_STACK` environment variable (default: 1GB). * The `vecs_implicitly_copyable` lint mode has been removed. Vectors are never implicitly copyable. * `#[static_assert]` makes compile-time assertions about static bools. * At long last, 'argument modes' no longer exist. * The rarely used `use mod` statement no longer exists. * Syntax extensions * `fail!` and `assert!` accept `~str`, `&'static str` or `fmt!`-style argument list. * `Encodable`, `Decodable`, `Ord`, `TotalOrd`, `TotalEq`, `DeepClone`, `Rand`, `Zero` and `ToStr` can all be automatically derived with `#[deriving(...)]`. * The `bytes!` macro returns a vector of bytes for string, u8, char, and unsuffixed integer literals. * Libraries * The `core` crate was renamed to `std`. * The `std` crate was renamed to `extra`. * More and improved documentation. * std: `iterator` module for external iterator objects. * Many old-style (internal, higher-order function) iterators replaced by implementations of `Iterator`. * std: Many old internal vector and string iterators, incl. `any`, `all`. removed. * std: The `finalize` method of `Drop` renamed to `drop`. * std: The prelude no longer reexports any modules, only types and traits. * std: Prelude additions: `print`, `println`, `FromStr`, `ApproxEq`, `Equiv`, `Iterator`, `IteratorUtil`, many numeric traits, many tuple traits. * std: New numeric traits: `Fractional`, `Real`, `RealExt`, `Integer`, `Ratio`, `Algebraic`, `Trigonometric`, `Exponential`, `Primitive`. * std: Tuple traits and accessors defined for up to 12-tuples, e.g. `(0, 1, 2).n2()` or `(0, 1, 2).n2_ref()`. * std: Many types implement `Clone`. * std: `path` type renamed to `Path`. * std: `mut` module and `Mut` type removed. * std: Many standalone functions removed in favor of methods and iterators in `vec`, `str`. In the future methods will also work as functions. * std: `reinterpret_cast` removed. Use `transmute`. * std: ascii string handling in `std::ascii`. * std: `Rand` is implemented for ~/@. * std: `run` module for spawning processes overhauled. * std: Various atomic types added to `unstable::atomic`. * std: Various types implement `Zero`. * std: `LinearMap` and `LinearSet` renamed to `HashMap` and `HashSet`. * std: Borrowed pointer functions moved from `ptr` to `borrow`. * std: Added `os::mkdir_recursive`. * std: Added `os::glob` function performs filesystems globs. * std: `FuzzyEq` renamed to `ApproxEq`. * std: `Map` now defines `pop` and `swap` methods. * std: `Cell` constructors converted to static methods. * extra: `rc` module adds the reference counted pointers, `Rc` and `RcMut`. * extra: `flate` module moved from `std` to `extra`. * extra: `fileinput` module for iterating over a series of files. * extra: `Complex` number type and `complex` module. * extra: `Rational` number type and `rational` module. * extra: `BigInt`, `BigUint` implement numeric and comparison traits. * extra: `term` uses terminfo now, is more correct. * extra: `arc` functions converted to methods. * extra: Implementation of fixed output size variations of SHA-2. * Tooling * `unused_variable` lint mode for unused variables (default: warn). * `unused_unsafe` lint mode for detecting unnecessary `unsafe` blocks (default: warn). * `unused_mut` lint mode for identifying unused `mut` qualifiers (default: warn). * `dead_assignment` lint mode for unread variables (default: warn). * `unnecessary_allocation` lint mode detects some heap allocations that are immediately borrowed so could be written without allocating (default: warn). * `missing_doc` lint mode (default: allow). * `unreachable_code` lint mode (default: warn). * The `rusti` command has been rewritten and a number of bugs addressed. * rustc outputs in color on more terminals. * rustc accepts a `--link-args` flag to pass arguments to the linker. * rustc accepts a `-Z print-link-args` flag for debugging linkage. * Compiling with `-g` will make the binary record information about dynamic borrowcheck failures for debugging. * rustdoc has a nicer stylesheet. * Various improvements to rustdoc. * Improvements to rustpkg (see the detailed release notes). Version 0.6 (April 2013) ------------------------ * ~2100 changes, numerous bugfixes * Syntax changes * The self type parameter in traits is now spelled `Self` * The `self` parameter in trait and impl methods must now be explicitly named (for example: `fn f(&self) { }`). Implicit self is deprecated. * Static methods no longer require the `static` keyword and instead are distinguished by the lack of a `self` parameter * Replaced the `Durable` trait with the `'static` lifetime * The old closure type syntax with the trailing sigil has been removed in favor of the more consistent leading sigil * `super` is a keyword, and may be prefixed to paths * Trait bounds are separated with `+` instead of whitespace * Traits are implemented with `impl Trait for Type` instead of `impl Type: Trait` * Lifetime syntax is now `&'l foo` instead of `&l/foo` * The `export` keyword has finally been removed * The `move` keyword has been removed (see "Semantic changes") * The interior mutability qualifier on vectors, `[mut T]`, has been removed. Use `&mut [T]`, etc. * `mut` is no longer valid in `~mut T`. Use inherited mutability * `fail` is no longer a keyword. Use `fail!()` * `assert` is no longer a keyword. Use `assert!()` * `log` is no longer a keyword. use `debug!`, etc. * 1-tuples may be represented as `(T,)` * Struct fields may no longer be `mut`. Use inherited mutability, `@mut T`, `core::mut` or `core::cell` * `extern mod { ... }` is no longer valid syntax for foreign function modules. Use extern blocks: `extern { ... }` * Newtype enums removed. Use tuple-structs. * Trait implementations no longer support visibility modifiers * Pattern matching over vectors improved and expanded * `const` renamed to `static` to correspond to lifetime name, and make room for future `static mut` unsafe mutable globals. * Replaced `#[deriving_eq]` with `#[deriving(Eq)]`, etc. * `Clone` implementations can be automatically generated with `#[deriving(Clone)]` * Casts to traits must use a pointer sigil, e.g. `@foo as @Bar` instead of `foo as Bar`. * Fixed length vector types are now written as `[int, .. 3]` instead of `[int * 3]`. * Fixed length vector types can express the length as a constant expression. (ex: `[int, .. GL_BUFFER_SIZE - 2]`) * Semantic changes * Types with owned pointers or custom destructors move by default, eliminating the `move` keyword * All foreign functions are considered unsafe * &mut is now unaliasable * Writes to borrowed @mut pointers are prevented dynamically * () has size 0 * The name of the main function can be customized using #[main] * The default type of an inferred closure is &fn instead of @fn * `use` statements may no longer be "chained" - they cannot import identifiers imported by previous `use` statements * `use` statements are crate relative, importing from the "top" of the crate by default. Paths may be prefixed with `super::` or `self::` to change the search behavior. * Method visibility is inherited from the implementation declaration * Structural records have been removed * Many more types can be used in static items, including enums 'static-lifetime pointers and vectors * Pattern matching over vectors improved and expanded * Typechecking of closure types has been overhauled to improve inference and eliminate unsoundness * Macros leave scope at the end of modules, unless that module is tagged with #[macro_escape] * Libraries * Added big integers to `std::bigint` * Removed `core::oldcomm` module * Added pipe-based `core::comm` module * Numeric traits have been reorganized under `core::num` * `vec::slice` finally returns a slice * `debug!` and friends don't require a format string, e.g. `debug!(Foo)` * Containers reorganized around traits in `core::container` * `core::dvec` removed, `~[T]` is a drop-in replacement * `core::send_map` renamed to `core::hashmap` * `std::map` removed; replaced with `core::hashmap` * `std::treemap` reimplemented as an owned balanced tree * `std::deque` and `std::smallintmap` reimplemented as owned containers * `core::trie` added as a fast ordered map for integer keys * Set types added to `core::hashmap`, `core::trie` and `std::treemap` * `Ord` split into `Ord` and `TotalOrd`. `Ord` is still used to overload the comparison operators, whereas `TotalOrd` is used by certain container types * Other * Replaced the 'cargo' package manager with 'rustpkg' * Added all-purpose 'rust' tool * `rustc --test` now supports benchmarks with the `#[bench]` attribute * rustc now *attempts* to offer spelling suggestions * Improved support for ARM and Android * Preliminary MIPS backend * Improved foreign function ABI implementation for x86, x86_64 * Various memory usage improvements * Rust code may be embedded in foreign code under limited circumstances * Inline assembler supported by new asm!() syntax extension. Version 0.5 (December 2012) --------------------------- * ~900 changes, numerous bugfixes * Syntax changes * Removed `<-` move operator * Completed the transition from the `#fmt` extension syntax to `fmt!` * Removed old fixed length vector syntax - `[T]/N` * New token-based quasi-quoters, `quote_tokens!`, `quote_expr!`, etc. * Macros may now expand to items and statements * `a.b()` is always parsed as a method call, never as a field projection * `Eq` and `IterBytes` implementations can be automatically generated with `#[deriving_eq]` and `#[deriving_iter_bytes]` respectively * Removed the special crate language for `.rc` files * Function arguments may consist of any irrefutable pattern * Semantic changes * `&` and `~` pointers may point to objects * Tuple structs - `struct Foo(Bar, Baz)`. Will replace newtype enums. * Enum variants may be structs * Destructors can be added to all nominal types with the Drop trait * Structs and nullary enum variants may be constants * Values that cannot be implicitly copied are now automatically moved without writing `move` explicitly * `&T` may now be coerced to `*T` * Coercions happen in `let` statements as well as function calls * `use` statements now take crate-relative paths * The module and type namespaces have been merged so that static method names can be resolved under the trait in which they are declared * Improved support for language features * Trait inheritance works in many scenarios * More support for explicit self arguments in methods - `self`, `&self` `@self`, and `~self` all generally work as expected * Static methods work in more situations * Experimental: Traits may declare default methods for the implementations to use * Libraries * New condition handling system in `core::condition` * Timsort added to `std::sort` * New priority queue, `std::priority_queue` * Pipes for serializable types, `std::flatpipes' * Serialization overhauled to be trait-based * Expanded `getopts` definitions * Moved futures to `std` * More functions are pure now * `core::comm` renamed to `oldcomm`. Still deprecated * `rustdoc` and `cargo` are libraries now * Misc * Added a preliminary REPL, `rusti` * License changed from MIT to dual MIT/APL2 Version 0.4 (October 2012) -------------------------- * ~2000 changes, numerous bugfixes * Syntax * All keywords are now strict and may not be used as identifiers anywhere * Keyword removal: 'again', 'import', 'check', 'new', 'owned', 'send', 'of', 'with', 'to', 'class'. * Classes are replaced with simpler structs * Explicit method self types * `ret` became `return` and `alt` became `match` * `import` is now `use`; `use is now `extern mod` * `extern mod { ... }` is now `extern { ... }` * `use mod` is the recommended way to import modules * `pub` and `priv` replace deprecated export lists * The syntax of `match` pattern arms now uses fat arrow (=>) * `main` no longer accepts an args vector; use `os::args` instead * Semantics * Trait implementations are now coherent, ala Haskell typeclasses * Trait methods may be static * Argument modes are deprecated * Borrowed pointers are much more mature and recommended for use * Strings and vectors in the static region are stored in constant memory * Typestate was removed * Resolution rewritten to be more reliable * Support for 'dual-mode' data structures (freezing and thawing) * Libraries * Most binary operators can now be overloaded via the traits in `core::ops' * `std::net::url` for representing URLs * Sendable hash maps in `core::send_map` * `core::task' gained a (currently unsafe) task-local storage API * Concurrency * An efficient new intertask communication primitive called the pipe, along with a number of higher-level channel types, in `core::pipes` * `std::arc`, an atomically reference counted, immutable, shared memory type * `std::sync`, various exotic synchronization tools based on arcs and pipes * Futures are now based on pipes and sendable * More robust linked task failure * Improved task builder API * Other * Improved error reporting * Preliminary JIT support * Preliminary work on precise GC * Extensive architectural improvements to rustc * Begun a transition away from buggy C++-based reflection (shape) code to Rust-based (visitor) code * All hash functions and tables converted to secure, randomized SipHash Version 0.3 (July 2012) ------------------------ * ~1900 changes, numerous bugfixes * New coding conveniences * Integer-literal suffix inference * Per-item control over warnings, errors * #[cfg(windows)] and #[cfg(unix)] attributes * Documentation comments * More compact closure syntax * 'do' expressions for treating higher-order functions as control structures * *-patterns (wildcard extended to all constructor fields) * Semantic cleanup * Name resolution pass and exhaustiveness checker rewritten * Region pointers and borrow checking supersede alias analysis * Init-ness checking is now provided by a region-based liveness pass instead of the typestate pass; same for last-use analysis * Extensive work on region pointers * Experimental new language features * Slices and fixed-size, interior-allocated vectors * #!-comments for lang versioning, shell execution * Destructors and iface implementation for classes; type-parameterized classes and class methods * 'const' type kind for types that can be used to implement shared-memory concurrency patterns * Type reflection * Removal of various obsolete features * Keywords: 'be', 'prove', 'syntax', 'note', 'mutable', 'bind', 'crust', 'native' (now 'extern'), 'cont' (now 'again') * Constructs: do-while loops ('do' repurposed), fn binding, resources (replaced by destructors) * Compiler reorganization * Syntax-layer of compiler split into separate crate * Clang (from LLVM project) integrated into build * Typechecker split into sub-modules * New library code * New time functions * Extension methods for many built-in types * Arc: atomic-refcount read-only / exclusive-use shared cells * Par: parallel map and search routines * Extensive work on libuv interface * Much vector code moved to libraries * Syntax extensions: #line, #col, #file, #mod, #stringify, #include, #include_str, #include_bin * Tool improvements * Cargo automatically resolves dependencies Version 0.2 (March 2012) ------------------------- * >1500 changes, numerous bugfixes * New docs and doc tooling * New port: FreeBSD x86_64 * Compilation model enhancements * Generics now specialized, multiply instantiated * Functions now inlined across separate crates * Scheduling, stack and threading fixes * Noticeably improved message-passing performance * Explicit schedulers * Callbacks from C * Helgrind clean * Experimental new language features * Operator overloading * Region pointers * Classes * Various language extensions * C-callback function types: 'crust fn ...' * Infinite-loop construct: 'loop { ... }' * Shorten 'mutable' to 'mut' * Required mutable-local qualifier: 'let mut ...' * Basic glob-exporting: 'export foo::*;' * Alt now exhaustive, 'alt check' for runtime-checked * Block-function form of 'for' loop, with 'break' and 'ret'. * New library code * AST quasi-quote syntax extension * Revived libuv interface * New modules: core::{future, iter}, std::arena * Merged per-platform std::{os*, fs*} to core::{libc, os} * Extensive cleanup, regularization in libstd, libcore Version 0.1 (January 2012) --------------------------- * Most language features work, including: * Unique pointers, unique closures, move semantics * Interface-constrained generics * Static interface dispatch * Stack growth * Multithread task scheduling * Typestate predicates * Failure unwinding, destructors * Pattern matching and destructuring assignment * Lightweight block-lambda syntax * Preliminary macro-by-example * Compiler works with the following configurations: * Linux: x86 and x86_64 hosts and targets * MacOS: x86 and x86_64 hosts and targets * Windows: x86 hosts and targets * Cross compilation / multi-target configuration supported. * Preliminary API-documentation and package-management tools included. Known issues: * Documentation is incomplete. * Performance is below intended target. * Standard library APIs are subject to extensive change, reorganization. * Language-level versioning is not yet operational - future code will break unexpectedly.