C++ 与 Rust 编程理念的融合

struct Some { T value; };struct None { };using Optional = std::variant<Some, None>;

auto value = [] { // Complex initializer return result;}(); // notice the invocation

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template <typename Val, typename... Ts>auto match(Val val, Ts... ts) { return std::visit(overloaded{ts...}, val);}

visit( overloaded { []<one_of<string, int> T>(T value) {} [](auto other) {} }, value)

struct Error { data: Rc<ExpensiveToCloneDirectly>,}
pub type Response = Result<Output, Error>;
fn parse(input: Input) -> Response { todo!()}

enum Command { Input(Input), Exit,}
pub enum RequestStatus { Completed(Response), Running,}
pub struct Parser { command_sender: Sender<Command>, response_receiver: Receiver<(Input, Response)>, cached_result: HashMap<Input, RequestStatus>,}
impl Parser { pub fn new() -> Self { let (command_sender, command_receiver) = channel::<Command>(); let (response_sender, response_receiver) = channel::<(Input, Response)>();
 std::thread::spawn(move || loop { match command_receiver.recv() { Ok(Command::Input(input)) => { let response = parse(input); let _ = response_sender.send((input, response)); } Ok(Command::Exit) => break, Err(_) => break, } });
 Self { command_sender, response_receiver, cached_result: HashMap::default(), } }
 pub fn request_parsing(&mut self, input: Input) -> RequestStatus { // pump previously received responses while let Ok((input, response)) = self.response.receiver.try_recv() { self.cached_result .insert(input, RequestStatus::Completed(response)); }
 let response = match self.cached_result.entry(input) { Entry::Vacant(entry) => { self.command_sender .send(Command::Input(entry.key())) .unwrap(); entry.insert(RequestStatus::Running) } Entry::Occupied(entry) => entry.into_mut(), }; response.clone() }}

error[E0277]: `Rc<String>` cannot be sent between threads safely --> src/main.rs:58:32 |58 | std::thread::spawn(move || loop { | _____________------------------_^ | | | | | required by a bound introduced by this call59 | | match command_receiver.recv() {60 | | Ok(Command::Input(input)) => {61 | | let response = maybe_make(input);... |68 | | }69 | | }); | |_____________^ `Rc<String>` cannot be sent between threads safely | = help: within `(&'static str, Result<worker::Output, worker::Error>)`, the trait `Send` is not implemented for `Rc<String>`note: required because it appears within the type `Error` --> src/main.rs:17:16 |17 | pub struct Error { | ^^^^^note: required because it appears within the type `Result<Output, Error>` --> /home/dureuill/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/result.rs:502:10 |502 | pub enum Result<T, E> { | ^^^^^^ = note: required because it appears within the type `(&str, Result<Output, Error>)` = note: required for `Sender<(&'static str, Result<worker::Output, worker::Error>)>` to implement `Send`note: required because it's used within this closure --> src/main.rs:58:32 |58 | std::thread::spawn(move || loop { | ^^^^^^^note: required by a bound in `spawn` --> /home/dureuill/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/thread/mod.rs:683:8 |680 | pub fn spawn<F, T>(f: F) -> JoinHandle<T> | ----- required by a bound in this function...683 | F: Send + 'static, | ^^^^ required by this bound in `spawn`

diff --git a/src/main.rs b/src/main.rsindex 04ec0d0..fd4b447 100644--- a/src/main.rs+++ b/src/main.rs@@ -3,9 +3,9 @@ use std::{io::Write, time::Duration}; mod parse { use std::{ collections::{hash_map::Entry, HashMap},- rc::Rc, sync::{ mpsc::{channel, Receiver, Sender},+ Arc, }, time::Duration, };@@ -15,13 +15,13 @@ mod parse {
 #[derive(Clone, Debug)] pub struct Error {- data: Rc<ExpensiveToCloneDirectly>,+ data: Arc<ExpensiveToCloneDirectly>, }
 impl Error { fn new(data: ExpensiveToCloneDirectly) -> Self { Self {- data: Rc::new(data),+ data: Arc::new(data), } } }