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