Merge pull request #4 from contextgeneric/hypershell

Publish the release of v0.4.1 and Hypershell

Author: soareschen

code/bin/hello.rs

@@ -10,7 +10,7 @@ pub trait CanGreet // Name of the consumer trait
 // A getter trait representing a dependency for `name` value
 #[cgp_auto_getter] // Derive blanket implementation
 pub trait HasName {
-    fn name(&self) -> &String;
+    fn name(&self) -> &str;
 }
 
 // Implement `Greeter` that is generic over `Context`

config.toml

@@ -11,7 +11,7 @@ build_search_index = true
 [markdown]
 
 highlight_code = true
-highlight_theme = "kronuz"
+highlight_theme = "visual-studio-dark"
 
 [extra]
 

content/_index.md

@@ -10,9 +10,9 @@ sort_by = "weight"
 
 # Announcement
 
-I'm excited to announce the release of [v0.4.0](https://github.com/contextgeneric/cgp/releases/tag/v0.4.0) of the [`cgp`](https://docs.rs/cgp/0.4.0/cgp/) crate. This update includes significantly improved developer experience, improved debuggability, and many more new features!
+I am thrilled to announce the release of `cgp` [v0.4.1](/blog/v0-4-1-release), along with the release of [**Hypershell**](/blog/hypershell-release), a modular, *type-level* domain-specific language (DSL) for writing shell-script-like programs in Rust.
 
-Read the blog post for more details: [CGP v0.4.0 is Here: Unlocking Easier Debugging, Extensible Presets, and More!](/blog/v0-4-0-release/).
+Read the blog post for more details: [**Hypershell: A Type-Level DSL for Shell-Scripting in Rust**](/blog/hypershell-release).
 
 # Overview
 

content/blog/2025-06-14-hypershell-release.md

@@ -0,0 +1,171 @@
++++
+
+title = "CGP v0.4.1 Release"
+
+description = "Announcing the release of CGP v0.4.1, with new features like the cgp-handler crate, improved preset macros, and more."
+
+authors = ["Soares Chen"]
+
++++
+
+We are excited to announce the release of CGP v0.4.1! This release brings several new features, quality-of-life improvements for macro usages, and a new crate `cgp-handler`.
+
+Here are some of the highlights:
+
+- **New `cgp-handler` crate**: Provides abstract interfaces for defining components with common method signatures.
+- **`cgp_preset!` macro improvement**: Now supports wrapping of `Preset::Provider`.
+- **`#[cgp_component]` macro improvement**: Now supports automated derivation of `UseDelegate`.
+- **Improved Documentation**: Added inline Rust documentation for common CGP constructs.
+
+Below we will go through some of the most significant changes in this release.
+
+# New `cgp-handler` Crate
+
+This release introduces a new `cgp-handler` crate, which offers abstract interfaces for defining components with common method signatures. This helps in creating reusable and composable handlers for various tasks.
+
+As a semi-stable and non-essential crate, the `cgp-handler` crate is re-exported by `cgp-extra`, and is available from `cgp::extra::handler`.
+
+The introduction of `cgp-handler` is mainly to support the development of [Hypershell](/blog/hypershell-release), which makes heavy use of the `Handler` component to design and implement its DSL providers.
+
+The crate introduces three main components: `Handler`, `Computer`, and `Producer`.
+
+## `Handler`
+
+The `Handler` component provides the most commonly used interface for performing asynchronous operations that may fail:
+
+```rust
+#[cgp_component(Handler)]
+#[async_trait]
+pub trait CanHandle<Code: Send, Input: Send>: HasAsyncErrorType {
+    type Output: Send;
+
+    async fn handle(
+        &self,
+        _tag: PhantomData<Code>,
+        input: Input,
+    ) -> Result<Self::Output, Self::Error>;
+}
+```
+
+## `Computer`
+
+The `Computer` component mirrors a pure function that takes some input, performs some computation, and produces an output.
+
+```rust
+#[cgp_component(Computer)]
+pub trait CanCompute<Code, Input> {
+    type Output;
+
+    fn compute(&self, _tag: PhantomData<Code>, input: Input) -> Self::Output;
+}
+```
+
+## `Producer`
+
+The `Producer` component mirrors a global singleton function to produce an output value. It is useful to emulate global values that cannot be constructed through the `const` context in Rust, such as `String`.
+
+```rust
+#[cgp_component(Producer)]
+pub trait CanProduce<Code> {
+    type Output;
+
+    fn produce(&self, _tag: PhantomData<Code>) -> Self::Output;
+}
+```
+
+## `Code` Parameter
+
+All the traits in `cgp-handler` contain a phantom `Code` parameter that can be used for building type-level DSLs such as [Hypershell](https://github.com/contextgeneric/hypershell). They can also be used as type-level identifiers for dispatching, such as in API handlers.
+
+# `cgp_preset!` Macro Improvements
+
+This release also brings minor improvements to our `cgp_preset!` macro, supporting the definition of CGP presets for more diverse use cases.
+
+## Support for Wrapping `Preset::Provider` in `cgp_preset!`
+
+The `cgp_preset!` macro now allows users to specify a `#[wrap_provider]` attribute to wrap the `Preset::Provider` type. This is particularly useful when using CGP presets to define extensible mappings for generic dispatch through the `UseDelegate` pattern.
+
+Wrapping the provider makes it easier to extend non-provider mappings across multiple levels of preset inheritance. The wrapped `Preset::Provider` type will implement the expected provider trait, making it a valid delegation target.
+
+### Example
+
+Given the following preset definition:
+
+```rust
+cgp_preset! {
+    #[wrap_provider(UseDelegate)]
+    MyHandlerPreset {
+        String: HandleString,
+        u64: HandleU64,
+        ...
+    }
+}
+```
+
+The macro generates the following implementation:
+
+```rust
+pub mod MyHandlerPreset {
+    ...
+
+    pub type Provider = UseDelegate<Components>;
+
+    delegate_components! {
+        new Components {
+            String: HandleString,
+            u64: HandleU64,
+            ...
+        }
+    }
+
+    ...
+}
+```
+
+## Automated `UseDelegate` Derivation in `#[cgp_component]`
+
+The `#[cgp_component]` family of macros now includes a `derive_delegate` field, which allows for the automated implementation of `UseDelegate` for CGP components. This reduces boilerplate code that was previously required to be implemented manually.
+
+### Example
+
+The updated `ErrorRaiser` component can now be defined as:
+
+```rust
+#[cgp_component {
+    provider: ErrorRaiser,
+    derive_delegate: UseDelegate<SourceError>,
+}]
+pub trait CanRaiseError<SourceError>: HasErrorType {
+    fn raise_error(error: SourceError) -> Self::Error;
+}
+```
+
+This will automatically derive the `UseDelegate` implementation:
+
+```rust
+#[cgp_provider(ErrorRaiserComponent)]
+impl<Context, SourceError, Components, Delegate> ErrorRaiser<Context, SourceError>
+    for UseDelegate<Components>
+where
+    Context: HasErrorType,
+    Components: DelegateComponent<SourceError, Delegate = Delegate>,
+    Delegate: ErrorRaiser<Context, SourceError>,
+{
+    fn raise_error(e: SourceError) -> Context::Error {
+        Delegate::raise_error(e)
+    }
+}
+```
+
+# Other Improvements
+
+This release also includes several other minor improvements and fixes:
+
+- **Improved Documentation**: We have added inline Rust documentation for many common CGP constructs, making it easier for developers to understand and use them. This is part of our ongoing effort to improve the developer experience.
+- **Static `Char` Formatting**: The `Char` type can now be formatted statically without requiring `self`, which allows type-level strings to be formatted without constructing any value.
+- Use `__Self__` instead of `T` when deriving `Preset::IsPreset` to avoid identifier conflicts when users use `T` in their generic parameters.
+- Included trait bound identifiers in `Preset::components` re-export.
+
+---
+
+We hope you enjoy the new features and improvements in this release. As always, we welcome feedback and contributions from the community. Check out the project on [GitHub](https://github.com/contextgeneric/cgp/) and the full [changelog](https://github.com/contextgeneric/cgp/blob/main/CHANGELOG.md) for more details. 

content/blog/2025-06-14-v0.4.1-release.md

@@ -34,7 +34,16 @@ Help raise awareness of CGP by sharing it on social media. Follow our official B
 
 ## Write About It
 
-If you find CGP interesting, consider writing your own blog posts or tutorials to share your learning journey. Sharing your insights can help others learn CGP in different ways, and even if the topic is already covered on the official site, your perspective might make it clearer to others.
+If you find CGP interesting, consider writing your own blog posts or tutorials to share your learning journey. Sharing your insights can help others learn CGP in different ways, and even if the topic is 
+already covered on the official site, your perspective might make it clearer to others.
+
+## Sponsor Me
+
+If you appreciate my work and want to see CGP gain wider adoption, the best way to support it is to *sponsor* me, regardless of the amount. I have sponsorship pages on [Github Sponsor](https://github.com/sponsors/soareschen/), [Patreon](www.patreon.com/c/maybevoid/about), and [Ko-Fi](https://ko-fi.com/maybevoid).
+
+*As with most open-source projects*, I don't expect sponsorship to be enough to allow me to quit my job and work full-time on CGP, or even *with* CGP. *However*, any financial support will significantly boost my confidence in the *value* of my work and encourage me to continue dedicating hundreds of hours of my free time to it instead of other pursuits.
+
+I do hope to eventually spend a year or two working full-time on CGP using my *personal savings*, even if sponsorships don't cover my living expenses. *However*, exponential growth is important, and if I could secure around a quarter of my living expenses through monthly sponsorship, it would reduce some risk and suggest a higher chance of CGP becoming self-sustaining later on.
 
 # Acknowledgement