rust/tests/ui/issues/issue-3609.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

31 lines
715 B
Rust
Raw Normal View History

// check-pass
#![allow(unused_must_use)]
#![allow(dead_code)]
#![allow(unused_mut)]
use std::thread;
std: Second pass stabilization for `comm` 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-23 13:53:35 -06:00
use std::sync::mpsc::Sender;
type RingBuffer = Vec<f64> ;
2019-05-28 13:46:13 -05:00
type SamplesFn = Box<dyn FnMut(&RingBuffer) + Send>;
enum Msg
{
GetSamples(String, SamplesFn), // sample set name, callback which receives samples
}
fn foo(name: String, samples_chan: Sender<Msg>) {
2015-04-13 17:15:32 -05:00
thread::spawn(move|| {
2013-12-05 20:19:06 -06:00
let mut samples_chan = samples_chan;
let callback: SamplesFn = Box::new(move |buffer| {
for i in 0..buffer.len() {
println!("{}: {}", i, buffer[i])
}
});
samples_chan.send(Msg::GetSamples(name.clone(), callback));
2015-04-13 17:15:32 -05:00
}).join();
}
pub fn main() {}