Merge pull request #10 from contextgeneric/v0.5.0-release

V0.5.0 release blog post

Author: soareschen

code/Cargo.lock

@@ -12,23 +12,7 @@ name = "abstract-name"
 path = "bin/abstract_name.rs"
 
 [dependencies]
-cgp = { version = "0.4.0" }
+cgp = { version = "0.5.0" }
 
 [patch.crates-io]
-# cgp                         = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-core                    = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-extra                   = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-async                   = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-async-macro             = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-component               = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-macro                   = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-macro-lib               = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-type                    = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-field                   = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-error                   = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-error-extra             = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-error-anyhow            = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-run                     = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-runtime                 = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-sync                    = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-inner                   = { git = "https://github.com/contextgeneric/cgp.git" }
+cgp                         = { git = "https://github.com/contextgeneric/cgp.git", branch = "v0.5.0-release" }

code/Cargo.toml

@@ -30,7 +30,7 @@ CGP introduces a novel approach to error handling that differs significantly fro
 
 CGP provides a robust mechanism for dependency injection using [impl-side dependencies](https://patterns.contextgeneric.dev/impl-side-dependencies.html). However, since these dependencies are expressed through traits and constraints, we need to define _accessor traits_ to retrieve field values from a generic context.
 
-In the [new chapter](https://patterns.contextgeneric.dev/field-accessors.html), we explore different approaches for defining, using, and implementing accessor traits in CGP. This chapter explains how the `#[derive(HasField)]` macro operates and dives into the internal workings of `HasField` and `symbol!`. It also introduces the` #[cgp_auto_getter]` and `#[cgp_getter]` macros, which automatically generate accessor provider implementations that work with `HasField`.
+In the [new chapter](https://patterns.contextgeneric.dev/field-accessors.html), we explore different approaches for defining, using, and implementing accessor traits in CGP. This chapter explains how the `#[derive(HasField)]` macro operates and dives into the internal workings of `HasField` and `Symbol!`. It also introduces the` #[cgp_auto_getter]` and `#[cgp_getter]` macros, which automatically generate accessor provider implementations that work with `HasField`.
 
 # `cgp` v0.3.0 Release
 

content/blog/2025-01-09-v0.3.0-release.md

@@ -303,9 +303,9 @@ delegate_components! {
     MyContextComponents {
         ListenPortGetterComponent:
             WithProvider<ChainGetters<Product! [
-                UseField<symbol!("config")>,
-                UseField<symbol!("network")>,
-                UseField<symbol!("listen_port")>,
+                UseField<Symbol!("config")>,
+                UseField<Symbol!("network")>,
+                UseField<Symbol!("listen_port")>,
             ]>>
     }
 }
@@ -381,8 +381,8 @@ The derive macro would generate the following `HasField` implementation:
 impl HasFields for Person {
     type Fields =
         Product! [
-            Field<symbol!("name"), String>,
-            Field<symbol!("age"), u64>,
+            Field<Symbol!("name"), String>,
+            Field<Symbol!("age"), u64>,
         ];
 }
 ```
@@ -393,8 +393,8 @@ Additionally, [#85](https://github.com/contextgeneric/cgp/pull/85) introduces th
 
 ```rust
 Product! [
-    Field<symbol!("name"), String>,
-    Field<symbol!("age"), u8>,
+    Field<Symbol!("name"), String>,
+    Field<Symbol!("age"), u8>,
 ]
 ```
 

content/blog/2025-05-09-v0.4.0-release.md

@@ -105,10 +105,10 @@ For instance, the previous "hello world" program can be rewritten as follows:
 ```rust
 pub type Program = Pipe<Product![
     SimpleExec<
-        StaticArg<symbol!("echo")>,
+        StaticArg<Symbol!("echo")>,
         WithStaticArgs<Product![
-            symbol!("hello"),
-            symbol!("world!"),
+            Symbol!("hello"),
+            Symbol!("world!"),
         ]>,
     >,
     StreamToStdout,
@@ -119,9 +119,9 @@ Compared to the "prettified" version, the raw Hypershell syntax is slightly more
 
 You can also see that the `WithStaticArgs[...]` syntax **desugars** to `WithStaticArgs<Product![...]>.` With `hypershell!`, syntax that accepts a variable number of arguments can use the `[]` shorthand to wrap the inner arguments within `Product!`. This results in cleaner, more concise syntax, making Hypershell programs more readable.
 
-Finally, you might notice that all occurrences of strings are wrapped inside the **`symbol!`** macro from CGP. This is because Hypershell programs are types, but string literals are value-level expressions. The `symbol!` macro allows you to turn string literals into _types_, enabling their use within type expressions.
+Finally, you might notice that all occurrences of strings are wrapped inside the **`Symbol!`** macro from CGP. This is because Hypershell programs are types, but string literals are value-level expressions. The `Symbol!` macro allows you to turn string literals into _types_, enabling their use within type expressions.
 
-Behind the scenes, `symbol!` functions similarly to **const-generics** in Rust. However, since Rust doesn't yet support using `String` or `&str` as const-generic arguments, the macro desugars the string literal into a type-level list of `char`, which *can* be used with const-generics.
+Behind the scenes, `Symbol!` functions similarly to **const-generics** in Rust. However, since Rust doesn't yet support using `String` or `&str` as const-generic arguments, the macro desugars the string literal into a type-level list of `char`, which *can* be used with const-generics.
 
 With these three syntax transformations, we can now better understand how the `hypershell!` macro works. In Hypershell's DSL architecture, the `hypershell!` macro provides the _surface syntax_ of the DSL, which is then desugared into Rust types that serve as the _abstract syntax_.
 
@@ -746,7 +746,7 @@ pub trait HasCommandArgType {
 
 The `CommandArgExtractor` component provides an `extract_command_arg` method to extract a command-line argument from an `Arg` code type. This method returns an abstract `CommandArg` type, which can be instantiated with concrete types like `PathBuf` or `String`.
 
-For example, given code like `SimpleExec<StaticArg<symbol!("echo")>, ...>`, the `Arg` type passed to `CanExtractCommandArg` would be `StaticArg<symbol!("echo")>`. This means that for `HandleSimpleExec` to implement `Handler<Context, SimpleExec<StaticArg<symbol!("echo")>, ...>, Input>`, it requires `Context` to implement `CanExtractCommandArg<StaticArg<symbol!("echo")>>`.
+For example, given code like `SimpleExec<StaticArg<Symbol!("echo")>, ...>`, the `Arg` type passed to `CanExtractCommandArg` would be `StaticArg<Symbol!("echo")>`. This means that for `HandleSimpleExec` to implement `Handler<Context, SimpleExec<StaticArg<Symbol!("echo")>, ...>, Input>`, it requires `Context` to implement `CanExtractCommandArg<StaticArg<Symbol!("echo")>>`.
 
 Since `extract_command_arg` returns an abstract `CommandArg` type, `HandleSimpleExec` also has an additional constraint: `Context::CommandArg: AsRef<OsStr> + Send`. This implies that the context can instantiate `CommandArg` with any concrete type that implements `AsRef<OsStr> + Send`, such as `PathBuf` or `OsString`.
 
@@ -771,25 +771,25 @@ To see this in action, consider the example code:
 
 ```rust
 SimpleExec<
-    StaticArg<symbol!("echo")>,
+    StaticArg<Symbol!("echo")>,
     WithStaticArgs<Product![
-        symbol!("hello"),
-        symbol!("world!"),
+        Symbol!("hello"),
+        Symbol!("world!"),
     ]>,
 >
 ```
 
-The `Args` type given to `HandleSimpleExec` would be `WithStaticArgs<Product![symbol!("hello"), symbol!("world!")]>`. This means the following constraint needs to be satisfied:
+The `Args` type given to `HandleSimpleExec` would be `WithStaticArgs<Product![Symbol!("hello"), Symbol!("world!")]>`. This means the following constraint needs to be satisfied:
 
 ```rust
-Context: CanUpdateCommand<WithStaticArgs<Product![symbol!("hello"), symbol!("world!")]>>
+Context: CanUpdateCommand<WithStaticArgs<Product![Symbol!("hello"), Symbol!("world!")]>>
 ```
 
 To keep our focus on the core implementation of `HandleSimpleExec`, we'll omit the detailed workings of argument updates. At a high level, the main idea is to perform a **type-level iteration** on the list passed to `WithStaticArgs`. So, the implementation would be broken down into two smaller constraints:
 
 ```rust
-Context: CanUpdateCommand<StaticArg<symbol!("hello")>>
-    + CanUpdateCommand<StaticArg<symbol!("world!")>>
+Context: CanUpdateCommand<StaticArg<Symbol!("hello")>>
+    + CanUpdateCommand<StaticArg<Symbol!("world!")>>
 ```
 
 Once we reach each individual argument, we then use `CanExtractCommandArg` to extract the argument and subsequently call [`Command::arg`](https://docs.rs/tokio/latest/tokio/process/struct.Command.html#method.arg) to add it to the `Command`.

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

@@ -170,4 +170,4 @@ This release also includes several other minor improvements and fixes:
 
 ---
 
-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.
+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.