Support externally provided storage for `Channel`

[sandersaares]

This is one of my favorite crates but one tiny thing is nagging at me - that heap allocation for Channel! I would like to manage the allocation of the Channel myself and just call something like unsafe fn channel_with_external_storage<T>(channel_ptr: NonNull<Channel<T>>, drop_channel: fn(NonNull<Channel<T>>)) -> (Sender<T>, Receiver<T>) which would let me manage the memory and control what happens on drop.

The goal is to ultimately enable allocation-free scenarios by reusing Channel and/or embedding it inside other objects.

Does this sound feasible? I suppose this would need to be some pub struct ExternalChannel<T> { real_channel: Channel<T> } to hide any details of the channel object and just let the caller provide storage for it.

WDYT? I can try come up with a pull request at some point if it sounds like a feature that would be a good fit for this crate.

[sandersaares]

Created #67 with initial draft implementation.

[faern]

I really like the idea of being able to provide the storage for the channel externally! To reuse an existing allocation, or being able to run it without the heap etc. However, I do not really fancy the very raw, unsafe C-esque pointer way of solving it. I'm not sure I want this unless we can express it in a more type safe and elegant API.

I'm thinking about something like this constructor maybe:

/// Creates a new channel, backed by the memory passed in by the caller
pub fn channel_with_storage<T>(storage: &mut MaybeUninit<Channel<T>>) -> (Sender<T>, Receiver<T>) {

I have not really tried this at all. But I hope this can be massaged into working. One problem is around reusing the same memory over and over. To be expressable as safe Rust and checked at compile time, the type system would somehow need to capture when the channel is no longer used, to allow the caller to reclaim their MaybeUninit<Channel<T>> for reuse. Or the channels state could be checked at runtime to check if the memory is free to re-use, but that would cost runtime checks, which is unfortunate.

Either way, the drop impl of the Sender/Receiver would need to be aware of if it owns or borrows the memory, to know if it should free the Box or not.

[sandersaares]

Oh, time flies! I ended up reinventing some oneshot wheels here and created events_once using it as inspiration. I implemented the external storage as an unsafe Event::placed() method, hiding the MaybeUninit inside a EmbeddedEvent struct. Maybe something valuable to use as reference here if you want this in oneshot.

The lifetime considerations did not feel very tractable with safe Rust, though - being safe about lifetime of the storage would require introducing a lifetime parameter to the sender/receiver, which would just be nasty. So I just gave up on that bit and stamped it with unsafe.