| Version 0.8 (September 2013) |
| -------------------------- |
| |
| * ~2200 changes, numerous bugfixes |
| |
| * Language |
| * The `for` loop syntax has changed to work with the `Iterator` trait. |
| * At long last, unwinding works on Windows. |
| * Default methods are ready for use. |
| * Many trait inheritance bugs fixed. |
| * Owned and borrowed trait objects work more reliably. |
| * `copy` is no longer a keyword. It has been replaced by the `Clone` trait. |
| * rustc can omit emission of code for the `debug!` macro if it is passed |
| `--cfg ndebug` |
| * mod.rs is now "blessed". When loading `mod foo;`, rustc will now look |
| for foo.rs, then foo/mod.rs, and will generate an error when both are |
| present. |
| * Strings no longer contain trailing nulls. The new `std::c_str` module |
| provides new mechanisms for converting to C strings. |
| * The type of foreign functions is now `extern "C" fn` instead of `*u8'. |
| * The FFI has been overhauled such that foreign functions are called directly, |
| instead of through a stack-switching wrapper. |
| * Calling a foreign function must be done through a Rust function with the |
| `#[fixed_stack_segment]` attribute. |
| * The `externfn!` macro can be used to declare both a foreign function and |
| a `#[fixed_stack_segment]` wrapper at once. |
| * `pub` and `priv` modifiers on `extern` blocks are no longer parsed. |
| * `unsafe` is no longer allowed on extern fns - they are all unsafe. |
| * `priv` is disallowed everywhere except for struct fields and enum variants. |
| * `&T` (besides `&'static T`) is no longer allowed in `@T`. |
| * `ref` bindings in irrefutable patterns work correctly now. |
| * `char` is now prevented from containing invalid code points. |
| * Casting to `bool` is no longer allowed. |
| * `\0` is now accepted as an escape in chars and strings. |
| * `yield` is a reserved keyword. |
| * `typeof` is a reserved keyword. |
| * Crates may be imported by URL with `extern mod foo = "url";`. |
| * Explicit enum discriminants may be given as uints as in `enum E { V = 0u }` |
| * Static vectors can be initialized with repeating elements, |
| e.g. `static foo: [u8, .. 100]: [0, .. 100];`. |
| * Static structs can be initialized with functional record update, |
| e.g. `static foo: Foo = Foo { a: 5, .. bar };`. |
| * `cfg!` can be used to conditionally execute code based on the crate |
| configuration, similarly to `#[cfg(...)]`. |
| * The `unnecessary_qualification` lint detects unneeded module |
| prefixes (default: allow). |
| * Arithmetic operations have been implemented on the SIMD types in |
| `std::unstable::simd`. |
| * Exchange allocation headers were removed, reducing memory usage. |
| * `format!` implements a completely new, extensible, and higher-performance |
| string formatting system. It will replace `fmt!`. |
| * `print!` and `println!` write formatted strings (using the `format!` |
| extension) to stdout. |
| * `write!` and `writeln!` write formatted strings (using the `format!` |
| extension) to the new Writers in `std::rt::io`. |
| * The library section in which a function or static is placed may |
| be specified with `#[link_section = "..."]`. |
| * The `proto!` syntax extension for defining bounded message protocols |
| was removed. |
| * `macro_rules!` is hygienic for `let` declarations. |
| * The `#[export_name]` attribute specifies the name of a symbol. |
| * `unreachable!` can be used to indicate unreachable code, and fails |
| if executed. |
| |
| * Libraries |
| * std: Transitioned to the new runtime, written in Rust. |
| * std: Added an experimental I/O library, `rt::io`, based on the new |
| runtime. |
| * std: A new generic `range` function was added to the prelude, replacing |
| `uint::range` and friends. |
| * std: `range_rev` no longer exists. Since range is an iterator it can be |
| reversed with `range(lo, hi).invert()`. |
| * std: The `chain` method on option renamed to `and_then`; `unwrap_or_default` |
| renamed to `unwrap_or`. |
| * std: The `iterator` module was renamed to `iter`. |
| * std: Integral types now support the `checked_add`, `checked_sub`, and |
| `checked_mul` operations for detecting overflow. |
| * std: Many methods in `str`, `vec`, `option, `result` were renamed for |
| consistency. |
| * std: Methods are standardizing on conventions for casting methods: |
| `to_foo` for copying, `into_foo` for moving, `as_foo` for temporary |
| and cheap casts. |
| * std: The `CString` type in `c_str` provides new ways to convert to and |
| from C strings. |
| * std: `DoubleEndedIterator` can yield elements in two directions. |
| * std: The `mut_split` method on vectors partitions an `&mut [T]` into |
| two splices. |
| * std: `str::from_bytes` renamed to `str::from_utf8`. |
| * std: `pop_opt` and `shift_opt` methods added to vectors. |
| * std: The task-local data interface no longer uses @, and keys are |
| no longer function pointers. |
| * std: The `swap_unwrap` method of `Option` renamed to `take_unwrap`. |
| * std: Added `SharedPort` to `comm`. |
| * std: `Eq` has a default method for `ne`; only `eq` is required |
| in implementations. |
| * std: `Ord` has default methods for `le`, `gt` and `ge`; only `lt` |
| is required in implementations. |
| * std: `is_utf8` performance is improved, impacting many string functions. |
| * std: `os::MemoryMap` provides cross-platform mmap. |
| * std: `ptr::offset` is now unsafe, but also more optimized. Offsets that |
| are not 'in-bounds' are considered undefined. |
| * std: Many freestanding functions in `vec` removed in favor of methods. |
| * std: Many freestanding functions on scalar types removed in favor of |
| methods. |
| * std: Many options to task builders were removed since they don't make |
| sense in the new scheduler design. |
| * std: More containers implement `FromIterator` so can be created by the |
| `collect` method. |
| * std: More complete atomic types in `unstable::atomics`. |
| * std: `comm::PortSet` removed. |
| * std: Mutating methods in the `Set` and `Map` traits have been moved into |
| the `MutableSet` and `MutableMap` traits. `Container::is_empty`, |
| `Map::contains_key`, `MutableMap::insert`, and `MutableMap::remove` have |
| default implementations. |
| * std: Various `from_str` functions were removed in favor of a generic |
| `from_str` which is available in the prelude. |
| * std: `util::unreachable` removed in favor of the `unreachable!` macro. |
| * extra: `dlist`, the doubly-linked list was modernized. |
| * extra: Added a `hex` module with `ToHex` and `FromHex` traits. |
| * extra: Added `glob` module, replacing `std::os::glob`. |
| * extra: `rope` was removed. |
| * extra: `deque` was renamed to `ringbuf`. `RingBuf` implements `Deque`. |
| * extra: `net`, and `timer` were removed. The experimental replacements |
| are `std::rt::io::net` and `std::rt::io::timer`. |
| * extra: Iterators implemented for `SmallIntMap`. |
| * extra: Iterators implemented for `Bitv` and `BitvSet`. |
| * extra: `SmallIntSet` removed. Use `BitvSet`. |
| * extra: Performance of JSON parsing greatly improved. |
| * extra: `semver` updated to SemVer 2.0.0. |
| * extra: `term` handles more terminals correctly. |
| * extra: `dbg` module removed. |
| * extra: `par` module removed. |
| * extra: `future` was cleaned up, with some method renames. |
| * extra: Most free functions in `getopts` were converted to methods. |
| |
| * Other |
| * rustc's debug info generation (`-Z debug-info`) is greatly improved. |
| * rustc accepts `--target-cpu` to compile to a specific CPU architecture, |
| similarly to gcc's `--march` flag. |
| * rustc's performance compiling small crates is much better. |
| * rustpkg has received many improvements. |
| * rustpkg supports git tags as package IDs. |
| * rustpkg builds into target-specific directories so it can be used for |
| cross-compiling. |
| * The number of concurrent test tasks is controlled by the environment |
| variable RUST_TEST_TASKS. |
| * The test harness can now report metrics for benchmarks. |
| * All tools have man pages. |
| * Programs compiled with `--test` now support the `-h` and `--help` flags. |
| * The runtime uses jemalloc for allocations. |
| * Segmented stacks are temporarily disabled as part of the transition to |
| the new runtime. Stack overflows are possible! |
| * A new documentation backend, rustdoc_ng, is available for use. It is |
| still invoked through the normal `rustdoc` command. |
| |
| Version 0.7 (July 2013) |
| ----------------------- |
| |
| * ~2000 changes, numerous bugfixes |
| |
| * Language |
| * `impl`s no longer accept a visibility qualifier. Put them on methods |
| instead. |
| * The borrow checker has been rewritten with flow-sensitivity, fixing |
| many bugs and inconveniences. |
| * The `self` parameter no longer implicitly means `&'self self`, |
| and can be explicitly marked with a lifetime. |
| * Overloadable compound operators (`+=`, etc.) have been temporarily |
| removed due to bugs. |
| * The `for` loop protocol now requires `for`-iterators to return `bool` |
| so they compose better. |
| * The `Durable` trait is replaced with the `'static` bounds. |
| * Trait default methods work more often. |
| * Structs with the `#[packed]` attribute have byte alignment and |
| no padding between fields. |
| * Type parameters bound by `Copy` must now be copied explicitly with |
| the `copy` keyword. |
| * It is now illegal to move out of a dereferenced unsafe pointer. |
| * `Option<~T>` is now represented as a nullable pointer. |
| * `@mut` does dynamic borrow checks correctly. |
| * The `main` function is only detected at the topmost level of the crate. |
| The `#[main]` attribute is still valid anywhere. |
| * Struct fields may no longer be mutable. Use inherited mutability. |
| * The `#[no_send]` attribute makes a type that would otherwise be |
| `Send`, not. |
| * The `#[no_freeze]` attribute makes a type that would otherwise be |
| `Freeze`, not. |
| * Unbounded recursion will abort the process after reaching the limit |
| specified by the `RUST_MAX_STACK` environment variable (default: 1GB). |
| * The `vecs_implicitly_copyable` lint mode has been removed. Vectors |
| are never implicitly copyable. |
| * `#[static_assert]` makes compile-time assertions about static bools. |
| * At long last, 'argument modes' no longer exist. |
| * The rarely used `use mod` statement no longer exists. |
| |
| * Syntax extensions |
| * `fail!` and `assert!` accept `~str`, `&'static str` or `fmt!`-style |
| argument list. |
| * `Encodable`, `Decodable`, `Ord`, `TotalOrd`, `TotalEq`, `DeepClone`, |
| `Rand`, `Zero` and `ToStr` can all be automatically derived with |
| `#[deriving(...)]`. |
| * The `bytes!` macro returns a vector of bytes for string, u8, char, |
| and unsuffixed integer literals. |
| |
| * Libraries |
| * The `core` crate was renamed to `std`. |
| * The `std` crate was renamed to `extra`. |
| * More and improved documentation. |
| * std: `iterator` module for external iterator objects. |
| * Many old-style (internal, higher-order function) iterators replaced by |
| implementations of `Iterator`. |
| * std: Many old internal vector and string iterators, |
| incl. `any`, `all`. removed. |
| * std: The `finalize` method of `Drop` renamed to `drop`. |
| * std: The `drop` method now takes `&mut self` instead of `&self`. |
| * std: The prelude no longer reexports any modules, only types and traits. |
| * std: Prelude additions: `print`, `println`, `FromStr`, `ApproxEq`, `Equiv`, |
| `Iterator`, `IteratorUtil`, many numeric traits, many tuple traits. |
| * std: New numeric traits: `Fractional`, `Real`, `RealExt`, `Integer`, `Ratio`, |
| `Algebraic`, `Trigonometric`, `Exponential`, `Primitive`. |
| * std: Tuple traits and accessors defined for up to 12-tuples, e.g. |
| `(0, 1, 2).n2()` or `(0, 1, 2).n2_ref()`. |
| * std: Many types implement `Clone`. |
| * std: `path` type renamed to `Path`. |
| * std: `mut` module and `Mut` type removed. |
| * std: Many standalone functions removed in favor of methods and iterators |
| in `vec`, `str`. In the future methods will also work as functions. |
| * std: `reinterpret_cast` removed. Use `transmute`. |
| * std: ascii string handling in `std::ascii`. |
| * std: `Rand` is implemented for ~/@. |
| * std: `run` module for spawning processes overhauled. |
| * std: Various atomic types added to `unstable::atomic`. |
| * std: Various types implement `Zero`. |
| * std: `LinearMap` and `LinearSet` renamed to `HashMap` and `HashSet`. |
| * std: Borrowed pointer functions moved from `ptr` to `borrow`. |
| * std: Added `os::mkdir_recursive`. |
| * std: Added `os::glob` function performs filesystems globs. |
| * std: `FuzzyEq` renamed to `ApproxEq`. |
| * std: `Map` now defines `pop` and `swap` methods. |
| * std: `Cell` constructors converted to static methods. |
| * extra: `rc` module adds the reference counted pointers, `Rc` and `RcMut`. |
| * extra: `flate` module moved from `std` to `extra`. |
| * extra: `fileinput` module for iterating over a series of files. |
| * extra: `Complex` number type and `complex` module. |
| * extra: `Rational` number type and `rational` module. |
| * extra: `BigInt`, `BigUint` implement numeric and comparison traits. |
| * extra: `term` uses terminfo now, is more correct. |
| * extra: `arc` functions converted to methods. |
| * extra: Implementation of fixed output size variations of SHA-2. |
| |
| * Tooling |
| * `unused_variable` lint mode for unused variables (default: warn). |
| * `unused_unsafe` lint mode for detecting unnecessary `unsafe` blocks |
| (default: warn). |
| * `unused_mut` lint mode for identifying unused `mut` qualifiers |
| (default: warn). |
| * `dead_assignment` lint mode for unread variables (default: warn). |
| * `unnecessary_allocation` lint mode detects some heap allocations that are |
| immediately borrowed so could be written without allocating (default: warn). |
| * `missing_doc` lint mode (default: allow). |
| * `unreachable_code` lint mode (default: warn). |
| * The `rusti` command has been rewritten and a number of bugs addressed. |
| * rustc outputs in color on more terminals. |
| * rustc accepts a `--link-args` flag to pass arguments to the linker. |
| * rustc accepts a `-Z print-link-args` flag for debugging linkage. |
| * Compiling with `-g` will make the binary record information about |
| dynamic borrowcheck failures for debugging. |
| * rustdoc has a nicer stylesheet. |
| * Various improvements to rustdoc. |
| * Improvements to rustpkg (see the detailed release notes). |
| |
| Version 0.6 (April 2013) |
| ------------------------ |
| |
| * ~2100 changes, numerous bugfixes |
| |
| * Syntax changes |
| * The self type parameter in traits is now spelled `Self` |
| * The `self` parameter in trait and impl methods must now be explicitly |
| named (for example: `fn f(&self) { }`). Implicit self is deprecated. |
| * Static methods no longer require the `static` keyword and instead |
| are distinguished by the lack of a `self` parameter |
| * Replaced the `Durable` trait with the `'static` lifetime |
| * The old closure type syntax with the trailing sigil has been |
| removed in favor of the more consistent leading sigil |
| * `super` is a keyword, and may be prefixed to paths |
| * Trait bounds are separated with `+` instead of whitespace |
| * Traits are implemented with `impl Trait for Type` |
| instead of `impl Type: Trait` |
| * Lifetime syntax is now `&'l foo` instead of `&l/foo` |
| * The `export` keyword has finally been removed |
| * The `move` keyword has been removed (see "Semantic changes") |
| * The interior mutability qualifier on vectors, `[mut T]`, has been |
| removed. Use `&mut [T]`, etc. |
| * `mut` is no longer valid in `~mut T`. Use inherited mutability |
| * `fail` is no longer a keyword. Use `fail!()` |
| * `assert` is no longer a keyword. Use `assert!()` |
| * `log` is no longer a keyword. use `debug!`, etc. |
| * 1-tuples may be represented as `(T,)` |
| * Struct fields may no longer be `mut`. Use inherited mutability, |
| `@mut T`, `core::mut` or `core::cell` |
| * `extern mod { ... }` is no longer valid syntax for foreign |
| function modules. Use extern blocks: `extern { ... }` |
| * Newtype enums removed. Use tuple-structs. |
| * Trait implementations no longer support visibility modifiers |
| * Pattern matching over vectors improved and expanded |
| * `const` renamed to `static` to correspond to lifetime name, |
| and make room for future `static mut` unsafe mutable globals. |
| * Replaced `#[deriving_eq]` with `#[deriving(Eq)]`, etc. |
| * `Clone` implementations can be automatically generated with |
| `#[deriving(Clone)]` |
| * Casts to traits must use a pointer sigil, e.g. `@foo as @Bar` |
| instead of `foo as Bar`. |
| * Fixed length vector types are now written as `[int, .. 3]` |
| instead of `[int * 3]`. |
| * Fixed length vector types can express the length as a constant |
| expression. (ex: `[int, .. GL_BUFFER_SIZE - 2]`) |
| |
| * Semantic changes |
| * Types with owned pointers or custom destructors move by default, |
| eliminating the `move` keyword |
| * All foreign functions are considered unsafe |
| * &mut is now unaliasable |
| * Writes to borrowed @mut pointers are prevented dynamically |
| * () has size 0 |
| * The name of the main function can be customized using #[main] |
| * The default type of an inferred closure is &fn instead of @fn |
| * `use` statements may no longer be "chained" - they cannot import |
| identifiers imported by previous `use` statements |
| * `use` statements are crate relative, importing from the "top" |
| of the crate by default. Paths may be prefixed with `super::` |
| or `self::` to change the search behavior. |
| * Method visibility is inherited from the implementation declaration |
| * Structural records have been removed |
| * Many more types can be used in static items, including enums |
| 'static-lifetime pointers and vectors |
| * Pattern matching over vectors improved and expanded |
| * Typechecking of closure types has been overhauled to |
| improve inference and eliminate unsoundness |
| * Macros leave scope at the end of modules, unless that module is |
| tagged with #[macro_escape] |
| |
| * Libraries |
| * Added big integers to `std::bigint` |
| * Removed `core::oldcomm` module |
| * Added pipe-based `core::comm` module |
| * Numeric traits have been reorganized under `core::num` |
| * `vec::slice` finally returns a slice |
| * `debug!` and friends don't require a format string, e.g. `debug!(Foo)` |
| * Containers reorganized around traits in `core::container` |
| * `core::dvec` removed, `~[T]` is a drop-in replacement |
| * `core::send_map` renamed to `core::hashmap` |
| * `std::map` removed; replaced with `core::hashmap` |
| * `std::treemap` reimplemented as an owned balanced tree |
| * `std::deque` and `std::smallintmap` reimplemented as owned containers |
| * `core::trie` added as a fast ordered map for integer keys |
| * Set types added to `core::hashmap`, `core::trie` and `std::treemap` |
| * `Ord` split into `Ord` and `TotalOrd`. `Ord` is still used to |
| overload the comparison operators, whereas `TotalOrd` is used |
| by certain container types |
| |
| * Other |
| * Replaced the 'cargo' package manager with 'rustpkg' |
| * Added all-purpose 'rust' tool |
| * `rustc --test` now supports benchmarks with the `#[bench]` attribute |
| * rustc now *attempts* to offer spelling suggestions |
| * Improved support for ARM and Android |
| * Preliminary MIPS backend |
| * Improved foreign function ABI implementation for x86, x86_64 |
| * Various memory usage improvements |
| * Rust code may be embedded in foreign code under limited circumstances |
| * Inline assembler supported by new asm!() syntax extension. |
| |
| Version 0.5 (December 2012) |
| --------------------------- |
| |
| * ~900 changes, numerous bugfixes |
| |
| * Syntax changes |
| * Removed `<-` move operator |
| * Completed the transition from the `#fmt` extension syntax to `fmt!` |
| * Removed old fixed length vector syntax - `[T]/N` |
| * New token-based quasi-quoters, `quote_tokens!`, `quote_expr!`, etc. |
| * Macros may now expand to items and statements |
| * `a.b()` is always parsed as a method call, never as a field projection |
| * `Eq` and `IterBytes` implementations can be automatically generated |
| with `#[deriving_eq]` and `#[deriving_iter_bytes]` respectively |
| * Removed the special crate language for `.rc` files |
| * Function arguments may consist of any irrefutable pattern |
| |
| * Semantic changes |
| * `&` and `~` pointers may point to objects |
| * Tuple structs - `struct Foo(Bar, Baz)`. Will replace newtype enums. |
| * Enum variants may be structs |
| * Destructors can be added to all nominal types with the Drop trait |
| * Structs and nullary enum variants may be constants |
| * Values that cannot be implicitly copied are now automatically moved |
| without writing `move` explicitly |
| * `&T` may now be coerced to `*T` |
| * Coercions happen in `let` statements as well as function calls |
| * `use` statements now take crate-relative paths |
| * The module and type namespaces have been merged so that static |
| method names can be resolved under the trait in which they are |
| declared |
| |
| * Improved support for language features |
| * Trait inheritance works in many scenarios |
| * More support for explicit self arguments in methods - `self`, `&self` |
| `@self`, and `~self` all generally work as expected |
| * Static methods work in more situations |
| * Experimental: Traits may declare default methods for the implementations |
| to use |
| |
| * Libraries |
| * New condition handling system in `core::condition` |
| * Timsort added to `std::sort` |
| * New priority queue, `std::priority_queue` |
| * Pipes for serializable types, `std::flatpipes' |
| * Serialization overhauled to be trait-based |
| * Expanded `getopts` definitions |
| * Moved futures to `std` |
| * More functions are pure now |
| * `core::comm` renamed to `oldcomm`. Still deprecated |
| * `rustdoc` and `cargo` are libraries now |
| |
| * Misc |
| * Added a preliminary REPL, `rusti` |
| * License changed from MIT to dual MIT/APL2 |
| |
| Version 0.4 (October 2012) |
| -------------------------- |
| |
| * ~2000 changes, numerous bugfixes |
| |
| * Syntax |
| * All keywords are now strict and may not be used as identifiers anywhere |
| * Keyword removal: 'again', 'import', 'check', 'new', 'owned', 'send', |
| 'of', 'with', 'to', 'class'. |
| * Classes are replaced with simpler structs |
| * Explicit method self types |
| * `ret` became `return` and `alt` became `match` |
| * `import` is now `use`; `use is now `extern mod` |
| * `extern mod { ... }` is now `extern { ... }` |
| * `use mod` is the recommended way to import modules |
| * `pub` and `priv` replace deprecated export lists |
| * The syntax of `match` pattern arms now uses fat arrow (=>) |
| * `main` no longer accepts an args vector; use `os::args` instead |
| |
| * Semantics |
| * Trait implementations are now coherent, ala Haskell typeclasses |
| * Trait methods may be static |
| * Argument modes are deprecated |
| * Borrowed pointers are much more mature and recommended for use |
| * Strings and vectors in the static region are stored in constant memory |
| * Typestate was removed |
| * Resolution rewritten to be more reliable |
| * Support for 'dual-mode' data structures (freezing and thawing) |
| |
| * Libraries |
| * Most binary operators can now be overloaded via the traits in |
| `core::ops' |
| * `std::net::url` for representing URLs |
| * Sendable hash maps in `core::send_map` |
| * `core::task' gained a (currently unsafe) task-local storage API |
| |
| * Concurrency |
| * An efficient new intertask communication primitive called the pipe, |
| along with a number of higher-level channel types, in `core::pipes` |
| * `std::arc`, an atomically reference counted, immutable, shared memory |
| type |
| * `std::sync`, various exotic synchronization tools based on arcs and pipes |
| * Futures are now based on pipes and sendable |
| * More robust linked task failure |
| * Improved task builder API |
| |
| * Other |
| * Improved error reporting |
| * Preliminary JIT support |
| * Preliminary work on precise GC |
| * Extensive architectural improvements to rustc |
| * Begun a transition away from buggy C++-based reflection (shape) code to |
| Rust-based (visitor) code |
| * All hash functions and tables converted to secure, randomized SipHash |
| |
| Version 0.3 (July 2012) |
| ------------------------ |
| |
| * ~1900 changes, numerous bugfixes |
| |
| * New coding conveniences |
| * Integer-literal suffix inference |
| * Per-item control over warnings, errors |
| * #[cfg(windows)] and #[cfg(unix)] attributes |
| * Documentation comments |
| * More compact closure syntax |
| * 'do' expressions for treating higher-order functions as |
| control structures |
| * *-patterns (wildcard extended to all constructor fields) |
| |
| * Semantic cleanup |
| * Name resolution pass and exhaustiveness checker rewritten |
| * Region pointers and borrow checking supersede alias |
| analysis |
| * Init-ness checking is now provided by a region-based liveness |
| pass instead of the typestate pass; same for last-use analysis |
| * Extensive work on region pointers |
| |
| * Experimental new language features |
| * Slices and fixed-size, interior-allocated vectors |
| * #!-comments for lang versioning, shell execution |
| * Destructors and iface implementation for classes; |
| type-parameterized classes and class methods |
| * 'const' type kind for types that can be used to implement |
| shared-memory concurrency patterns |
| |
| * Type reflection |
| |
| * Removal of various obsolete features |
| * Keywords: 'be', 'prove', 'syntax', 'note', 'mutable', 'bind', |
| 'crust', 'native' (now 'extern'), 'cont' (now 'again') |
| |
| * Constructs: do-while loops ('do' repurposed), fn binding, |
| resources (replaced by destructors) |
| |
| * Compiler reorganization |
| * Syntax-layer of compiler split into separate crate |
| * Clang (from LLVM project) integrated into build |
| * Typechecker split into sub-modules |
| |
| * New library code |
| * New time functions |
| * Extension methods for many built-in types |
| * Arc: atomic-refcount read-only / exclusive-use shared cells |
| * Par: parallel map and search routines |
| * Extensive work on libuv interface |
| * Much vector code moved to libraries |
| * Syntax extensions: #line, #col, #file, #mod, #stringify, |
| #include, #include_str, #include_bin |
| |
| * Tool improvements |
| * Cargo automatically resolves dependencies |
| |
| Version 0.2 (March 2012) |
| ------------------------- |
| |
| * >1500 changes, numerous bugfixes |
| |
| * New docs and doc tooling |
| |
| * New port: FreeBSD x86_64 |
| |
| * Compilation model enhancements |
| * Generics now specialized, multiply instantiated |
| * Functions now inlined across separate crates |
| |
| * Scheduling, stack and threading fixes |
| * Noticeably improved message-passing performance |
| * Explicit schedulers |
| * Callbacks from C |
| * Helgrind clean |
| |
| * Experimental new language features |
| * Operator overloading |
| * Region pointers |
| * Classes |
| |
| * Various language extensions |
| * C-callback function types: 'crust fn ...' |
| * Infinite-loop construct: 'loop { ... }' |
| * Shorten 'mutable' to 'mut' |
| * Required mutable-local qualifier: 'let mut ...' |
| * Basic glob-exporting: 'export foo::*;' |
| * Alt now exhaustive, 'alt check' for runtime-checked |
| * Block-function form of 'for' loop, with 'break' and 'ret'. |
| |
| * New library code |
| * AST quasi-quote syntax extension |
| * Revived libuv interface |
| * New modules: core::{future, iter}, std::arena |
| * Merged per-platform std::{os*, fs*} to core::{libc, os} |
| * Extensive cleanup, regularization in libstd, libcore |
| |
| Version 0.1 (January 2012) |
| --------------------------- |
| |
| * Most language features work, including: |
| * Unique pointers, unique closures, move semantics |
| * Interface-constrained generics |
| * Static interface dispatch |
| * Stack growth |
| * Multithread task scheduling |
| * Typestate predicates |
| * Failure unwinding, destructors |
| * Pattern matching and destructuring assignment |
| * Lightweight block-lambda syntax |
| * Preliminary macro-by-example |
| |
| * Compiler works with the following configurations: |
| * Linux: x86 and x86_64 hosts and targets |
| * MacOS: x86 and x86_64 hosts and targets |
| * Windows: x86 hosts and targets |
| |
| * Cross compilation / multi-target configuration supported. |
| |
| * Preliminary API-documentation and package-management tools included. |
| |
| Known issues: |
| |
| * Documentation is incomplete. |
| |
| * Performance is below intended target. |
| |
| * Standard library APIs are subject to extensive change, reorganization. |
| |
| * Language-level versioning is not yet operational - future code will |
| break unexpectedly. |
