allow typed blocks in flowgraph api

benches/apply.rs

@@ -19,7 +19,7 @@ pub fn apply(c: &mut Criterion) {
 
     group.bench_function(format!("mock-u32-plus-1-{n_samp}"), |b| {
         b.iter(|| {
-            let block = Apply::new_typed(|x: &u32| x + 1);
+            let block = Apply::new(|x: &u32| x + 1);
 
             let mut mocker = Mocker::new(block);
             mocker.input(0, input.clone());

crates/macros/src/lib.rs

@@ -165,6 +165,8 @@ pub fn connect(attr: proc_macro::TokenStream) -> proc_macro::TokenStream {
         use futuresdr::runtime::Block;
         use futuresdr::runtime::Error;
         use futuresdr::runtime::Flowgraph;
+        use futuresdr::runtime::Kernel;
+        use futuresdr::runtime::TypedBlock;
         use std::result::Result;
 
         struct FgOp;
@@ -181,6 +183,11 @@ pub fn connect(attr: proc_macro::TokenStream) -> proc_macro::TokenStream {
                 fg.add_block(b)
             }
         }
+        impl<T: Kernel + 'static> Add<TypedBlock<T>> for FgOp {
+            fn add(fg: &mut Flowgraph, b: TypedBlock<T>) -> Result<usize, Error> {
+                fg.add_block(b)
+            }
+        }
     });
 
     // Add the blocks to the flowgraph

examples/egui/src/lib.rs

@@ -10,5 +10,5 @@ use futuresdr::num_complex::Complex32;
 use futuresdr::runtime::Block;
 
 pub fn power_block() -> Block {
-    Apply::new(|x: &Complex32| x.norm_sqr())
+    Apply::new(|x: &Complex32| x.norm_sqr()).into()
 }

examples/m17/src/moving_average.rs

@@ -19,11 +19,7 @@ pub struct MovingAverage {
 }
 
 impl MovingAverage {
-    pub fn new(len: usize) -> Block {
-        Block::from_typed(Self::new_typed(len))
-    }
-
-    pub fn new_typed(len: usize) -> TypedBlock<Self> {
+    pub fn new(len: usize) -> TypedBlock<Self> {
         assert!(len > 0);
         TypedBlock::new(
             BlockMetaBuilder::new("MovingAverage").build(),

examples/mock.rs

@@ -9,7 +9,7 @@ fn main() {
         .take(64)
         .collect();
 
-    let block = Apply::new_typed(|x: &u32| x + 1);
+    let block = Apply::new(|x: &u32| x + 1);
 
     let mut mocker = Mocker::new(block);
     mocker.input(0, input.clone());

examples/spectrum/src/lib.rs

@@ -11,13 +11,13 @@ use futuresdr::num_complex::Complex32;
 use futuresdr::runtime::Block;
 
 pub fn lin2db_block() -> Block {
-    Apply::new(|x: &f32| 10.0 * x.log10())
+    Apply::new(|x: &f32| 10.0 * x.log10()).into()
 }
 
 pub fn power_block() -> Block {
-    Apply::new(|x: &Complex32| x.norm_sqr())
+    Apply::new(|x: &Complex32| x.norm_sqr()).into()
 }
 
 pub fn lin2power_db() -> Block {
-    Apply::new(|x: &Complex32| 10.0 * x.norm_sqr().log10())
+    Apply::new(|x: &Complex32| 10.0 * x.norm_sqr().log10()).into()
 }

examples/wlan/src/moving_average.rs

@@ -45,11 +45,7 @@ pub struct MovingAverage<T: MovingAverageType + Send + 'static> {
 }
 
 impl<T: MovingAverageType + Send + 'static> MovingAverage<T> {
-    pub fn new(len: usize) -> Block {
-        Block::from_typed(Self::new_typed(len))
-    }
-
-    pub fn new_typed(len: usize) -> TypedBlock<Self> {
+    pub fn new(len: usize) -> TypedBlock<Self> {
         assert!(len > 0);
         TypedBlock::new(
             BlockMetaBuilder::new("MovingAverage").build(),

src/blocks/apply.rs

@@ -1,5 +1,4 @@
 use crate::anyhow::Result;
-use crate::runtime::Block;
 use crate::runtime::BlockMeta;
 use crate::runtime::BlockMetaBuilder;
 use crate::runtime::Kernel;
@@ -68,15 +67,7 @@ where
     ///
     /// ## Parameter
     /// - `f`: Function to apply on each sample
-    pub fn new(f: F) -> Block {
-        Block::from_typed(Self::new_typed(f))
-    }
-
-    /// Create typed [`Apply`] block
-    ///
-    /// ## Parameter
-    /// - `f`: Function to apply on each sample
-    pub fn new_typed(f: F) -> TypedBlock<Self> {
+    pub fn new(f: F) -> TypedBlock<Self> {
         TypedBlock::new(
             BlockMetaBuilder::new("Apply").build(),
             StreamIoBuilder::new()

src/blocks/combine.rs

@@ -24,13 +24,10 @@ use crate::runtime::WorkIo;
 /// # Usage
 /// ```
 /// use futuresdr::blocks::Combine;
-/// use futuresdr::runtime::Flowgraph;
 ///
-/// let mut fg = Flowgraph::new();
-///
-/// let adder = fg.add_block(Combine::new(|a: &f32, b: &f32| {
+/// let adder = Combine::new(|a: &f32, b: &f32| {
 ///     a + b
-/// }))?;
+/// });
 /// ```
 #[allow(clippy::type_complexity)]
 pub struct Combine<F, A, B, C>

src/blocks/message_copy.rs

@@ -1,4 +1,3 @@
-use crate::runtime::Block;
 use crate::runtime::BlockMeta;
 use crate::runtime::BlockMetaBuilder;
 use crate::runtime::Kernel;
@@ -14,12 +13,7 @@ pub struct MessageCopy {}
 
 impl MessageCopy {
     /// Create MessageCopy block
-    pub fn new() -> Block {
-        Self::new_typed().into()
-    }
-
-    /// Create MessageCopy block
-    pub fn new_typed() -> TypedBlock<Self> {
+    pub fn new() -> TypedBlock<Self> {
         TypedBlock::new(
             BlockMetaBuilder::new("MessageCopy").build(),
             StreamIoBuilder::new().build(),

src/blocks/moving_avg.rs

@@ -1,5 +1,4 @@
 use crate::anyhow::Result;
-use crate::runtime::Block;
 use crate::runtime::BlockMeta;
 use crate::runtime::BlockMetaBuilder;
 use crate::runtime::Kernel;
@@ -25,22 +24,7 @@ pub struct MovingAvg<const WIDTH: usize> {
 }
 
 impl<const WIDTH: usize> MovingAvg<WIDTH> {
-    /// Instantiate moving average as a [`Block`].
-    ///
-    /// # Arguments
-    ///
-    /// * `decay_factor`: amount current value should contribute to the rolling average.
-    ///    Must be in `[0.0, 1.0]`.
-    /// * `history_size`: number of chunks to average over
-    ///
-    /// Typical parameter values might be `decay_factor=0.1` and `history_size=3`
-    /// # Panics
-    /// Function will panic if `decay_factor` is not in `[0.0, 1.0]`
-    pub fn new(decay_factor: f32, history_size: usize) -> Block {
-        Block::from_typed(Self::new_typed(decay_factor, history_size))
-    }
-
-    /// Instantiate moving average as a [`TypedBlock`].
+    /// Instantiate moving average.
     ///
     /// # Arguments
     ///
@@ -52,7 +36,7 @@ impl<const WIDTH: usize> MovingAvg<WIDTH> {
     ///
     /// # Panics
     /// Function will panic if `decay_factor` is not in `[0.0, 1.0]`
-    pub fn new_typed(decay_factor: f32, history_size: usize) -> TypedBlock<Self> {
+    pub fn new(decay_factor: f32, history_size: usize) -> TypedBlock<Self> {
         assert!(
             (0.0..=1.0).contains(&decay_factor),
             "decay_factor must be in [0, 1]"

src/blocks/seify/builder.rs

@@ -115,7 +115,7 @@ impl<D: DeviceTrait + Clone> Builder<D> {
         match (self.dev.take(), self.builder_type) {
             (Some(dev), BuilderType::Source) => {
                 self.config.apply(&dev, &self.channels, Direction::Rx)?;
-                Ok(Source::new_typed(dev, self.channels, self.start_time))
+                Ok(Source::new(dev, self.channels, self.start_time))
             }
             _ => Err(Error::InvalidParameter),
         }
@@ -125,7 +125,7 @@ impl<D: DeviceTrait + Clone> Builder<D> {
         match (self.dev.take(), self.builder_type) {
             (Some(dev), BuilderType::Sink) => {
                 self.config.apply(&dev, &self.channels, Direction::Tx)?;
-                Ok(Sink::new_typed(dev, self.channels, self.start_time))
+                Ok(Sink::new(dev, self.channels, self.start_time))
             }
             _ => Err(Error::InvalidParameter),
         }
@@ -136,23 +136,23 @@ impl<D: DeviceTrait + Clone> Builder<D> {
             Some(dev) => match self.builder_type {
                 BuilderType::Sink => {
                     self.config.apply(&dev, &self.channels, Direction::Tx)?;
-                    Ok(Sink::new(dev, self.channels, self.start_time))
+                    Ok(Sink::new(dev, self.channels, self.start_time).into())
                 }
                 BuilderType::Source => {
                     self.config.apply(&dev, &self.channels, Direction::Rx)?;
-                    Ok(Source::new(dev, self.channels, self.start_time))
+                    Ok(Source::new(dev, self.channels, self.start_time).into())
                 }
             },
             None => {
                 let dev = Device::from_args(&self.args)?;
                 match self.builder_type {
                     BuilderType::Sink => {
                         self.config.apply(&dev, &self.channels, Direction::Tx)?;
-                        Ok(Sink::new(dev, self.channels, self.start_time))
+                        Ok(Sink::new(dev, self.channels, self.start_time).into())
                     }
                     BuilderType::Source => {
                         self.config.apply(&dev, &self.channels, Direction::Rx)?;
-                        Ok(Source::new(dev, self.channels, self.start_time))
+                        Ok(Source::new(dev, self.channels, self.start_time).into())
                     }
                 }
             }

src/blocks/seify/sink.rs

@@ -10,7 +10,6 @@ use crate::anyhow::Result;
 use crate::blocks::seify::Builder;
 use crate::blocks::seify::Config;
 use crate::num_complex::Complex32;
-use crate::runtime::Block;
 use crate::runtime::BlockMeta;
 use crate::runtime::BlockMetaBuilder;
 use crate::runtime::ItemTag;
@@ -50,11 +49,7 @@ pub struct Sink<D: DeviceTrait + Clone> {
 }
 
 impl<D: DeviceTrait + Clone> Sink<D> {
-    pub(super) fn new(dev: Device<D>, channels: Vec<usize>, start_time: Option<i64>) -> Block {
-        Self::new_typed(dev, channels, start_time).into()
-    }
-
-    pub(super) fn new_typed(
+    pub(super) fn new(
         dev: Device<D>,
         channels: Vec<usize>,
         start_time: Option<i64>,

src/blocks/seify/source.rs

@@ -11,7 +11,6 @@ use crate::blocks::seify::builder::BuilderType;
 use crate::blocks::seify::Builder;
 use crate::blocks::seify::Config;
 use crate::num_complex::Complex32;
-use crate::runtime::Block;
 use crate::runtime::BlockMeta;
 use crate::runtime::BlockMetaBuilder;
 use crate::runtime::Kernel;
@@ -47,11 +46,7 @@ pub struct Source<D: DeviceTrait + Clone> {
 }
 
 impl<D: DeviceTrait + Clone> Source<D> {
-    pub(super) fn new(dev: Device<D>, channels: Vec<usize>, start_time: Option<i64>) -> Block {
-        Self::new_typed(dev, channels, start_time).into()
-    }
-
-    pub(super) fn new_typed(
+    pub(super) fn new(
         dev: Device<D>,
         channels: Vec<usize>,
         start_time: Option<i64>,

src/runtime/flowgraph.rs

@@ -39,8 +39,8 @@ impl Flowgraph {
     }
 
     /// Add [`Block`] to flowgraph
-    pub fn add_block(&mut self, block: Block) -> Result<usize, Error> {
-        self.topology.as_mut().unwrap().add_block(block)
+    pub fn add_block(&mut self, block: impl Into<Block>) -> Result<usize, Error> {
+        self.topology.as_mut().unwrap().add_block(block.into())
     }
 
     /// Make stream connection

src/runtime/topology.rs

@@ -1,5 +1,11 @@
 use futures::channel::mpsc::Sender;
+use slab::Slab;
+use std::any::Any;
+use std::any::TypeId;
 use std::collections::HashMap;
+use std::fmt::Debug;
+use std::hash::Hash;
+use std::hash::Hasher;
 
 use crate::runtime::buffer::BufferBuilder;
 use crate::runtime::buffer::BufferWriter;
@@ -8,12 +14,6 @@ use crate::runtime::BlockMessage;
 use crate::runtime::ConnectCtx;
 use crate::runtime::Error;
 use crate::runtime::PortId;
-use slab::Slab;
-use std::any::Any;
-use std::any::TypeId;
-use std::fmt::Debug;
-use std::hash::Hash;
-use std::hash::Hasher;
 
 pub trait BufferBuilderKey: Debug + Send + Sync {
     fn eq(&self, other: &dyn BufferBuilderKey) -> bool;

tests/mocker.rs

@@ -16,7 +16,7 @@ fn multi_input_mock() {
         .take(128)
         .collect();
 
-    let block = Apply::new_typed(|x: &u32| x + 1);
+    let block = Apply::new(|x: &u32| x + 1);
 
     let mut mocker = Mocker::new(block);
     mocker.input(0, input[..64].to_vec());
@@ -34,7 +34,7 @@ fn multi_input_mock() {
 
 #[test]
 fn tags_through_mock() -> Result<()> {
-    let mut noop = Apply::<_, f32, f32>::new_typed(|x| *x);
+    let mut noop = Apply::<_, f32, f32>::new(|x| *x);
     noop.sio.set_tag_propagation(Box::new(copy_tag_propagation));
 
     let mut mock = Mocker::new(noop);
@@ -91,7 +91,7 @@ fn tags_through_mock() -> Result<()> {
 
 #[test]
 fn mock_pmts() -> Result<()> {
-    let copy = MessageCopy::new_typed();
+    let copy = MessageCopy::new();
 
     let mut mock = Mocker::new(copy);
     mock.init();

tests/moving_avg.rs

@@ -3,7 +3,7 @@ use futuresdr::runtime::Mocker;
 
 #[test]
 fn moving_avg_correct_output() {
-    let block = MovingAvg::<3>::new_typed(0.1, 3);
+    let block = MovingAvg::<3>::new(0.1, 3);
     let mut mocker = Mocker::new(block);
 
     mocker.input::<f32>(0, vec![1.0, 2.0, 3.0, 1.0, 2.0, 3.0, 1.0, 2.0, 3.0]);
@@ -15,7 +15,7 @@ fn moving_avg_correct_output() {
 
 #[test]
 fn moving_avg_handles_non_finite_values() {
-    let block = MovingAvg::<3>::new_typed(0.1, 3);
+    let block = MovingAvg::<3>::new(0.1, 3);
     let mut mocker = Mocker::new(block);
     mocker.input::<f32>(
         0,