Welcome to context-generic-programming-patterns Discussions!

[soareschen]

👋 Welcome!

We’re using Discussions as a place to connect with other members of our community. We hope that you:

• Ask questions you’re wondering about.
• Share ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

To get started, comment below with an introduction of yourself and tell us about what you do with this community.

[thaodt]

thank for writing this @soareschen

[marvin-hansen]

Thank you for taking the time to write the book, @soareschen

For the open issue around errors, it seems getting a patch into the Rust compiler is going to take some meaningful time. As a stopgap, have you considered generating CheckTraits with a macro?

Maybe something like:

#[derive(check)]
.....

This is just one idea, any other idea is as valid. Point is, if you want to move forward and encourage adoption, a simpler workaround would do the trick.

[soareschen]

Hi @marvin-hansen, thanks for your feedback! Yes, I have considered about auto deriving the check traits before. However, there are issues with that approach when the consumer traits contain generic parameters. It is a more advanced feature that I have not yet covered in the book, but a short example would be a string formatter that is parameterized by an encoding generic parameter such as follows:

#[cgp_component {
   name: StringFormatterWithEncodingComponent,
   provider: StringFormatterWithEncoding,
   context: Context,
}]
pub trait CanFormatToStringWithEncoding<Encoding> {
    fn format_to_string(&self) -> Result<String, Error>;
}

In this case, we may have different encoding formats implemented by a concrete context. For example, the Person context could implement CanFormatToStringWithEncoding<JsonEncoding>, but not CanFormatToStringWithEncoding<TomlEncoding>.

In this generalized case, it is more tricky to generate suitable check traits, without advanced knowledge of what the generic parameters are intended for. As such, it is still necessary for concrete contexts to define check traits that fill in the generic parameters with concrete types.

In any case, I'd encourage you to experiment with various approaches by hand-deriving the check traits you have in mind. If we can find a common pattern that is applicable to all hand-derivation, then we can consider about automating that pattern using macros.

Btw, also note that the forked Rust compiler is only required for development and debugging. Once a CGP program is free of compile errors, it is perfectly fine to compile them using the standard compiler, such as on the CI.

[marvin-hansen]

I see,

That makes sense. I think part of the problem roots in Rust not supporting higher kinded types.

In any case, that's not a blocker for me as I can write a proc macro for the trivial case. For the parametric case, I have to see how much of a problem it actually is in practice.

Thank you for your detailed elaboration.