RELEASES.txt

   1 Version 0.7 (July 2013)
   2 -----------------------
   3
   4    * ~2000 changes, numerous bugfixes
   5
   6    * Language
   7       * `impl`s no longer accept a visibility qualifier. Put them on methods
   8         instead.
   9       * The borrow checker has been rewritten with flow-sensitivity, fixing
  10         many bugs and inconveniences.
  11       * The `self` parameter no longer implicitly means `&'self self`,
  12         and can be explicitly marked with a lifetime.
  13       * Overloadable compound operators (`+=`, etc.) have been temporarily
  14         removed due to bugs.
  15       * The `for` loop protocol now requires `for`-iterators to return `bool`
  16         so they compose better.
  17       * The `Durable` trait is replaced with the `'static` bounds.
  18       * Trait default methods work more often.
  19       * Structs with the `#[packed]` attribute have byte alignment and
  20         no padding between fields.
  21       * Type parameters bound by `Copy` must now be copied explicitly with
  22         the `copy` keyword.
  23       * It is now illegal to move out of a dereferenced unsafe pointer.
  24       * `Option<~T>` is now represented as a nullable pointer.
  25       * `@mut` does dynamic borrow checks correctly.
  26       * The `main` function is only detected at the topmost level of the crate.
  27         The `#[main]` attribute is still valid anywhere.
  28       * Struct fields may no longer be mutable. Use inherited mutability.
  29       * The `#[no_send]` attribute makes a type that would otherwise be
  30         `Send`, not.
  31       * The `#[no_freeze]` attribute makes a type that would otherwise be
  32         `Freeze`, not.
  33       * Unbounded recursion will abort the process after reaching the limit
  34         specified by the `RUST_MAX_STACK` environment variable (default: 1GB).
  35       * The `vecs_implicitly_copyable` lint mode has been removed. Vectors
  36         are never implicitly copyable.
  37       * `#[static_assert]` makes compile-time assertions about static bools.
  38       * At long last, 'argument modes' no longer exist.
  39       * The rarely used `use mod` statement no longer exists.
  40
  41    * Syntax extensions
  42       * `fail!` and `assert!` accept `~str`, `&'static str` or `fmt!`-style
  43         argument list.
  44       * `Encodable`, `Decodable`, `Ord`, `TotalOrd`, `TotalEq`, `DeepClone`,
  45         `Rand`, `Zero` and `ToStr` can all be automatically derived with
  46         `#[deriving(...)]`.
  47       * The `bytes!` macro returns a vector of bytes for string, u8, char,
  48         and unsuffixed integer literals.
  49
  50    * Libraries
  51       * The `core` crate was renamed to `std`.
  52       * The `std` crate was renamed to `extra`.
  53       * More and improved documentation.
  54       * std: `iterator` module for external iterator objects.
  55       * Many old-style (internal, higher-order function) iterators replaced by
  56         implementations of `Iterator`.
  57       * std: Many old internal vector and string iterators,
  58         incl. `any`, `all`. removed.
  59       * std: The `finalize` method of `Drop` renamed to `drop`.
  60       * std: The prelude no longer reexports any modules, only types and traits.
  61       * std: Prelude additions: `print`, `println`, `FromStr`, `ApproxEq`, `Equiv`,
  62         `Iterator`, `IteratorUtil`, many numeric traits, many tuple traits.
  63       * std: New numeric traits: `Fractional`, `Real`, `RealExt`, `Integer`, `Ratio`,
  64         `Algebraic`, `Trigonometric`, `Exponential`, `Primitive`.
  65       * std: Tuple traits and accessors defined for up to 12-tuples, e.g.
  66         `(0, 1, 2).n2()` or `(0, 1, 2).n2_ref()`.
  67       * std: Many types implement `Clone`.
  68       * std: `path` type renamed to `Path`.
  69       * std: `mut` module and `Mut` type removed.
  70       * std: Many standalone functions removed in favor of methods and iterators
  71         in `vec`, `str`. In the future methods will also work as functions.
  72       * std: `reinterpret_cast` removed. Use `transmute`.
  73       * std: ascii string handling in `std::ascii`.
  74       * std: `Rand` is implemented for ~/@.
  75       * std: `run` module for spawning processes overhauled.
  76       * std: Various atomic types added to `unstable::atomic`.
  77       * std: Various types implement `Zero`.
  78       * std: `LinearMap` and `LinearSet` renamed to `HashMap` and `HashSet`.
  79       * std: Borrowed pointer functions moved from `ptr` to `borrow`.
  80       * std: Added `os::mkdir_recursive`.
  81       * std: Added `os::glob` function performs filesystems globs.
  82       * std: `FuzzyEq` renamed to `ApproxEq`.
  83       * std: `Map` now defines `pop` and `swap` methods.
  84       * std: `Cell` constructors converted to static methods.
  85       * extra: `rc` module adds the reference counted pointers, `Rc` and `RcMut`.
  86       * extra: `flate` module moved from `std` to `extra`.
  87       * extra: `fileinput` module for iterating over a series of files.
  88       * extra: `Complex` number type and `complex` module.
  89       * extra: `Rational` number type and `rational` module.
  90       * extra: `BigInt`, `BigUint` implement numeric and comparison traits.
  91       * extra: `term` uses terminfo now, is more correct.
  92       * extra: `arc` functions converted to methods.
  93       * extra: Implementation of fixed output size variations of SHA-2.
  94
  95    * Tooling
  96       * `unused_variable`  lint mode for unused variables (default: warn).
  97       * `unused_unsafe` lint mode for detecting unnecessary `unsafe` blocks
  98         (default: warn).
  99       * `unused_mut` lint mode for identifying unused `mut` qualifiers
 100         (default: warn).
 101       * `dead_assignment` lint mode for unread variables (default: warn).
 102       * `unnecessary_allocation` lint mode detects some heap allocations that are
 103         immediately borrowed so could be written without allocating (default: warn).
 104       * `missing_doc` lint mode (default: allow).
 105       * `unreachable_code` lint mode (default: warn).
 106       * The `rusti` command has been rewritten and a number of bugs addressed.
 107       * rustc outputs in color on more terminals.
 108       * rustc accepts a `--link-args` flag to pass arguments to the linker.
 109       * rustc accepts a `-Z print-link-args` flag for debugging linkage.
 110       * Compiling with `-g` will make the binary record information about
 111         dynamic borrowcheck failures for debugging.
 112       * rustdoc has a nicer stylesheet.
 113       * Various improvements to rustdoc.
 114       * Improvements to rustpkg (see the detailed release notes).
 115
 116 Version 0.6 (April 2013)
 117 ------------------------
 118
 119    * ~2100 changes, numerous bugfixes
 120
 121    * Syntax changes
 122       * The self type parameter in traits is now spelled `Self`
 123       * The `self` parameter in trait and impl methods must now be explicitly
 124         named (for example: `fn f(&self) { }`). Implicit self is deprecated.
 125       * Static methods no longer require the `static` keyword and instead
 126         are distinguished by the lack of a `self` parameter
 127       * Replaced the `Durable` trait with the `'static` lifetime
 128       * The old closure type syntax with the trailing sigil has been
 129         removed in favor of the more consistent leading sigil
 130       * `super` is a keyword, and may be prefixed to paths
 131       * Trait bounds are separated with `+` instead of whitespace
 132       * Traits are implemented with `impl Trait for Type`
 133         instead of `impl Type: Trait`
 134       * Lifetime syntax is now `&'l foo` instead of `&l/foo`
 135       * The `export` keyword has finally been removed
 136       * The `move` keyword has been removed (see "Semantic changes")
 137       * The interior mutability qualifier on vectors, `[mut T]`, has been
 138         removed. Use `&mut [T]`, etc.
 139       * `mut` is no longer valid in `~mut T`. Use inherited mutability
 140       * `fail` is no longer a keyword. Use `fail!()`
 141       * `assert` is no longer a keyword. Use `assert!()`
 142       * `log` is no longer a keyword. use `debug!`, etc.
 143       * 1-tuples may be represented as `(T,)`
 144       * Struct fields may no longer be `mut`. Use inherited mutability,
 145         `@mut T`, `core::mut` or `core::cell`
 146       * `extern mod { ... }` is no longer valid syntax for foreign
 147         function modules. Use extern blocks: `extern { ... }`
 148       * Newtype enums removed. Use tuple-structs.
 149       * Trait implementations no longer support visibility modifiers
 150       * Pattern matching over vectors improved and expanded
 151       * `const` renamed to `static` to correspond to lifetime name,
 152         and make room for future `static mut` unsafe mutable globals.
 153       * Replaced `#[deriving_eq]` with `#[deriving(Eq)]`, etc.
 154       * `Clone` implementations can be automatically generated with
 155         `#[deriving(Clone)]`
 156       * Casts to traits must use a pointer sigil, e.g. `@foo as @Bar`
 157         instead of `foo as Bar`.
 158       * Fixed length vector types are now written as `[int, .. 3]`
 159         instead of `[int * 3]`.
 160       * Fixed length vector types can express the length as a constant
 161         expression. (ex: `[int, .. GL_BUFFER_SIZE - 2]`)
 162
 163    * Semantic changes
 164       * Types with owned pointers or custom destructors move by default,
 165         eliminating the `move` keyword
 166       * All foreign functions are considered unsafe
 167       * &mut is now unaliasable
 168       * Writes to borrowed @mut pointers are prevented dynamically
 169       * () has size 0
 170       * The name of the main function can be customized using #[main]
 171       * The default type of an inferred closure is &fn instead of @fn
 172       * `use` statements may no longer be "chained" - they cannot import
 173         identifiers imported by previous `use` statements
 174       * `use` statements are crate relative, importing from the "top"
 175         of the crate by default. Paths may be prefixed with `super::`
 176         or `self::` to change the search behavior.
 177       * Method visibility is inherited from the implementation declaration
 178       * Structural records have been removed
 179       * Many more types can be used in static items, including enums
 180         'static-lifetime pointers and vectors
 181       * Pattern matching over vectors improved and expanded
 182       * Typechecking of closure types has been overhauled to
 183         improve inference and eliminate unsoundness
 184       * Macros leave scope at the end of modules, unless that module is
 185         tagged with #[macro_escape]
 186
 187    * Libraries
 188       * Added big integers to `std::bigint`
 189       * Removed `core::oldcomm` module
 190       * Added pipe-based `core::comm` module
 191       * Numeric traits have been reorganized under `core::num`
 192       * `vec::slice` finally returns a slice
 193       * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
 194       * Containers reorganized around traits in `core::container`
 195       * `core::dvec` removed, `~[T]` is a drop-in replacement
 196       * `core::send_map` renamed to `core::hashmap`
 197       * `std::map` removed; replaced with `core::hashmap`
 198       * `std::treemap` reimplemented as an owned balanced tree
 199       * `std::deque` and `std::smallintmap` reimplemented as owned containers
 200       * `core::trie` added as a fast ordered map for integer keys
 201       * Set types added to `core::hashmap`, `core::trie` and `std::treemap`
 202       * `Ord` split into `Ord` and `TotalOrd`. `Ord` is still used to
 203         overload the comparison operators, whereas `TotalOrd` is used
 204         by certain container types
 205
 206    * Other
 207       * Replaced the 'cargo' package manager with 'rustpkg'
 208       * Added all-purpose 'rust' tool
 209       * `rustc --test` now supports benchmarks with the `#[bench]` attribute
 210       * rustc now *attempts* to offer spelling suggestions
 211       * Improved support for ARM and Android
 212       * Preliminary MIPS backend
 213       * Improved foreign function ABI implementation for x86, x86_64
 214       * Various memory usage improvements
 215       * Rust code may be embedded in foreign code under limited circumstances
 216       * Inline assembler supported by new asm!() syntax extension.
 217
 218 Version 0.5 (December 2012)
 219 ---------------------------
 220
 221    * ~900 changes, numerous bugfixes
 222
 223    * Syntax changes
 224       * Removed `<-` move operator
 225       * Completed the transition from the `#fmt` extension syntax to `fmt!`
 226       * Removed old fixed length vector syntax - `[T]/N`
 227       * New token-based quasi-quoters, `quote_tokens!`, `quote_expr!`, etc.
 228       * Macros may now expand to items and statements
 229       * `a.b()` is always parsed as a method call, never as a field projection
 230       * `Eq` and `IterBytes` implementations can be automatically generated
 231         with `#[deriving_eq]` and `#[deriving_iter_bytes]` respectively
 232       * Removed the special crate language for `.rc` files
 233       * Function arguments may consist of any irrefutable pattern
 234
 235    * Semantic changes
 236       * `&` and `~` pointers may point to objects
 237       * Tuple structs - `struct Foo(Bar, Baz)`. Will replace newtype enums.
 238       * Enum variants may be structs
 239       * Destructors can be added to all nominal types with the Drop trait
 240       * Structs and nullary enum variants may be constants
 241       * Values that cannot be implicitly copied are now automatically moved
 242         without writing `move` explicitly
 243       * `&T` may now be coerced to `*T`
 244       * Coercions happen in `let` statements as well as function calls
 245       * `use` statements now take crate-relative paths
 246       * The module and type namespaces have been merged so that static
 247         method names can be resolved under the trait in which they are
 248         declared
 249
 250    * Improved support for language features
 251       * Trait inheritance works in many scenarios
 252       * More support for explicit self arguments in methods - `self`, `&self`
 253         `@self`, and `~self` all generally work as expected
 254       * Static methods work in more situations
 255       * Experimental: Traits may declare default methods for the implementations
 256         to use
 257
 258    * Libraries
 259       * New condition handling system in `core::condition`
 260       * Timsort added to `std::sort`
 261       * New priority queue, `std::priority_queue`
 262       * Pipes for serializable types, `std::flatpipes'
 263       * Serialization overhauled to be trait-based
 264       * Expanded `getopts` definitions
 265       * Moved futures to `std`
 266       * More functions are pure now
 267       * `core::comm` renamed to `oldcomm`. Still deprecated
 268       * `rustdoc` and `cargo` are libraries now
 269
 270    * Misc
 271       * Added a preliminary REPL, `rusti`
 272       * License changed from MIT to dual MIT/APL2
 273
 274 Version 0.4 (October 2012)
 275 --------------------------
 276
 277    * ~2000 changes, numerous bugfixes
 278
 279    * Syntax
 280       * All keywords are now strict and may not be used as identifiers anywhere
 281       * Keyword removal: 'again', 'import', 'check', 'new', 'owned', 'send',
 282         'of', 'with', 'to', 'class'.
 283       * Classes are replaced with simpler structs
 284       * Explicit method self types
 285       * `ret` became `return` and `alt` became `match`
 286       * `import` is now `use`; `use is now `extern mod`
 287       * `extern mod { ... }` is now `extern { ... }`
 288       * `use mod` is the recommended way to import modules
 289       * `pub` and `priv` replace deprecated export lists
 290       * The syntax of `match` pattern arms now uses fat arrow (=>)
 291       * `main` no longer accepts an args vector; use `os::args` instead
 292
 293    * Semantics
 294       * Trait implementations are now coherent, ala Haskell typeclasses
 295       * Trait methods may be static
 296       * Argument modes are deprecated
 297       * Borrowed pointers are much more mature and recommended for use
 298       * Strings and vectors in the static region are stored in constant memory
 299       * Typestate was removed
 300       * Resolution rewritten to be more reliable
 301       * Support for 'dual-mode' data structures (freezing and thawing)
 302
 303    * Libraries
 304       * Most binary operators can now be overloaded via the traits in
 305         `core::ops'
 306       * `std::net::url` for representing URLs
 307       * Sendable hash maps in `core::send_map`
 308       * `core::task' gained a (currently unsafe) task-local storage API
 309
 310    * Concurrency
 311       * An efficient new intertask communication primitive called the pipe,
 312         along with a number of higher-level channel types, in `core::pipes`
 313       * `std::arc`, an atomically reference counted, immutable, shared memory
 314         type
 315       * `std::sync`, various exotic synchronization tools based on arcs and pipes
 316       * Futures are now based on pipes and sendable
 317       * More robust linked task failure
 318       * Improved task builder API
 319
 320    * Other
 321       * Improved error reporting
 322       * Preliminary JIT support
 323       * Preliminary work on precise GC
 324       * Extensive architectural improvements to rustc
 325       * Begun a transition away from buggy C++-based reflection (shape) code to
 326         Rust-based (visitor) code
 327       * All hash functions and tables converted to secure, randomized SipHash
 328
 329 Version 0.3  (July 2012)
 330 ------------------------
 331
 332    * ~1900 changes, numerous bugfixes
 333
 334    * New coding conveniences
 335       * Integer-literal suffix inference
 336       * Per-item control over warnings, errors
 337       * #[cfg(windows)] and #[cfg(unix)] attributes
 338       * Documentation comments
 339       * More compact closure syntax
 340       * 'do' expressions for treating higher-order functions as
 341         control structures
 342       * *-patterns (wildcard extended to all constructor fields)
 343
 344    * Semantic cleanup
 345       * Name resolution pass and exhaustiveness checker rewritten
 346       * Region pointers and borrow checking supersede alias
 347         analysis
 348       * Init-ness checking is now provided by a region-based liveness
 349         pass instead of the typestate pass; same for last-use analysis
 350       * Extensive work on region pointers
 351
 352    * Experimental new language features
 353       * Slices and fixed-size, interior-allocated vectors
 354       * #!-comments for lang versioning, shell execution
 355       * Destructors and iface implementation for classes;
 356         type-parameterized classes and class methods
 357       * 'const' type kind for types that can be used to implement
 358         shared-memory concurrency patterns
 359
 360    * Type reflection
 361
 362    * Removal of various obsolete features
 363       * Keywords: 'be', 'prove', 'syntax', 'note', 'mutable', 'bind',
 364                  'crust', 'native' (now 'extern'), 'cont' (now 'again')
 365
 366       * Constructs: do-while loops ('do' repurposed), fn binding,
 367                     resources (replaced by destructors)
 368
 369    * Compiler reorganization
 370       * Syntax-layer of compiler split into separate crate
 371       * Clang (from LLVM project) integrated into build
 372       * Typechecker split into sub-modules
 373
 374    * New library code
 375       * New time functions
 376       * Extension methods for many built-in types
 377       * Arc: atomic-refcount read-only / exclusive-use shared cells
 378       * Par: parallel map and search routines
 379       * Extensive work on libuv interface
 380       * Much vector code moved to libraries
 381       * Syntax extensions: #line, #col, #file, #mod, #stringify,
 382         #include, #include_str, #include_bin
 383
 384    * Tool improvements
 385       * Cargo automatically resolves dependencies
 386
 387 Version 0.2  (March 2012)
 388 -------------------------
 389
 390    * >1500 changes, numerous bugfixes
 391
 392    * New docs and doc tooling
 393
 394    * New port: FreeBSD x86_64
 395
 396    * Compilation model enhancements
 397       * Generics now specialized, multiply instantiated
 398       * Functions now inlined across separate crates
 399
 400    * Scheduling, stack and threading fixes
 401       * Noticeably improved message-passing performance
 402       * Explicit schedulers
 403       * Callbacks from C
 404       * Helgrind clean
 405
 406    * Experimental new language features
 407       * Operator overloading
 408       * Region pointers
 409       * Classes
 410
 411    * Various language extensions
 412       * C-callback function types: 'crust fn ...'
 413       * Infinite-loop construct: 'loop { ... }'
 414       * Shorten 'mutable' to 'mut'
 415       * Required mutable-local qualifier: 'let mut ...'
 416       * Basic glob-exporting: 'export foo::*;'
 417       * Alt now exhaustive, 'alt check' for runtime-checked
 418       * Block-function form of 'for' loop, with 'break' and 'ret'.
 419
 420    * New library code
 421       * AST quasi-quote syntax extension
 422       * Revived libuv interface
 423       * New modules: core::{future, iter}, std::arena
 424       * Merged per-platform std::{os*, fs*} to core::{libc, os}
 425       * Extensive cleanup, regularization in libstd, libcore
 426
 427 Version 0.1  (January 2012)
 428 ---------------------------
 429
 430    * Most language features work, including:
 431       * Unique pointers, unique closures, move semantics
 432       * Interface-constrained generics
 433       * Static interface dispatch
 434       * Stack growth
 435       * Multithread task scheduling
 436       * Typestate predicates
 437       * Failure unwinding, destructors
 438       * Pattern matching and destructuring assignment
 439       * Lightweight block-lambda syntax
 440       * Preliminary macro-by-example
 441
 442    * Compiler works with the following configurations:
 443       * Linux: x86 and x86_64 hosts and targets
 444       * MacOS: x86 and x86_64 hosts and targets
 445       * Windows: x86 hosts and targets
 446
 447    * Cross compilation / multi-target configuration supported.
 448
 449    * Preliminary API-documentation and package-management tools included.
 450
 451 Known issues:
 452
 453    * Documentation is incomplete.
 454
 455    * Performance is below intended target.
 456
 457    * Standard library APIs are subject to extensive change, reorganization.
 458
 459    * Language-level versioning is not yet operational - future code will
 460      break unexpectedly.