1 Version 0.7 (July 2013)
2 -----------------------
4 * ~2000 changes, numerous bugfixes
7 * `impl`s no longer accept a visibility qualifier. Put them on methods
9 * The borrow checker has been rewritten with flow-sensitivity, fixing
10 many bugs and inconveniences.
11 * The `self` parameter no longer implicitly means `&'self self`,
12 and can be explicitly marked with a lifetime.
13 * Overloadable compound operators (`+=`, etc.) have been temporarily
15 * The `for` loop protocol now requires `for`-iterators to return `bool`
16 so they compose better.
17 * The `Durable` trait is replaced with the `'static` bounds.
18 * Trait default methods work more often.
19 * Structs with the `#[packed]` attribute have byte alignment and
20 no padding between fields.
21 * Type parameters bound by `Copy` must now be copied explicitly with
23 * It is now illegal to move out of a dereferenced unsafe pointer.
24 * `Option<~T>` is now represented as a nullable pointer.
25 * `@mut` does dynamic borrow checks correctly.
26 * The `main` function is only detected at the topmost level of the crate.
27 The `#[main]` attribute is still valid anywhere.
28 * Struct fields may no longer be mutable. Use inherited mutability.
29 * The `#[no_send]` attribute makes a type that would otherwise be
31 * The `#[no_freeze]` attribute makes a type that would otherwise be
33 * Unbounded recursion will abort the process after reaching the limit
34 specified by the `RUST_MAX_STACK` environment variable (default: 1GB).
35 * The `vecs_implicitly_copyable` lint mode has been removed. Vectors
36 are never implicitly copyable.
37 * `#[static_assert]` makes compile-time assertions about static bools.
38 * At long last, 'argument modes' no longer exist.
39 * The rarely used `use mod` statement no longer exists.
42 * `fail!` and `assert!` accept `~str`, `&'static str` or `fmt!`-style
44 * `Encodable`, `Decodable`, `Ord`, `TotalOrd`, `TotalEq`, `DeepClone`,
45 `Rand`, `Zero` and `ToStr` can all be automatically derived with
47 * The `bytes!` macro returns a vector of bytes for string, u8, char,
48 and unsuffixed integer literals.
51 * The `core` crate was renamed to `std`.
52 * The `std` crate was renamed to `extra`.
53 * More and improved documentation.
54 * std: `iterator` module for external iterator objects.
55 * Many old-style (internal, higher-order function) iterators replaced by
56 implementations of `Iterator`.
57 * std: Many old internal vector and string iterators,
58 incl. `any`, `all`. removed.
59 * std: The `finalize` method of `Drop` renamed to `drop`.
60 * std: The prelude no longer reexports any modules, only types and traits.
61 * std: Prelude additions: `print`, `println`, `FromStr`, `ApproxEq`, `Equiv`,
62 `Iterator`, `IteratorUtil`, many numeric traits, many tuple traits.
63 * std: New numeric traits: `Fractional`, `Real`, `RealExt`, `Integer`, `Ratio`,
64 `Algebraic`, `Trigonometric`, `Exponential`, `Primitive`.
65 * std: Tuple traits and accessors defined for up to 12-tuples, e.g.
66 `(0, 1, 2).n2()` or `(0, 1, 2).n2_ref()`.
67 * std: Many types implement `Clone`.
68 * std: `path` type renamed to `Path`.
69 * std: `mut` module and `Mut` type removed.
70 * std: Many standalone functions removed in favor of methods and iterators
71 in `vec`, `str`. In the future methods will also work as functions.
72 * std: `reinterpret_cast` removed. Use `transmute`.
73 * std: ascii string handling in `std::ascii`.
74 * std: `Rand` is implemented for ~/@.
75 * std: `run` module for spawning processes overhauled.
76 * std: Various atomic types added to `unstable::atomic`.
77 * std: Various types implement `Zero`.
78 * std: `LinearMap` and `LinearSet` renamed to `HashMap` and `HashSet`.
79 * std: Borrowed pointer functions moved from `ptr` to `borrow`.
80 * std: Added `os::mkdir_recursive`.
81 * std: Added `os::glob` function performs filesystems globs.
82 * std: `FuzzyEq` renamed to `ApproxEq`.
83 * std: `Map` now defines `pop` and `swap` methods.
84 * std: `Cell` constructors converted to static methods.
85 * extra: `rc` module adds the reference counted pointers, `Rc` and `RcMut`.
86 * extra: `flate` module moved from `std` to `extra`.
87 * extra: `fileinput` module for iterating over a series of files.
88 * extra: `Complex` number type and `complex` module.
89 * extra: `Rational` number type and `rational` module.
90 * extra: `BigInt`, `BigUint` implement numeric and comparison traits.
91 * extra: `term` uses terminfo now, is more correct.
92 * extra: `arc` functions converted to methods.
93 * extra: Implementation of fixed output size variations of SHA-2.
96 * `unused_variable` lint mode for unused variables (default: warn).
97 * `unused_unsafe` lint mode for detecting unnecessary `unsafe` blocks
99 * `unused_mut` lint mode for identifying unused `mut` qualifiers
101 * `dead_assignment` lint mode for unread variables (default: warn).
102 * `unnecessary_allocation` lint mode detects some heap allocations that are
103 immediately borrowed so could be written without allocating (default: warn).
104 * `missing_doc` lint mode (default: allow).
105 * `unreachable_code` lint mode (default: warn).
106 * The `rusti` command has been rewritten and a number of bugs addressed.
107 * rustc outputs in color on more terminals.
108 * rustc accepts a `--link-args` flag to pass arguments to the linker.
109 * rustc accepts a `-Z print-link-args` flag for debugging linkage.
110 * Compiling with `-g` will make the binary record information about
111 dynamic borrowcheck failures for debugging.
112 * rustdoc has a nicer stylesheet.
113 * Various improvements to rustdoc.
114 * Improvements to rustpkg (see the detailed release notes).
116 Version 0.6 (April 2013)
117 ------------------------
119 * ~2100 changes, numerous bugfixes
122 * The self type parameter in traits is now spelled `Self`
123 * The `self` parameter in trait and impl methods must now be explicitly
124 named (for example: `fn f(&self) { }`). Implicit self is deprecated.
125 * Static methods no longer require the `static` keyword and instead
126 are distinguished by the lack of a `self` parameter
127 * Replaced the `Durable` trait with the `'static` lifetime
128 * The old closure type syntax with the trailing sigil has been
129 removed in favor of the more consistent leading sigil
130 * `super` is a keyword, and may be prefixed to paths
131 * Trait bounds are separated with `+` instead of whitespace
132 * Traits are implemented with `impl Trait for Type`
133 instead of `impl Type: Trait`
134 * Lifetime syntax is now `&'l foo` instead of `&l/foo`
135 * The `export` keyword has finally been removed
136 * The `move` keyword has been removed (see "Semantic changes")
137 * The interior mutability qualifier on vectors, `[mut T]`, has been
138 removed. Use `&mut [T]`, etc.
139 * `mut` is no longer valid in `~mut T`. Use inherited mutability
140 * `fail` is no longer a keyword. Use `fail!()`
141 * `assert` is no longer a keyword. Use `assert!()`
142 * `log` is no longer a keyword. use `debug!`, etc.
143 * 1-tuples may be represented as `(T,)`
144 * Struct fields may no longer be `mut`. Use inherited mutability,
145 `@mut T`, `core::mut` or `core::cell`
146 * `extern mod { ... }` is no longer valid syntax for foreign
147 function modules. Use extern blocks: `extern { ... }`
148 * Newtype enums removed. Use tuple-structs.
149 * Trait implementations no longer support visibility modifiers
150 * Pattern matching over vectors improved and expanded
151 * `const` renamed to `static` to correspond to lifetime name,
152 and make room for future `static mut` unsafe mutable globals.
153 * Replaced `#[deriving_eq]` with `#[deriving(Eq)]`, etc.
154 * `Clone` implementations can be automatically generated with
156 * Casts to traits must use a pointer sigil, e.g. `@foo as @Bar`
157 instead of `foo as Bar`.
158 * Fixed length vector types are now written as `[int, .. 3]`
159 instead of `[int * 3]`.
160 * Fixed length vector types can express the length as a constant
161 expression. (ex: `[int, .. GL_BUFFER_SIZE - 2]`)
164 * Types with owned pointers or custom destructors move by default,
165 eliminating the `move` keyword
166 * All foreign functions are considered unsafe
167 * &mut is now unaliasable
168 * Writes to borrowed @mut pointers are prevented dynamically
170 * The name of the main function can be customized using #[main]
171 * The default type of an inferred closure is &fn instead of @fn
172 * `use` statements may no longer be "chained" - they cannot import
173 identifiers imported by previous `use` statements
174 * `use` statements are crate relative, importing from the "top"
175 of the crate by default. Paths may be prefixed with `super::`
176 or `self::` to change the search behavior.
177 * Method visibility is inherited from the implementation declaration
178 * Structural records have been removed
179 * Many more types can be used in static items, including enums
180 'static-lifetime pointers and vectors
181 * Pattern matching over vectors improved and expanded
182 * Typechecking of closure types has been overhauled to
183 improve inference and eliminate unsoundness
184 * Macros leave scope at the end of modules, unless that module is
185 tagged with #[macro_escape]
188 * Added big integers to `std::bigint`
189 * Removed `core::oldcomm` module
190 * Added pipe-based `core::comm` module
191 * Numeric traits have been reorganized under `core::num`
192 * `vec::slice` finally returns a slice
193 * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
194 * Containers reorganized around traits in `core::container`
195 * `core::dvec` removed, `~[T]` is a drop-in replacement
196 * `core::send_map` renamed to `core::hashmap`
197 * `std::map` removed; replaced with `core::hashmap`
198 * `std::treemap` reimplemented as an owned balanced tree
199 * `std::deque` and `std::smallintmap` reimplemented as owned containers
200 * `core::trie` added as a fast ordered map for integer keys
201 * Set types added to `core::hashmap`, `core::trie` and `std::treemap`
202 * `Ord` split into `Ord` and `TotalOrd`. `Ord` is still used to
203 overload the comparison operators, whereas `TotalOrd` is used
204 by certain container types
207 * Replaced the 'cargo' package manager with 'rustpkg'
208 * Added all-purpose 'rust' tool
209 * `rustc --test` now supports benchmarks with the `#[bench]` attribute
210 * rustc now *attempts* to offer spelling suggestions
211 * Improved support for ARM and Android
212 * Preliminary MIPS backend
213 * Improved foreign function ABI implementation for x86, x86_64
214 * Various memory usage improvements
215 * Rust code may be embedded in foreign code under limited circumstances
216 * Inline assembler supported by new asm!() syntax extension.
218 Version 0.5 (December 2012)
219 ---------------------------
221 * ~900 changes, numerous bugfixes
224 * Removed `<-` move operator
225 * Completed the transition from the `#fmt` extension syntax to `fmt!`
226 * Removed old fixed length vector syntax - `[T]/N`
227 * New token-based quasi-quoters, `quote_tokens!`, `quote_expr!`, etc.
228 * Macros may now expand to items and statements
229 * `a.b()` is always parsed as a method call, never as a field projection
230 * `Eq` and `IterBytes` implementations can be automatically generated
231 with `#[deriving_eq]` and `#[deriving_iter_bytes]` respectively
232 * Removed the special crate language for `.rc` files
233 * Function arguments may consist of any irrefutable pattern
236 * `&` and `~` pointers may point to objects
237 * Tuple structs - `struct Foo(Bar, Baz)`. Will replace newtype enums.
238 * Enum variants may be structs
239 * Destructors can be added to all nominal types with the Drop trait
240 * Structs and nullary enum variants may be constants
241 * Values that cannot be implicitly copied are now automatically moved
242 without writing `move` explicitly
243 * `&T` may now be coerced to `*T`
244 * Coercions happen in `let` statements as well as function calls
245 * `use` statements now take crate-relative paths
246 * The module and type namespaces have been merged so that static
247 method names can be resolved under the trait in which they are
250 * Improved support for language features
251 * Trait inheritance works in many scenarios
252 * More support for explicit self arguments in methods - `self`, `&self`
253 `@self`, and `~self` all generally work as expected
254 * Static methods work in more situations
255 * Experimental: Traits may declare default methods for the implementations
259 * New condition handling system in `core::condition`
260 * Timsort added to `std::sort`
261 * New priority queue, `std::priority_queue`
262 * Pipes for serializable types, `std::flatpipes'
263 * Serialization overhauled to be trait-based
264 * Expanded `getopts` definitions
265 * Moved futures to `std`
266 * More functions are pure now
267 * `core::comm` renamed to `oldcomm`. Still deprecated
268 * `rustdoc` and `cargo` are libraries now
271 * Added a preliminary REPL, `rusti`
272 * License changed from MIT to dual MIT/APL2
274 Version 0.4 (October 2012)
275 --------------------------
277 * ~2000 changes, numerous bugfixes
280 * All keywords are now strict and may not be used as identifiers anywhere
281 * Keyword removal: 'again', 'import', 'check', 'new', 'owned', 'send',
282 'of', 'with', 'to', 'class'.
283 * Classes are replaced with simpler structs
284 * Explicit method self types
285 * `ret` became `return` and `alt` became `match`
286 * `import` is now `use`; `use is now `extern mod`
287 * `extern mod { ... }` is now `extern { ... }`
288 * `use mod` is the recommended way to import modules
289 * `pub` and `priv` replace deprecated export lists
290 * The syntax of `match` pattern arms now uses fat arrow (=>)
291 * `main` no longer accepts an args vector; use `os::args` instead
294 * Trait implementations are now coherent, ala Haskell typeclasses
295 * Trait methods may be static
296 * Argument modes are deprecated
297 * Borrowed pointers are much more mature and recommended for use
298 * Strings and vectors in the static region are stored in constant memory
299 * Typestate was removed
300 * Resolution rewritten to be more reliable
301 * Support for 'dual-mode' data structures (freezing and thawing)
304 * Most binary operators can now be overloaded via the traits in
306 * `std::net::url` for representing URLs
307 * Sendable hash maps in `core::send_map`
308 * `core::task' gained a (currently unsafe) task-local storage API
311 * An efficient new intertask communication primitive called the pipe,
312 along with a number of higher-level channel types, in `core::pipes`
313 * `std::arc`, an atomically reference counted, immutable, shared memory
315 * `std::sync`, various exotic synchronization tools based on arcs and pipes
316 * Futures are now based on pipes and sendable
317 * More robust linked task failure
318 * Improved task builder API
321 * Improved error reporting
322 * Preliminary JIT support
323 * Preliminary work on precise GC
324 * Extensive architectural improvements to rustc
325 * Begun a transition away from buggy C++-based reflection (shape) code to
326 Rust-based (visitor) code
327 * All hash functions and tables converted to secure, randomized SipHash
329 Version 0.3 (July 2012)
330 ------------------------
332 * ~1900 changes, numerous bugfixes
334 * New coding conveniences
335 * Integer-literal suffix inference
336 * Per-item control over warnings, errors
337 * #[cfg(windows)] and #[cfg(unix)] attributes
338 * Documentation comments
339 * More compact closure syntax
340 * 'do' expressions for treating higher-order functions as
342 * *-patterns (wildcard extended to all constructor fields)
345 * Name resolution pass and exhaustiveness checker rewritten
346 * Region pointers and borrow checking supersede alias
348 * Init-ness checking is now provided by a region-based liveness
349 pass instead of the typestate pass; same for last-use analysis
350 * Extensive work on region pointers
352 * Experimental new language features
353 * Slices and fixed-size, interior-allocated vectors
354 * #!-comments for lang versioning, shell execution
355 * Destructors and iface implementation for classes;
356 type-parameterized classes and class methods
357 * 'const' type kind for types that can be used to implement
358 shared-memory concurrency patterns
362 * Removal of various obsolete features
363 * Keywords: 'be', 'prove', 'syntax', 'note', 'mutable', 'bind',
364 'crust', 'native' (now 'extern'), 'cont' (now 'again')
366 * Constructs: do-while loops ('do' repurposed), fn binding,
367 resources (replaced by destructors)
369 * Compiler reorganization
370 * Syntax-layer of compiler split into separate crate
371 * Clang (from LLVM project) integrated into build
372 * Typechecker split into sub-modules
376 * Extension methods for many built-in types
377 * Arc: atomic-refcount read-only / exclusive-use shared cells
378 * Par: parallel map and search routines
379 * Extensive work on libuv interface
380 * Much vector code moved to libraries
381 * Syntax extensions: #line, #col, #file, #mod, #stringify,
382 #include, #include_str, #include_bin
385 * Cargo automatically resolves dependencies
387 Version 0.2 (March 2012)
388 -------------------------
390 * >1500 changes, numerous bugfixes
392 * New docs and doc tooling
394 * New port: FreeBSD x86_64
396 * Compilation model enhancements
397 * Generics now specialized, multiply instantiated
398 * Functions now inlined across separate crates
400 * Scheduling, stack and threading fixes
401 * Noticeably improved message-passing performance
402 * Explicit schedulers
406 * Experimental new language features
407 * Operator overloading
411 * Various language extensions
412 * C-callback function types: 'crust fn ...'
413 * Infinite-loop construct: 'loop { ... }'
414 * Shorten 'mutable' to 'mut'
415 * Required mutable-local qualifier: 'let mut ...'
416 * Basic glob-exporting: 'export foo::*;'
417 * Alt now exhaustive, 'alt check' for runtime-checked
418 * Block-function form of 'for' loop, with 'break' and 'ret'.
421 * AST quasi-quote syntax extension
422 * Revived libuv interface
423 * New modules: core::{future, iter}, std::arena
424 * Merged per-platform std::{os*, fs*} to core::{libc, os}
425 * Extensive cleanup, regularization in libstd, libcore
427 Version 0.1 (January 2012)
428 ---------------------------
430 * Most language features work, including:
431 * Unique pointers, unique closures, move semantics
432 * Interface-constrained generics
433 * Static interface dispatch
435 * Multithread task scheduling
436 * Typestate predicates
437 * Failure unwinding, destructors
438 * Pattern matching and destructuring assignment
439 * Lightweight block-lambda syntax
440 * Preliminary macro-by-example
442 * Compiler works with the following configurations:
443 * Linux: x86 and x86_64 hosts and targets
444 * MacOS: x86 and x86_64 hosts and targets
445 * Windows: x86 hosts and targets
447 * Cross compilation / multi-target configuration supported.
449 * Preliminary API-documentation and package-management tools included.
453 * Documentation is incomplete.
455 * Performance is below intended target.
457 * Standard library APIs are subject to extensive change, reorganization.
459 * Language-level versioning is not yet operational - future code will