glaze VS AnyAny

Previously in the Glaze library, you would need to write out your key names along with the member object pointers. However, as of version 1.8.0, these key names are now optional. If the keys are not provided the member variable name will be reflected for serialization/deserialization. I'm even more excited about this reflection than the previously announced pure Clang reflection, because it works well with user customization and supports non-aggregate, non-default constructible, and non-constexpr types.

BEVE fully supports JSON messages. The Glaze C++ JSON library allows users to use the same API to encode/decode to either JSON or EVE binary. Glaze also encodes/decodes directly into your C++ structures and standard library containers, making it easy to use without additional copies.

I would either look at https://github.com/eyalz800/zpp_bits or https://github.com/stephenberry/glaze. FYI, glaze both supports json and binary.

Glaze is a software that uses artificial intelligence to create realistic images from text descriptions. It is based on Stable Diffusion, an open source framework for image synthesis using diffusion models. Glaze claims to offer enhanced model training with minimal style interference by using a technique called ControlNet1.

I ended up adopting this approach in some test code https://godbolt.org/z/GKW8Preva when I was thinking about adding automatic enum serialization/deserialization to stephenberry/glaze. But there are too many limitations.

Alternatively, use a preexisting library for binary serialization and deserialization. If you’re trying to serialize your own stuff, glaze is a good option since it supports both json and binary serialization/deserialization. https://github.com/stephenberry/glaze

This parse file has some of the chunk simd processing: https://github.com/stephenberry/glaze/blob/main/include/glaze/util/parse.hpp

https://github.com/kelbon/AnyAny trait(add, void(int), self.add(args...));

i dont know what he means, but with this type erasure library you can have non virtual interface and still use dynamic polymorphism with those types, so you dont need choose *do i need to do this type polymorphic* etc

There are also invoking from tuple and curring (just an example of technique)https://github.com/kelbon/AnyAny/blob/main/examples/functional_paradigm.hpp

As for my example containers: https://github.com/kelbon/AnyAny/blob/main/include/data_parallel_vector.hpp

variant_swarm - container which behaves as set of std::variant, but with much faster visit operation and operation for getting view to all values of type T. It short, it just stores all types separatelly and supports operations visit, view, also you can change underlying containers for Ts..., it is std::vector by default https://github.com/kelbon/AnyAny/blob/main/include/variant_swarm.hpp

Its part of my library for working with polymorphic types.

Good idea selling Rust from behind enemy lines soldier! My god, your readme doesn't even mention Rust, wonderful!

https://github.com/kelbon/AnyAny here you can see how it implemented, for example