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