Struct of Arrays (SoA) container template for C++20 that uses compile-time reflection to iterate over existing fields and access fields by name. - gilzoide/soa.hpp

Struct of Arrays (SoA) container template for C++20 that uses compile-time reflection to iterate over existing fields and access fields by name. - gilzoide/soa.hpp

Oh, `Thin` works fine for this situation, with some little adjustments struct StructOfArrays<Xs = Thin<[f32]>, Ys = Thin<[f32]>> { xs: Xs, ys: Ys, } In addition, we should add these stuffs related to `ValueSized` (as proposed in the pre-RFC): * `...Ts: ValueSized` implies `X<...Ts>: ValueSized`, where `...Ts: ValueSized` means for each `T` in `Ts`, there is `T: ValueSized` * `...Ts: Sized + Unsize<...Us>, ...Us: ValueSized` implies `X<...Ts>: Unsize<X<...Us>>`, where `...Ts: Unsize<...Us>` means for each (`T`, `U`) in (`...Ts`, `...Us`), there is `T: Unsize<U>`. Then, `StructOfArrays` can be constructed (on stack) in the folllewing steps: // 1. create the sized value with metadata let foo: StructOfArrays< Thin<[f32; 3], [f32]>, Thin<[f32; 3], [f32]>, > = StructOfArrays { xs: Thin::new_unsized([1.0, 2.0, 3.0]), ys: Thin::new_unsizsd([4.0, 5.0, 6.0]), }; // 2. create the reference to the sized value let foo: &StructOfArray< Thin<[f32; 3], [f32]>, Thin<[f32; 3], [f32]>, > = &foo; // 3. coerce to the unsized reference // (given that `Thin<[f32; 3], [f32]>: Unsize<Thin<[f32]>>`) let foo: &StructOfArray = foo;

Oh, `Thin` works fine for this situation, with some little adjustments struct StructOfArrays<Xs = Thin<[f32]>, Ys = Thin<[f32]>> { xs: Xs, ys: Ys, } In addition, we should add these stuffs related to `ValueSized` (as proposed in the pre-RFC): * `...Ts: ValueSized` implies `X<...Ts>: ValueSized`, where `...Ts: ValueSized` means for each `T` in `Ts`, there is `T: ValueSized` * `...Ts: Sized + Unsize<...Us>, ...Us: ValueSized` implies `X<...Ts>: Unsize<X<...Us>>`, where `...Ts: Unsize<...Us>` means for each (`T`, `U`) in (`...Ts`, `...Us`), there is `T: Unsize<U>`. Then, `StructOfArrays` can be constructed (on stack) in the folllewing steps: // 1. create the sized value with metadata let foo: StructOfArrays< Thin<[f32; 3], [f32]>, Thin<[f32; 3], [f32]>, > = StructOfArrays { xs: Thin::new_unsized([1.0, 2.0, 3.0]), ys: Thin::new_unsizsd([4.0, 5.0, 6.0]), }; // 2. create the reference to the sized value let foo: &StructOfArray< Thin<[f32; 3], [f32]>, Thin<[f32; 3], [f32]>, > = &foo; // 3. coerce to the unsized reference // (given that `Thin<[f32; 3], [f32]>: Unsize<Thin<[f32]>>`) let foo: &StructOfArray = foo;

Oh, `Thin` works fine for this situation, with some little adjustments struct StructOfArrays<Xs = Thin<[f32]>, Ys = Thin<[f32]>> { xs: Xs, ys: Ys, } In addition, we should add these stuffs related to `ValueSized` (as proposed in the pre-RFC): * `...Ts: ValueSized` implies `X<...Ts>: ValueSized`, where `...Ts: ValueSized` means for each `T` in `Ts`, there is `T: ValueSized` * `...Ts: Sized + Unsize<...Us>, ...Us: ValueSized` implies `X<...Ts>: Unsize<X<...Us>>`, where `...Ts: Unsize<...Us>` means for each (`T`, `U`) in (`...Ts`, `...Us`), there is `T: Unsize<U>`. Then, `StructOfArrays` can be constructed (on stack) in the folllewing steps: // 1. create the sized value with metadata let foo: StructOfArrays< Thin<[f32; 3], [f32]>, Thin<[f32; 3], [f32]>, > = StructOfArrays { xs: Thin::new_unsized([1.0, 2.0, 3.0]), ys: Thin::new_unsizsd([4.0, 5.0, 6.0]), }; // 2. create the reference to the sized value let foo: &StructOfArray< Thin<[f32; 3], [f32]>, Thin<[f32; 3], [f32]>, > = &foo; // 3. coerce to the unsized reference // (given that `Thin<[f32; 3], [f32]>: Unsize<Thin<[f32]>>`) let foo: &StructOfArray = foo;

Wouldn't it be neat to be able to do struct StructOfArrays { xs: [f32], ys: [f32] } ? That is, allow a struct to contain any number of DST fields so long as they are at the end of the definition. In this case, the lengths of both fields comprise the metadata of the pointer in the form of `(usize, usize)`. The offset of the second slice may be calculated at runtime using the length of the first and the elements' alignment. Another desirable feature is slices of DSTs. For this to work, all elements should possess the same metadata. For example, one could coerce a `&[Foo] where Foo: Trait` to a `&[dyn Trait]`. This way, instead of storing many `Box<dyn Trait>` pointing to the same type, one could allocate a bunch and coerce the whole slice to one of trait objects. Another usage would be to create nested slices (aka tensors). A matrix, for instance, would be `[[T]]` where the lengths of the 'rows' are all the same and are contained in the metadata of the pointer - `(nrows: usize, row_len: usize)`. In general, the metadata of a pointer to a slice of DSTs `[T] where T: ?Sized` is `(usize, <T as Pointee>::Metadata)`. For regular slices it's `(usize, ())` which has the same represantation as `usize`

Wouldn't it be neat to be able to do struct StructOfArrays { xs: [f32], ys: [f32] } ? That is, allow a struct to contain any number of DST fields so long as they are at the end of the definition. In this case, the lengths of both fields comprise the metadata of the pointer in the form of `(usize, usize)`. The offset of the second slice may be calculated at runtime using the length of the first and the elements' alignment. Another desirable feature is slices of DSTs. For this to work, all elements should possess the same metadata. For example, one could coerce a `&[Foo] where Foo: Trait` to a `&[dyn Trait]`. This way, instead of storing many `Box<dyn Trait>` pointing to the same type, one could allocate a bunch and coerce the whole slice to one of trait objects. Another usage would be to create nested slices (aka tensors). A matrix, for instance, would be `[[T]]` where the lengths of the 'rows' are all the same and are contained in the metadata of the pointer - `(nrows: usize, row_len: usize)`. In general, the metadata of a pointer to a slice of DSTs `[T] where T: ?Sized` is `(usize, <T as Pointee>::Metadata)`. For regular slices it's `(usize, ())` which has the same represantation as `usize`

Wouldn't it be neat to be able to do struct StructOfArrays { xs: [f32], ys: [f32] } ? That is, allow a struct to contain any number of DST fields so long as they are at the end of the definition. In this case, the lengths of both fields comprise the metadata of the pointer in the form of `(usize, usize)`. The offset of the second slice may be calculated at runtime using the length of the first and the elements' alignment. Another desirable feature is slices of DSTs. For this to work, all elements should possess the same metadata. For example, one could coerce a `&[Foo] where Foo: Trait` to a `&[dyn Trait]`. This way, instead of storing many `Box<dyn Trait>` pointing to the same type, one could allocate a bunch and coerce the whole slice to one of trait objects. Another usage would be to create nested slices (aka tensors). A matrix, for instance, would be `[[T]]` where the lengths of the 'rows' are all the same and are contained in the metadata of the pointer - `(nrows: usize, row_len: usize)`. In general, the metadata of a pointer to a slice of DSTs `[T] where T: ?Sized` is `(usize, <T as Pointee>::Metadata)`. For regular slices it's `(usize, ())` which has the same represantation as `usize`