RELEASES.txt

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