Rust 0.6

• ~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.

Rust 0.5

• ~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

Rust 0.4

• ~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

Rust 0.3

• ~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

Rust 0.2

• 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

Rust 0.1

• 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.