Question: Best approach for polymorphic members

[cobalthex]

This isn't an issue but a question:

I have a struct something like

#[derive(Encode, Decode)]
struct Foo
{
   .. members
  blah: Box<[Box<dyn T>]>,
}

my current approach is to have a 'serializing' version of this struct like:

struct DynType { type_id: u64, size: u64 }
struct FooFile
{
  .. members
  blah: &[DynType],
  blah_data: &[u8],
}

where blah's values are stored in blah_data and as bitcode-encoded values linearly written into a byte buf

Is this a reasonable approach? Is there a more efficient approach?

[finnbear]

Hi,

If you can implement:

fn decode_dyn(t: DynType, data: &[u8]) -> Box<dyn Trait> { ... }

Then presumably that function will contain a mapping of all type_id to T: Trait. In this case, you can use an enum with a variant per T. On the serializer side, you could use std::any::Any::downcast_ref to create an instance of that enum. This would be natively supported by bitcode (although, if you plan to add variants without changing the protocol, add several placeholder variants at the end and replace them sequentially. This is to compensate for bitcode's use of fewer bits for enums with fewer variants).

If you can't implement decode_dyn, I'm not sure how your code will work but I don't see a better way.

[cobalthex]

Are you saying to make something like enum AllImplsOfT { A(A), B(B), ... } where A and B impl T?

[finnbear]

Yes and, if you can't do that, I need to understand why not and how your proposed code would work :)

[cobalthex]

Unfortunately it's not practical to do that.
Not knowing the specifics of how the encoding works, am I losing out much on much compression/efficiency vs an enum/known types approach?

[caibear]

Pre-encoding each Box<dyn T> to [u8] with bitcode and then encoding them again can reduce how well compression algorithms work on the result. You would have to benchmark with your own data to get reliable results, but in general this approach would be inefficient in size/compression for many small objects (somewhere between bitcode's efficiency and other serializers, e.g. bincode) and almost as efficient for few large objects.