RELEASES.txt

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