#USB_port
LightNews LightNews
DWVO 55" Convertible Sofa Bed 3-in-1 Sleeper Sofa with Pull-Out Couch Velvet Futon Couch with Adjustable Backrest and USB Modern Loveseat for Living Room Apartment Light Beige #living_room #sofa_bed #convertible_sofa #USB_port
DWVO 55" Convertible Sofa Bed 3-in-1 Sleeper Sofa with Pull-Out Couch Velvet Futon Couch with Adjustable Backrest and USB Modern Loveseat for Living Room Apartment Light Beige
www.amazon.com
November 7, 2026 at 11:55 AM
jamesmunns.com
Following up with another "intrusively stored collections" type, this is `PinList`, which I think is going to be more directly useful.

I plan to use this (or more likely, a tree-based `PinMap<K, V>` type) to store things like "network interfaces" and "open sockets" for a no-std network stack.
A block diagram showing a central `PinList` block, attached to three `PinListNode` blocks, each intrusively stored in a task. There are two comment blocks, one above that says: Tasks can pin data in a `PinListNode<T>`, then add themselves to the `static` `PinList<T>`. When the Node is dropped, the item is removed from the linked list. Tasks still need to lock the Mutex to access the T they are storing. This is similar to a normal `List<T>`, but with an extra "no item anchor point" you can stick in a global static for access. Unlike `List<T>`, `PinList<T>` does not OWN the items in the list, instead the `PinList` has the moral equivalent of `Vec<&mut T>`, where the lifetime of the items are temporary, and can only be accessed while the mutex is locked. The other comment block below says: Consumers can access the list via the `PinList<T>` anchor, and new `PinListNode<T>`s can also be added through the anchor. Consumers use a closure-based API like `find` or `find_mut` that both finds the list item they want, and does something with the found `T`. This closure handles the iteration while the mutex is locked. `PinList<T>` doesn't HAVE to be `static`, but practically that is when it is most useful for no-std usage. It must be pinned. It could also be in an Arc for `std`/`alloc` usage. I may also want to make a `PinMap<K, V>`, and use something like cordyceps-wavl to store nodes in a tree instead of a, allowing for faster lookup using a key. This will be useful when looking up interfaces by IP addr, or sockets by addr:port-like info. A screenshot of the following Rust code snippet: static INTERFACES: PinList<ThreadModeRawMutex, Interface> = PinList::empty(); #[task] async fn usb_port(...) { // `local` is what we can use here, `interface` is the "remote" side let (local, interface) = make_interface(...); let pinterface = PinListNode::new(interface); let mut pinterface = pin!(pinterface); INTERFACES.push(pinterface); loop { let msg = local.do_something().await; // ... if ... { break; } } // at end of scope, the `PinListNode` is destroyed, and it is removed from the list } #[task] async fn dispatch(...) { loop { let msg = recv_and_decode(...).await; let res = INTERFACES.find_with(|intfc| { if intfc.addr() != msg.addr { return None; } // ... Some(result) }); if res.is_some() { /* worked! */ } else { /* no interface found! */ nak().await; } } }
May 2, 2025 at 8:42 AM