Implement basic combinators map, filter and filter_map for irpc channels. (#68)

I find these useful quite a few times. They already exist on Sink and
Stream of course, but often you don't want to convert your senders and
receivers into Sink / Stream and lose the extra fns. Also Sink API is
just weird!

In the fns that filter (with_filter, with_filter_map, filter,
filter_map) the item is just dropped if it does not match the filter. I
think for these channels this is uncontroversial, besides SinkExt does
the same. It does not produce an error if you use e.g.
[with_flat_map](https://docs.rs/futures/latest/futures/sink/trait.SinkExt.html#method.with_flat_map)
to map to an empty stream.

An additional change is that the bounds for
crate::channel::mpsc::Sender/Receiver are reduced so you can now use a
crate::channel::mpsc::Sender/Receiver as the channel to an actor even
for messages that are not serializable.

Author: rklaehn

examples/compute.rs

@@ -55,12 +55,12 @@ struct Multiply {
 
 // The actor that processes requests
 struct ComputeActor {
-    recv: tokio::sync::mpsc::Receiver<ComputeMessage>,
+    recv: irpc::channel::mpsc::Receiver<ComputeMessage>,
 }
 
 impl ComputeActor {
     pub fn local() -> ComputeApi {
-        let (tx, rx) = tokio::sync::mpsc::channel(128);
+        let (tx, rx) = irpc::channel::mpsc::channel(128);
         let actor = Self { recv: rx };
         n0_future::task::spawn(actor.run());
         ComputeApi {
@@ -69,7 +69,7 @@ impl ComputeActor {
     }
 
     async fn run(mut self) {
-        while let Some(msg) = self.recv.recv().await {
+        while let Ok(Some(msg)) = self.recv.recv().await {
             n0_future::task::spawn(async move {
                 if let Err(cause) = Self::handle(msg).await {
                     eprintln!("Error: {cause}");