chore: reset working tree (v0.5)

Temporary commit clearing working tree for v0.6 rebuild

src/channel.rs

@@ -1,143 +0,0 @@
-//! Unbounded MPSC channels.
-//!
-//! Inner state is `Arc<Mutex<Inner<T>>>` so channels can be sent across OS
-//! threads (required for the multi-scheduler runtime where a sender and
-//! receiver may run on different scheduler threads simultaneously).
-//!
-//! Semantics:
-//!   - Senders are clonable; the last sender drop closes the channel.
-//!   - `Receiver::recv` on an empty open channel parks the receiver.
-//!   - `Receiver::recv` on an empty closed channel returns `Err(RecvError)`.
-//!   - `Sender::send` on an open channel always succeeds.
-//!   - `Sender::send` on a closed channel (receiver dropped) returns
-//!     `Err(SendError(value))`.
-//!   - When a send pushes to a previously empty queue and a receiver is
-//!     parked, the receiver is unparked.
-
-use crate::pid::Pid;
-use std::collections::VecDeque;
-use std::sync::{Arc, Mutex};
-
-pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
-    let inner = Arc::new(Mutex::new(Inner {
-        queue: VecDeque::new(),
-        parked_receiver: None,
-        senders: 1,
-        receiver_alive: true,
-    }));
-    (Sender { inner: inner.clone() }, Receiver { inner })
-}
-
-struct Inner<T> {
-    queue: VecDeque<T>,
-    parked_receiver: Option<Pid>,
-    senders: usize,
-    receiver_alive: bool,
-}
-
-pub struct Sender<T> {
-    inner: Arc<Mutex<Inner<T>>>,
-}
-
-pub struct Receiver<T> {
-    inner: Arc<Mutex<Inner<T>>>,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct SendError<T>(pub T);
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub struct RecvError;
-
-impl std::fmt::Display for RecvError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "channel closed")
-    }
-}
-
-impl std::error::Error for RecvError {}
-
-impl<T> Clone for Sender<T> {
-    fn clone(&self) -> Self {
-        self.inner.lock().unwrap().senders += 1;
-        Sender { inner: self.inner.clone() }
-    }
-}
-
-impl<T> Drop for Sender<T> {
-    fn drop(&mut self) {
-        let unpark = {
-            let mut g = self.inner.lock().unwrap();
-            g.senders -= 1;
-            if g.senders == 0 && g.queue.is_empty() {
-                g.parked_receiver.take()
-            } else {
-                None
-            }
-        };
-        if let Some(pid) = unpark {
-            crate::scheduler::unpark(pid);
-        }
-    }
-}
-
-impl<T> Drop for Receiver<T> {
-    fn drop(&mut self) {
-        self.inner.lock().unwrap().receiver_alive = false;
-    }
-}
-
-impl<T> Sender<T> {
-    pub fn send(&self, value: T) -> Result<(), SendError<T>> {
-        let unpark = {
-            let mut g = self.inner.lock().unwrap();
-            if !g.receiver_alive {
-                return Err(SendError(value));
-            }
-            g.queue.push_back(value);
-            g.parked_receiver.take()
-        };
-        if let Some(pid) = unpark {
-            crate::scheduler::unpark(pid);
-        }
-        Ok(())
-    }
-}
-
-impl<T> Receiver<T> {
-    pub fn recv(&self) -> Result<T, RecvError> {
-        loop {
-            {
-                let mut g = self.inner.lock().unwrap();
-                if let Some(v) = g.queue.pop_front() {
-                    return Ok(v);
-                }
-                if g.senders == 0 {
-                    return Err(RecvError);
-                }
-                let me = crate::actor::current_pid()
-                    .expect("recv() called outside an actor");
-                debug_assert!(
-                    g.parked_receiver.is_none(),
-                    "channel has more than one receiver"
-                );
-                g.parked_receiver = Some(me);
-            }
-            // Release the lock before parking — the unparker will need it.
-            crate::scheduler::park_current();
-        }
-    }
-
-    /// Non-blocking. `Ok(Some(v))` if a message was available, `Ok(None)` if
-    /// the channel is empty but open, `Err(RecvError)` if closed and drained.
-    pub fn try_recv(&self) -> Result<Option<T>, RecvError> {
-        let mut g = self.inner.lock().unwrap();
-        if let Some(v) = g.queue.pop_front() {
-            return Ok(Some(v));
-        }
-        if g.senders == 0 {
-            return Err(RecvError);
-        }
-        Ok(None)
-    }
-}