https://github.com/rust-lang/rust http://git.dreamy.place/mirrors/rust/atom?h=perf-tmp 2014-12-29T20:16:49+00:00 2014-12-29T20:16:49+00:00 Alex Crichton alex@alexcrichton.com 2014-12-23T19:53:35+00:00 urn:sha1:bc83a009f655dd3896be4a7cd33cac8032a605f2 This commit is a second pass stabilization for the `std::comm` module, performing the following actions: * The entire `std::comm` module was moved under `std::sync::mpsc`. This movement reflects that channels are just yet another synchronization primitive, and they don't necessarily deserve a special place outside of the other concurrency primitives that the standard library offers. * The `send` and `recv` methods have all been removed. * The `send_opt` and `recv_opt` methods have been renamed to `send` and `recv`. This means that all send/receive operations return a `Result` now indicating whether the operation was successful or not. * The error type of `send` is now a `SendError` to implement a custom error message and allow for `unwrap()`. The error type contains an `into_inner` method to extract the value. * The error type of `recv` is now `RecvError` for the same reasons as `send`. * The `TryRecvError` and `TrySendError` types have had public reexports removed of their variants and the variant names have been tweaked with enum namespacing rules. * The `Messages` iterator is renamed to `Iter` This functionality is now all `#[stable]`: * `Sender` * `SyncSender` * `Receiver` * `std::sync::mpsc` * `channel` * `sync_channel` * `Iter` * `Sender::send` * `Sender::clone` * `SyncSender::send` * `SyncSender::try_send` * `SyncSender::clone` * `Receiver::recv` * `Receiver::try_recv` * `Receiver::iter` * `SendError` * `RecvError` * `TrySendError::{mod, Full, Disconnected}` * `TryRecvError::{mod, Empty, Disconnected}` * `SendError::into_inner` * `TrySendError::into_inner` This is a breaking change due to the modification of where this module is located, as well as the changing of the semantics of `send` and `recv`. Most programs just need to rename imports of `std::comm` to `std::sync::mpsc` and add calls to `unwrap` after a send or a receive operation. [breaking-change] 2014-12-29T16:58:21+00:00 Alex Crichton alex@alexcrichton.com 2014-12-22T17:04:23+00:00 urn:sha1:c32d03f4172580e3f33e4844ed3c01234dca2d53 This commit is an implementation of [RFC 503][rfc] which is a stabilization story for the prelude. Most of the RFC was directly applied, removing reexports. Some reexports are kept around, however: * `range` remains until range syntax has landed to reduce churn. * `Path` and `GenericPath` remain until path reform lands. This is done to prevent many imports of `GenericPath` which will soon be removed. * All `io` traits remain until I/O reform lands so imports can be rewritten all at once to `std::io::prelude::*`. This is a breaking change because many prelude reexports have been removed, and the RFC can be consulted for the exact list of removed reexports, as well as to find the locations of where to import them. [rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0503-prelude-stabilization.md [breaking-change] Closes #20068 2014-12-19T07:31:51+00:00 Aaron Turon aturon@mozilla.com 2014-12-07T02:34:37+00:00 urn:sha1:43ae4b3301cc0605839778ecf59effb32b752e33 2014-12-19T07:31:51+00:00 Aaron Turon aturon@mozilla.com 2014-12-01T16:14:35+00:00 urn:sha1:7fd7ce682dd6f98d456d817a297b15bdc9841190 2014-12-19T07:31:34+00:00 Aaron Turon aturon@mozilla.com 2014-11-24T03:21:17+00:00 urn:sha1:2b3477d373603527d23cc578f3737857b7b253d7 This commit merges the `rustrt` crate into `std`, undoing part of the facade. This merger continues the paring down of the runtime system. Code relying on the public API of `rustrt` will break; some of this API is now available through `std::rt`, but is likely to change and/or be removed very soon. [breaking-change] 2014-12-18T17:09:07+00:00 Patrick Walton pcwalton@mimiga.net 2014-11-14T17:18:10+00:00 urn:sha1:ddb2466f6a1bb66f22824334022a4cee61c73bdc followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change] 2014-12-14T09:21:56+00:00 Niko Matsakis niko@alum.mit.edu 2014-11-26T13:12:18+00:00 urn:sha1:5c3d3989192f88b16f39d554c3844700c91b6c8e 2014-11-26T16:42:06+00:00 Niko Matsakis niko@alum.mit.edu 2014-11-20T20:08:02+00:00 urn:sha1:f4e29e7e9aa1da4fc91a6074b0e4df44a2986517 2014-11-24T18:51:39+00:00 Aaron Turon aturon@mozilla.com 2014-11-23T20:52:37+00:00 urn:sha1:985acfdb67d550d0259fcdcfbeed0a86ec3da9d0 This patch merges the `libsync` crate into `libstd`, undoing part of the facade. This is in preparation for ultimately merging `librustrt`, as well as the upcoming rewrite of `sync`. Because this removes the `libsync` crate, it is a: [breaking-change] However, all uses of `libsync` should be able to reroute through `std::sync` and `std::comm` instead. 2014-06-11T17:00:43+00:00 Alex Crichton alex@alexcrichton.com 2014-06-07T18:13:26+00:00 urn:sha1:b1c9ce9c6f0eb7d4a7df1aad6b6799f4b548181c This commit is the final step in the libstd facade, #13851. The purpose of this commit is to move libsync underneath the standard library, behind the facade. This will allow core primitives like channels, queues, and atomics to all live in the same location. There were a few notable changes and a few breaking changes as part of this movement: * The `Vec` and `String` types are reexported at the top level of libcollections * The `unreachable!()` macro was copied to libcore * The `std::rt::thread` module was moved to librustrt, but it is still reexported at the same location. * The `std::comm` module was moved to libsync * The `sync::comm` module was moved under `sync::comm`, and renamed to `duplex`. It is now a private module with types/functions being reexported under `sync::comm`. This is a breaking change for any existing users of duplex streams. * All concurrent queues/deques were moved directly under libsync. They are also all marked with #![experimental] for now if they are public. * The `task_pool` and `future` modules no longer live in libsync, but rather live under `std::sync`. They will forever live at this location, but they may move to libsync if the `std::task` module moves as well. [breaking-change]