2 --------------------------
4 * ~XXX changes, numerous bugfixes
7 * The `rust` and `rusti` commands have been removed, due to lack of maintenance.
9 Version 0.8 (September 2013)
10 --------------------------
12 * ~2200 changes, numerous bugfixes
15 * The `for` loop syntax has changed to work with the `Iterator` trait.
16 * At long last, unwinding works on Windows.
17 * Default methods are ready for use.
18 * Many trait inheritance bugs fixed.
19 * Owned and borrowed trait objects work more reliably.
20 * `copy` is no longer a keyword. It has been replaced by the `Clone` trait.
21 * rustc can omit emission of code for the `debug!` macro if it is passed
23 * mod.rs is now "blessed". When loading `mod foo;`, rustc will now look
24 for foo.rs, then foo/mod.rs, and will generate an error when both are
26 * Strings no longer contain trailing nulls. The new `std::c_str` module
27 provides new mechanisms for converting to C strings.
28 * The type of foreign functions is now `extern "C" fn` instead of `*u8'.
29 * The FFI has been overhauled such that foreign functions are called directly,
30 instead of through a stack-switching wrapper.
31 * Calling a foreign function must be done through a Rust function with the
32 `#[fixed_stack_segment]` attribute.
33 * The `externfn!` macro can be used to declare both a foreign function and
34 a `#[fixed_stack_segment]` wrapper at once.
35 * `pub` and `priv` modifiers on `extern` blocks are no longer parsed.
36 * `unsafe` is no longer allowed on extern fns - they are all unsafe.
37 * `priv` is disallowed everywhere except for struct fields and enum variants.
38 * `&T` (besides `&'static T`) is no longer allowed in `@T`.
39 * `ref` bindings in irrefutable patterns work correctly now.
40 * `char` is now prevented from containing invalid code points.
41 * Casting to `bool` is no longer allowed.
42 * `\0` is now accepted as an escape in chars and strings.
43 * `yield` is a reserved keyword.
44 * `typeof` is a reserved keyword.
45 * Crates may be imported by URL with `extern mod foo = "url";`.
46 * Explicit enum discriminants may be given as uints as in `enum E { V = 0u }`
47 * Static vectors can be initialized with repeating elements,
48 e.g. `static foo: [u8, .. 100]: [0, .. 100];`.
49 * Static structs can be initialized with functional record update,
50 e.g. `static foo: Foo = Foo { a: 5, .. bar };`.
51 * `cfg!` can be used to conditionally execute code based on the crate
52 configuration, similarly to `#[cfg(...)]`.
53 * The `unnecessary_qualification` lint detects unneeded module
54 prefixes (default: allow).
55 * Arithmetic operations have been implemented on the SIMD types in
56 `std::unstable::simd`.
57 * Exchange allocation headers were removed, reducing memory usage.
58 * `format!` implements a completely new, extensible, and higher-performance
59 string formatting system. It will replace `fmt!`.
60 * `print!` and `println!` write formatted strings (using the `format!`
62 * `write!` and `writeln!` write formatted strings (using the `format!`
63 extension) to the new Writers in `std::rt::io`.
64 * The library section in which a function or static is placed may
65 be specified with `#[link_section = "..."]`.
66 * The `proto!` syntax extension for defining bounded message protocols
68 * `macro_rules!` is hygienic for `let` declarations.
69 * The `#[export_name]` attribute specifies the name of a symbol.
70 * `unreachable!` can be used to indicate unreachable code, and fails
74 * std: Transitioned to the new runtime, written in Rust.
75 * std: Added an experimental I/O library, `rt::io`, based on the new
77 * std: A new generic `range` function was added to the prelude, replacing
78 `uint::range` and friends.
79 * std: `range_rev` no longer exists. Since range is an iterator it can be
80 reversed with `range(lo, hi).invert()`.
81 * std: The `chain` method on option renamed to `and_then`; `unwrap_or_default`
82 renamed to `unwrap_or`.
83 * std: The `iterator` module was renamed to `iter`.
84 * std: Integral types now support the `checked_add`, `checked_sub`, and
85 `checked_mul` operations for detecting overflow.
86 * std: Many methods in `str`, `vec`, `option, `result` were renamed for
88 * std: Methods are standardizing on conventions for casting methods:
89 `to_foo` for copying, `into_foo` for moving, `as_foo` for temporary
91 * std: The `CString` type in `c_str` provides new ways to convert to and
93 * std: `DoubleEndedIterator` can yield elements in two directions.
94 * std: The `mut_split` method on vectors partitions an `&mut [T]` into
96 * std: `str::from_bytes` renamed to `str::from_utf8`.
97 * std: `pop_opt` and `shift_opt` methods added to vectors.
98 * std: The task-local data interface no longer uses @, and keys are
99 no longer function pointers.
100 * std: The `swap_unwrap` method of `Option` renamed to `take_unwrap`.
101 * std: Added `SharedPort` to `comm`.
102 * std: `Eq` has a default method for `ne`; only `eq` is required
104 * std: `Ord` has default methods for `le`, `gt` and `ge`; only `lt`
105 is required in implementations.
106 * std: `is_utf8` performance is improved, impacting many string functions.
107 * std: `os::MemoryMap` provides cross-platform mmap.
108 * std: `ptr::offset` is now unsafe, but also more optimized. Offsets that
109 are not 'in-bounds' are considered undefined.
110 * std: Many freestanding functions in `vec` removed in favor of methods.
111 * std: Many freestanding functions on scalar types removed in favor of
113 * std: Many options to task builders were removed since they don't make
114 sense in the new scheduler design.
115 * std: More containers implement `FromIterator` so can be created by the
117 * std: More complete atomic types in `unstable::atomics`.
118 * std: `comm::PortSet` removed.
119 * std: Mutating methods in the `Set` and `Map` traits have been moved into
120 the `MutableSet` and `MutableMap` traits. `Container::is_empty`,
121 `Map::contains_key`, `MutableMap::insert`, and `MutableMap::remove` have
122 default implementations.
123 * std: Various `from_str` functions were removed in favor of a generic
124 `from_str` which is available in the prelude.
125 * std: `util::unreachable` removed in favor of the `unreachable!` macro.
126 * extra: `dlist`, the doubly-linked list was modernized.
127 * extra: Added a `hex` module with `ToHex` and `FromHex` traits.
128 * extra: Added `glob` module, replacing `std::os::glob`.
129 * extra: `rope` was removed.
130 * extra: `deque` was renamed to `ringbuf`. `RingBuf` implements `Deque`.
131 * extra: `net`, and `timer` were removed. The experimental replacements
132 are `std::rt::io::net` and `std::rt::io::timer`.
133 * extra: Iterators implemented for `SmallIntMap`.
134 * extra: Iterators implemented for `Bitv` and `BitvSet`.
135 * extra: `SmallIntSet` removed. Use `BitvSet`.
136 * extra: Performance of JSON parsing greatly improved.
137 * extra: `semver` updated to SemVer 2.0.0.
138 * extra: `term` handles more terminals correctly.
139 * extra: `dbg` module removed.
140 * extra: `par` module removed.
141 * extra: `future` was cleaned up, with some method renames.
142 * extra: Most free functions in `getopts` were converted to methods.
145 * rustc's debug info generation (`-Z debug-info`) is greatly improved.
146 * rustc accepts `--target-cpu` to compile to a specific CPU architecture,
147 similarly to gcc's `--march` flag.
148 * rustc's performance compiling small crates is much better.
149 * rustpkg has received many improvements.
150 * rustpkg supports git tags as package IDs.
151 * rustpkg builds into target-specific directories so it can be used for
153 * The number of concurrent test tasks is controlled by the environment
154 variable RUST_TEST_TASKS.
155 * The test harness can now report metrics for benchmarks.
156 * All tools have man pages.
157 * Programs compiled with `--test` now support the `-h` and `--help` flags.
158 * The runtime uses jemalloc for allocations.
159 * Segmented stacks are temporarily disabled as part of the transition to
160 the new runtime. Stack overflows are possible!
161 * A new documentation backend, rustdoc_ng, is available for use. It is
162 still invoked through the normal `rustdoc` command.
164 Version 0.7 (July 2013)
165 -----------------------
167 * ~2000 changes, numerous bugfixes
170 * `impl`s no longer accept a visibility qualifier. Put them on methods
172 * The borrow checker has been rewritten with flow-sensitivity, fixing
173 many bugs and inconveniences.
174 * The `self` parameter no longer implicitly means `&'self self`,
175 and can be explicitly marked with a lifetime.
176 * Overloadable compound operators (`+=`, etc.) have been temporarily
178 * The `for` loop protocol now requires `for`-iterators to return `bool`
179 so they compose better.
180 * The `Durable` trait is replaced with the `'static` bounds.
181 * Trait default methods work more often.
182 * Structs with the `#[packed]` attribute have byte alignment and
183 no padding between fields.
184 * Type parameters bound by `Copy` must now be copied explicitly with
186 * It is now illegal to move out of a dereferenced unsafe pointer.
187 * `Option<~T>` is now represented as a nullable pointer.
188 * `@mut` does dynamic borrow checks correctly.
189 * The `main` function is only detected at the topmost level of the crate.
190 The `#[main]` attribute is still valid anywhere.
191 * Struct fields may no longer be mutable. Use inherited mutability.
192 * The `#[no_send]` attribute makes a type that would otherwise be
194 * The `#[no_freeze]` attribute makes a type that would otherwise be
196 * Unbounded recursion will abort the process after reaching the limit
197 specified by the `RUST_MAX_STACK` environment variable (default: 1GB).
198 * The `vecs_implicitly_copyable` lint mode has been removed. Vectors
199 are never implicitly copyable.
200 * `#[static_assert]` makes compile-time assertions about static bools.
201 * At long last, 'argument modes' no longer exist.
202 * The rarely used `use mod` statement no longer exists.
205 * `fail!` and `assert!` accept `~str`, `&'static str` or `fmt!`-style
207 * `Encodable`, `Decodable`, `Ord`, `TotalOrd`, `TotalEq`, `DeepClone`,
208 `Rand`, `Zero` and `ToStr` can all be automatically derived with
210 * The `bytes!` macro returns a vector of bytes for string, u8, char,
211 and unsuffixed integer literals.
214 * The `core` crate was renamed to `std`.
215 * The `std` crate was renamed to `extra`.
216 * More and improved documentation.
217 * std: `iterator` module for external iterator objects.
218 * Many old-style (internal, higher-order function) iterators replaced by
219 implementations of `Iterator`.
220 * std: Many old internal vector and string iterators,
221 incl. `any`, `all`. removed.
222 * std: The `finalize` method of `Drop` renamed to `drop`.
223 * std: The `drop` method now takes `&mut self` instead of `&self`.
224 * std: The prelude no longer reexports any modules, only types and traits.
225 * std: Prelude additions: `print`, `println`, `FromStr`, `ApproxEq`, `Equiv`,
226 `Iterator`, `IteratorUtil`, many numeric traits, many tuple traits.
227 * std: New numeric traits: `Fractional`, `Real`, `RealExt`, `Integer`, `Ratio`,
228 `Algebraic`, `Trigonometric`, `Exponential`, `Primitive`.
229 * std: Tuple traits and accessors defined for up to 12-tuples, e.g.
230 `(0, 1, 2).n2()` or `(0, 1, 2).n2_ref()`.
231 * std: Many types implement `Clone`.
232 * std: `path` type renamed to `Path`.
233 * std: `mut` module and `Mut` type removed.
234 * std: Many standalone functions removed in favor of methods and iterators
235 in `vec`, `str`. In the future methods will also work as functions.
236 * std: `reinterpret_cast` removed. Use `transmute`.
237 * std: ascii string handling in `std::ascii`.
238 * std: `Rand` is implemented for ~/@.
239 * std: `run` module for spawning processes overhauled.
240 * std: Various atomic types added to `unstable::atomic`.
241 * std: Various types implement `Zero`.
242 * std: `LinearMap` and `LinearSet` renamed to `HashMap` and `HashSet`.
243 * std: Borrowed pointer functions moved from `ptr` to `borrow`.
244 * std: Added `os::mkdir_recursive`.
245 * std: Added `os::glob` function performs filesystems globs.
246 * std: `FuzzyEq` renamed to `ApproxEq`.
247 * std: `Map` now defines `pop` and `swap` methods.
248 * std: `Cell` constructors converted to static methods.
249 * extra: `rc` module adds the reference counted pointers, `Rc` and `RcMut`.
250 * extra: `flate` module moved from `std` to `extra`.
251 * extra: `fileinput` module for iterating over a series of files.
252 * extra: `Complex` number type and `complex` module.
253 * extra: `Rational` number type and `rational` module.
254 * extra: `BigInt`, `BigUint` implement numeric and comparison traits.
255 * extra: `term` uses terminfo now, is more correct.
256 * extra: `arc` functions converted to methods.
257 * extra: Implementation of fixed output size variations of SHA-2.
260 * `unused_variable` lint mode for unused variables (default: warn).
261 * `unused_unsafe` lint mode for detecting unnecessary `unsafe` blocks
263 * `unused_mut` lint mode for identifying unused `mut` qualifiers
265 * `dead_assignment` lint mode for unread variables (default: warn).
266 * `unnecessary_allocation` lint mode detects some heap allocations that are
267 immediately borrowed so could be written without allocating (default: warn).
268 * `missing_doc` lint mode (default: allow).
269 * `unreachable_code` lint mode (default: warn).
270 * The `rusti` command has been rewritten and a number of bugs addressed.
271 * rustc outputs in color on more terminals.
272 * rustc accepts a `--link-args` flag to pass arguments to the linker.
273 * rustc accepts a `-Z print-link-args` flag for debugging linkage.
274 * Compiling with `-g` will make the binary record information about
275 dynamic borrowcheck failures for debugging.
276 * rustdoc has a nicer stylesheet.
277 * Various improvements to rustdoc.
278 * Improvements to rustpkg (see the detailed release notes).
280 Version 0.6 (April 2013)
281 ------------------------
283 * ~2100 changes, numerous bugfixes
286 * The self type parameter in traits is now spelled `Self`
287 * The `self` parameter in trait and impl methods must now be explicitly
288 named (for example: `fn f(&self) { }`). Implicit self is deprecated.
289 * Static methods no longer require the `static` keyword and instead
290 are distinguished by the lack of a `self` parameter
291 * Replaced the `Durable` trait with the `'static` lifetime
292 * The old closure type syntax with the trailing sigil has been
293 removed in favor of the more consistent leading sigil
294 * `super` is a keyword, and may be prefixed to paths
295 * Trait bounds are separated with `+` instead of whitespace
296 * Traits are implemented with `impl Trait for Type`
297 instead of `impl Type: Trait`
298 * Lifetime syntax is now `&'l foo` instead of `&l/foo`
299 * The `export` keyword has finally been removed
300 * The `move` keyword has been removed (see "Semantic changes")
301 * The interior mutability qualifier on vectors, `[mut T]`, has been
302 removed. Use `&mut [T]`, etc.
303 * `mut` is no longer valid in `~mut T`. Use inherited mutability
304 * `fail` is no longer a keyword. Use `fail!()`
305 * `assert` is no longer a keyword. Use `assert!()`
306 * `log` is no longer a keyword. use `debug!`, etc.
307 * 1-tuples may be represented as `(T,)`
308 * Struct fields may no longer be `mut`. Use inherited mutability,
309 `@mut T`, `core::mut` or `core::cell`
310 * `extern mod { ... }` is no longer valid syntax for foreign
311 function modules. Use extern blocks: `extern { ... }`
312 * Newtype enums removed. Use tuple-structs.
313 * Trait implementations no longer support visibility modifiers
314 * Pattern matching over vectors improved and expanded
315 * `const` renamed to `static` to correspond to lifetime name,
316 and make room for future `static mut` unsafe mutable globals.
317 * Replaced `#[deriving_eq]` with `#[deriving(Eq)]`, etc.
318 * `Clone` implementations can be automatically generated with
320 * Casts to traits must use a pointer sigil, e.g. `@foo as @Bar`
321 instead of `foo as Bar`.
322 * Fixed length vector types are now written as `[int, .. 3]`
323 instead of `[int * 3]`.
324 * Fixed length vector types can express the length as a constant
325 expression. (ex: `[int, .. GL_BUFFER_SIZE - 2]`)
328 * Types with owned pointers or custom destructors move by default,
329 eliminating the `move` keyword
330 * All foreign functions are considered unsafe
331 * &mut is now unaliasable
332 * Writes to borrowed @mut pointers are prevented dynamically
334 * The name of the main function can be customized using #[main]
335 * The default type of an inferred closure is &fn instead of @fn
336 * `use` statements may no longer be "chained" - they cannot import
337 identifiers imported by previous `use` statements
338 * `use` statements are crate relative, importing from the "top"
339 of the crate by default. Paths may be prefixed with `super::`
340 or `self::` to change the search behavior.
341 * Method visibility is inherited from the implementation declaration
342 * Structural records have been removed
343 * Many more types can be used in static items, including enums
344 'static-lifetime pointers and vectors
345 * Pattern matching over vectors improved and expanded
346 * Typechecking of closure types has been overhauled to
347 improve inference and eliminate unsoundness
348 * Macros leave scope at the end of modules, unless that module is
349 tagged with #[macro_escape]
352 * Added big integers to `std::bigint`
353 * Removed `core::oldcomm` module
354 * Added pipe-based `core::comm` module
355 * Numeric traits have been reorganized under `core::num`
356 * `vec::slice` finally returns a slice
357 * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
358 * Containers reorganized around traits in `core::container`
359 * `core::dvec` removed, `~[T]` is a drop-in replacement
360 * `core::send_map` renamed to `core::hashmap`
361 * `std::map` removed; replaced with `core::hashmap`
362 * `std::treemap` reimplemented as an owned balanced tree
363 * `std::deque` and `std::smallintmap` reimplemented as owned containers
364 * `core::trie` added as a fast ordered map for integer keys
365 * Set types added to `core::hashmap`, `core::trie` and `std::treemap`
366 * `Ord` split into `Ord` and `TotalOrd`. `Ord` is still used to
367 overload the comparison operators, whereas `TotalOrd` is used
368 by certain container types
371 * Replaced the 'cargo' package manager with 'rustpkg'
372 * Added all-purpose 'rust' tool
373 * `rustc --test` now supports benchmarks with the `#[bench]` attribute
374 * rustc now *attempts* to offer spelling suggestions
375 * Improved support for ARM and Android
376 * Preliminary MIPS backend
377 * Improved foreign function ABI implementation for x86, x86_64
378 * Various memory usage improvements
379 * Rust code may be embedded in foreign code under limited circumstances
380 * Inline assembler supported by new asm!() syntax extension.
382 Version 0.5 (December 2012)
383 ---------------------------
385 * ~900 changes, numerous bugfixes
388 * Removed `<-` move operator
389 * Completed the transition from the `#fmt` extension syntax to `fmt!`
390 * Removed old fixed length vector syntax - `[T]/N`
391 * New token-based quasi-quoters, `quote_tokens!`, `quote_expr!`, etc.
392 * Macros may now expand to items and statements
393 * `a.b()` is always parsed as a method call, never as a field projection
394 * `Eq` and `IterBytes` implementations can be automatically generated
395 with `#[deriving_eq]` and `#[deriving_iter_bytes]` respectively
396 * Removed the special crate language for `.rc` files
397 * Function arguments may consist of any irrefutable pattern
400 * `&` and `~` pointers may point to objects
401 * Tuple structs - `struct Foo(Bar, Baz)`. Will replace newtype enums.
402 * Enum variants may be structs
403 * Destructors can be added to all nominal types with the Drop trait
404 * Structs and nullary enum variants may be constants
405 * Values that cannot be implicitly copied are now automatically moved
406 without writing `move` explicitly
407 * `&T` may now be coerced to `*T`
408 * Coercions happen in `let` statements as well as function calls
409 * `use` statements now take crate-relative paths
410 * The module and type namespaces have been merged so that static
411 method names can be resolved under the trait in which they are
414 * Improved support for language features
415 * Trait inheritance works in many scenarios
416 * More support for explicit self arguments in methods - `self`, `&self`
417 `@self`, and `~self` all generally work as expected
418 * Static methods work in more situations
419 * Experimental: Traits may declare default methods for the implementations
423 * New condition handling system in `core::condition`
424 * Timsort added to `std::sort`
425 * New priority queue, `std::priority_queue`
426 * Pipes for serializable types, `std::flatpipes'
427 * Serialization overhauled to be trait-based
428 * Expanded `getopts` definitions
429 * Moved futures to `std`
430 * More functions are pure now
431 * `core::comm` renamed to `oldcomm`. Still deprecated
432 * `rustdoc` and `cargo` are libraries now
435 * Added a preliminary REPL, `rusti`
436 * License changed from MIT to dual MIT/APL2
438 Version 0.4 (October 2012)
439 --------------------------
441 * ~2000 changes, numerous bugfixes
444 * All keywords are now strict and may not be used as identifiers anywhere
445 * Keyword removal: 'again', 'import', 'check', 'new', 'owned', 'send',
446 'of', 'with', 'to', 'class'.
447 * Classes are replaced with simpler structs
448 * Explicit method self types
449 * `ret` became `return` and `alt` became `match`
450 * `import` is now `use`; `use is now `extern mod`
451 * `extern mod { ... }` is now `extern { ... }`
452 * `use mod` is the recommended way to import modules
453 * `pub` and `priv` replace deprecated export lists
454 * The syntax of `match` pattern arms now uses fat arrow (=>)
455 * `main` no longer accepts an args vector; use `os::args` instead
458 * Trait implementations are now coherent, ala Haskell typeclasses
459 * Trait methods may be static
460 * Argument modes are deprecated
461 * Borrowed pointers are much more mature and recommended for use
462 * Strings and vectors in the static region are stored in constant memory
463 * Typestate was removed
464 * Resolution rewritten to be more reliable
465 * Support for 'dual-mode' data structures (freezing and thawing)
468 * Most binary operators can now be overloaded via the traits in
470 * `std::net::url` for representing URLs
471 * Sendable hash maps in `core::send_map`
472 * `core::task' gained a (currently unsafe) task-local storage API
475 * An efficient new intertask communication primitive called the pipe,
476 along with a number of higher-level channel types, in `core::pipes`
477 * `std::arc`, an atomically reference counted, immutable, shared memory
479 * `std::sync`, various exotic synchronization tools based on arcs and pipes
480 * Futures are now based on pipes and sendable
481 * More robust linked task failure
482 * Improved task builder API
485 * Improved error reporting
486 * Preliminary JIT support
487 * Preliminary work on precise GC
488 * Extensive architectural improvements to rustc
489 * Begun a transition away from buggy C++-based reflection (shape) code to
490 Rust-based (visitor) code
491 * All hash functions and tables converted to secure, randomized SipHash
493 Version 0.3 (July 2012)
494 ------------------------
496 * ~1900 changes, numerous bugfixes
498 * New coding conveniences
499 * Integer-literal suffix inference
500 * Per-item control over warnings, errors
501 * #[cfg(windows)] and #[cfg(unix)] attributes
502 * Documentation comments
503 * More compact closure syntax
504 * 'do' expressions for treating higher-order functions as
506 * *-patterns (wildcard extended to all constructor fields)
509 * Name resolution pass and exhaustiveness checker rewritten
510 * Region pointers and borrow checking supersede alias
512 * Init-ness checking is now provided by a region-based liveness
513 pass instead of the typestate pass; same for last-use analysis
514 * Extensive work on region pointers
516 * Experimental new language features
517 * Slices and fixed-size, interior-allocated vectors
518 * #!-comments for lang versioning, shell execution
519 * Destructors and iface implementation for classes;
520 type-parameterized classes and class methods
521 * 'const' type kind for types that can be used to implement
522 shared-memory concurrency patterns
526 * Removal of various obsolete features
527 * Keywords: 'be', 'prove', 'syntax', 'note', 'mutable', 'bind',
528 'crust', 'native' (now 'extern'), 'cont' (now 'again')
530 * Constructs: do-while loops ('do' repurposed), fn binding,
531 resources (replaced by destructors)
533 * Compiler reorganization
534 * Syntax-layer of compiler split into separate crate
535 * Clang (from LLVM project) integrated into build
536 * Typechecker split into sub-modules
540 * Extension methods for many built-in types
541 * Arc: atomic-refcount read-only / exclusive-use shared cells
542 * Par: parallel map and search routines
543 * Extensive work on libuv interface
544 * Much vector code moved to libraries
545 * Syntax extensions: #line, #col, #file, #mod, #stringify,
546 #include, #include_str, #include_bin
549 * Cargo automatically resolves dependencies
551 Version 0.2 (March 2012)
552 -------------------------
554 * >1500 changes, numerous bugfixes
556 * New docs and doc tooling
558 * New port: FreeBSD x86_64
560 * Compilation model enhancements
561 * Generics now specialized, multiply instantiated
562 * Functions now inlined across separate crates
564 * Scheduling, stack and threading fixes
565 * Noticeably improved message-passing performance
566 * Explicit schedulers
570 * Experimental new language features
571 * Operator overloading
575 * Various language extensions
576 * C-callback function types: 'crust fn ...'
577 * Infinite-loop construct: 'loop { ... }'
578 * Shorten 'mutable' to 'mut'
579 * Required mutable-local qualifier: 'let mut ...'
580 * Basic glob-exporting: 'export foo::*;'
581 * Alt now exhaustive, 'alt check' for runtime-checked
582 * Block-function form of 'for' loop, with 'break' and 'ret'.
585 * AST quasi-quote syntax extension
586 * Revived libuv interface
587 * New modules: core::{future, iter}, std::arena
588 * Merged per-platform std::{os*, fs*} to core::{libc, os}
589 * Extensive cleanup, regularization in libstd, libcore
591 Version 0.1 (January 2012)
592 ---------------------------
594 * Most language features work, including:
595 * Unique pointers, unique closures, move semantics
596 * Interface-constrained generics
597 * Static interface dispatch
599 * Multithread task scheduling
600 * Typestate predicates
601 * Failure unwinding, destructors
602 * Pattern matching and destructuring assignment
603 * Lightweight block-lambda syntax
604 * Preliminary macro-by-example
606 * Compiler works with the following configurations:
607 * Linux: x86 and x86_64 hosts and targets
608 * MacOS: x86 and x86_64 hosts and targets
609 * Windows: x86 hosts and targets
611 * Cross compilation / multi-target configuration supported.
613 * Preliminary API-documentation and package-management tools included.
617 * Documentation is incomplete.
619 * Performance is below intended target.
621 * Standard library APIs are subject to extensive change, reorganization.
623 * Language-level versioning is not yet operational - future code will