1 Version 0.6 (March 2013)
2 ---------------------------
4 * ~??? changes, numerous bugfixes
10 * Remove `static` keyword
11 * Static method syntax
16 * The self type parameter in traits is now spelled `Self`
17 * Replaced the `Durable` trait with the `'static` lifetime
18 * The old closure type syntax with the trailing sigil has been
19 removed in favor of the more consistent leading sigil
20 * `super` is a keyword, and may be prefixed to paths
21 * Trait bounds are separated with `+` instead of whitespace
22 * Traits are implemented with `impl Trait for Type`
23 instead of `impl Type: Trait`
24 * The `export` keyword has finally been removed
25 * The `move` keyword has been removed (linear types move by default)
26 * The interior mutability qualifier on vectors, `[mut T]`, has been
27 removed. Use `&mut [T]`, etc.
28 * `mut` is no longer valid in `~mut T`. Use inherited mutability
29 * `fail` is no longer a keyword. Use `fail!()`
30 * `assert` is no longer a keyword. Use `assert!()`
31 * `log` is no longer a keyword. use `debug!`, etc.
32 * 1-tuples may be represented as `(T,)`
33 * Struct fields may no longer be `mut`. Use inherited mutability,
34 `@mut T`, `core::mut` or `core::cell`
35 * `extern mod { ... }` is no longer valid syntax for foreign
36 function modules. Use extern blocks: `extern { ... }`
37 * Newtype enums removed. Used tuple-structs.
38 * Trait implementations no longer support visibility modifiers
41 * Linear types move by default, eliminating the `move` keyword
42 * All foreign functions are considered unsafe
43 * &mut is now unaliasable
44 * Writes to borrowed @mut pointers are prevented dynamically
46 * The name of the main function can be customized using #[main]
47 * The default type of an inferred closure is &fn instead of @fn
48 * Name resolution continues to be tweaked
49 * Method visibility is inherited from the implementation declaration
51 * Other language changes
52 * Structural records have been removed
53 * Many more types can be used in constants, including enums
54 `static lifetime pointers and vectors
55 * Pattern matching over vectors improved and expanded
56 * Typechecking of closure types has been overhauled to
57 improve inference and eliminate unsoundness
60 * Lots of effort to organize the container API's around `core::container`
61 * `core::send_map` renamed to `core::hashmap`
62 * Added big integers to `std::bigint`
63 * Removed `core::oldcomm` module
64 * Added pipe-based `core::comm` module
65 * Reimplemented `std::treemap`
66 * Numeric traits have been reorganized under `core::num`
67 * `core::dvec` removed. Use `@mut ~[T]` or other language types
68 * `vec::slice` finally returns a slice
69 * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
72 * Replaced the 'cargo' package manager with 'rustpkg'
73 * Added all-purpose 'rust' tool
74 * `rustc --test` now supports a benchmarks with the `#[bench]` attribute
75 * rustc now attempts to offer spelling suggestions
78 * Improved support for ARM and Android
79 * Preliminary MIPS backend
80 * Improved foreign function ABI implementation for x86, x86_64
81 * Various and memory usage improvements
82 * Rust code may be embedded in foreign code under limited circumstances
84 Version 0.5 (December 2012)
85 ---------------------------
87 * ~900 changes, numerous bugfixes
90 * Removed `<-` move operator
91 * Completed the transition from the `#fmt` extension syntax to `fmt!`
92 * Removed old fixed length vector syntax - `[T]/N`
93 * New token-based quasi-quoters, `quote_tokens!`, `quote_expr!`, etc.
94 * Macros may now expand to items and statements
95 * `a.b()` is always parsed as a method call, never as a field projection
96 * `Eq` and `IterBytes` implementations can be automatically generated
97 with `#[deriving_eq]` and `#[deriving_iter_bytes]` respectively
98 * Removed the special crate language for `.rc` files
99 * Function arguments may consist of any irrefutable pattern
102 * `&` and `~` pointers may point to objects
103 * Tuple structs - `struct Foo(Bar, Baz)`. Will replace newtype enums.
104 * Enum variants may be structs
105 * Destructors can be added to all nominal types with the Drop trait
106 * Structs and nullary enum variants may be constants
107 * Values that cannot be implicitly copied are now automatically moved
108 without writing `move` explicitly
109 * `&T` may now be coerced to `*T`
110 * Coercions happen in `let` statements as well as function calls
111 * `use` statements now take crate-relative paths
112 * The module and type namespaces have been merged so that static
113 method names can be resolved under the trait in which they are
116 * Improved support for language features
117 * Trait inheritance works in many scenarios
118 * More support for explicit self arguments in methods - `self`, `&self`
119 `@self`, and `~self` all generally work as expected
120 * Static methods work in more situations
121 * Experimental: Traits may declare default methods for the implementations
125 * New condition handling system in `core::condition`
126 * Timsort added to `std::sort`
127 * New priority queue, `std::priority_queue`
128 * Pipes for serializable types, `std::flatpipes'
129 * Serialization overhauled to be trait-based
130 * Expanded `getopts` definitions
131 * Moved futures to `std`
132 * More functions are pure now
133 * `core::comm` renamed to `oldcomm`. Still deprecated
134 * `rustdoc` and `cargo` are libraries now
137 * Added a preliminary REPL, `rusti`
138 * License changed from MIT to dual MIT/APL2
140 Version 0.4 (October 2012)
141 --------------------------
143 * ~2000 changes, numerous bugfixes
146 * All keywords are now strict and may not be used as identifiers anywhere
147 * Keyword removal: 'again', 'import', 'check', 'new', 'owned', 'send',
148 'of', 'with', 'to', 'class'.
149 * Classes are replaced with simpler structs
150 * Explicit method self types
151 * `ret` became `return` and `alt` became `match`
152 * `import` is now `use`; `use is now `extern mod`
153 * `extern mod { ... }` is now `extern { ... }`
154 * `use mod` is the recommended way to import modules
155 * `pub` and `priv` replace deprecated export lists
156 * The syntax of `match` pattern arms now uses fat arrow (=>)
157 * `main` no longer accepts an args vector; use `os::args` instead
160 * Trait implementations are now coherent, ala Haskell typeclasses
161 * Trait methods may be static
162 * Argument modes are deprecated
163 * Borrowed pointers are much more mature and recommended for use
164 * Strings and vectors in the static region are stored in constant memory
165 * Typestate was removed
166 * Resolution rewritten to be more reliable
167 * Support for 'dual-mode' data structures (freezing and thawing)
170 * Most binary operators can now be overloaded via the traits in
172 * `std::net::url` for representing URLs
173 * Sendable hash maps in `core::send_map`
174 * `core::task' gained a (currently unsafe) task-local storage API
177 * An efficient new intertask communication primitive called the pipe,
178 along with a number of higher-level channel types, in `core::pipes`
179 * `std::arc`, an atomically reference counted, immutable, shared memory
181 * `std::sync`, various exotic synchronization tools based on arcs and pipes
182 * Futures are now based on pipes and sendable
183 * More robust linked task failure
184 * Improved task builder API
187 * Improved error reporting
188 * Preliminary JIT support
189 * Preliminary work on precise GC
190 * Extensive architectural improvements to rustc
191 * Begun a transition away from buggy C++-based reflection (shape) code to
192 Rust-based (visitor) code
193 * All hash functions and tables converted to secure, randomized SipHash
195 Version 0.3 (July 2012)
196 ------------------------
198 * ~1900 changes, numerous bugfixes
200 * New coding conveniences
201 * Integer-literal suffix inference
202 * Per-item control over warnings, errors
203 * #[cfg(windows)] and #[cfg(unix)] attributes
204 * Documentation comments
205 * More compact closure syntax
206 * 'do' expressions for treating higher-order functions as
208 * *-patterns (wildcard extended to all constructor fields)
211 * Name resolution pass and exhaustiveness checker rewritten
212 * Region pointers and borrow checking supersede alias
214 * Init-ness checking is now provided by a region-based liveness
215 pass instead of the typestate pass; same for last-use analysis
216 * Extensive work on region pointers
218 * Experimental new language features
219 * Slices and fixed-size, interior-allocated vectors
220 * #!-comments for lang versioning, shell execution
221 * Destructors and iface implementation for classes;
222 type-parameterized classes and class methods
223 * 'const' type kind for types that can be used to implement
224 shared-memory concurrency patterns
228 * Removal of various obsolete features
229 * Keywords: 'be', 'prove', 'syntax', 'note', 'mutable', 'bind',
230 'crust', 'native' (now 'extern'), 'cont' (now 'again')
232 * Constructs: do-while loops ('do' repurposed), fn binding,
233 resources (replaced by destructors)
235 * Compiler reorganization
236 * Syntax-layer of compiler split into separate crate
237 * Clang (from LLVM project) integrated into build
238 * Typechecker split into sub-modules
242 * Extension methods for many built-in types
243 * Arc: atomic-refcount read-only / exclusive-use shared cells
244 * Par: parallel map and search routines
245 * Extensive work on libuv interface
246 * Much vector code moved to libraries
247 * Syntax extensions: #line, #col, #file, #mod, #stringify,
248 #include, #include_str, #include_bin
251 * Cargo automatically resolves dependencies
253 Version 0.2 (March 2012)
254 -------------------------
256 * >1500 changes, numerous bugfixes
258 * New docs and doc tooling
260 * New port: FreeBSD x86_64
262 * Compilation model enhancements
263 * Generics now specialized, multiply instantiated
264 * Functions now inlined across separate crates
266 * Scheduling, stack and threading fixes
267 * Noticeably improved message-passing performance
268 * Explicit schedulers
272 * Experimental new language features
273 * Operator overloading
277 * Various language extensions
278 * C-callback function types: 'crust fn ...'
279 * Infinite-loop construct: 'loop { ... }'
280 * Shorten 'mutable' to 'mut'
281 * Required mutable-local qualifier: 'let mut ...'
282 * Basic glob-exporting: 'export foo::*;'
283 * Alt now exhaustive, 'alt check' for runtime-checked
284 * Block-function form of 'for' loop, with 'break' and 'ret'.
287 * AST quasi-quote syntax extension
288 * Revived libuv interface
289 * New modules: core::{future, iter}, std::arena
290 * Merged per-platform std::{os*, fs*} to core::{libc, os}
291 * Extensive cleanup, regularization in libstd, libcore
293 Version 0.1 (January 2012)
294 ---------------------------
296 * Most language features work, including:
297 * Unique pointers, unique closures, move semantics
298 * Interface-constrained generics
299 * Static interface dispatch
301 * Multithread task scheduling
302 * Typestate predicates
303 * Failure unwinding, destructors
304 * Pattern matching and destructuring assignment
305 * Lightweight block-lambda syntax
306 * Preliminary macro-by-example
308 * Compiler works with the following configurations:
309 * Linux: x86 and x86_64 hosts and targets
310 * MacOS: x86 and x86_64 hosts and targets
311 * Windows: x86 hosts and targets
313 * Cross compilation / multi-target configuration supported.
315 * Preliminary API-documentation and package-management tools included.
319 * Documentation is incomplete.
321 * Performance is below intended target.
323 * Standard library APIs are subject to extensive change, reorganization.
325 * Language-level versioning is not yet operational - future code will