Erase the const generics from the edge-nal-embassy types (#78)

* Make Udp and Tcp Copy; erase all generics by using a dyn trait for buffers alloc; documentation

* Reduce the size of the socket struct

* Document the Dns type; make it Copy

* Update changelog

* Address code review feedback

Author: ivmarkov

edge-nal-embassy/CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+* Erase the const generics from the edge-nal-embassy types #78
+* Make `Tcp`, `Udp` and `Dns` `Copy`
+* Change the TX_SZ and RX_SZ defaults for UDP buffers to 1472 bytes which is a bit smaller yet enough if the overall Ethernet MTU is 1500 bytes (which it typically is; Ethernet MTU might be lower, but is rarely higher)
 ## [0.6.0] - 2025-05-29
 * Optional `defmt` support via two new features (one has to specify one, or the other, or neither, but not both):
   * `log` - uses the `log` crate for all logging

edge-nal-embassy/src/dns.rs

@@ -2,13 +2,16 @@ use core::net::IpAddr;
 
 use edge_nal::AddrType;
 
-use embassy_net::{
-    dns::{DnsQueryType, Error},
-    Stack,
-};
+use embassy_net::dns::{DnsQueryType, Error};
+use embassy_net::Stack;
+
 use embedded_io_async::ErrorKind;
 
-/// A struct that implements the `Dns` trait from `edge-nal`
+/// A type that implements the `Dns` trait from `edge-nal`.
+/// It uses the DNS resolver from the provided Embassy networking stack.
+///
+/// The type is `Copy` and `Clone`, so it can be easily passed around.
+#[derive(Copy, Clone)]
 pub struct Dns<'a> {
     stack: Stack<'a>,
 }
@@ -51,6 +54,7 @@ impl edge_nal::Dns for Dns<'_> {
     }
 }
 
+/// DNS error type
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct DnsError(Error);
@@ -61,7 +65,6 @@ impl From<Error> for DnsError {
     }
 }
 
-// TODO
 impl embedded_io_async::Error for DnsError {
     fn kind(&self) -> ErrorKind {
         ErrorKind::Other

edge-nal-embassy/src/lib.rs

@@ -18,6 +18,8 @@ pub use tcp::*;
 #[cfg(feature = "udp")]
 pub use udp::*;
 
+use crate::sealed::SealedDynPool;
+
 // This mod MUST go first, so that the others see its macros.
 pub(crate) mod fmt;
 
@@ -28,7 +30,49 @@ mod tcp;
 #[cfg(feature = "udp")]
 mod udp;
 
-pub(crate) struct Pool<T, const N: usize> {
+/// A const-generics-erased trait variant of `Pool`
+///
+/// Allows for types like `Tcp`, `TcpSocket`, `Udp` and `UdpSocket` that do reference the
+/// pool to erase the const-generics set on the Pool object type when used for TCP and UDP buffers.
+///
+/// To erase the type of the pool itself, these types use `&dyn DynPool<B>`
+pub trait DynPool<B>: SealedDynPool<B> {}
+
+impl<T, B> DynPool<B> for &T where T: DynPool<B> {}
+
+mod sealed {
+    use core::ptr::NonNull;
+
+    /// The sealed trait variant of `DynPool`.
+    pub trait SealedDynPool<B> {
+        /// Allocate an object from the pool.
+        ///
+        /// Returns `None` if the pool is exhausted.
+        fn alloc(&self) -> Option<B>;
+
+        /// Free an object back to the pool.
+        ///
+        /// # Safety
+        /// - `buffer_token` must be a pointer obtained from `alloc` that hasn't been freed yet.
+        unsafe fn free(&self, buffer_token: NonNull<u8>);
+    }
+
+    impl<T, B> SealedDynPool<B> for &T
+    where
+        T: SealedDynPool<B>,
+    {
+        fn alloc(&self) -> Option<B> {
+            (**self).alloc()
+        }
+
+        unsafe fn free(&self, buffer_token: NonNull<u8>) {
+            (**self).free(buffer_token)
+        }
+    }
+}
+
+/// A simple fixed-size pool allocator for `T`.
+pub struct Pool<T, const N: usize> {
     used: [Cell<bool>; N],
     data: [UnsafeCell<MaybeUninit<T>>; N],
 }
@@ -39,7 +83,8 @@ impl<T, const N: usize> Pool<T, N> {
     #[allow(clippy::declare_interior_mutable_const)]
     const UNINIT: UnsafeCell<MaybeUninit<T>> = UnsafeCell::new(MaybeUninit::uninit());
 
-    const fn new() -> Self {
+    /// Create a new pool.
+    pub const fn new() -> Self {
         Self {
             used: [Self::VALUE; N],
             data: [Self::UNINIT; N],
@@ -48,6 +93,11 @@ impl<T, const N: usize> Pool<T, N> {
 }
 
 impl<T, const N: usize> Pool<T, N> {
+    /// Allocate an object from the pool.
+    ///
+    /// # Returns
+    /// - `Some(NonNull<T>)` if an object was successfully allocated.
+    /// - `None` if the pool is exhausted.
     fn alloc(&self) -> Option<NonNull<T>> {
         for n in 0..N {
             // this can't race because Pool is not Sync.
@@ -60,7 +110,12 @@ impl<T, const N: usize> Pool<T, N> {
         None
     }
 
-    /// safety: p must be a pointer obtained from self.alloc that hasn't been freed yet.
+    /// Free an object back to the pool.
+    ///
+    /// Safety: p must be a pointer obtained from `alloc` that hasn't been freed yet.
+    ///
+    /// # Arguments
+    /// - `p`: A pointer to the object to free.
     unsafe fn free(&self, p: NonNull<T>) {
         let origin = self.data.as_ptr() as *mut T;
         let n = p.as_ptr().offset_from(origin);
@@ -70,17 +125,20 @@ impl<T, const N: usize> Pool<T, N> {
     }
 }
 
+/// Convert an embassy-net `IpEndpoint` to a standard library `SocketAddr`.
 pub(crate) fn to_net_socket(socket: IpEndpoint) -> SocketAddr {
     SocketAddr::new(socket.addr.into(), socket.port)
 }
 
+/// Convert an embassy-net `IpListenEndpoint` to a standard library `SocketAddr`.
 pub(crate) fn to_emb_socket(socket: SocketAddr) -> Option<IpEndpoint> {
     Some(IpEndpoint {
         addr: to_emb_addr(socket.ip())?,
         port: socket.port(),
     })
 }
 
+/// Convert a standard library `SocketAddr` to an embassy-net `IpListenEndpoint`.
 pub(crate) fn to_emb_bind_socket(socket: SocketAddr) -> Option<IpListenEndpoint> {
     let addr = if socket.ip().is_unspecified() {
         None
@@ -94,6 +152,7 @@ pub(crate) fn to_emb_bind_socket(socket: SocketAddr) -> Option<IpListenEndpoint>
     })
 }
 
+/// Convert an embassy-net `IpAddress` to a standard library `IpAddr`.
 pub(crate) fn to_emb_addr(addr: IpAddr) -> Option<IpAddress> {
     match addr {
         #[cfg(feature = "proto-ipv4")]