v0.4.2

[soareschen]

Changelog

• Datatype-generic Programming Support

  • Data-generic programming support in CGP - #112
  • Implement DispatchHandlersRef for dispatching based on enum references - #116
  • Builder dispatcher refactoring - #117
  • Introduce ref version of handler traits - #118
  • Dispatcher Refactoring - #119
  • Remove Input param from MatchWithFieldHandlers - #120
  • Support use of ref handlers in handler macros - #121

• Preset Improvements

  • Add new direct delegation mode and use it in preset inheritance - #111

• Bug Fixes

  • Derive HasField<Index<{i}>> for structs with unnamed fields - #115
  • Allow unsized generic arguments in IsProviderFor trait - #114

---

This discussion was created from the release v0.4.2.

[marvin-hansen]

I think I might have a use case for CGP to explore.

After having read through your blog post about composable constructors and extensible types, i noticed that it may solve a problem I'm grappling when composing isomorphic recursive data structures in my DeepCausality project. When self contained, these are trivial to compose.

However, the problem pops up when bundling multiple context and a model in such a way that it can be composed with another bundle... Basically plug and play model composition from multiple sub models. Right now the preliminary model container does nothing for composition yet.

I think adding a composition layer with CGP on top of it might do the trick while preserving the ability to swap sub models in and out. Especially the
extensible construction seems applicaple as it would allow to streamline the building of complex models with or without context and cover cases where some sub models are needed but other not. This is of particular interest for the upcoming 0.8 release that adds non euclidean geometry that almost certainly will result in multiple isolated sub context per model. At some point encapsulation of a model context into a dedicated module that can be shared across different sub models becomes a real thing and allows for the sharing of reference models and context.

Is there a good starting point other than the blog post to investigate CGP modular composition for this kind of use case?

[soareschen]

Hi Marvin,

Yes, certainly we can probably use the extensible builder problem to solve your problem. In the next blog post, I'll also introduce extensible variants, which can probably be used to handle your recursive data structures.

Since our last conversation, I have also managed to hide the internals such as HasFields with more ergonomic interfaces like #[cgp_auto_getter]. The extensible builder pattern is also based on this, by using mergeable structs to hide the internal implementation.

Is there a good starting point other than the blog post to investigate CGP modular composition for this kind of use case?

Unfortunately there has been less demand for the low level documentation on using CGP, and more demand for showcasing the problems that CGP solve. So I have spent most of my time writing the blog posts, which is more time consuming than coding or writing documentation.

However, I have created a Discord channel for CGP. So you can join there and we can have more interactive and in-depth discussions on how to help solve your problems. I also have more free time recently, so I'm happy to organize some hackathon sessions with you to help you navigate how to use CGP effectively for your project.