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