RELEASES.txt

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