Context-Generic Programming

I am excited to announce the release of cgp-serde, a modular serialization library for Serde that leverages the power of Context-Generic Programming (CGP). contextgeneric.dev/blog/cgp-ser...

I am excited to share the second part of my blog series on Extensible Data Types with CGP. This post dives into how CGP leverages extensible variants to elegantly solve the expression problem. contextgeneric.dev/blog/extensi...

I'm excited to share the release of CGP v0.4.2, with new support for extensible records and variants! contextgeneric.dev/blog/extensi... In short extensible data types allows us to read, construct, and deconstruct a *generic* struct or enum without needing access to the concrete type.

It is now possible to do OOP-like inheritance at the type-level in #RustLang using #CGP! Our latest PR brings significant improvements to defining and using presets in CGP, with support for multiple-inheritance, and override mechanism to overcome the diamond inheritance problem.

Now before you start wondering or getting disgusted, the inheritance in CGP is quite different from the classical inheritance in the OOP world. CGP presets are more like type-level dictionaries of generic mixins. So in a way, preset inheritance is sort of like extending type-level lookup tables.

A lot of new features have been added to the `#[cgp_getter]` macro! For the basic use cases, you can now define getter methods that return &str or Option<&T>, and the macro will generate getter implementations that read from String or Option<T> fields. github.com/contextgener...

This mainly improves use of CGP with idiomatic Rust code. Apparently, some readers pointed out about the aesthetic of getter methods returning &String instead of &str. This especially affects first impressions, when the hello world of CGP demonstrates the dependency injection of string fields.

A great article that gives an overview of the coherence problem in typeclasses/traits has been surfaced on Hacker News. I am trying to take the opportunity to pitch about CGP and how it helps solve the given coherence problems. Help give me an upvote here: news.ycombinator.com/item?id=4334...

CGP now has a new logo! The website has been updated with the new logo and color theme: contextgeneric.dev There are many exciting features in the upcoming v0.4.0 release. In particular, CGP now shows much more informative compile errors that makes it much easier to debug CGP code.

We have just published an update blog post on the release of #CGP v0.3.0, along with new book chapters! #RustLang contextgeneric.dev/blog/v0-3-0-...

#CGP v0.3.0 has been released! This release includes a lot of QoL improvements, including the new `cgp_type!` and `#[cgp_getter]` macros, and the new `cgp-error-anyhow` crate. #RustLang The CGP Patterns book has also been updated with significant revision on based on the new features.

Another new chapter for #CGP Patterns has been released! This time on error reporting: patterns.contextgeneric.dev/error-report... The chapter walks through how we can decouple #RustLang code that produce errors from code that handles/report errors.

With the decoupling, we can produce highly detailed error reports externally, but the core implementation would not need to be tightly coupled with any of such error handling logic.

New chapter released for #CGP Patterns: Error Handling. patterns.contextgeneric.dev/error-handli... The introduction to error handling in CGP is very important, as it is very different from how error handling is typically done in #RustLang.

The error handling techniques are also useful for showing how various CGP patterns, such as associated types, can be used to solve various programming patterns. So once the readers understood CGP error handling, they can also apply the same patterns in other problem domains.

New chapter for CGP Patterns has been released! With the introduction of associated types, we can now walk through more practical examples of using CGP to validate authentication tokens using abstract time and auth token types. patterns.contextgeneric.dev/associated-t...

We still need to finish the next chapter on error handling, before we can present a full practical use case of using CGP for real world applications. But hopefully this new chapter can give readers a better glimpse of how CGP can be useful for real world applications.

A reddit commentator has mentioned that #CGP looks similar to Scala's cake pattern. I have looked into one of the example code that uses cake pattern, and drafted an equivalent CGP #RustLang code that follows as closely with the original example: gist.github.com/soareschen/f...