From 8499f2e49a4568364e7054639d1c3d0a17857a0d Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 08:53:50 +0000
Subject: [PATCH 01/19] Update cgp to v0.4.0

---
 Cargo.lock | 141 +++++++++++++++++++----------------------------------
 Cargo.toml |  40 ++++++++-------
 flake.lock |   6 +--
 3 files changed, 73 insertions(+), 114 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f781e42..5d87666 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -100,9 +100,8 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "cgp"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "255ecfdb81d1786bf4212e1e038e5f6da8836cbb5603ce2347308ede426dbcea"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-async",
  "cgp-core",
@@ -111,9 +110,8 @@ dependencies = [
 
 [[package]]
 name = "cgp-async"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cca3a368634ced2b77f1e00e7ebb0872402a1d8fd6dbf05880329b0a001b37e"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-async-macro",
  "cgp-sync",
@@ -121,9 +119,8 @@ dependencies = [
 
 [[package]]
 name = "cgp-async-macro"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1656912abbbf7ff2fe11c9680ae5883afe79cac6f2f51bd486d04a3fbba9426"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -132,65 +129,37 @@ dependencies = [
 
 [[package]]
 name = "cgp-component"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12793289566a983f8a3151448cb8820bcc4704c34a0a9cf19bb1ed48e0844e81"
-
-[[package]]
-name = "cgp-component-macro"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f37331b62cbb29d159d2c3bc3c21bdc885576d9c024d0e9ea4cb3e7513138897"
-dependencies = [
- "cgp-component-macro-lib",
- "syn",
-]
-
-[[package]]
-name = "cgp-component-macro-lib"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29461124d295bf42c48106e81cb0f89a4eb64132752b916d5ec5df9875d03d58"
-dependencies = [
- "itertools",
- "prettyplease",
- "proc-macro2",
- "quote",
- "syn",
-]
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 
 [[package]]
 name = "cgp-core"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "021293135043b9a4f630a1fea79c1cee2de5161e71902e2cd665965945d4b546"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-async",
  "cgp-component",
- "cgp-component-macro",
  "cgp-error",
  "cgp-field",
- "cgp-field-macro",
+ "cgp-macro",
  "cgp-type",
 ]
 
 [[package]]
 name = "cgp-error"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f4b69e873357e304d1a7a91894f40f98543a5f1fac84b3087037110826e4afe"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-async",
  "cgp-component",
- "cgp-component-macro",
+ "cgp-macro",
  "cgp-type",
 ]
 
 [[package]]
 name = "cgp-error-anyhow"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e69c88a7ec1ce29d204d6f9d3b975933a050dc1b1b71da646fc74e56f0cdbe7"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "anyhow",
  "cgp-core",
@@ -198,18 +167,16 @@ dependencies = [
 
 [[package]]
 name = "cgp-error-extra"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb44c5e45fb8de9d5e8d77a4736c01d09fdee2f4e822b5ea5a3b6243ddbdd9c"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
- "cgp-error",
+ "cgp-core",
 ]
 
 [[package]]
 name = "cgp-extra"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04a67b3e5c5fd4420c0fd16c1e93a9e28a7e10f9aa911b66d7a2b9588fbb11c4"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-error-extra",
  "cgp-inner",
@@ -219,44 +186,42 @@ dependencies = [
 
 [[package]]
 name = "cgp-field"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "193dec7508c4b4efd6a1ef5eac6789eb0a297561e55dcb8cd377a904f055a176"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-component",
+ "cgp-macro",
  "cgp-type",
 ]
 
 [[package]]
-name = "cgp-field-macro"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7853451aedcc73c0edf67d44ca9652a7b1ba8a18ac0499f4fced1ac845b7711"
+name = "cgp-inner"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
- "cgp-field-macro-lib",
- "proc-macro2",
+ "cgp-component",
+ "cgp-macro",
 ]
 
 [[package]]
-name = "cgp-field-macro-lib"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "785d154b6d17929919e3bee306c515c7d78e420303605829e48116fcef2ccf9e"
+name = "cgp-macro"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
- "prettyplease",
- "proc-macro2",
- "quote",
+ "cgp-macro-lib",
  "syn",
 ]
 
 [[package]]
-name = "cgp-inner"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4e35f1ad7bfb5df01c9f263d054ba53ff87c3d1da20cb5c0872191df904583"
+name = "cgp-macro-lib"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
- "cgp-component",
- "cgp-component-macro",
+ "itertools",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
@@ -276,42 +241,38 @@ dependencies = [
 
 [[package]]
 name = "cgp-run"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ec7009079ecfd0a5db07a5dda0e7cece70b1774ead842a42919a93b4662eb96"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-async",
  "cgp-component",
- "cgp-component-macro",
  "cgp-error",
+ "cgp-macro",
 ]
 
 [[package]]
 name = "cgp-runtime"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "332d92088b07754adbde9ecdf894b8c3b9303b287c8d82d11f8886a394121925"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-core",
 ]
 
 [[package]]
 name = "cgp-sync"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb37ca18a65f3603aaa307ba76d92f64025db56160143a0e96466b5855d61a29"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-async-macro",
 ]
 
 [[package]]
 name = "cgp-type"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a4638c888a38fbb1c88406c224c38d7b9e230a306e7b07f796280b89f5baa54"
+version = "0.4.0"
+source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
 dependencies = [
  "cgp-component",
- "cgp-component-macro",
+ "cgp-macro",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 20945d3..2f37435 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,8 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-cgp                 = { version = "0.3.0" }
-cgp-error-anyhow    = { version = "0.3.0" }
+cgp                 = { version = "0.4.0" }
+cgp-error-anyhow    = { version = "0.4.0" }
 serde               = { version = "1", features = ["derive"] }
 reqwest             = { version = "0.12.12", features = [ "blocking", "json" ] }
 itertools           = { version = "0.14.0" }
@@ -15,22 +15,20 @@ datetime            = { version = "0.5.2" }
 sha1                = { version = "0.10.6" }
 
 [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-component-macro         = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-component-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-field-macro             = { git = "https://github.com/contextgeneric/cgp.git" }
-# cgp-field-macro-lib         = { 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" }
+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" }
diff --git a/flake.lock b/flake.lock
index 94820cf..1442493 100644
--- a/flake.lock
+++ b/flake.lock
@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1730272153,
-        "narHash": "sha256-B5WRZYsRlJgwVHIV6DvidFN7VX7Fg9uuwkRW9Ha8z+w=",
+        "lastModified": 1746397377,
+        "narHash": "sha256-5oLdRa3vWSRbuqPIFFmQBGGUqaYZBxX+GGtN9f/n4lU=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "2d2a9ddbe3f2c00747398f3dc9b05f7f2ebb0f53",
+        "rev": "ed30f8aba41605e3ab46421e3dcb4510ec560ff8",
         "type": "github"
       },
       "original": {

From e6e8bc22bf5a748a3a7d8265ca2bfe132f06b1da Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 11:07:55 +0000
Subject: [PATCH 02/19] Fix chapters up to Associated Types

---
 Cargo.lock                            |  34 ++--
 content/associated-types.md           | 240 +++++++++++---------------
 content/component-macros.md           |  12 +-
 content/consumer-provider-link.md     |  24 +--
 content/debugging-techniques.md       |  23 ++-
 content/delegated-error-raiser.md     |   4 +-
 content/error-handling.md             |  10 +-
 content/error-reporting.md            |  56 +++---
 content/error-wrapping.md             |  12 +-
 content/field-accessors.md            |   6 +-
 content/generic-accessor-providers.md |  12 +-
 content/provider-delegation.md        |  50 +++---
 content/use-field-pattern.md          |   6 +-
 13 files changed, 228 insertions(+), 261 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5d87666..bb703f6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -101,7 +101,7 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "cgp"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-async",
  "cgp-core",
@@ -111,7 +111,7 @@ dependencies = [
 [[package]]
 name = "cgp-async"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-async-macro",
  "cgp-sync",
@@ -120,7 +120,7 @@ dependencies = [
 [[package]]
 name = "cgp-async-macro"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -130,12 +130,12 @@ dependencies = [
 [[package]]
 name = "cgp-component"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 
 [[package]]
 name = "cgp-core"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -148,7 +148,7 @@ dependencies = [
 [[package]]
 name = "cgp-error"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -159,7 +159,7 @@ dependencies = [
 [[package]]
 name = "cgp-error-anyhow"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "anyhow",
  "cgp-core",
@@ -168,7 +168,7 @@ dependencies = [
 [[package]]
 name = "cgp-error-extra"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-core",
 ]
@@ -176,7 +176,7 @@ dependencies = [
 [[package]]
 name = "cgp-extra"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-error-extra",
  "cgp-inner",
@@ -187,7 +187,7 @@ dependencies = [
 [[package]]
 name = "cgp-field"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-component",
  "cgp-macro",
@@ -197,7 +197,7 @@ dependencies = [
 [[package]]
 name = "cgp-inner"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-component",
  "cgp-macro",
@@ -206,7 +206,7 @@ dependencies = [
 [[package]]
 name = "cgp-macro"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-macro-lib",
  "syn",
@@ -215,7 +215,7 @@ dependencies = [
 [[package]]
 name = "cgp-macro-lib"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "itertools",
  "prettyplease",
@@ -242,7 +242,7 @@ dependencies = [
 [[package]]
 name = "cgp-run"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -253,7 +253,7 @@ dependencies = [
 [[package]]
 name = "cgp-runtime"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-core",
 ]
@@ -261,7 +261,7 @@ dependencies = [
 [[package]]
 name = "cgp-sync"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-async-macro",
 ]
@@ -269,7 +269,7 @@ dependencies = [
 [[package]]
 name = "cgp-type"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#5cc02c7ab0bced98a3833679b6d36041dbbfbf31"
+source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
 dependencies = [
  "cgp-component",
  "cgp-macro",
diff --git a/content/associated-types.md b/content/associated-types.md
index f0a068e..6ff5d9a 100644
--- a/content/associated-types.md
+++ b/content/associated-types.md
@@ -15,23 +15,17 @@ pub mod traits {
     use anyhow::Error;
     use cgp::prelude::*;
 
-    #[cgp_component {
-        provider: AuthTokenValidator,
-    }]
+    #[cgp_component(AuthTokenValidator)]
     pub trait CanValidateAuthToken {
         fn validate_auth_token(&self, auth_token: &str) -> Result<(), Error>;
     }
 
-    #[cgp_component {
-        provider: AuthTokenExpiryFetcher,
-    }]
+    #[cgp_component(AuthTokenExpiryFetcher)]
     pub trait CanFetchAuthTokenExpiry {
         fn fetch_auth_token_expiry(&self, auth_token: &str) -> Result<u64, Error>;
     }
 
-    #[cgp_component {
-        provider: CurrentTimeGetter,
-    }]
+    #[cgp_component(CurrentTimeGetter)]
     pub trait HasCurrentTime {
         fn current_time(&self) -> Result<u64, Error>;
     }
@@ -41,11 +35,11 @@ pub mod impls {
     use std::time::{SystemTime, UNIX_EPOCH};
 
     use anyhow::{anyhow, Error};
+    use cgp::prelude::*;
 
     use super::traits::*;
 
-    pub struct ValidateTokenIsNotExpired;
-
+    #[cgp_new_provider]
     impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
     where
         Context: HasCurrentTime + CanFetchAuthTokenExpiry,
@@ -63,8 +57,7 @@ pub mod impls {
         }
     }
 
-    pub struct GetSystemTimestamp;
-
+    #[cgp_new_provider]
     impl<Context> CurrentTimeGetter<Context> for GetSystemTimestamp {
         fn current_time(_context: &Context) -> Result<u64, Error> {
             let now = SystemTime::now()
@@ -86,16 +79,11 @@ pub mod contexts {
     use super::impls::*;
     use super::traits::*;
 
+    #[cgp_context]
     pub struct MockApp {
         pub auth_tokens_store: BTreeMap<String, u64>,
     }
 
-    pub struct MockAppComponents;
-
-    impl HasComponents for MockApp {
-        type Components = MockAppComponents;
-    }
-
     delegate_components! {
         MockAppComponents {
             CurrentTimeGetterComponent: GetSystemTimestamp,
@@ -103,6 +91,7 @@ pub mod contexts {
         }
     }
 
+    #[cgp_provider]
     impl AuthTokenExpiryFetcher<MockApp> for MockAppComponents {
         fn fetch_auth_token_expiry(
             context: &MockApp,
@@ -116,9 +105,11 @@ pub mod contexts {
         }
     }
 
-    pub trait CanUseMockApp: CanValidateAuthToken {}
-
-    impl CanUseMockApp for MockApp {}
+    check_components! {
+        CanUseMockApp for MockApp {
+            AuthTokenValidatorComponent,
+        }
+    }
 }
 #
 # }
@@ -155,18 +146,12 @@ A more flexible approach is to define an _abstract_ `Time` type that allows us t
 #
 use cgp::prelude::*;
 
-#[cgp_component {
-    name: TimeTypeComponent,
-    provider: ProvideTimeType,
-}]
+#[cgp_component(TimeTypeProviderComponent)]
 pub trait HasTimeType {
     type Time: Eq + Ord;
 }
 
-#[cgp_component {
-    name: AuthTokenTypeComponent,
-    provider: ProvideAuthTokenType,
-}]
+#[cgp_component(AuthTokenTypeProviderComponent)]
 pub trait HasAuthTokenType {
     type AuthToken;
 }
@@ -174,7 +159,7 @@ pub trait HasAuthTokenType {
 
 Here, we define the `HasTimeType` trait with an associated type `Time`, which is constrained to types that implement `Eq` and `Ord` so that they can be compared. Similarly, the `HasAuthTokenType` trait defines an associated type `AuthToken`, without any additional constraints.
 
-Similar to regular trait methods, CGP allows us to auto-derive blanket implementations that delegate the associated types to providers using `HasComponents` and `DelegateComponent`. Therefore, we can use `#[cgp_component]` on traits containing associated types as well.
+Similar to regular trait methods, CGP allows us to auto-derive blanket implementations that delegate the associated types to providers using `HasProvider` and `DelegateComponent`. Therefore, we can use `#[cgp_component]` on traits containing associated types as well.
 
 With these type traits in place, we can now update our authentication components to leverage abstract types within the trait methods:
 
@@ -187,39 +172,27 @@ With these type traits in place, we can now update our authentication components
 # use anyhow::Error;
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
-# }]
+# #[cgp_component(TimeTypeProviderComponent)]
 # pub trait HasTimeType {
 #     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
-# }]
+# #[cgp_component(AuthTokenTypeProvider)]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
 #
-#[cgp_component {
-    provider: AuthTokenValidator,
-}]
+#[cgp_component(AuthTokenValidator)]
 pub trait CanValidateAuthToken: HasAuthTokenType {
     fn validate_auth_token(&self, auth_token: &Self::AuthToken) -> Result<(), Error>;
 }
 
-#[cgp_component {
-    provider: AuthTokenExpiryFetcher,
-}]
+#[cgp_component(AuthTokenExpiryFetcher)]
 pub trait CanFetchAuthTokenExpiry: HasAuthTokenType + HasTimeType {
     fn fetch_auth_token_expiry(&self, auth_token: &Self::AuthToken) -> Result<Self::Time, Error>;
 }
 
-#[cgp_component {
-    provider: CurrentTimeGetter,
-}]
+#[cgp_component(CurrentTimeGetter)]
 pub trait HasCurrentTime: HasTimeType {
     fn current_time(&self) -> Result<Self::Time, Error>;
 }
@@ -236,45 +209,32 @@ With the abstract types defined, we can now update `ValidateTokenIsNotExpired` t
 # use anyhow::{anyhow, Error};
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
-# }]
+# #[cgp_component(TimeTypeProviderComponent)]
 # pub trait HasTimeType {
 #     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
-# }]
+# #[cgp_component(AuthTokenTypeProviderComponent)]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
 #
-# #[cgp_component {
-#     provider: AuthTokenValidator,
-# }]
+# #[cgp_component(AuthTokenValidator)]
 # pub trait CanValidateAuthToken: HasAuthTokenType {
 #     fn validate_auth_token(&self, auth_token: &Self::AuthToken) -> Result<(), Error>;
 # }
 #
-# #[cgp_component {
-#     provider: AuthTokenExpiryFetcher,
-# }]
+# #[cgp_component(AuthTokenExpiryFetcher)]
 # pub trait CanFetchAuthTokenExpiry: HasAuthTokenType + HasTimeType {
 #     fn fetch_auth_token_expiry(&self, auth_token: &Self::AuthToken) -> Result<Self::Time, Error>;
 # }
 #
-# #[cgp_component {
-#     provider: CurrentTimeGetter,
-# }]
+# #[cgp_component(CurrentTimeGetter)]
 # pub trait HasCurrentTime: HasTimeType {
 #     fn current_time(&self) -> Result<Self::Time, Error>;
 # }
 #
-pub struct ValidateTokenIsNotExpired;
-
+#[cgp_new_provider]
 impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
 where
     Context: HasCurrentTime + CanFetchAuthTokenExpiry,
@@ -309,8 +269,15 @@ Here's how you can define the same types with `cgp_type!`:
 #
 use cgp::prelude::*;
 
-cgp_type!( Time: Eq + Ord );
-cgp_type!( AuthToken );
+#[cgp_type]
+pub trait HasTimeType {
+    type Time: Eq + Ord;
+}
+
+#[cgp_type]
+pub trait HasAuthTokenType {
+    type AuthToken;
+}
 ```
 
 The `cgp_type!` macro accepts the name of an abstract type, `$name`, along with any applicable constraints for that type. It then automatically generates the same implementation as the `cgp_component` macro: a consumer trait named `Has{$name}Type`, a provider trait named `Provide{$name}Type`, and a component name type named `${name}TypeComponent`. Each of the generated traits includes an associated type defined as `type $name: $constraints;`.
@@ -327,9 +294,7 @@ At first glance, it might seem overly verbose to define multiple type traits and
 # use cgp::prelude::*;
 # use anyhow::Error;
 #
-#[cgp_component {
-    provider: AppImpl,
-}]
+#[cgp_component(AppImpl)]
 pub trait AppTrait {
     type Time: Eq + Ord;
 
@@ -366,7 +331,10 @@ The minimalism philosophy of CGP extends to the constraints placed on associated
 #
 # use cgp::prelude::*;
 #
-cgp_type!( Time: Eq + Ord );
+#[cgp_type]
+pub trait HasTimeType {
+    type Time: Eq + Ord;
+}
 ```
 
 Here, the associated `Time` type is constrained by `Eq + Ord`. This means that all concrete implementations of `Time` must satisfy these constraints, regardless of whether they are actually required by the providers. In fact, if we revisit our previous examples, we notice that the `Eq` constraint isn’t used anywhere.
@@ -382,33 +350,32 @@ Fortunately, CGP allows us to apply the same principle of impl-side dependencies
 # use anyhow::{anyhow, Error};
 # use cgp::prelude::*;
 #
-cgp_type!( Time );
-
-# cgp_type!( AuthToken );
+#[cgp_type]
+pub trait HasTimeType {
+    type Time: Eq + Ord;
+}
 #
-# #[cgp_component {
-#     provider: AuthTokenValidator,
-# }]
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(AuthTokenValidator)]
 # pub trait CanValidateAuthToken: HasAuthTokenType {
 #     fn validate_auth_token(&self, auth_token: &Self::AuthToken) -> Result<(), Error>;
 # }
 #
-# #[cgp_component {
-#     provider: AuthTokenExpiryFetcher,
-# }]
+# #[cgp_component(AuthTokenExpiryFetcher)]
 # pub trait CanFetchAuthTokenExpiry: HasAuthTokenType + HasTimeType {
 #     fn fetch_auth_token_expiry(&self, auth_token: &Self::AuthToken) -> Result<Self::Time, Error>;
 # }
 #
-# #[cgp_component {
-#     provider: CurrentTimeGetter,
-# }]
+# #[cgp_component(CurrentTimeGetter)]
 # pub trait HasCurrentTime: HasTimeType {
 #     fn current_time(&self) -> Result<Self::Time, Error>;
 # }
 #
-pub struct ValidateTokenIsNotExpired;
-
+#[cgp_new_provider]
 impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
 where
     Context: HasCurrentTime + CanFetchAuthTokenExpiry,
@@ -452,10 +419,7 @@ With type abstraction in place, we can define context-generic providers for the
 # use cgp::prelude::*;
 # use anyhow::Error;
 #
-# #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
-# }]
+# #[cgp_type]
 # pub trait HasTimeType {
 #     type Time: Eq + Ord;
 # }
@@ -469,10 +433,12 @@ With type abstraction in place, we can define context-generic providers for the
 #
 pub struct UseInstant;
 
-impl<Context> ProvideTimeType<Context> for UseInstant {
+#[cgp_provider]
+impl<Context> TimeTypeProvider<Context> for UseInstant {
     type Time = Instant;
 }
 
+#[cgp_provider]
 impl<Context> CurrentTimeGetter<Context> for UseInstant
 where
     Context: HasTimeType<Time = Instant>,
@@ -483,9 +449,9 @@ where
 }
 ```
 
-Here, the `UseInstant` provider implements `ProvideTimeType` for any `Context` type by setting the associated type `Time` to `Instant`. Additionally, it implements `CurrentTimeGetter` for any `Context`, _provided_ that `Context::Time` is `Instant`. This type equality constraint works similarly to regular implementation-side dependencies and is frequently used for scope-limited access to a concrete type associated with an abstract type.
+Here, the `UseInstant` provider implements `TimeTypeProvider` for any `Context` type by setting the associated type `Time` to `Instant`. Additionally, it implements `CurrentTimeGetter` for any `Context`, _provided_ that `Context::Time` is `Instant`. This type equality constraint works similarly to regular implementation-side dependencies and is frequently used for scope-limited access to a concrete type associated with an abstract type.
 
-The type equality constraint is necessary because a given context might not always use `UseInstant` as the provider for `ProvideTimeType`. Instead, the context could choose a different provider that uses another type to represent `Time`. Consequently, `UseInstant` can only implement `CurrentTimeGetter` if the `Context` uses it or another provider that also uses `Instant` as its `Time` type.
+The type equality constraint is necessary because a given context might not always use `UseInstant` as the provider for `TimeTypeProvider`. Instead, the context could choose a different provider that uses another type to represent `Time`. Consequently, `UseInstant` can only implement `CurrentTimeGetter` if the `Context` uses it or another provider that also uses `Instant` as its `Time` type.
 
 Aside from `Instant`, we can also define alternative providers for `Time`, using other types like [`datetime::LocalDateTime`](https://docs.rs/datetime/latest/datetime/struct.LocalDateTime.html):
 
@@ -498,27 +464,24 @@ Aside from `Instant`, we can also define alternative providers for `Time`, using
 # use anyhow::Error;
 # use datetime::LocalDateTime;
 #
-# #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
-# }]
+# #[cgp_type]
 # pub trait HasTimeType {
 #     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     provider: CurrentTimeGetter,
-# }]
+# #[cgp_component(CurrentTimeGetter)]
 # pub trait HasCurrentTime: HasTimeType {
 #     fn current_time(&self) -> Result<Self::Time, Error>;
 # }
 #
 pub struct UseLocalDateTime;
 
-impl<Context> ProvideTimeType<Context> for UseLocalDateTime {
+#[cgp_provider]
+impl<Context> TimeTypeProvider<Context> for UseLocalDateTime {
     type Time = LocalDateTime;
 }
 
+#[cgp_provider]
 impl<Context> CurrentTimeGetter<Context> for UseLocalDateTime
 where
     Context: HasTimeType<Time = LocalDateTime>,
@@ -531,24 +494,20 @@ where
 
 Since our application only requires the `Time` type to implement `Ord` and the ability to retrieve the current time, we can easily swap between different time providers, as long as they meet these dependencies. As the application evolves, additional constraints might be introduced on the Time type, potentially limiting the available concrete time types. However, with CGP, we can incrementally introduce new dependencies based on the application’s needs, avoiding premature restrictions caused by unused requirements.
 
-Similarly, for the abstract `AuthToken` type, we can define a context-generic provider `ProvideAuthTokenType` that uses `String` as its implementation:
+Similarly, for the abstract `AuthToken` type, we can define a context-generic provider `AuthTokenTypeProvider` that uses `String` as its implementation:
 
 ```rust
 # extern crate cgp;
 #
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
-# }]
+# #[cgp_type]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
 #
-pub struct UseStringAuthToken;
-
-impl<Context> ProvideAuthTokenType<Context> for UseStringAuthToken {
+#[cgp_new_provider]
+impl<Context> AuthTokenTypeProvider<Context> for UseStringAuthToken {
     type AuthToken = String;
 }
 ```
@@ -561,7 +520,7 @@ Throughout this book, we will primarily use plain types to implement abstract ty
 
 ## The `UseType` Pattern
 
-Implementing type providers can quickly become repetitive as the number of abstract types grows. For example, to use `String` as the `AuthToken` type, we first need to define a new struct, `UseStringAuthToken`, and then implement `ProvideAuthTokenType` for it. To streamline this process, the `cgp_type!` macro simplifies the implementation by automatically generating a provider using the _`UseType`_ pattern. The generated implementation looks like this:
+Implementing type providers can quickly become repetitive as the number of abstract types grows. For example, to use `String` as the `AuthToken` type, we first need to define a new struct, `UseStringAuthToken`, and then implement `AuthTokenTypeProvider` for it. To streamline this process, the `cgp_type!` macro simplifies the implementation by automatically generating a provider using the _`UseType`_ pattern. The generated implementation looks like this:
 
 ```rust
 # extern crate cgp;
@@ -570,22 +529,20 @@ Implementing type providers can quickly become repetitive as the number of abstr
 #
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
-# }]
+# #[cgp_component(AuthTokenTypeProvider)]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
 #
 pub struct UseType<Type>(pub PhantomData<Type>);
 
-impl<Context, AuthToken> ProvideAuthTokenType<Context> for UseType<AuthToken> {
+#[cgp_provider]
+impl<Context, AuthToken> AuthTokenTypeProvider<Context> for UseType<AuthToken> {
     type AuthToken = AuthToken;
 }
 ```
 
-Here, `UseType` is a _marker_ type with a generic parameter `Type`, representing the type to be used for a given type trait. Since `PhantomData` is its only field, `UseType` is never intended to be used as a runtime value. The generic implementation of `ProvideAuthTokenType` for `UseType` ensures that the AuthToken type is directly set to the `Type` parameter of `UseType`.
+Here, `UseType` is a _marker_ type with a generic parameter `Type`, representing the type to be used for a given type trait. Since `PhantomData` is its only field, `UseType` is never intended to be used as a runtime value. The generic implementation of `AuthTokenTypeProvider` for `UseType` ensures that the AuthToken type is directly set to the `Type` parameter of `UseType`.
 
 With this generic implementation, we can redefine `UseStringAuthToken` as a simple type alias for `UseType<String>`:
 
@@ -615,19 +572,22 @@ pub mod traits {
     use anyhow::Error;
     use cgp::prelude::*;
 
-    cgp_type!( Time );
-    cgp_type!( AuthToken );
+    #[cgp_type]
+    pub trait HasTimeType {
+        type Time: Eq + Ord;
+    }
+
+    #[cgp_type]
+    pub trait HasAuthTokenType {
+        type AuthToken;
+    }
 
-    #[cgp_component {
-        provider: AuthTokenValidator,
-    }]
+    #[cgp_component(AuthTokenValidator)]
     pub trait CanValidateAuthToken: HasAuthTokenType {
         fn validate_auth_token(&self, auth_token: &Self::AuthToken) -> Result<(), Error>;
     }
 
-    #[cgp_component {
-        provider: AuthTokenExpiryFetcher,
-    }]
+    #[cgp_component(AuthTokenExpiryFetcher)]
     pub trait CanFetchAuthTokenExpiry: HasAuthTokenType + HasTimeType {
         fn fetch_auth_token_expiry(
             &self,
@@ -635,9 +595,7 @@ pub mod traits {
         ) -> Result<Self::Time, Error>;
     }
 
-    #[cgp_component {
-        provider: CurrentTimeGetter,
-    }]
+    #[cgp_component(CurrentTimeGetter)]
     pub trait HasCurrentTime: HasTimeType {
         fn current_time(&self) -> Result<Self::Time, Error>;
     }
@@ -650,8 +608,7 @@ pub mod impls {
 
     use super::traits::*;
 
-    pub struct ValidateTokenIsNotExpired;
-
+    #[cgp_new_provider]
     impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
     where
         Context: HasCurrentTime + CanFetchAuthTokenExpiry,
@@ -675,10 +632,12 @@ pub mod impls {
 
     pub struct UseLocalDateTime;
 
-    impl<Context> ProvideTimeType<Context> for UseLocalDateTime {
+    #[cgp_provider]
+    impl<Context> TimeTypeProvider<Context> for UseLocalDateTime {
         type Time = LocalDateTime;
     }
 
+    #[cgp_provider]
     impl<Context> CurrentTimeGetter<Context> for UseLocalDateTime
     where
         Context: HasTimeType<Time = LocalDateTime>,
@@ -699,27 +658,23 @@ pub mod contexts {
     use super::impls::*;
     use super::traits::*;
 
+    #[cgp_context]
     pub struct MockApp {
         pub auth_tokens_store: BTreeMap<String, LocalDateTime>,
     }
 
-    pub struct MockAppComponents;
-
-    impl HasComponents for MockApp {
-        type Components = MockAppComponents;
-    }
-
     delegate_components! {
         MockAppComponents {
             [
-                TimeTypeComponent,
+                TimeTypeProviderComponent,
                 CurrentTimeGetterComponent,
             ]: UseLocalDateTime,
-            AuthTokenTypeComponent: UseType<String>,
+            AuthTokenTypeProviderComponent: UseType<String>,
             AuthTokenValidatorComponent: ValidateTokenIsNotExpired,
         }
     }
 
+    #[cgp_provider]
     impl AuthTokenExpiryFetcher<MockApp> for MockAppComponents {
         fn fetch_auth_token_expiry(
             context: &MockApp,
@@ -733,9 +688,12 @@ pub mod contexts {
         }
     }
 
-    pub trait CanUseMockApp: CanValidateAuthToken {}
 
-    impl CanUseMockApp for MockApp {}
+    check_components! {
+        CanUseMockApp for MockApp {
+            AuthTokenValidatorComponent,
+        }
+    }
 }
 #
 # }
diff --git a/content/component-macros.md b/content/component-macros.md
index 8069fd2..2e48358 100644
--- a/content/component-macros.md
+++ b/content/component-macros.md
@@ -6,7 +6,7 @@ In summary, a CGP component is consist of the following building blocks:
 - A consumer trait.
 - A provider trait.
 - A component name type.
-- A blanket implementation of the consumer trait using `HasComponents`.
+- A blanket implementation of the consumer trait using `HasProvider`.
 - A blanket implementation of the provider trait using `DelegateComponent`.
 
 Syntactically, all CGP components follow the same pattern. The pattern is
@@ -45,7 +45,7 @@ pub struct ActionPerformerComponent;
 impl<Context, GenericA, GenericB, ...>
     CanPerformAction<GenericA, GenericB, ...> for Context
 where
-    Context: HasComponents + ConstraintA + ConstraintB + ...,
+    Context: HasProvider + ConstraintA + ConstraintB + ...,
     Context::Components: ActionPerformer<Context>,
 {
     fn perform_action(
@@ -109,7 +109,7 @@ pub trait CanPerformAction<GenericA, GenericB, ...>:
 
 To use the macro, the bulk import statement `use cgp::prelude::*` has to
 be used to bring all CGP constructs into scope. This includes the
-`HasComponents` and `DelegateComponent` traits, which are also provided
+`HasProvider` and `DelegateComponent` traits, which are also provided
 by the `cgp` crate.
 
 We then use `cgp_component` as an attribute proc macro, with several
@@ -241,6 +241,7 @@ pub trait CanParseFromString: Sized {
 
 pub struct FormatAsJsonString;
 
+#[cgp_provider(StringFormatterComponent)]
 impl<Context> StringFormatter<Context> for FormatAsJsonString
 where
     Context: Serialize,
@@ -252,6 +253,7 @@ where
 
 pub struct ParseFromJsonString;
 
+#[cgp_provider(StringParserComponent)]
 impl<Context> StringParser<Context> for ParseFromJsonString
 where
     Context: for<'a> Deserialize<'a>,
@@ -271,8 +273,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasComponents for Person {
-    type Components = PersonComponents;
+impl HasProvider for Person {
+    type Provider = PersonComponents;
 }
 
 delegate_components! {
diff --git a/content/consumer-provider-link.md b/content/consumer-provider-link.md
index 185f7cd..52ae55e 100644
--- a/content/consumer-provider-link.md
+++ b/content/consumer-provider-link.md
@@ -89,7 +89,7 @@ chosen provider. We would define the blanket implementation for `CanFormatString
 as follows:
 
 ```rust
-pub trait HasComponents {
+pub trait HasProvider {
     type Components;
 }
 
@@ -103,7 +103,7 @@ pub trait StringFormatter<Context> {
 
 impl<Context> CanFormatString for Context
 where
-    Context: HasComponents,
+    Context: HasProvider,
     Context::Components: StringFormatter<Context>,
 {
     fn format_string(&self) -> String {
@@ -112,18 +112,18 @@ where
 }
 ```
 
-First of all, we define a new `HasComponents` trait that contains an associated
+First of all, we define a new `HasProvider` trait that contains an associated
 type `Components`. The `Components` type would be specified by a context to
 choose a provider that it would use to forward all implementations of consumer
 traits. Following that, we add a blanket implementation for `CanFormatString`,
-which would be implemented for any `Context` that implements `HasComponents`,
+which would be implemented for any `Context` that implements `HasProvider`,
 provided that `Context::Components` implements `StringFormatter<Context>`.
 
 To explain in simpler terms - if a context has a provider that implements
 a provider trait for that context, then the consumer trait for that context
 is also automatically implemented.
 
-With the new blanket implementation in place, we can now implement `HasComponents`
+With the new blanket implementation in place, we can now implement `HasProvider`
 for the `Person` context, and it would now help us to implement `CanFormatString`
 for free:
 
@@ -142,15 +142,15 @@ impl Display for Person {
     }
 }
 
-impl HasComponents for Person {
-    type Components = FormatStringWithDisplay;
+impl HasProvider for Person {
+    type Provider = FormatStringWithDisplay;
 }
 
 let person = Person { first_name: "John".into(), last_name: "Smith".into() };
 
 assert_eq!(person.format_string(), "John Smith");
 #
-# pub trait HasComponents {
+# pub trait HasProvider {
 #     type Components;
 # }
 #
@@ -164,7 +164,7 @@ assert_eq!(person.format_string(), "John Smith");
 #
 # impl<Context> CanFormatString for Context
 # where
-#     Context: HasComponents,
+#     Context: HasProvider,
 #     Context::Components: StringFormatter<Context>,
 # {
 #     fn format_string(&self) -> String {
@@ -184,7 +184,7 @@ assert_eq!(person.format_string(), "John Smith");
 # }
 ```
 
-Compared to before, the implementation of `HasComponents` is much shorter than
+Compared to before, the implementation of `HasProvider` is much shorter than
 implementing `CanFormatString` directly, since we only need to specify the provider
 type without any function definition.
 
@@ -198,10 +198,10 @@ link multiple providers of different provider traits together.
 ## Component System
 
 You may have noticed that the trait for specifying the provider for a context is called
-`HasComponents` instead of `HasProviders`. This is to generalize the idea of a pair of
+`HasProvider` instead of `HasProviders`. This is to generalize the idea of a pair of
 consumer trait and provider trait working together, forming a _component_.
 
 In context-generic programming, we use the term _component_ to refer to a consumer-provider
 trait pair. The consumer trait and the provider trait are linked together through blanket
-implementations and traits such as `HasComponents`. These constructs working together to
+implementations and traits such as `HasProvider`. These constructs working together to
 form the basis for a _component system_ for CGP.
\ No newline at end of file
diff --git a/content/debugging-techniques.md b/content/debugging-techniques.md
index 72fd72e..ff99f03 100644
--- a/content/debugging-techniques.md
+++ b/content/debugging-techniques.md
@@ -55,6 +55,7 @@ Consider if we made a mistake and forgot to implement `Serialize` for `Person`:
 #
 # pub struct FormatAsJsonString;
 #
+# #[cgp_provider(StringFormatterComponent)]
 # impl<Context> StringFormatter<Context> for FormatAsJsonString
 # where
 #     Context: Serialize,
@@ -66,6 +67,7 @@ Consider if we made a mistake and forgot to implement `Serialize` for `Person`:
 #
 # pub struct ParseFromJsonString;
 #
+# #[cgp_provider(StringParserComponent)]
 # impl<Context> StringParser<Context> for ParseFromJsonString
 # where
 #     Context: for<'a> Deserialize<'a>,
@@ -84,8 +86,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasComponents for Person {
-    type Components = PersonComponents;
+impl HasProvider for Person {
+    type Provider = PersonComponents;
 }
 
 delegate_components! {
@@ -147,6 +149,7 @@ call `format_to_string`, and check if it works:
 #
 # pub struct ParseFromJsonString;
 #
+# #[cgp_provider(StringParserComponent)]
 # impl<Context> StringParser<Context> for ParseFromJsonString
 # where
 #     Context: for<'a> Deserialize<'a>,
@@ -165,8 +168,8 @@ call `format_to_string`, and check if it works:
 #
 # pub struct PersonComponents;
 #
-# impl HasComponents for Person {
-#     type Components = PersonComponents;
+# impl HasProvider for Person {
+#     type Provider = PersonComponents;
 # }
 #
 # delegate_components! {
@@ -294,6 +297,7 @@ defined as follows:
 #
 # pub struct FormatAsJsonString;
 #
+# #[cgp_provider(StringFormatterComponent)]
 # impl<Context> StringFormatter<Context> for FormatAsJsonString
 # where
 #     Context: Serialize,
@@ -305,6 +309,7 @@ defined as follows:
 #
 # pub struct ParseFromJsonString;
 #
+# #[cgp_provider(StringParserComponent)]
 # impl<Context> StringParser<Context> for ParseFromJsonString
 # where
 #     Context: for<'a> Deserialize<'a>,
@@ -323,8 +328,8 @@ defined as follows:
 #
 # pub struct PersonComponents;
 #
-# impl HasComponents for Person {
-#     type Components = PersonComponents;
+# impl HasProvider for Person {
+#     type Provider = PersonComponents;
 # }
 #
 # delegate_components! {
@@ -443,6 +448,7 @@ the super trait of `CanUsePerson` as follows:
 #
 # pub struct FormatAsJsonString;
 #
+# #[cgp_provider(StringFormatterComponent)]
 # impl<Context> StringFormatter<Context> for FormatAsJsonString
 # where
 #     Context: Serialize,
@@ -454,6 +460,7 @@ the super trait of `CanUsePerson` as follows:
 #
 # pub struct ParseFromJsonString;
 #
+# #[cgp_provider(StringParserComponent)]
 # impl<Context> StringParser<Context> for ParseFromJsonString
 # where
 #     Context: for<'a> Deserialize<'a>,
@@ -472,8 +479,8 @@ the super trait of `CanUsePerson` as follows:
 #
 # pub struct PersonComponents;
 #
-# impl HasComponents for Person {
-#     type Components = PersonComponents;
+# impl HasProvider for Person {
+#     type Provider = PersonComponents;
 # }
 #
 # delegate_components! {
diff --git a/content/delegated-error-raiser.md b/content/delegated-error-raiser.md
index 753e022..2ad18b0 100644
--- a/content/delegated-error-raiser.md
+++ b/content/delegated-error-raiser.md
@@ -328,8 +328,8 @@ pub mod contexts {
 
     pub struct MyErrorRaiserComponents;
 
-    impl HasComponents for MyApp {
-        type Components = MyAppComponents;
+    impl HasProvider for MyApp {
+        type Provider = MyAppComponents;
     }
 
     delegate_components! {
diff --git a/content/error-handling.md b/content/error-handling.md
index 0e15708..be44a87 100644
--- a/content/error-handling.md
+++ b/content/error-handling.md
@@ -451,7 +451,7 @@ pub mod impls {
 
     pub struct UseLocalDateTime;
 
-    impl<Context> ProvideTimeType<Context> for UseLocalDateTime {
+    impl<Context> TimeTypeProvider<Context> for UseLocalDateTime {
         type Time = LocalDateTime;
     }
 
@@ -483,8 +483,8 @@ pub mod contexts {
 
     pub struct MockAppComponents;
 
-    impl HasComponents for MockApp {
-        type Components = MockAppComponents;
+    impl HasProvider for MockApp {
+        type Provider = MockAppComponents;
     }
 
     delegate_components! {
@@ -492,10 +492,10 @@ pub mod contexts {
             ErrorTypeComponent: UseAnyhowError,
             ErrorRaiserComponent: DebugAnyhowError,
             [
-                TimeTypeComponent,
+                TimeTypeProviderComponent,
                 CurrentTimeGetterComponent,
             ]: UseLocalDateTime,
-            AuthTokenTypeComponent: UseType<String>,
+            AuthTokenTypeProviderComponent: UseType<String>,
             AuthTokenValidatorComponent: ValidateTokenIsNotExpired,
         }
     }
diff --git a/content/error-reporting.md b/content/error-reporting.md
index be73aa8..ff704a6 100644
--- a/content/error-reporting.md
+++ b/content/error-reporting.md
@@ -40,16 +40,16 @@ and then format them as a string before raising it as an error:
 # use cgp::prelude::*;
 #
 # #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
+#     name: TimeTypeProviderComponent,
+#     provider: TimeTypeProvider,
 # }]
 # pub trait HasTimeType {
 #     type Time;
 # }
 #
 # #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
+#     name: AuthTokenTypeProviderComponent,
+#     provider: AuthTokenTypeProvider,
 # }]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
@@ -130,16 +130,16 @@ generating a good error report:
 # use cgp::prelude::*;
 #
 # #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
+#     name: TimeTypeProviderComponent,
+#     provider: TimeTypeProvider,
 # }]
 # pub trait HasTimeType {
 #     type Time;
 # }
 #
 # #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
+#     name: AuthTokenTypeProviderComponent,
+#     provider: AuthTokenTypeProvider,
 # }]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
@@ -176,16 +176,16 @@ default way to format `ErrAuthTokenHasExpired` as string:
 # use cgp::prelude::*;
 #
 # #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
+#     name: TimeTypeProviderComponent,
+#     provider: TimeTypeProvider,
 # }]
 # pub trait HasTimeType {
 #     type Time;
 # }
 #
 # #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
+#     name: AuthTokenTypeProviderComponent,
+#     provider: AuthTokenTypeProvider,
 # }]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
@@ -245,16 +245,16 @@ as follows:
 # use cgp::prelude::*;
 #
 # #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
+#     name: TimeTypeProviderComponent,
+#     provider: TimeTypeProvider,
 # }]
 # pub trait HasTimeType {
 #     type Time;
 # }
 #
 # #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
+#     name: AuthTokenTypeProviderComponent,
+#     provider: AuthTokenTypeProvider,
 # }]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
@@ -405,16 +405,16 @@ instance as follows:
 # use cgp::core::error::ErrorRaiser;
 #
 # #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
+#     name: TimeTypeProviderComponent,
+#     provider: TimeTypeProvider,
 # }]
 # pub trait HasTimeType {
 #     type Time;
 # }
 #
 # #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
+#     name: AuthTokenTypeProviderComponent,
+#     provider: AuthTokenTypeProvider,
 # }]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
@@ -469,16 +469,16 @@ But in case if it does not, we can still do something similar using a customized
 use sha1::{Digest, Sha1};
 
 # #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
+#     name: TimeTypeProviderComponent,
+#     provider: TimeTypeProvider,
 # }]
 # pub trait HasTimeType {
 #     type Time;
 # }
 #
 # #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
+#     name: AuthTokenTypeProviderComponent,
+#     provider: AuthTokenTypeProvider,
 # }]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
@@ -542,16 +542,16 @@ as follows:
 use sha1::{Digest, Sha1};
 
 # #[cgp_component {
-#     name: TimeTypeComponent,
-#     provider: ProvideTimeType,
+#     name: TimeTypeProviderComponent,
+#     provider: TimeTypeProvider,
 # }]
 # pub trait HasTimeType {
 #     type Time;
 # }
 #
 # #[cgp_component {
-#     name: AuthTokenTypeComponent,
-#     provider: ProvideAuthTokenType,
+#     name: AuthTokenTypeProviderComponent,
+#     provider: AuthTokenTypeProvider,
 # }]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
diff --git a/content/error-wrapping.md b/content/error-wrapping.md
index 5db57f5..fbc1d0f 100644
--- a/content/error-wrapping.md
+++ b/content/error-wrapping.md
@@ -210,8 +210,8 @@ pub mod contexts {
 
     pub struct RaiseAppErrors;
 
-    impl HasComponents for App {
-        type Components = AppComponents;
+    impl HasProvider for App {
+        type Provider = AppComponents;
     }
 
     delegate_components! {
@@ -806,8 +806,8 @@ pub mod contexts {
 
     pub struct RaiseAppErrors;
 
-    impl HasComponents for App {
-        type Components = AppComponents;
+    impl HasProvider for App {
+        type Provider = AppComponents;
     }
 
     delegate_components! {
@@ -1068,8 +1068,8 @@ pub struct RaiseAppErrors;
 
 pub struct WrapAppErrors;
 
-impl HasComponents for App {
-    type Components = AppComponents;
+impl HasProvider for App {
+    type Provider = AppComponents;
 }
 
 delegate_components! {
diff --git a/content/field-accessors.md b/content/field-accessors.md
index 217e890..6ed77ea 100644
--- a/content/field-accessors.md
+++ b/content/field-accessors.md
@@ -456,8 +456,8 @@ pub struct ApiClientComponents;
 
 pub struct RaiseApiErrors;
 
-impl HasComponents for ApiClient {
-    type Components = ApiClientComponents;
+impl HasProvider for ApiClient {
+    type Provider = ApiClientComponents;
 }
 
 delegate_components! {
@@ -466,7 +466,7 @@ delegate_components! {
         ErrorRaiserComponent: UseDelegate<RaiseApiErrors>,
         MessageIdTypeComponent: UseType<u64>,
         MessageTypeComponent: UseType<String>,
-        AuthTokenTypeComponent: UseType<String>,
+        AuthTokenTypeProviderComponent: UseType<String>,
         MessageQuerierComponent: ReadMessageFromApi,
     }
 }
diff --git a/content/generic-accessor-providers.md b/content/generic-accessor-providers.md
index 60fc140..8262d97 100644
--- a/content/generic-accessor-providers.md
+++ b/content/generic-accessor-providers.md
@@ -401,8 +401,8 @@ pub struct ApiClient {
 
 pub struct ApiClientComponents;
 
-impl HasComponents for ApiClient {
-    type Components = ApiClientComponents;
+impl HasProvider for ApiClient {
+    type Provider = ApiClientComponents;
 }
 
 delegate_components! {
@@ -411,7 +411,7 @@ delegate_components! {
         ErrorRaiserComponent: UseDelegate<RaiseApiErrors>,
         MessageTypeComponent: UseType<String>,
         MessageIdTypeComponent: UseType<u64>,
-        AuthTokenTypeComponent: UseType<String>,
+        AuthTokenTypeProviderComponent: UseType<String>,
         [
             ApiBaseUrlGetterComponent,
             AuthTokenGetterComponent,
@@ -617,8 +617,8 @@ pub struct ApiClientComponents;
 
 # pub struct RaiseApiErrors;
 #
-impl HasComponents for ApiClient {
-    type Components = ApiClientComponents;
+impl HasProvider for ApiClient {
+    type Provider = ApiClientComponents;
 }
 
 delegate_components! {
@@ -627,7 +627,7 @@ delegate_components! {
         ErrorRaiserComponent: UseDelegate<RaiseApiErrors>,
         MessageIdTypeComponent: UseType<u64>,
         MessageTypeComponent: UseType<String>,
-        AuthTokenTypeComponent: UseType<String>,
+        AuthTokenTypeProviderComponent: UseType<String>,
         ApiBaseUrlGetterComponent: UseProductionApiUrl,
         AuthTokenGetterComponent: GetAuthToken,
         MessageQuerierComponent: ReadMessageFromApi,
diff --git a/content/provider-delegation.md b/content/provider-delegation.md
index 8bde386..34b254d 100644
--- a/content/provider-delegation.md
+++ b/content/provider-delegation.md
@@ -1,10 +1,10 @@
 # Provider Delegation
 
-In the previous chapter, we learned to make use of the `HasComponents` trait
+In the previous chapter, we learned to make use of the `HasProvider` trait
 to define a blanket implementation for a consumer trait like `CanFormatString`,
 so that a context would automatically delegate the implementation to a provider
 trait like `StringFormatter`. However, because there can only be one `Components`
-type defined for `HasComponents`, this means that the given provider needs to
+type defined for `HasProvider`, this means that the given provider needs to
 implement _all_ provider traits that we would like to use for the context.
 
 In this chapter, we will learn to combine multiple providers that each implements
@@ -46,7 +46,7 @@ Next, we also define the provider traits as follows:
 #
 # use anyhow::Error;
 #
-# pub trait HasComponents {
+# pub trait HasProvider {
 #     type Components;
 # }
 #
@@ -68,7 +68,7 @@ pub trait StringParser<Context> {
 
 impl<Context> CanFormatToString for Context
 where
-    Context: HasComponents,
+    Context: HasProvider,
     Context::Components: StringFormatter<Context>,
 {
     fn format_to_string(&self) -> Result<String, Error> {
@@ -78,7 +78,7 @@ where
 
 impl<Context> CanParseFromString for Context
 where
-    Context: HasComponents,
+    Context: HasProvider,
     Context::Components: StringParser<Context>,
 {
     fn parse_from_string(raw: &str) -> Result<Context, Error> {
@@ -88,7 +88,7 @@ where
 ```
 
 Similar to the previous chapter, we make use of blanket implementations
-and `HasComponents` to link the consumer traits `CanFormatToString`
+and `HasProvider` to link the consumer traits `CanFormatToString`
 and `CanParseFromString` with their respective provider traits, `StringFormatter`
 and `StringParser`.
 
@@ -171,7 +171,7 @@ and `StringParser` by delegating the call to the actual providers.
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# pub trait HasComponents {
+# pub trait HasProvider {
 #     type Components;
 # }
 #
@@ -193,7 +193,7 @@ and `StringParser` by delegating the call to the actual providers.
 #
 # impl<Context> CanFormatToString for Context
 # where
-#     Context: HasComponents,
+#     Context: HasProvider,
 #     Context::Components: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
@@ -203,7 +203,7 @@ and `StringParser` by delegating the call to the actual providers.
 #
 # impl<Context> CanParseFromString for Context
 # where
-#     Context: HasComponents,
+#     Context: HasProvider,
 #     Context::Components: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
@@ -241,8 +241,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasComponents for Person {
-    type Components = PersonComponents;
+impl HasProvider for Person {
+    type Provider = PersonComponents;
 }
 
 impl StringFormatter<Person> for PersonComponents {
@@ -277,7 +277,7 @@ later on.
 
 We then define a dummy struct `PersonComponents`,
 which would be used to aggregate the providers for `Person`. Compared to the
-previous chapter, we implement `HasComponents` for `Person` with `PersonComponents`
+previous chapter, we implement `HasProvider` for `Person` with `PersonComponents`
 as the provider.
 
 We then implement the provider traits `StringFormatter` and `StringParser`
@@ -296,7 +296,7 @@ The main differences between the two implementation boilerplate is that
 we want to choose `FormatAsJsonString` as the provider for `StringFormatter`,
 and `ParseFromJsonString` as the provider for `StringParser`.
 
-Similar to how we can use `HasComponents` with blanket implementations to link
+Similar to how we can use `HasProvider` with blanket implementations to link
 a consumer with a provider, we can reduce the boilerplate required by using
 similar pattern to link a provider with _another_ provider:
 
@@ -350,7 +350,7 @@ where
 }
 ```
 
-The `DelegateComponent` is similar to the `HasComponents` trait, but it is intended
+The `DelegateComponent` is similar to the `HasProvider` trait, but it is intended
 to be implemented by providers instead of concrete contexts. It also has an extra
 generic `Name` type that is used to differentiate which component the provider
 delegation is intended for.
@@ -378,7 +378,7 @@ different `Delegate` to be used depending on the `Name`.
 ## Using `DelegateComponent`
 
 It may take a while to fully understand how the blanket implementations with
-`DelegateComponent` and `HasComponents` work. But since the same pattern will
+`DelegateComponent` and `HasProvider` work. But since the same pattern will
 be used everywhere, it would hopefully become clear as we see more examples.
 It would also help to see how the blanket implementation is used, by going
 back to the example of implementing the concrete context `Person`.
@@ -391,7 +391,7 @@ back to the example of implementing the concrete context `Person`.
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# pub trait HasComponents {
+# pub trait HasProvider {
 #     type Components;
 # }
 #
@@ -413,7 +413,7 @@ back to the example of implementing the concrete context `Person`.
 #
 # impl<Context> CanFormatToString for Context
 # where
-#     Context: HasComponents,
+#     Context: HasProvider,
 #     Context::Components: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
@@ -423,7 +423,7 @@ back to the example of implementing the concrete context `Person`.
 #
 # impl<Context> CanParseFromString for Context
 # where
-#     Context: HasComponents,
+#     Context: HasProvider,
 #     Context::Components: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
@@ -488,8 +488,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasComponents for Person {
-    type Components = PersonComponents;
+impl HasProvider for Person {
+    type Provider = PersonComponents;
 }
 
 impl DelegateComponent<StringFormatterComponent> for PersonComponents {
@@ -579,7 +579,7 @@ which provider to use in each concrete context implementation.
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# pub trait HasComponents {
+# pub trait HasProvider {
 #     type Components;
 # }
 #
@@ -601,7 +601,7 @@ which provider to use in each concrete context implementation.
 #
 # impl<Context> CanFormatToString for Context
 # where
-#     Context: HasComponents,
+#     Context: HasProvider,
 #     Context::Components: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
@@ -611,7 +611,7 @@ which provider to use in each concrete context implementation.
 #
 # impl<Context> CanParseFromString for Context
 # where
-#     Context: HasComponents,
+#     Context: HasProvider,
 #     Context::Components: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
@@ -687,8 +687,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasComponents for Person {
-    type Components = PersonComponents;
+impl HasProvider for Person {
+    type Provider = PersonComponents;
 }
 
 impl DelegateComponent<StringFormatterComponent> for PersonComponents {
diff --git a/content/use-field-pattern.md b/content/use-field-pattern.md
index b5c5b48..a3fef99 100644
--- a/content/use-field-pattern.md
+++ b/content/use-field-pattern.md
@@ -164,8 +164,8 @@ pub trait HasAuthToken: HasAuthTokenType {
 #
 # pub struct RaiseApiErrors;
 #
-# impl HasComponents for ApiClient {
-#     type Components = ApiClientComponents;
+# impl HasProvider for ApiClient {
+#     type Provider = ApiClientComponents;
 # }
 #
 delegate_components! {
@@ -174,7 +174,7 @@ delegate_components! {
         ErrorRaiserComponent: UseDelegate<RaiseApiErrors>,
         MessageIdTypeComponent: UseType<u64>,
         MessageTypeComponent: UseType<String>,
-        AuthTokenTypeComponent: UseType<String>,
+        AuthTokenTypeProviderComponent: UseType<String>,
         ApiBaseUrlGetterComponent: UseField<symbol!("api_base_url")>,
         AuthTokenGetterComponent: UseField<symbol!("auth_token")>,
         MessageQuerierComponent: ReadMessageFromApi,

From 354ac1e5c07730e7920d831bad856dfcfa4e6d73 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 11:45:59 +0000
Subject: [PATCH 03/19] Fix errors in error handling chapters

---
 content/delegated-error-raiser.md |  64 +++++------
 content/error-handling.md         | 165 +++++++++++++++------------
 content/error-reporting.md        | 103 +++++------------
 content/error-wrapping.md         | 183 +++++++++---------------------
 4 files changed, 203 insertions(+), 312 deletions(-)

diff --git a/content/delegated-error-raiser.md b/content/delegated-error-raiser.md
index 2ad18b0..9f9365e 100644
--- a/content/delegated-error-raiser.md
+++ b/content/delegated-error-raiser.md
@@ -21,11 +21,12 @@ use core::convert::Infallible;
 use core::num::ParseIntError;
 
 use anyhow::anyhow;
-use cgp::core::error::ErrorRaiser;
+use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 use cgp::prelude::*;
 
 pub struct MyErrorRaiser;
 
+#[cgp_provider]
 impl<Context> ErrorRaiser<Context, anyhow::Error> for MyErrorRaiser
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -35,6 +36,7 @@ where
     }
 }
 
+#[cgp_provider]
 impl<Context> ErrorRaiser<Context, Infallible> for MyErrorRaiser
 where
     Context: HasErrorType,
@@ -44,6 +46,7 @@ where
     }
 }
 
+#[cgp_provider]
 impl<Context> ErrorRaiser<Context, std::io::Error> for MyErrorRaiser
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -53,6 +56,7 @@ where
     }
 }
 
+#[cgp_provider]
 impl<Context> ErrorRaiser<Context, ParseIntError> for MyErrorRaiser
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -62,6 +66,7 @@ where
     }
 }
 
+#[cgp_provider]
 impl<Context> ErrorRaiser<Context, ErrAuthTokenHasExpired> for MyErrorRaiser
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -71,6 +76,7 @@ where
     }
 }
 
+#[cgp_provider]
 impl<Context> ErrorRaiser<Context, String> for MyErrorRaiser
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -80,6 +86,7 @@ where
     }
 }
 
+#[cgp_provider]
 impl<'a, Context> ErrorRaiser<Context, &'a str> for MyErrorRaiser
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -106,11 +113,12 @@ When examining the patterns for implementing custom error raisers, we notice sim
 #
 use core::marker::PhantomData;
 
-use cgp::core::error::ErrorRaiser;
+use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 use cgp::prelude::*;
 
 pub struct UseDelegate<Components>(pub PhantomData<Components>);
 
+#[cgp_provider]
 impl<Context, SourceError, Components> ErrorRaiser<Context, SourceError> for UseDelegate<Components>
 where
     Context: HasErrorType,
@@ -136,7 +144,7 @@ We can better understand this by looking at a concrete example. Using `UseDelega
 # extern crate anyhow;
 #
 # use cgp::core::component::UseDelegate;
-# use cgp::core::error::ErrorRaiser;
+# use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 # use cgp::prelude::*;
 #
 # use core::fmt::Debug;
@@ -149,6 +157,7 @@ We can better understand this by looking at a concrete example. Using `UseDelega
 #
 # pub struct DebugAnyhowError;
 #
+# #[cgp_provider]
 # impl<Context, E> ErrorRaiser<Context, E> for DebugAnyhowError
 # where
 #     Context: HasErrorType<Error = anyhow::Error>,
@@ -159,8 +168,7 @@ We can better understand this by looking at a concrete example. Using `UseDelega
 #     }
 # }
 #
-# pub struct RaiseFrom;
-#
+# #[cgp_new_provider]
 # impl<Context, E> ErrorRaiser<Context, E> for RaiseFrom
 # where
 #     Context: HasErrorType,
@@ -171,10 +179,8 @@ We can better understand this by looking at a concrete example. Using `UseDelega
 #     }
 # }
 #
-pub struct MyErrorRaiserComponents;
-
 delegate_components! {
-    MyErrorRaiserComponents {
+    new MyErrorRaiserComponents {
         [
             std::io::Error,
             ParseIntError,
@@ -205,11 +211,11 @@ In addition to the delegation pattern, it can be useful to implement generic err
 ```rust
 # extern crate cgp;
 #
-use cgp::core::error::{CanRaiseError, ErrorRaiser};
+use cgp::prelude::*;
+use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 use core::fmt::Debug;
 
-pub struct DebugError;
-
+#[cgp_new_provider]
 impl<Context, SourceError> ErrorRaiser<Context, SourceError> for DebugError
 where
     Context: CanRaiseError<String>,
@@ -241,14 +247,13 @@ pub mod impls {
     use core::fmt::{Debug, Display};
 
     use anyhow::anyhow;
-    use cgp::core::error::{CanRaiseError, ErrorRaiser, ProvideErrorType};
-    use cgp::prelude::HasErrorType;
+    use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
+    use cgp::prelude::*;
 
     #[derive(Debug)]
     pub struct ErrAuthTokenHasExpired;
 
-    pub struct ReturnError;
-
+    #[cgp_new_provider]
     impl<Context, Error> ErrorRaiser<Context, Error> for ReturnError
     where
         Context: HasErrorType<Error = Error>,
@@ -258,8 +263,7 @@ pub mod impls {
         }
     }
 
-    pub struct RaiseFrom;
-
+    #[cgp_new_provider]
     impl<Context, SourceError> ErrorRaiser<Context, SourceError> for RaiseFrom
     where
         Context: HasErrorType,
@@ -270,8 +274,7 @@ pub mod impls {
         }
     }
 
-    pub struct RaiseInfallible;
-
+    #[cgp_new_provider]
     impl<Context> ErrorRaiser<Context, Infallible> for RaiseInfallible
     where
         Context: HasErrorType,
@@ -281,8 +284,7 @@ pub mod impls {
         }
     }
 
-    pub struct DebugError;
-
+    #[cgp_new_provider]
     impl<Context, SourceError> ErrorRaiser<Context, SourceError> for DebugError
     where
         Context: CanRaiseError<String>,
@@ -293,14 +295,7 @@ pub mod impls {
         }
     }
 
-    pub struct UseAnyhow;
-
-    impl<Context> ProvideErrorType<Context> for UseAnyhow {
-        type Error = anyhow::Error;
-    }
-
-    pub struct DisplayAnyhowError;
-
+    #[cgp_new_provider]
     impl<Context, SourceError> ErrorRaiser<Context, SourceError> for DisplayAnyhowError
     where
         Context: HasErrorType<Error = anyhow::Error>,
@@ -317,24 +312,19 @@ pub mod contexts {
     use core::num::ParseIntError;
 
     use cgp::core::component::UseDelegate;
-    use cgp::core::error::{ErrorRaiserComponent, ErrorTypeComponent};
+    use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
     use cgp::prelude::*;
 
     use super::impls::*;
 
+    #[cgp_context]
     pub struct MyApp;
 
-    pub struct MyAppComponents;
-
     pub struct MyErrorRaiserComponents;
 
-    impl HasProvider for MyApp {
-        type Provider = MyAppComponents;
-    }
-
     delegate_components! {
         MyAppComponents {
-            ErrorTypeComponent: UseAnyhow,
+            ErrorTypeProviderComponent: UseType<anyhow::Error>,
             ErrorRaiserComponent: UseDelegate<MyErrorRaiserComponents>,
         }
     }
diff --git a/content/error-handling.md b/content/error-handling.md
index be44a87..fd498fb 100644
--- a/content/error-handling.md
+++ b/content/error-handling.md
@@ -19,7 +19,10 @@ use core::fmt::Debug;
 
 use cgp::prelude::*;
 
-cgp_type!( Error: Debug );
+#[cgp_type]
+pub trait HasErrorType {
+    type Error: Debug;
+}
 ```
 
 The `HasErrorType` trait is particularly significant because it serves as a standard type API for _all_ CGP components that involve abstract errors. Its definition is intentionally minimal, consisting of a single associated type, `Error`, constrained by `Debug` by default. This `Debug` constraint was chosen because many Rust APIs, such as `Result::unwrap`, rely on error types implementing `Debug`.
@@ -33,8 +36,15 @@ Building on the example from the previous chapter, we can update authentication
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( Time );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasTimeType {
+#     type Time: Eq + Ord;
+# }
+#
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
 #
 #[cgp_component {
     provider: AuthTokenValidator,
@@ -74,19 +84,22 @@ For example, we can modify the `ValidateTokenIsNotExpired` provider to convert a
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( Time );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasTimeType {
+#     type Time: Eq + Ord;
+# }
 #
-# #[cgp_component {
-#     provider: AuthTokenValidator,
-# }]
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(AuthTokenValidator)]
 # pub trait CanValidateAuthToken: HasAuthTokenType + HasErrorType {
 #     fn validate_auth_token(&self, auth_token: &Self::AuthToken) -> Result<(), Self::Error>;
 # }
 #
-# #[cgp_component {
-#     provider: AuthTokenExpiryFetcher,
-# }]
+# #[cgp_component(AuthTokenExpiryFetcher)]
 # pub trait CanFetchAuthTokenExpiry: HasAuthTokenType + HasTimeType + HasErrorType {
 #     fn fetch_auth_token_expiry(
 #         &self,
@@ -94,15 +107,12 @@ For example, we can modify the `ValidateTokenIsNotExpired` provider to convert a
 #     ) -> Result<Self::Time, Self::Error>;
 # }
 #
-# #[cgp_component {
-#     provider: CurrentTimeGetter,
-# }]
+# #[cgp_component(CurrentTimeGetter)]
 # pub trait HasCurrentTime: HasTimeType + HasErrorType {
 #     fn current_time(&self) -> Result<Self::Time, Self::Error>;
 # }
 #
-pub struct ValidateTokenIsNotExpired;
-
+#[cgp_new_provider]
 impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
 where
     Context: HasCurrentTime + CanFetchAuthTokenExpiry + HasErrorType,
@@ -137,19 +147,22 @@ CGP encourages an iterative approach to error handling. Developers can begin wit
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( Time );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasTimeType {
+#     type Time: Eq + Ord;
+# }
 #
-# #[cgp_component {
-#     provider: AuthTokenValidator,
-# }]
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(AuthTokenValidator)]
 # pub trait CanValidateAuthToken: HasAuthTokenType + HasErrorType {
 #     fn validate_auth_token(&self, auth_token: &Self::AuthToken) -> Result<(), Self::Error>;
 # }
 #
-# #[cgp_component {
-#     provider: AuthTokenExpiryFetcher,
-# }]
+# #[cgp_component(AuthTokenExpiryFetcher)]
 # pub trait CanFetchAuthTokenExpiry: HasAuthTokenType + HasTimeType + HasErrorType {
 #     fn fetch_auth_token_expiry(
 #         &self,
@@ -157,18 +170,12 @@ CGP encourages an iterative approach to error handling. Developers can begin wit
 #     ) -> Result<Self::Time, Self::Error>;
 # }
 #
-# #[cgp_component {
-#     provider: CurrentTimeGetter,
-# }]
+# #[cgp_component(CurrentTimeGetter)]
 # pub trait HasCurrentTime: HasTimeType + HasErrorType {
 #     fn current_time(&self) -> Result<Self::Time, Self::Error>;
 # }
 #
-pub struct ValidateTokenIsNotExpired;
-
-#[derive(Debug)]
-pub struct ErrAuthTokenHasExpired;
-
+#[cgp_new_provider]
 impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
 where
     Context: HasCurrentTime + CanFetchAuthTokenExpiry + HasErrorType,
@@ -191,6 +198,9 @@ where
     }
 }
 
+#[derive(Debug)]
+pub struct ErrAuthTokenHasExpired;
+
 impl Display for ErrAuthTokenHasExpired {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "auth token has expired")
@@ -215,9 +225,7 @@ To address these issues, we recommend using a more flexible — though slightly
 #
 # use cgp::prelude::*;
 #
-#[cgp_component {
-    provider: ErrorRaiser,
-}]
+#[cgp_component(ErrorRaiser)]
 pub trait CanRaiseError<SourceError>: HasErrorType {
     fn raise_error(e: SourceError) -> Self::Error;
 }
@@ -234,8 +242,15 @@ We can now update the `ValidateTokenIsNotExpired` provider to use `CanRaiseError
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( Time );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasTimeType {
+#     type Time: Eq + Ord;
+# }
+#
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
 #
 # #[cgp_component {
 #     provider: AuthTokenValidator,
@@ -261,8 +276,7 @@ We can now update the `ValidateTokenIsNotExpired` provider to use `CanRaiseError
 #     fn current_time(&self) -> Result<Self::Time, Self::Error>;
 # }
 #
-pub struct ValidateTokenIsNotExpired;
-
+#[cgp_new_provider]
 impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
 where
     Context: HasCurrentTime + CanFetchAuthTokenExpiry + CanRaiseError<&'static str>,
@@ -297,10 +311,10 @@ By defining the `CanRaiseError` trait using CGP, we overcome the limitations of
 # extern crate cgp;
 # extern crate anyhow;
 #
-use cgp::core::error::{ErrorRaiser, HasErrorType};
-
-pub struct RaiseAnyhowError;
+# use cgp::prelude::*;
+use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent, HasErrorType};
 
+#[cgp_new_provider]
 impl<Context, SourceError> ErrorRaiser<Context, SourceError> for RaiseAnyhowError
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -319,10 +333,10 @@ For a more generalized approach, we can create a provider that works with _any_
 ```rust
 # extern crate cgp;
 #
-use cgp::core::error::{ErrorRaiser, HasErrorType};
-
-pub struct RaiseFrom;
+# use cgp::prelude::*;
+use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent, HasErrorType};
 
+#[cgp_new_provider]
 impl<Context, SourceError> ErrorRaiser<Context, SourceError> for RaiseFrom
 where
     Context: HasErrorType,
@@ -345,10 +359,10 @@ The introduction of `CanRaiseError` might seem redundant when it ultimately reli
 use core::fmt::Debug;
 
 use anyhow::anyhow;
-use cgp::core::error::{ErrorRaiser, HasErrorType};
-
-pub struct DebugAnyhowError;
+use cgp::prelude::*;
+use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent, HasErrorType};
 
+#[cgp_new_provider]
 impl<Context, SourceError> ErrorRaiser<Context, SourceError> for DebugAnyhowError
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -385,19 +399,22 @@ from the previous chapter, and make it generic over the error type:
 pub mod traits {
     use cgp::prelude::*;
 
-    cgp_type!( Time );
-    cgp_type!( AuthToken );
+    #[cgp_type]
+    pub trait HasTimeType {
+        type Time: Eq + Ord;
+    }
 
-    #[cgp_component {
-        provider: AuthTokenValidator,
-    }]
+    #[cgp_type]
+    pub trait HasAuthTokenType {
+        type AuthToken;
+    }
+
+    #[cgp_component(AuthTokenValidator)]
     pub trait CanValidateAuthToken: HasAuthTokenType + HasErrorType {
         fn validate_auth_token(&self, auth_token: &Self::AuthToken) -> Result<(), Self::Error>;
     }
 
-    #[cgp_component {
-        provider: AuthTokenExpiryFetcher,
-    }]
+    #[cgp_component(AuthTokenExpiryFetcher)]
     pub trait CanFetchAuthTokenExpiry: HasAuthTokenType + HasTimeType + HasErrorType {
         fn fetch_auth_token_expiry(
             &self,
@@ -405,9 +422,7 @@ pub mod traits {
         ) -> Result<Self::Time, Self::Error>;
     }
 
-    #[cgp_component {
-        provider: CurrentTimeGetter,
-    }]
+    #[cgp_component(CurrentTimeGetter)]
     pub trait HasCurrentTime: HasTimeType + HasErrorType {
         fn current_time(&self) -> Result<Self::Time, Self::Error>;
     }
@@ -417,17 +432,15 @@ pub mod impls {
     use core::fmt::Debug;
 
     use anyhow::anyhow;
-    use cgp::core::error::{ErrorRaiser, ProvideErrorType};
-    use cgp::prelude::{CanRaiseError, HasErrorType};
+    use cgp::prelude::*;
     use datetime::LocalDateTime;
 
     use super::traits::*;
 
-    pub struct ValidateTokenIsNotExpired;
-
     #[derive(Debug)]
     pub struct ErrAuthTokenHasExpired;
 
+    #[cgp_new_provider]
     impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
     where
         Context: HasCurrentTime + CanFetchAuthTokenExpiry + CanRaiseError<ErrAuthTokenHasExpired>,
@@ -451,10 +464,12 @@ pub mod impls {
 
     pub struct UseLocalDateTime;
 
+    #[cgp_provider]
     impl<Context> TimeTypeProvider<Context> for UseLocalDateTime {
         type Time = LocalDateTime;
     }
 
+    #[cgp_provider]
     impl<Context> CurrentTimeGetter<Context> for UseLocalDateTime
     where
         Context: HasTimeType<Time = LocalDateTime> + HasErrorType,
@@ -469,7 +484,7 @@ pub mod contexts {
     use std::collections::BTreeMap;
 
     use anyhow::anyhow;
-    use cgp::core::error::{ErrorRaiserComponent, ErrorTypeComponent};
+    use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
     use cgp::prelude::*;
     use cgp_error_anyhow::{UseAnyhowError, DebugAnyhowError};
     use datetime::LocalDateTime;
@@ -477,20 +492,17 @@ pub mod contexts {
     use super::impls::*;
     use super::traits::*;
 
+    #[cgp_context]
     pub struct MockApp {
         pub auth_tokens_store: BTreeMap<String, LocalDateTime>,
     }
 
-    pub struct MockAppComponents;
-
-    impl HasProvider for MockApp {
-        type Provider = MockAppComponents;
-    }
-
     delegate_components! {
         MockAppComponents {
-            ErrorTypeComponent: UseAnyhowError,
-            ErrorRaiserComponent: DebugAnyhowError,
+            ErrorTypeProviderComponent:
+                UseAnyhowError,
+            ErrorRaiserComponent:
+                DebugAnyhowError,
             [
                 TimeTypeProviderComponent,
                 CurrentTimeGetterComponent,
@@ -500,6 +512,7 @@ pub mod contexts {
         }
     }
 
+    #[cgp_provider]
     impl AuthTokenExpiryFetcher<MockApp> for MockAppComponents {
         fn fetch_auth_token_expiry(
             context: &MockApp,
@@ -513,9 +526,11 @@ pub mod contexts {
         }
     }
 
-    pub trait CanUseMockApp: CanValidateAuthToken {}
-
-    impl CanUseMockApp for MockApp {}
+    check_components! {
+        CanUseMockApp for MockApp {
+            AuthTokenValidatorComponent,
+        }
+    }
 }
 #
 # }
diff --git a/content/error-reporting.md b/content/error-reporting.md
index ff704a6..65d5fc3 100644
--- a/content/error-reporting.md
+++ b/content/error-reporting.md
@@ -39,18 +39,12 @@ and then format them as a string before raising it as an error:
 #
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     name: TimeTypeProviderComponent,
-#     provider: TimeTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasTimeType {
-#     type Time;
+#     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     name: AuthTokenTypeProviderComponent,
-#     provider: AuthTokenTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
@@ -79,8 +73,7 @@ and then format them as a string before raising it as an error:
 #     fn current_time(&self) -> Result<Self::Time, Self::Error>;
 # }
 #
-pub struct ValidateTokenIsNotExpired;
-
+#[cgp_new_provider]
 impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
 where
     Context: HasCurrentTime + CanFetchAuthTokenExpiry + for<'a> CanRaiseError<String>,
@@ -129,18 +122,12 @@ generating a good error report:
 #
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     name: TimeTypeProviderComponent,
-#     provider: TimeTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasTimeType {
-#     type Time;
+#     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     name: AuthTokenTypeProviderComponent,
-#     provider: AuthTokenTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
@@ -175,18 +162,12 @@ default way to format `ErrAuthTokenHasExpired` as string:
 #
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     name: TimeTypeProviderComponent,
-#     provider: TimeTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasTimeType {
-#     type Time;
+#     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     name: AuthTokenTypeProviderComponent,
-#     provider: AuthTokenTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
@@ -244,18 +225,12 @@ as follows:
 #
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     name: TimeTypeProviderComponent,
-#     provider: TimeTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasTimeType {
-#     type Time;
+#     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     name: AuthTokenTypeProviderComponent,
-#     provider: AuthTokenTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
@@ -309,8 +284,7 @@ as follows:
 #     }
 # }
 #
-pub struct ValidateTokenIsNotExpired;
-
+#[cgp_new_provider]
 impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
 where
     Context: HasCurrentTime
@@ -369,11 +343,11 @@ implementation to and raise it using `DebugError`:
 ```rust
 # extern crate cgp;
 #
-use cgp::core::error::{CanRaiseError, ErrorRaiser};
+use cgp::prelude::*;
+use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 use core::fmt::Debug;
 
-pub struct DebugError;
-
+#[cgp_new_provider]
 impl<Context, SourceError> ErrorRaiser<Context, SourceError> for DebugError
 where
     Context: CanRaiseError<String>,
@@ -402,7 +376,7 @@ instance as follows:
 # use core::fmt::Display;
 #
 # use cgp::prelude::*;
-# use cgp::core::error::ErrorRaiser;
+# use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 #
 # #[cgp_component {
 #     name: TimeTypeProviderComponent,
@@ -430,8 +404,7 @@ instance as follows:
 #     pub expiry_time: &'a Context::Time,
 # }
 #
-pub struct DisplayAuthTokenExpiredError;
-
+#[cgp_new_provider]
 impl<'a, Context> ErrorRaiser<Context, ErrAuthTokenHasExpired<'a, Context>>
     for DisplayAuthTokenExpiredError
 where
@@ -465,21 +438,15 @@ But in case if it does not, we can still do something similar using a customized
 # use core::fmt::Display;
 #
 # use cgp::prelude::*;
-# use cgp::core::error::ErrorRaiser;
+# use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 use sha1::{Digest, Sha1};
 
-# #[cgp_component {
-#     name: TimeTypeProviderComponent,
-#     provider: TimeTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasTimeType {
-#     type Time;
+#     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     name: AuthTokenTypeProviderComponent,
-#     provider: AuthTokenTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
@@ -494,8 +461,7 @@ use sha1::{Digest, Sha1};
 #     pub expiry_time: &'a Context::Time,
 # }
 #
-pub struct ShowAuthTokenExpiredError;
-
+#[cgp_new_provider]
 impl<'a, Context> ErrorRaiser<Context, ErrAuthTokenHasExpired<'a, Context>>
     for ShowAuthTokenExpiredError
 where
@@ -538,21 +504,15 @@ as follows:
 # use core::fmt::Display;
 #
 # use cgp::prelude::*;
-# use cgp::core::error::ErrorRaiser;
+# use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 use sha1::{Digest, Sha1};
 
-# #[cgp_component {
-#     name: TimeTypeProviderComponent,
-#     provider: TimeTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasTimeType {
-#     type Time;
+#     type Time: Eq + Ord;
 # }
 #
-# #[cgp_component {
-#     name: AuthTokenTypeProviderComponent,
-#     provider: AuthTokenTypeProvider,
-# }]
+# #[cgp_type]
 # pub trait HasAuthTokenType {
 #     type AuthToken;
 # }
@@ -567,15 +527,12 @@ use sha1::{Digest, Sha1};
 #     pub expiry_time: &'a Context::Time,
 # }
 #
-#[cgp_component {
-    provider: DocumentIdGetter,
-}]
+#[cgp_component(DocumentIdGetter)]
 pub trait HasDocumentId {
     fn document_id(&self) -> u64;
 }
 
-pub struct ShowAuthTokenExpiredError;
-
+#[cgp_new_provider]
 impl<'a, Context> ErrorRaiser<Context, ErrAuthTokenHasExpired<'a, Context>>
     for ShowAuthTokenExpiredError
 where
diff --git a/content/error-wrapping.md b/content/error-wrapping.md
index fbc1d0f..86cd389 100644
--- a/content/error-wrapping.md
+++ b/content/error-wrapping.md
@@ -30,24 +30,17 @@ pub mod traits {
 
     use cgp::prelude::*;
 
-    #[cgp_component {
-        name: ConfigTypeComponent,
-        provider: ProvideConfigType,
-    }]
+    #[cgp_type]
     pub trait HasConfigType {
         type Config;
     }
 
-    #[cgp_component {
-        provider: ConfigLoader,
-    }]
+    #[cgp_component(ConfigLoader)]
     pub trait CanLoadConfig: HasConfigType + HasErrorType {
         fn load_config(&self) -> Result<Self::Config, Self::Error>;
     }
 
-    #[cgp_component {
-        provider: ConfigPathGetter,
-    }]
+    #[cgp_component(ConfigPathGetter)]
     pub trait HasConfigPath {
         fn config_path(&self) -> &PathBuf;
     }
@@ -56,14 +49,13 @@ pub mod traits {
 pub mod impls {
     use std::{fs, io};
 
-    use cgp::core::error::{ErrorRaiser, ProvideErrorType};
+    use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
     use cgp::prelude::*;
     use serde::Deserialize;
 
     use super::traits::*;
 
-    pub struct LoadJsonConfig;
-
+    #[cgp_new_provider]
     impl<Context> ConfigLoader<Context> for LoadJsonConfig
     where
         Context: HasConfigType
@@ -113,24 +105,17 @@ load its config as follows:
 #
 #     use cgp::prelude::*;
 #
-#     #[cgp_component {
-#         name: ConfigTypeComponent,
-#         provider: ProvideConfigType,
-#     }]
+#     #[cgp_type]
 #     pub trait HasConfigType {
 #         type Config;
 #     }
 #
-#     #[cgp_component {
-#         provider: ConfigLoader,
-#     }]
+#     #[cgp_component(ConfigLoader)]
 #     pub trait CanLoadConfig: HasConfigType + HasErrorType {
 #         fn load_config(&self) -> Result<Self::Config, Self::Error>;
 #     }
 #
-#     #[cgp_component {
-#         provider: ConfigPathGetter,
-#     }]
+#     #[cgp_component(ConfigPathGetter)]
 #     pub trait HasConfigPath {
 #         fn config_path(&self) -> &PathBuf;
 #     }
@@ -139,14 +124,13 @@ load its config as follows:
 # pub mod impls {
 #     use std::{fs, io};
 #
-#     use cgp::core::error::{ErrorRaiser, ProvideErrorType};
+#     use cgp::core::error::{ErrorRaiser, ErrorRaiserComponent};
 #     use cgp::prelude::*;
 #     use serde::Deserialize;
 #
 #     use super::traits::*;
 #
-#     pub struct LoadJsonConfig;
-#
+#     #[cgp_new_provider]
 #     impl<Context> ConfigLoader<Context> for LoadJsonConfig
 #     where
 #         Context: HasConfigType
@@ -166,14 +150,7 @@ load its config as follows:
 #         }
 #     }
 #
-#     pub struct UseAnyhowError;
-#
-#     impl<Context> ProvideErrorType<Context> for UseAnyhowError {
-#         type Error = anyhow::Error;
-#     }
-#
-#     pub struct RaiseFrom;
-#
+#     #[cgp_new_provider]
 #     impl<Context, SourceError> ErrorRaiser<Context, SourceError> for RaiseFrom
 #     where
 #         Context: HasErrorType,
@@ -190,13 +167,14 @@ pub mod contexts {
     use std::path::PathBuf;
 
     use cgp::core::component::UseDelegate;
-    use cgp::core::error::{ErrorRaiserComponent, ErrorTypeComponent};
+    use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
     use cgp::prelude::*;
     use serde::Deserialize;
 
     use super::impls::*;
     use super::traits::*;
 
+    #[cgp_context]
     pub struct App {
         pub config_path: PathBuf,
     }
@@ -206,24 +184,16 @@ pub mod contexts {
         pub api_secret: String,
     }
 
-    pub struct AppComponents;
-
-    pub struct RaiseAppErrors;
-
-    impl HasProvider for App {
-        type Provider = AppComponents;
-    }
-
     delegate_components! {
         AppComponents {
-            ErrorTypeComponent: UseAnyhowError,
+            ErrorTypeProviderComponent: UseType<anyhow::Error>,
             ErrorRaiserComponent: UseDelegate<RaiseAppErrors>,
             ConfigLoaderComponent: LoadJsonConfig,
         }
     }
 
     delegate_components! {
-        RaiseAppErrors {
+        new RaiseAppErrors {
             [
                 io::Error,
                 serde_json::Error,
@@ -232,10 +202,12 @@ pub mod contexts {
         }
     }
 
-    impl ProvideConfigType<App> for AppComponents {
+    #[cgp_provider]
+    impl ConfigTypeProvider<App> for AppComponents {
         type Config = AppConfig;
     }
 
+    #[cgp_provider]
     impl ConfigPathGetter<App> for AppComponents {
         fn config_path(app: &App) -> &PathBuf {
             &app.config_path
@@ -259,7 +231,7 @@ and we use `UseDelegate<RaiseAppErrors>` to implement the error raiser.
 Inside of `RaiseAppErrors`, we make use of `RaiseFrom` to convert `std::io::Error`
 and `serde_json::Error` to `anyhow::Error` using the `From` instance.
 
-We also provide context-specific implementations of `ProvideConfigType` and
+We also provide context-specific implementations of `ConfigTypeProvider` and
 `ConfigPathGetter` for the `App` context. Following that, we define a check
 trait `CanUseApp` to check that the wiring is done correctly and that `App`
 implements `CanLoadConfig`.
@@ -300,9 +272,7 @@ details. We can do that by introduce an _error wrapper_ trait as follows:
 #
 # use cgp::prelude::*;
 #
-#[cgp_component {
-    provider: ErrorWrapper,
-}]
+#[cgp_component(ErrorWrapper)]
 pub trait CanWrapError<Detail>: HasErrorType {
     fn wrap_error(error: Self::Error, detail: Detail) -> Self::Error;
 }
@@ -328,10 +298,7 @@ To see how `CanWrapError` works in practice, we can redefine `LoadJsonConfig` to
 # use cgp::prelude::*;
 # use serde::Deserialize;
 #
-# #[cgp_component {
-#     name: ConfigTypeComponent,
-#     provider: ProvideConfigType,
-# }]
+# #[cgp_type]
 # pub trait HasConfigType {
 #     type Config;
 # }
@@ -350,8 +317,7 @@ To see how `CanWrapError` works in practice, we can redefine `LoadJsonConfig` to
 #     fn config_path(&self) -> &PathBuf;
 # }
 #
-pub struct LoadJsonConfig;
-
+#[cgp_new_provider]
 impl<Context> ConfigLoader<Context> for LoadJsonConfig
 where
     Context: HasConfigType
@@ -423,10 +389,9 @@ So we can implement an error wrapper provider for `anyhow::Error` as follows:
 # use core::fmt::Display;
 #
 # use cgp::prelude::*;
-# use cgp::core::error::ErrorWrapper;
+# use cgp::core::error::{ErrorWrapper, ErrorWrapperComponent};
 #
-pub struct WrapWithAnyhowContext;
-
+#[cgp_new_provider]
 impl<Context, Detail> ErrorWrapper<Context, Detail> for WrapWithAnyhowContext
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -490,8 +455,8 @@ type as follows:
 # use serde::Deserialize;
 #
 # #[cgp_component {
-#     name: ConfigTypeComponent,
-#     provider: ProvideConfigType,
+#     name: ConfigTypeProviderComponent,
+#     provider: ConfigTypeProvider,
 # }]
 # pub trait HasConfigType {
 #     type Config;
@@ -511,8 +476,6 @@ type as follows:
 #     fn config_path(&self) -> &PathBuf;
 # }
 #
-pub struct LoadJsonConfig;
-
 pub struct ErrLoadJsonConfig<'a, Context> {
     pub context: &'a Context,
     pub config_path: &'a PathBuf,
@@ -524,6 +487,7 @@ pub enum LoadJsonConfigAction {
     ParseFile,
 }
 
+#[cgp_new_provider]
 impl<Context> ConfigLoader<Context> for LoadJsonConfig
 where
     Context: HasConfigType
@@ -607,10 +571,9 @@ as follows:
 # use core::fmt::Debug;
 #
 # use cgp::prelude::*;
-# use cgp::core::error::ErrorWrapper;
+# use cgp::core::error::{ErrorWrapper, ErrorWrapperComponent};
 #
-pub struct WrapWithAnyhowDebug;
-
+#[cgp_new_provider]
 impl<Context, Detail> ErrorWrapper<Context, Detail> for WrapWithAnyhowDebug
 where
     Context: HasErrorType<Error = anyhow::Error>,
@@ -644,24 +607,17 @@ pub mod traits {
     use cgp::core::component::UseDelegate;
     use cgp::prelude::*;
 
-    #[cgp_component {
-        name: ConfigTypeComponent,
-        provider: ProvideConfigType,
-    }]
+    #[cgp_type]
     pub trait HasConfigType {
         type Config;
     }
 
-    #[cgp_component {
-        provider: ConfigLoader,
-    }]
+    #[cgp_component(ConfigLoader)]
     pub trait CanLoadConfig: HasConfigType + HasErrorType {
         fn load_config(&self) -> Result<Self::Config, Self::Error>;
     }
 
-    #[cgp_component {
-        provider: ConfigPathGetter,
-    }]
+    #[cgp_component(ConfigPathGetter)]
     pub trait HasConfigPath {
         fn config_path(&self) -> &PathBuf;
     }
@@ -672,14 +628,12 @@ pub mod impls {
     use std::path::PathBuf;
     use std::{fs, io};
 
-    use cgp::core::error::{ErrorRaiser, ErrorWrapper,ProvideErrorType};
+    use cgp::core::error::{ErrorRaiser, ErrorWrapper, ErrorRaiserComponent, ErrorWrapperComponent};
     use cgp::prelude::*;
     use serde::Deserialize;
 
     use super::traits::*;
 
-    pub struct LoadJsonConfig;
-
     pub struct ErrLoadJsonConfig<'a, Context> {
         pub context: &'a Context,
         pub config_path: &'a PathBuf,
@@ -691,6 +645,7 @@ pub mod impls {
         ParseFile,
     }
 
+    #[cgp_new_provider]
     impl<Context> ConfigLoader<Context> for LoadJsonConfig
     where
         Context: HasConfigType
@@ -750,14 +705,7 @@ pub mod impls {
         }
     }
 
-    pub struct UseAnyhowError;
-
-    impl<Context> ProvideErrorType<Context> for UseAnyhowError {
-        type Error = anyhow::Error;
-    }
-
-    pub struct RaiseFrom;
-
+    #[cgp_new_provider]
     impl<Context, SourceError> ErrorRaiser<Context, SourceError> for RaiseFrom
     where
         Context: HasErrorType,
@@ -768,8 +716,7 @@ pub mod impls {
         }
     }
 
-    pub struct WrapWithAnyhowDebug;
-
+    #[cgp_new_provider]
     impl<Context, Detail> ErrorWrapper<Context, Detail> for WrapWithAnyhowDebug
     where
         Context: HasErrorType<Error = anyhow::Error>,
@@ -786,13 +733,14 @@ pub mod contexts {
     use std::path::PathBuf;
 
     use cgp::core::component::UseDelegate;
-    use cgp::core::error::{ErrorRaiserComponent, ErrorWrapperComponent, ErrorTypeComponent};
+    use cgp::core::error::{ErrorRaiserComponent, ErrorWrapperComponent, ErrorTypeProviderComponent};
     use cgp::prelude::*;
     use serde::Deserialize;
 
     use super::impls::*;
     use super::traits::*;
 
+    #[cgp_context]
     pub struct App {
         pub config_path: PathBuf,
     }
@@ -802,17 +750,11 @@ pub mod contexts {
         pub secret: String,
     }
 
-    pub struct AppComponents;
-
     pub struct RaiseAppErrors;
 
-    impl HasProvider for App {
-        type Provider = AppComponents;
-    }
-
     delegate_components! {
         AppComponents {
-            ErrorTypeComponent: UseAnyhowError,
+            ErrorTypeProviderComponent: UseType<anyhow::Error>,
             ErrorRaiserComponent: UseDelegate<RaiseAppErrors>,
             ErrorWrapperComponent: WrapWithAnyhowDebug,
             ConfigLoaderComponent: LoadJsonConfig,
@@ -829,10 +771,12 @@ pub mod contexts {
         }
     }
 
-    impl ProvideConfigType<App> for AppComponents {
+    #[cgp_provider]
+    impl ConfigTypeProvider<App> for AppComponents {
         type Config = AppConfig;
     }
 
+    #[cgp_provider]
     impl ConfigPathGetter<App> for AppComponents {
         fn config_path(app: &App) -> &PathBuf {
             &app.config_path
@@ -858,10 +802,11 @@ we can also make use of the `UseDelegate` pattern to implement delegated error w
 # use core::marker::PhantomData;
 #
 # use cgp::prelude::*;
-# use cgp::core::error::ErrorWrapper;
+# use cgp::core::error::{ErrorWrapper, ErrorWrapperComponent};
 #
 # pub struct UseDelegate<Components>(pub PhantomData<Components>);
 #
+#[cgp_provider]
 impl<Context, Detail, Components> ErrorWrapper<Context, Detail> for UseDelegate<Components>
 where
     Context: HasErrorType,
@@ -892,10 +837,7 @@ to different error wrappers, similar to how we dispatch the error raisers based
 #     use cgp::core::error::ErrorWrapper;
 #     use cgp::prelude::*;
 #
-#     #[cgp_component {
-#         name: ConfigTypeComponent,
-#         provider: ProvideConfigType,
-#     }]
+#     #[cgp_type]
 #     pub trait HasConfigType {
 #         type Config;
 #     }
@@ -920,14 +862,12 @@ to different error wrappers, similar to how we dispatch the error raisers based
 #     use std::path::PathBuf;
 #     use std::{fs, io};
 #
-#     use cgp::core::error::{ErrorRaiser, ErrorWrapper, ProvideErrorType};
+#     use cgp::core::error::{ErrorRaiser, ErrorWrapper, ErrorRaiserComponent, ErrorWrapperComponent};
 #     use cgp::prelude::*;
 #     use serde::Deserialize;
 #
 #     use super::traits::*;
 #
-#     pub struct LoadJsonConfig;
-#
 #     pub struct ErrLoadJsonConfig<'a, Context> {
 #         pub context: &'a Context,
 #         pub config_path: &'a PathBuf,
@@ -939,6 +879,7 @@ to different error wrappers, similar to how we dispatch the error raisers based
 #         ParseFile,
 #     }
 #
+#     #[cgp_new_provider]
 #     impl<Context> ConfigLoader<Context> for LoadJsonConfig
 #     where
 #         Context: HasConfigType
@@ -998,14 +939,7 @@ to different error wrappers, similar to how we dispatch the error raisers based
 #         }
 #     }
 #
-#     pub struct UseAnyhowError;
-#
-#     impl<Context> ProvideErrorType<Context> for UseAnyhowError {
-#         type Error = anyhow::Error;
-#     }
-#
-#     pub struct RaiseFrom;
-#
+#     #[cgp_new_provider]
 #     impl<Context, SourceError> ErrorRaiser<Context, SourceError> for RaiseFrom
 #     where
 #         Context: HasErrorType,
@@ -1016,8 +950,7 @@ to different error wrappers, similar to how we dispatch the error raisers based
 #         }
 #     }
 #
-#     pub struct WrapWithAnyhowContext;
-#
+#     #[cgp_new_provider]
 #     impl<Context, Detail> ErrorWrapper<Context, Detail> for WrapWithAnyhowContext
 #     where
 #         Context: HasErrorType<Error = anyhow::Error>,
@@ -1028,8 +961,7 @@ to different error wrappers, similar to how we dispatch the error raisers based
 #         }
 #     }
 #
-#     pub struct WrapWithAnyhowDebug;
-#
+#     #[cgp_new_provider]
 #     impl<Context, Detail> ErrorWrapper<Context, Detail> for WrapWithAnyhowDebug
 #     where
 #         Context: HasErrorType<Error = anyhow::Error>,
@@ -1046,13 +978,14 @@ to different error wrappers, similar to how we dispatch the error raisers based
 #     use std::path::PathBuf;
 #
 #     use cgp::core::component::UseDelegate;
-#     use cgp::core::error::{ErrorRaiserComponent, ErrorWrapperComponent, ErrorTypeComponent};
+#     use cgp::core::error::{ErrorRaiserComponent, ErrorWrapperComponent, ErrorTypeProviderComponent};
 #     use cgp::prelude::*;
 #     use serde::Deserialize;
 #
 #     use super::impls::*;
 #     use super::traits::*;
 #
+#[cgp_context]
 pub struct App {
     pub config_path: PathBuf,
 }
@@ -1062,19 +995,13 @@ pub struct AppConfig {
     pub secret: String,
 }
 
-pub struct AppComponents;
-
 pub struct RaiseAppErrors;
 
 pub struct WrapAppErrors;
 
-impl HasProvider for App {
-    type Provider = AppComponents;
-}
-
 delegate_components! {
     AppComponents {
-        ErrorTypeComponent: UseAnyhowError,
+        ErrorTypeProviderComponent: UseType<anyhow::Error>,
         ErrorRaiserComponent: UseDelegate<RaiseAppErrors>,
         ErrorWrapperComponent: UseDelegate<WrapAppErrors>,
         ConfigLoaderComponent: LoadJsonConfig,
@@ -1100,10 +1027,12 @@ delegate_components! {
     }
 }
 #
-#     impl ProvideConfigType<App> for AppComponents {
+#     #[cgp_provider]
+#     impl ConfigTypeProvider<App> for AppComponents {
 #         type Config = AppConfig;
 #     }
 #
+#     #[cgp_provider]
 #     impl ConfigPathGetter<App> for AppComponents {
 #         fn config_path(app: &App) -> &PathBuf {
 #             &app.config_path

From b4bc4312ff7f705647110911fe8f3d3f7e04c4f5 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 12:30:01 +0000
Subject: [PATCH 04/19] Fix errors in field accessor chapters

---
 content/error-handling.md             |   2 +-
 content/field-accessors.md            | 162 ++++++++++++---------
 content/generic-accessor-providers.md | 196 +++++++++++++++-----------
 content/use-field-pattern.md          |  63 +++++----
 4 files changed, 240 insertions(+), 183 deletions(-)

diff --git a/content/error-handling.md b/content/error-handling.md
index fd498fb..c65df71 100644
--- a/content/error-handling.md
+++ b/content/error-handling.md
@@ -538,7 +538,7 @@ pub mod contexts {
 
 In the updated code, we refactored `ValidateTokenIsNotExpired` to use `CanRaiseError<ErrAuthTokenHasExpired>`, with `ErrAuthTokenHasExpired` implementing only `Debug`. Additionally, we use the provider `UseAnyhowError` from `cgp-error-anyhow`, which implements `ProvideErrorType` by setting `Error` to `anyhow::Error`.
 
-In the component wiring for `MockAppComponents`, we wire up `ErrorTypeComponent` with `UseAnyhowError` and `ErrorRaiserComponent` with `DebugAnyhowError`. In the context-specific implementation `AuthTokenExpiryFetcher<MockApp>`, we can now use `anyhow::Error` directly, since Rust already knows that `MockApp::Error` is the same type as `anyhow::Error`.
+In the component wiring for `MockAppComponents`, we wire up `ErrorTypeProviderComponent` with `UseAnyhowError` and `ErrorRaiserComponent` with `DebugAnyhowError`. In the context-specific implementation `AuthTokenExpiryFetcher<MockApp>`, we can now use `anyhow::Error` directly, since Rust already knows that `MockApp::Error` is the same type as `anyhow::Error`.
 
 ## Conclusion
 
diff --git a/content/field-accessors.md b/content/field-accessors.md
index 6ed77ea..d7c6779 100644
--- a/content/field-accessors.md
+++ b/content/field-accessors.md
@@ -11,12 +11,17 @@ Suppose our application needs to make API calls to an external service to read m
 #
 use cgp::prelude::*;
 
-cgp_type!( Message );
-cgp_type!( MessageId );
+#[cgp_type]
+pub trait HasMessageType {
+    type Message;
+}
+
+#[cgp_type]
+pub trait HasMessageIdType {
+    type MessageId;
+}
 
-#[cgp_component {
-    provider: MessageQuerier,
-}]
+#[cgp_component(MessageQuerier)]
 pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 }
@@ -36,18 +41,21 @@ use reqwest::blocking::Client;
 use reqwest::StatusCode;
 use serde::Deserialize;
 #
-# cgp_type!( Message );
-# cgp_type!( MessageId );
+# #[cgp_type]
+# pub trait HasMessageType {
+#     type Message;
+# }
 #
-# #[cgp_component {
-#     provider: MessageQuerier,
-# }]
+# #[cgp_type]
+# pub trait HasMessageIdType {
+#     type MessageId;
+# }
+#
+# #[cgp_component(MessageQuerier)]
 # pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
 #     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 # }
 #
-pub struct ReadMessageFromApi;
-
 #[derive(Debug)]
 pub struct ErrStatusCode {
     pub status_code: StatusCode,
@@ -58,6 +66,7 @@ pub struct ApiMessageResponse {
     pub message: String,
 }
 
+#[cgp_new_provider]
 impl<Context> MessageQuerier<Context> for ReadMessageFromApi
 where
     Context: HasMessageIdType<MessageId = u64>
@@ -105,9 +114,7 @@ In CGP, defining an accessor trait to retrieve values from the context is straig
 #
 # use cgp::prelude::*;
 #
-#[cgp_component {
-    provider: ApiBaseUrlGetter,
-}]
+#[cgp_component(ApiBaseUrlGetter)]
 pub trait HasApiBaseUrl {
     fn api_base_url(&self) -> &String;
 }
@@ -127,25 +134,26 @@ Next, we can include the `HasApiBaseUrl` trait within `ReadMessageFromApi`, allo
 # use reqwest::StatusCode;
 # use serde::Deserialize;
 #
-# cgp_type!( Message );
-# cgp_type!( MessageId );
+# #[cgp_type]
+# pub trait HasMessageType {
+#     type Message;
+# }
+#
+# #[cgp_type]
+# pub trait HasMessageIdType {
+#     type MessageId;
+# }
 #
-# #[cgp_component {
-#     provider: MessageQuerier,
-# }]
+# #[cgp_component(MessageQuerier)]
 # pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
 #     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 # }
 #
-# #[cgp_component {
-#     provider: ApiBaseUrlGetter,
-# }]
+# #[cgp_component(ApiBaseUrlGetter)]
 # pub trait HasApiBaseUrl {
 #     fn api_base_url(&self) -> &String;
 # }
 #
-# pub struct ReadMessageFromApi;
-#
 # #[derive(Debug)]
 # pub struct ErrStatusCode {
 #     pub status_code: StatusCode,
@@ -156,6 +164,7 @@ Next, we can include the `HasApiBaseUrl` trait within `ReadMessageFromApi`, allo
 #     pub message: String,
 # }
 #
+#[cgp_new_provider]
 impl<Context> MessageQuerier<Context> for ReadMessageFromApi
 where
     Context: HasMessageIdType<MessageId = u64>
@@ -195,11 +204,12 @@ Just as we did with `HasApiBaseUrl`, we can define a `HasAuthToken` trait to ret
 #
 # use cgp::prelude::*;
 #
-cgp_type!( AuthToken );
+#[cgp_type]
+pub trait HasAuthTokenType {
+    type AuthToken;
+}
 
-#[cgp_component {
-    provider: AuthTokenGetter,
-}]
+#[cgp_component(AuthTokenGetter)]
 pub trait HasAuthToken: HasAuthTokenType {
     fn auth_token(&self) -> &Self::AuthToken;
 }
@@ -221,13 +231,22 @@ Next, we define a getter trait, `HasAuthToken`, which provides access to an abst
 # use reqwest::StatusCode;
 # use serde::Deserialize;
 #
-# cgp_type!( Message );
-# cgp_type!( MessageId );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasMessageType {
+#     type Message;
+# }
+#
+# #[cgp_type]
+# pub trait HasMessageIdType {
+#     type MessageId;
+# }
 #
-# #[cgp_component {
-#     provider: MessageQuerier,
-# }]
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(MessageQuerier)]
 # pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
 #     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 # }
@@ -246,8 +265,6 @@ Next, we define a getter trait, `HasAuthToken`, which provides access to an abst
 #     fn auth_token(&self) -> &Self::AuthToken;
 # }
 #
-# pub struct ReadMessageFromApi;
-#
 # #[derive(Debug)]
 # pub struct ErrStatusCode {
 #     pub status_code: StatusCode,
@@ -258,6 +275,7 @@ Next, we define a getter trait, `HasAuthToken`, which provides access to an abst
 #     pub message: String,
 # }
 #
+#[cgp_new_provider]
 impl<Context> MessageQuerier<Context> for ReadMessageFromApi
 where
     Context: HasMessageIdType<MessageId = u64>
@@ -303,11 +321,12 @@ When creating providers like `ReadMessageFromApi`, which often need to use both
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
 #
-#[cgp_component {
-    provider: ApiClientFieldsGetter,
-}]
+#[cgp_component(ApiClientFieldsGetter)]
 pub trait HasApiClientFields: HasAuthTokenType {
     fn api_base_url(&self) -> &String;
 
@@ -339,9 +358,7 @@ pub struct ApiClientFields {
     pub auth_token: String,
 }
 
-#[cgp_component {
-    provider: ApiClientFieldsGetter,
-}]
+#[cgp_component(ApiClientFieldsGetter)]
 pub trait HasApiClientFields {
     fn api_client_fields(&self) -> &ApiClientFields;
 }
@@ -370,20 +387,29 @@ as follows:
 #
 # use cgp::core::component::UseDelegate;
 # use cgp::extra::error::RaiseFrom;
-# use cgp::core::error::{ErrorRaiserComponent, ErrorTypeComponent};
+# use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
 # use cgp::prelude::*;
 # use cgp_error_anyhow::{DebugAnyhowError, UseAnyhowError};
 # use reqwest::blocking::Client;
 # use reqwest::StatusCode;
 # use serde::Deserialize;
 #
-# cgp_type!( Message );
-# cgp_type!( MessageId );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasMessageType {
+#     type Message;
+# }
 #
-# #[cgp_component {
-#     provider: MessageQuerier,
-# }]
+# #[cgp_type]
+# pub trait HasMessageIdType {
+#     type MessageId;
+# }
+#
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(MessageQuerier)]
 # pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
 #     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 # }
@@ -402,8 +428,6 @@ as follows:
 #     fn auth_token(&self) -> &Self::AuthToken;
 # }
 #
-# pub struct ReadMessageFromApi;
-#
 # #[derive(Debug)]
 # pub struct ErrStatusCode {
 #     pub status_code: StatusCode,
@@ -414,6 +438,7 @@ as follows:
 #     pub message: String,
 # }
 #
+# #[cgp_new_provider]
 # impl<Context> MessageQuerier<Context> for ReadMessageFromApi
 # where
 #     Context: HasMessageIdType<MessageId = u64>
@@ -447,43 +472,44 @@ as follows:
 #     }
 # }
 #
+#[cgp_context]
 pub struct ApiClient {
     pub api_base_url: String,
     pub auth_token: String,
 }
 
-pub struct ApiClientComponents;
-
-pub struct RaiseApiErrors;
-
-impl HasProvider for ApiClient {
-    type Provider = ApiClientComponents;
-}
-
 delegate_components! {
     ApiClientComponents {
-        ErrorTypeComponent: UseAnyhowError,
-        ErrorRaiserComponent: UseDelegate<RaiseApiErrors>,
-        MessageIdTypeComponent: UseType<u64>,
-        MessageTypeComponent: UseType<String>,
-        AuthTokenTypeProviderComponent: UseType<String>,
-        MessageQuerierComponent: ReadMessageFromApi,
+        ErrorTypeProviderComponent:
+            UseAnyhowError,
+        ErrorRaiserComponent:
+            UseDelegate<RaiseApiErrors>,
+        MessageIdTypeProviderComponent:
+            UseType<u64>,
+        MessageTypeProviderComponent:
+            UseType<String>,
+        AuthTokenTypeProviderComponent:
+            UseType<String>,
+        MessageQuerierComponent:
+            ReadMessageFromApi,
     }
 }
 
 delegate_components! {
-    RaiseApiErrors {
+    new RaiseApiErrors {
         reqwest::Error: RaiseFrom,
         ErrStatusCode: DebugAnyhowError,
     }
 }
 
+#[cgp_provider]
 impl ApiBaseUrlGetter<ApiClient> for ApiClientComponents {
     fn api_base_url(api_client: &ApiClient) -> &String {
         &api_client.api_base_url
     }
 }
 
+#[cgp_provider]
 impl AuthTokenGetter<ApiClient> for ApiClientComponents {
     fn auth_token(api_client: &ApiClient) -> &String {
         &api_client.auth_token
diff --git a/content/generic-accessor-providers.md b/content/generic-accessor-providers.md
index 8262d97..78cf3d1 100644
--- a/content/generic-accessor-providers.md
+++ b/content/generic-accessor-providers.md
@@ -10,7 +10,7 @@ To enable the implementation of context-generic accessors, the `cgp` crate provi
 pub trait HasField<Tag> {
     type Value;
 
-    fn get_field(&self, tag: PhantomData<Tag>) -> &Self::Value;
+    fn get_field(&self, _tag: PhantomData<Tag>) -> &Self::Value;
 }
 ```
 
@@ -147,7 +147,10 @@ To streamline the creation of auto accessor traits, the `cgp` crate provides the
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
 #
 #[cgp_auto_getter]
 pub trait HasApiBaseUrl {
@@ -171,7 +174,10 @@ The `#[cgp_auto_getter]` attribute can also be applied to accessor traits that d
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
 #
 #[cgp_auto_getter]
 pub trait HasApiClientFields: HasAuthTokenType {
@@ -201,8 +207,7 @@ With `HasField`, we can implement context-generic providers like `ApiUrlGetter`.
 #     fn api_base_url(&self) -> &String;
 # }
 #
-pub struct GetApiUrl;
-
+#[cgp_new_provider]
 impl<Context> ApiBaseUrlGetter<Context> for GetApiUrl
 where
     Context: HasField<symbol!("api_url"), Value = String>,
@@ -224,7 +229,10 @@ Similarly, we can implement a context-generic provider for `AuthTokenGetter` as
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
 #
 # #[cgp_component {
 #     provider: AuthTokenGetter,
@@ -233,8 +241,7 @@ Similarly, we can implement a context-generic provider for `AuthTokenGetter` as
 #     fn auth_token(&self) -> &Self::AuthToken;
 # }
 #
-pub struct GetAuthToken;
-
+#[cgp_new_provider]
 impl<Context> AuthTokenGetter<Context> for GetAuthToken
 where
     Context: HasAuthTokenType + HasField<symbol!("auth_token"), Value = Context::AuthToken>,
@@ -271,7 +278,10 @@ With `UseFields`, we can bypass the need to define custom provider structs and i
 #     fn api_base_url(&self) -> &String;
 # }
 #
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
 #
 # #[cgp_component {
 #     provider: AuthTokenGetter,
@@ -280,6 +290,7 @@ With `UseFields`, we can bypass the need to define custom provider structs and i
 #     fn auth_token(&self) -> &Self::AuthToken;
 # }
 #
+#[cgp_provider]
 impl<Context> ApiBaseUrlGetter<Context> for UseFields
 where
     Context: HasField<symbol!("api_url"), Value = String>,
@@ -289,6 +300,7 @@ where
     }
 }
 
+#[cgp_provider]
 impl<Context> AuthTokenGetter<Context> for UseFields
 where
     Context: HasAuthTokenType + HasField<symbol!("auth_token"), Value = Context::AuthToken>,
@@ -314,7 +326,7 @@ With `#[cgp_getter]`, you can define accessor traits and seamlessly use `UseFiel
 # use core::fmt::Display;
 #
 # use cgp::core::component::UseDelegate;
-# use cgp::core::error::{ErrorRaiserComponent, ErrorTypeComponent};
+# use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
 # use cgp::core::field::UseField;
 # use cgp::extra::error::RaiseFrom;
 # use cgp::prelude::*;
@@ -323,19 +335,26 @@ With `#[cgp_getter]`, you can define accessor traits and seamlessly use `UseFiel
 # use reqwest::StatusCode;
 # use serde::Deserialize;
 #
-# cgp_type!(Message);
-# cgp_type!(MessageId);
-# cgp_type!(AuthToken);
+# #[cgp_type]
+# pub trait HasMessageType {
+#     type Message;
+# }
 #
-# #[cgp_component {
-#     provider: MessageQuerier,
-# }]
+# #[cgp_type]
+# pub trait HasMessageIdType {
+#     type MessageId;
+# }
+#
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(MessageQuerier)]
 # pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
 #     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 # }
 #
-# pub struct ReadMessageFromApi;
-#
 # #[derive(Debug)]
 # pub struct ErrStatusCode {
 #     pub status_code: StatusCode,
@@ -346,6 +365,7 @@ With `#[cgp_getter]`, you can define accessor traits and seamlessly use `UseFiel
 #     pub message: String,
 # }
 #
+# #[cgp_new_provider]
 # impl<Context> MessageQuerier<Context> for ReadMessageFromApi
 # where
 #     Context: HasMessageIdType<MessageId = u64>
@@ -379,44 +399,41 @@ With `#[cgp_getter]`, you can define accessor traits and seamlessly use `UseFiel
 #     }
 # }
 #
-#[cgp_getter {
-    provider: ApiBaseUrlGetter,
-}]
+#[cgp_getter]
 pub trait HasApiBaseUrl {
     fn api_base_url(&self) -> &String;
 }
 
-#[cgp_getter {
-    provider: AuthTokenGetter,
-}]
+#[cgp_getter]
 pub trait HasAuthToken: HasAuthTokenType {
     fn auth_token(&self) -> &Self::AuthToken;
 }
 
+#[cgp_context]
 #[derive(HasField)]
 pub struct ApiClient {
     pub api_base_url: String,
     pub auth_token: String,
 }
 
-pub struct ApiClientComponents;
-
-impl HasProvider for ApiClient {
-    type Provider = ApiClientComponents;
-}
-
 delegate_components! {
     ApiClientComponents {
-        ErrorTypeComponent: UseAnyhowError,
-        ErrorRaiserComponent: UseDelegate<RaiseApiErrors>,
-        MessageTypeComponent: UseType<String>,
-        MessageIdTypeComponent: UseType<u64>,
-        AuthTokenTypeProviderComponent: UseType<String>,
+        ErrorTypeProviderComponent:
+            UseAnyhowError,
+        ErrorRaiserComponent:
+            UseDelegate<RaiseApiErrors>,
+        MessageTypeProviderComponent:
+            UseType<String>,
+        MessageIdTypeProviderComponent:
+            UseType<u64>,
+        AuthTokenTypeProviderComponent:
+            UseType<String>,
         [
             ApiBaseUrlGetterComponent,
             AuthTokenGetterComponent,
         ]: UseFields,
-        MessageQuerierComponent: ReadMessageFromApi,
+        MessageQuerierComponent:
+            ReadMessageFromApi,
     }
 }
 #
@@ -447,11 +464,12 @@ Like `#[cgp_auto_getter]`, `#[cgp_getter]` can also be used with accessor traits
 #
 # use cgp::prelude::*;
 #
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
 #
-#[cgp_getter {
-    provider: ApiClientFieldsGetter,
-}]
+#[cgp_getter]
 pub trait HasApiClientFields: HasAuthTokenType {
     fn api_base_url(&self) -> &String;
 
@@ -473,15 +491,12 @@ use std::sync::OnceLock;
 
 # use cgp::prelude::*;
 #
-# #[cgp_component {
-#     provider: ApiBaseUrlGetter,
-# }]
+# #[cgp_getter]
 # pub trait HasApiBaseUrl {
 #     fn api_base_url(&self) -> &String;
 # }
 #
-pub struct UseProductionApiUrl;
-
+#[cgp_new_provider]
 impl<Context> ApiBaseUrlGetter<Context> for UseProductionApiUrl {
     fn api_base_url(_context: &Context) -> &String {
         static BASE_URL: OnceLock<String> = OnceLock::new();
@@ -509,7 +524,7 @@ With `UseProductionApiUrl`, we can now define a production `ApiClient` context,
 #
 # use cgp::core::component::UseDelegate;
 # use cgp::extra::error::RaiseFrom;
-# use cgp::core::error::{ErrorRaiserComponent, ErrorTypeComponent};
+# use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
 # use cgp::core::field::UseField;
 # use cgp::prelude::*;
 # use cgp_error_anyhow::{DebugAnyhowError, UseAnyhowError};
@@ -517,13 +532,22 @@ With `UseProductionApiUrl`, we can now define a production `ApiClient` context,
 # use reqwest::StatusCode;
 # use serde::Deserialize;
 #
-# cgp_type!( Message );
-# cgp_type!( MessageId );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasMessageType {
+#     type Message;
+# }
+#
+# #[cgp_type]
+# pub trait HasMessageIdType {
+#     type MessageId;
+# }
 #
-# #[cgp_component {
-#     provider: MessageQuerier,
-# }]
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(MessageQuerier)]
 # pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
 #     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 # }
@@ -542,8 +566,6 @@ With `UseProductionApiUrl`, we can now define a production `ApiClient` context,
 #     fn auth_token(&self) -> &Self::AuthToken;
 # }
 #
-# pub struct ReadMessageFromApi;
-#
 # #[derive(Debug)]
 # pub struct ErrStatusCode {
 #     pub status_code: StatusCode,
@@ -554,6 +576,7 @@ With `UseProductionApiUrl`, we can now define a production `ApiClient` context,
 #     pub message: String,
 # }
 #
+# #[cgp_new_provider]
 # impl<Context> MessageQuerier<Context> for ReadMessageFromApi
 # where
 #     Context: HasMessageIdType<MessageId = u64>
@@ -587,8 +610,7 @@ With `UseProductionApiUrl`, we can now define a production `ApiClient` context,
 #     }
 # }
 #
-# pub struct UseProductionApiUrl;
-#
+# #[cgp_new_provider]
 # impl<Context> ApiBaseUrlGetter<Context> for UseProductionApiUrl {
 #     fn api_base_url(_context: &Context) -> &String {
 #         static BASE_URL: OnceLock<String> = OnceLock::new();
@@ -597,8 +619,7 @@ With `UseProductionApiUrl`, we can now define a production `ApiClient` context,
 #     }
 # }
 #
-# pub struct GetAuthToken;
-#
+# #[cgp_new_provider]
 # impl<Context> AuthTokenGetter<Context> for GetAuthToken
 # where
 #     Context: HasAuthTokenType + HasField<symbol!("auth_token"), Value = Context::AuthToken>,
@@ -608,34 +629,35 @@ With `UseProductionApiUrl`, we can now define a production `ApiClient` context,
 #     }
 # }
 #
+#[cgp_context]
 #[derive(HasField)]
 pub struct ApiClient {
     pub auth_token: String,
 }
 
-pub struct ApiClientComponents;
-
-# pub struct RaiseApiErrors;
-#
-impl HasProvider for ApiClient {
-    type Provider = ApiClientComponents;
-}
-
 delegate_components! {
     ApiClientComponents {
-        ErrorTypeComponent: UseAnyhowError,
-        ErrorRaiserComponent: UseDelegate<RaiseApiErrors>,
-        MessageIdTypeComponent: UseType<u64>,
-        MessageTypeComponent: UseType<String>,
-        AuthTokenTypeProviderComponent: UseType<String>,
-        ApiBaseUrlGetterComponent: UseProductionApiUrl,
-        AuthTokenGetterComponent: GetAuthToken,
-        MessageQuerierComponent: ReadMessageFromApi,
+        ErrorTypeProviderComponent:
+            UseAnyhowError,
+        ErrorRaiserComponent:
+            UseDelegate<RaiseApiErrors>,
+        MessageIdTypeProviderComponent:
+            UseType<u64>,
+        MessageTypeProviderComponent:
+            UseType<String>,
+        AuthTokenTypeProviderComponent:
+            UseType<String>,
+        ApiBaseUrlGetterComponent:
+            UseProductionApiUrl,
+        AuthTokenGetterComponent:
+            GetAuthToken,
+        MessageQuerierComponent:
+            ReadMessageFromApi,
     }
 }
 #
 # delegate_components! {
-#     RaiseApiErrors {
+#     new RaiseApiErrors {
 #         reqwest::Error: RaiseFrom,
 #         ErrStatusCode: DebugAnyhowError,
 #     }
@@ -667,19 +689,26 @@ Since the `HasField` trait can be automatically derived by contexts, some develo
 # use reqwest::StatusCode;
 # use serde::Deserialize;
 #
-# cgp_type!( Message );
-# cgp_type!( MessageId );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasMessageType {
+#     type Message;
+# }
 #
-# #[cgp_component {
-#     provider: MessageQuerier,
-# }]
+# #[cgp_type]
+# pub trait HasMessageIdType {
+#     type MessageId;
+# }
+#
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(MessageQuerier)]
 # pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
 #     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 # }
 #
-# pub struct ReadMessageFromApi;
-#
 # #[derive(Debug)]
 # pub struct ErrStatusCode {
 #     pub status_code: StatusCode,
@@ -690,6 +719,7 @@ Since the `HasField` trait can be automatically derived by contexts, some develo
 #     pub message: String,
 # }
 #
+#[cgp_new_provider]
 impl<Context> MessageQuerier<Context> for ReadMessageFromApi
 where
     Context: HasMessageIdType<MessageId = u64>
diff --git a/content/use-field-pattern.md b/content/use-field-pattern.md
index a3fef99..443a801 100644
--- a/content/use-field-pattern.md
+++ b/content/use-field-pattern.md
@@ -22,14 +22,16 @@ Similar to the [`UseDelegate` pattern](./delegated-error-raiser.md), the `UseFie
 # use cgp::prelude::*;
 # use cgp::core::field::UseField;
 #
-# #[cgp_component {
-#     provider: ApiBaseUrlGetter,
-# }]
+# #[cgp_component(ApiBaseUrlGetter)]
 # pub trait HasApiBaseUrl {
 #     fn api_base_url(&self) -> &String;
 # }
 #
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
 # #[cgp_component {
 #     provider: AuthTokenGetter,
 # }]
@@ -37,6 +39,7 @@ Similar to the [`UseDelegate` pattern](./delegated-error-raiser.md), the `UseFie
 #     fn auth_token(&self) -> &Self::AuthToken;
 # }
 #
+#[cgp_provider]
 impl<Context, Tag> ApiBaseUrlGetter<Context> for UseField<Tag>
 where
     Context: HasField<Tag, Value = String>,
@@ -46,6 +49,7 @@ where
     }
 }
 
+#[cgp_provider]
 impl<Context, Tag> AuthTokenGetter<Context> for UseField<Tag>
 where
     Context: HasAuthTokenType + HasField<Tag, Value = Context::AuthToken>,
@@ -76,7 +80,7 @@ By combining `#[cgp_getter]` with `UseField`, we can streamline the implementati
 #
 # use cgp::core::component::UseDelegate;
 # use cgp::extra::error::RaiseFrom;
-# use cgp::core::error::{ErrorRaiserComponent, ErrorTypeComponent};
+# use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
 # use cgp::core::field::UseField;
 # use cgp::prelude::*;
 # use cgp_error_anyhow::{DebugAnyhowError, UseAnyhowError};
@@ -84,33 +88,36 @@ By combining `#[cgp_getter]` with `UseField`, we can streamline the implementati
 # use reqwest::StatusCode;
 # use serde::Deserialize;
 #
-# cgp_type!( Message );
-# cgp_type!( MessageId );
-# cgp_type!( AuthToken );
+# #[cgp_type]
+# pub trait HasMessageType {
+#     type Message;
+# }
 #
-# #[cgp_component {
-#     provider: MessageQuerier,
-# }]
+# #[cgp_type]
+# pub trait HasMessageIdType {
+#     type MessageId;
+# }
+#
+# #[cgp_type]
+# pub trait HasAuthTokenType {
+#     type AuthToken;
+# }
+#
+# #[cgp_component(MessageQuerier)]
 # pub trait CanQueryMessage: HasMessageIdType + HasMessageType + HasErrorType {
 #     fn query_message(&self, message_id: &Self::MessageId) -> Result<Self::Message, Self::Error>;
 # }
 #
-#[cgp_getter {
-    provider: ApiBaseUrlGetter,
-}]
+#[cgp_getter]
 pub trait HasApiBaseUrl {
     fn api_base_url(&self) -> &String;
 }
 
-#[cgp_getter {
-    provider: AuthTokenGetter,
-}]
+#[cgp_getter]
 pub trait HasAuthToken: HasAuthTokenType {
     fn auth_token(&self) -> &Self::AuthToken;
 }
 
-# pub struct ReadMessageFromApi;
-#
 # #[derive(Debug)]
 # pub struct ErrStatusCode {
 #     pub status_code: StatusCode,
@@ -121,6 +128,7 @@ pub trait HasAuthToken: HasAuthTokenType {
 #     pub message: String,
 # }
 #
+# #[cgp_new_provider]
 # impl<Context> MessageQuerier<Context> for ReadMessageFromApi
 # where
 #     Context: HasMessageIdType<MessageId = u64>
@@ -154,26 +162,19 @@ pub trait HasAuthToken: HasAuthTokenType {
 #     }
 # }
 #
+# #[cgp_context]
 # #[derive(HasField)]
 # pub struct ApiClient {
 #     pub api_base_url: String,
 #     pub auth_token: String,
 # }
 #
-# pub struct ApiClientComponents;
-#
-# pub struct RaiseApiErrors;
-#
-# impl HasProvider for ApiClient {
-#     type Provider = ApiClientComponents;
-# }
-#
 delegate_components! {
     ApiClientComponents {
-        ErrorTypeComponent: UseAnyhowError,
+        ErrorTypeProviderComponent: UseAnyhowError,
         ErrorRaiserComponent: UseDelegate<RaiseApiErrors>,
-        MessageIdTypeComponent: UseType<u64>,
-        MessageTypeComponent: UseType<String>,
+        MessageIdTypeProviderComponent: UseType<u64>,
+        MessageTypeProviderComponent: UseType<String>,
         AuthTokenTypeProviderComponent: UseType<String>,
         ApiBaseUrlGetterComponent: UseField<symbol!("api_base_url")>,
         AuthTokenGetterComponent: UseField<symbol!("auth_token")>,
@@ -182,7 +183,7 @@ delegate_components! {
 }
 #
 # delegate_components! {
-#     RaiseApiErrors {
+#     new RaiseApiErrors {
 #         reqwest::Error: RaiseFrom,
 #         ErrStatusCode: DebugAnyhowError,
 #     }

From 8308b31f4b2eae6af6f5753e791164e8bd2a2f50 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 12:42:23 +0000
Subject: [PATCH 05/19] Fix remaining chapters

---
 content/consumer-provider-link.md | 20 ++++++++--------
 content/provider-delegation.md    | 40 +++++++++++++++----------------
 2 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/content/consumer-provider-link.md b/content/consumer-provider-link.md
index 52ae55e..5b72051 100644
--- a/content/consumer-provider-link.md
+++ b/content/consumer-provider-link.md
@@ -90,7 +90,7 @@ as follows:
 
 ```rust
 pub trait HasProvider {
-    type Components;
+    type Provider;
 }
 
 pub trait CanFormatString {
@@ -104,20 +104,20 @@ pub trait StringFormatter<Context> {
 impl<Context> CanFormatString for Context
 where
     Context: HasProvider,
-    Context::Components: StringFormatter<Context>,
+    Context::Provider: StringFormatter<Context>,
 {
     fn format_string(&self) -> String {
-        Context::Components::format_string(self)
+        Context::Provider::format_string(self)
     }
 }
 ```
 
 First of all, we define a new `HasProvider` trait that contains an associated
-type `Components`. The `Components` type would be specified by a context to
+type `Provider`. The `Provider` type would be specified by a context to
 choose a provider that it would use to forward all implementations of consumer
 traits. Following that, we add a blanket implementation for `CanFormatString`,
 which would be implemented for any `Context` that implements `HasProvider`,
-provided that `Context::Components` implements `StringFormatter<Context>`.
+provided that `Context::Provider` implements `StringFormatter<Context>`.
 
 To explain in simpler terms - if a context has a provider that implements
 a provider trait for that context, then the consumer trait for that context
@@ -151,7 +151,7 @@ let person = Person { first_name: "John".into(), last_name: "Smith".into() };
 assert_eq!(person.format_string(), "John Smith");
 #
 # pub trait HasProvider {
-#     type Components;
+#     type Provider;
 # }
 #
 # pub trait CanFormatString {
@@ -165,10 +165,10 @@ assert_eq!(person.format_string(), "John Smith");
 # impl<Context> CanFormatString for Context
 # where
 #     Context: HasProvider,
-#     Context::Components: StringFormatter<Context>,
+#     Context::Provider: StringFormatter<Context>,
 # {
 #     fn format_string(&self) -> String {
-#         Context::Components::format_string(self)
+#         Context::Provider::format_string(self)
 #     }
 # }
 #
@@ -189,9 +189,9 @@ implementing `CanFormatString` directly, since we only need to specify the provi
 type without any function definition.
 
 At the moment, because the `Person` context only implements one consumer trait, we
-can set `FormatStringWithDisplay` directly as `Person::Components`. However, if there
+can set `FormatStringWithDisplay` directly as `Person::Provider`. However, if there
 are other consumer traits that we would like to use with `Person`, we would need to
-define `Person::Components` with a separate provider that implements multiple provider
+define `Person::Provider` with a separate provider that implements multiple provider
 traits. This will be covered in the next chapter, which we would talk about how to
 link multiple providers of different provider traits together.
 
diff --git a/content/provider-delegation.md b/content/provider-delegation.md
index 34b254d..c14b517 100644
--- a/content/provider-delegation.md
+++ b/content/provider-delegation.md
@@ -47,7 +47,7 @@ Next, we also define the provider traits as follows:
 # use anyhow::Error;
 #
 # pub trait HasProvider {
-#     type Components;
+#     type Provider;
 # }
 #
 # pub trait CanFormatToString {
@@ -69,20 +69,20 @@ pub trait StringParser<Context> {
 impl<Context> CanFormatToString for Context
 where
     Context: HasProvider,
-    Context::Components: StringFormatter<Context>,
+    Context::Provider: StringFormatter<Context>,
 {
     fn format_to_string(&self) -> Result<String, Error> {
-        Context::Components::format_to_string(self)
+        Context::Provider::format_to_string(self)
     }
 }
 
 impl<Context> CanParseFromString for Context
 where
     Context: HasProvider,
-    Context::Components: StringParser<Context>,
+    Context::Provider: StringParser<Context>,
 {
     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-        Context::Components::parse_from_string(raw)
+        Context::Provider::parse_from_string(raw)
     }
 }
 ```
@@ -172,7 +172,7 @@ and `StringParser` by delegating the call to the actual providers.
 # use serde::{Serialize, Deserialize};
 #
 # pub trait HasProvider {
-#     type Components;
+#     type Provider;
 # }
 #
 # pub trait CanFormatToString {
@@ -194,20 +194,20 @@ and `StringParser` by delegating the call to the actual providers.
 # impl<Context> CanFormatToString for Context
 # where
 #     Context: HasProvider,
-#     Context::Components: StringFormatter<Context>,
+#     Context::Provider: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Components::format_to_string(self)
+#         Context::Provider::format_to_string(self)
 #     }
 # }
 #
 # impl<Context> CanParseFromString for Context
 # where
 #     Context: HasProvider,
-#     Context::Components: StringParser<Context>,
+#     Context::Provider: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Components::parse_from_string(raw)
+#         Context::Provider::parse_from_string(raw)
 #     }
 # }
 #
@@ -392,7 +392,7 @@ back to the example of implementing the concrete context `Person`.
 # use serde::{Serialize, Deserialize};
 #
 # pub trait HasProvider {
-#     type Components;
+#     type Provider;
 # }
 #
 # pub trait CanFormatToString {
@@ -414,20 +414,20 @@ back to the example of implementing the concrete context `Person`.
 # impl<Context> CanFormatToString for Context
 # where
 #     Context: HasProvider,
-#     Context::Components: StringFormatter<Context>,
+#     Context::Provider: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Components::format_to_string(self)
+#         Context::Provider::format_to_string(self)
 #     }
 # }
 #
 # impl<Context> CanParseFromString for Context
 # where
 #     Context: HasProvider,
-#     Context::Components: StringParser<Context>,
+#     Context::Provider: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Components::parse_from_string(raw)
+#         Context::Provider::parse_from_string(raw)
 #     }
 # }
 #
@@ -580,7 +580,7 @@ which provider to use in each concrete context implementation.
 # use serde::{Serialize, Deserialize};
 #
 # pub trait HasProvider {
-#     type Components;
+#     type Provider;
 # }
 #
 # pub trait CanFormatToString {
@@ -602,20 +602,20 @@ which provider to use in each concrete context implementation.
 # impl<Context> CanFormatToString for Context
 # where
 #     Context: HasProvider,
-#     Context::Components: StringFormatter<Context>,
+#     Context::Provider: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Components::format_to_string(self)
+#         Context::Provider::format_to_string(self)
 #     }
 # }
 #
 # impl<Context> CanParseFromString for Context
 # where
 #     Context: HasProvider,
-#     Context::Components: StringParser<Context>,
+#     Context::Provider: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Components::parse_from_string(raw)
+#         Context::Provider::parse_from_string(raw)
 #     }
 # }
 #

From 18c9a24b672f3c8903d451c0474baf5310b433b2 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 13:44:00 +0000
Subject: [PATCH 06/19] Adding IsProviderFor section

---
 content/SUMMARY.md                            |   2 +-
 ...ing-techniques.md => debugging-support.md} | 379 ++++++++++++++++--
 2 files changed, 337 insertions(+), 44 deletions(-)
 rename content/{debugging-techniques.md => debugging-support.md} (68%)

diff --git a/content/SUMMARY.md b/content/SUMMARY.md
index 6a01cb9..f0855e6 100644
--- a/content/SUMMARY.md
+++ b/content/SUMMARY.md
@@ -15,8 +15,8 @@
 - [Provider Traits](provider-traits.md)
 - [Linking Consumers with Providers](consumer-provider-link.md)
 - [Provider Delegation](provider-delegation.md)
+- [Debugging Support](debugging-support.md)
 - [Component Macros](component-macros.md)
-- [Debugging Techniques](debugging-techniques.md)
 
 # Design Patterns
 
diff --git a/content/debugging-techniques.md b/content/debugging-support.md
similarity index 68%
rename from content/debugging-techniques.md
rename to content/debugging-support.md
index ff99f03..829eaac 100644
--- a/content/debugging-techniques.md
+++ b/content/debugging-support.md
@@ -1,4 +1,4 @@
-# Debugging Techniques
+# Debugging Support
 
 By leveraging [impl-side dependencies](./impl-side-dependencies.md), CGP providers
 are able to include additional dependencies that are not specified in the provider
@@ -22,40 +22,60 @@ try to use a consumer trait against a concrete context.
 ## Unsatisfied Dependency Errors
 
 To demonstrate how such error would arise, we would reuse the same example
-`Person` context as the [previous chapter](./component-macros.md#example-use).
+`Person` context as the [previous chapter](./provider-delegation.md).
 Consider if we made a mistake and forgot to implement `Serialize` for `Person`:
 
+
 ```rust
 # extern crate anyhow;
 # extern crate serde;
 # extern crate serde_json;
-# extern crate cgp;
 #
-# use cgp::prelude::*;
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# #[cgp_component {
-#    name: StringFormatterComponent,
-#    provider: StringFormatter,
-#    context: Context,
-# }]
+# pub trait HasProvider {
+#     type Provider;
+# }
+#
 # pub trait CanFormatToString {
 #     fn format_to_string(&self) -> Result<String, Error>;
 # }
 #
-# #[cgp_component {
-#    name: StringParserComponent,
-#    provider: StringParser,
-#    context: Context,
-# }]
 # pub trait CanParseFromString: Sized {
 #     fn parse_from_string(raw: &str) -> Result<Self, Error>;
 # }
 #
+# pub trait StringFormatter<Context> {
+#     fn format_to_string(context: &Context) -> Result<String, Error>;
+# }
+#
+# pub trait StringParser<Context> {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error>;
+# }
+#
+# impl<Context> CanFormatToString for Context
+# where
+#     Context: HasProvider,
+#     Context::Provider: StringFormatter<Context>,
+# {
+#     fn format_to_string(&self) -> Result<String, Error> {
+#         Context::Provider::format_to_string(self)
+#     }
+# }
+#
+# impl<Context> CanParseFromString for Context
+# where
+#     Context: HasProvider,
+#     Context::Provider: StringParser<Context>,
+# {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error> {
+#         Context::Provider::parse_from_string(raw)
+#     }
+# }
+#
 # pub struct FormatAsJsonString;
 #
-# #[cgp_provider(StringFormatterComponent)]
 # impl<Context> StringFormatter<Context> for FormatAsJsonString
 # where
 #     Context: Serialize,
@@ -67,7 +87,6 @@ Consider if we made a mistake and forgot to implement `Serialize` for `Person`:
 #
 # pub struct ParseFromJsonString;
 #
-# #[cgp_provider(StringParserComponent)]
 # impl<Context> StringParser<Context> for ParseFromJsonString
 # where
 #     Context: for<'a> Deserialize<'a>,
@@ -77,7 +96,34 @@ Consider if we made a mistake and forgot to implement `Serialize` for `Person`:
 #     }
 # }
 #
-// Note: We forgot to derive Serialize here
+# pub trait DelegateComponent<Name> {
+#     type Delegate;
+# }
+#
+# pub struct StringFormatterComponent;
+#
+# pub struct StringParserComponent;
+#
+# impl<Context, Component> StringFormatter<Context> for Component
+# where
+#     Component: DelegateComponent<StringFormatterComponent>,
+#     Component::Delegate: StringFormatter<Context>,
+# {
+#     fn format_to_string(context: &Context) -> Result<String, Error> {
+#         Component::Delegate::format_to_string(context)
+#     }
+# }
+#
+# impl<Context, Component> StringParser<Context> for Component
+# where
+#     Component: DelegateComponent<StringParserComponent>,
+#     Component::Delegate: StringParser<Context>,
+# {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error> {
+#         Component::Delegate::parse_from_string(raw)
+#     }
+# }
+// Note: We pretend to forgot to derive Serialize here
 #[derive(Deserialize, Debug, Eq, PartialEq)]
 pub struct Person {
     pub first_name: String,
@@ -90,11 +136,12 @@ impl HasProvider for Person {
     type Provider = PersonComponents;
 }
 
-delegate_components! {
-    PersonComponents {
-        StringFormatterComponent: FormatAsJsonString,
-        StringParserComponent: ParseFromJsonString,
-    }
+impl DelegateComponent<StringFormatterComponent> for PersonComponents {
+    type Delegate = FormatAsJsonString;
+}
+
+impl DelegateComponent<StringParserComponent> for PersonComponents {
+    type Delegate = ParseFromJsonString;
 }
 ```
 
@@ -107,35 +154,54 @@ However, notice that the above code still compiles successfully. This is because
 have not yet try to use `CanFormatToString` on person. We can try to add test code to
 call `format_to_string`, and check if it works:
 
-
 ```rust,compile_fail
 # extern crate anyhow;
 # extern crate serde;
 # extern crate serde_json;
-# extern crate cgp;
 #
-# use cgp::prelude::*;
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# #[cgp_component {
-#    name: StringFormatterComponent,
-#    provider: StringFormatter,
-#    context: Context,
-# }]
+# pub trait HasProvider {
+#     type Provider;
+# }
+#
 # pub trait CanFormatToString {
 #     fn format_to_string(&self) -> Result<String, Error>;
 # }
 #
-# #[cgp_component {
-#    name: StringParserComponent,
-#    provider: StringParser,
-#    context: Context,
-# }]
 # pub trait CanParseFromString: Sized {
 #     fn parse_from_string(raw: &str) -> Result<Self, Error>;
 # }
 #
+# pub trait StringFormatter<Context> {
+#     fn format_to_string(context: &Context) -> Result<String, Error>;
+# }
+#
+# pub trait StringParser<Context> {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error>;
+# }
+#
+# impl<Context> CanFormatToString for Context
+# where
+#     Context: HasProvider,
+#     Context::Provider: StringFormatter<Context>,
+# {
+#     fn format_to_string(&self) -> Result<String, Error> {
+#         Context::Provider::format_to_string(self)
+#     }
+# }
+#
+# impl<Context> CanParseFromString for Context
+# where
+#     Context: HasProvider,
+#     Context::Provider: StringParser<Context>,
+# {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error> {
+#         Context::Provider::parse_from_string(raw)
+#     }
+# }
+#
 # pub struct FormatAsJsonString;
 #
 # impl<Context> StringFormatter<Context> for FormatAsJsonString
@@ -149,7 +215,6 @@ call `format_to_string`, and check if it works:
 #
 # pub struct ParseFromJsonString;
 #
-# #[cgp_provider(StringParserComponent)]
 # impl<Context> StringParser<Context> for ParseFromJsonString
 # where
 #     Context: for<'a> Deserialize<'a>,
@@ -159,7 +224,34 @@ call `format_to_string`, and check if it works:
 #     }
 # }
 #
-# // Note: We forgot to derive Serialize here
+# pub trait DelegateComponent<Name> {
+#     type Delegate;
+# }
+#
+# pub struct StringFormatterComponent;
+#
+# pub struct StringParserComponent;
+#
+# impl<Context, Component> StringFormatter<Context> for Component
+# where
+#     Component: DelegateComponent<StringFormatterComponent>,
+#     Component::Delegate: StringFormatter<Context>,
+# {
+#     fn format_to_string(context: &Context) -> Result<String, Error> {
+#         Component::Delegate::format_to_string(context)
+#     }
+# }
+#
+# impl<Context, Component> StringParser<Context> for Component
+# where
+#     Component: DelegateComponent<StringParserComponent>,
+#     Component::Delegate: StringParser<Context>,
+# {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error> {
+#         Component::Delegate::parse_from_string(raw)
+#     }
+# }
+# // Note: We pretend to forgot to derive Serialize here
 # #[derive(Deserialize, Debug, Eq, PartialEq)]
 # pub struct Person {
 #     pub first_name: String,
@@ -172,11 +264,12 @@ call `format_to_string`, and check if it works:
 #     type Provider = PersonComponents;
 # }
 #
-# delegate_components! {
-#     PersonComponents {
-#         StringFormatterComponent: FormatAsJsonString,
-#         StringParserComponent: ParseFromJsonString,
-#     }
+# impl DelegateComponent<StringFormatterComponent> for PersonComponents {
+#     type Delegate = FormatAsJsonString;
+# }
+#
+# impl DelegateComponent<StringParserComponent> for PersonComponents {
+#     type Delegate = ParseFromJsonString;
 # }
 #
 let person = Person { first_name: "John".into(), last_name: "Smith".into() };
@@ -252,7 +345,207 @@ Technically, there is no reason why the Rust compiler cannot be improved to
 show more detailed errors to make using CGP easier. However, improving the
 compiler will take time, and we need to present strong argument on why
 such improvement is needed, e.g. through this book. Until then, we need
-temporary workarounds to make it easier to debug CGP errors in the meanwhile.
+workarounds to make it easier to debug CGP errors in the meanwhile.
+
+## `IsProviderFor` Trait
+
+Since `cgp` v0.4, we have developed a technique to explicitly propagate the constraint
+requirements, and "trick" Rust to show us the error messages that we need.
+We will first define a `IsProviderFor` trait as follows:
+
+```rust
+pub trait IsProviderFor<Component, Context, Params = ()> {}
+```
+
+The `IsProviderFor` trait is a marker trait that can be trivially implemented.
+It is intended to be implemented by provider structs, and is parameterized by 3 generic parameters:
+
+- `Component` - The component name type that corresponds to the provider implementation.
+- `Context` - The context type that is implemented by the provider.
+- `Params` - Any additional generic parameters present in the provider trait, combined as a tuple.
+
+Even though the `IsProviderFor` trait can be trivially implemented, we intentionally include
+additional constraints that are exactly the same as the original constraints specified in
+the corresponding provider trait implementation.
+
+For example, the provider `FormatAsJsonString` in the earlier example would implement
+`IsProviderFor` as follows:
+
+```rust
+# extern crate anyhow;
+# extern crate serde;
+# extern crate serde_json;
+#
+# use anyhow::Error;
+# use serde::{Serialize, Deserialize};
+#
+# pub trait IsProviderFor<Component, Context, Params = ()> {}
+#
+# pub struct StringFormatterComponent;
+#
+# pub trait StringFormatter<Context> {
+#     fn format_to_string(context: &Context) -> Result<String, Error>;
+# }
+#
+pub struct FormatAsJsonString;
+
+impl<Context> StringFormatter<Context> for FormatAsJsonString
+where
+    Context: Serialize,
+{
+    fn format_to_string(context: &Context) -> Result<String, Error> {
+        Ok(serde_json::to_string(context)?)
+    }
+}
+
+impl<Context> IsProviderFor<StringFormatterComponent, Context> for FormatAsJsonString
+where
+    Context: Serialize,
+{ }
+```
+
+The way to understand the trait implementation is follows: `FormatAsJsonString`
+has a provider implementation for `StringFormatterComponent` with the context `Context`,
+given that `Context: Serialize`.
+
+We can think of `IsProviderFor` trait to act as a "carrier" for the hidden constraints
+of provider traits. With it, instead of trying to check each provider trait implementation,
+we only need to check for the implementation of one trait, `IsProviderFor`.
+
+
+```rust
+# extern crate anyhow;
+# extern crate serde;
+# extern crate serde_json;
+#
+# use anyhow::Error;
+# use serde::{Serialize, Deserialize};
+#
+# pub trait IsProviderFor<Component, Context, Params = ()> {}
+#
+# pub trait HasProvider {
+#     type Provider;
+# }
+#
+# pub trait CanFormatToString {
+#     fn format_to_string(&self) -> Result<String, Error>;
+# }
+#
+# pub trait CanParseFromString: Sized {
+#     fn parse_from_string(raw: &str) -> Result<Self, Error>;
+# }
+#
+# pub trait StringFormatter<Context> {
+#     fn format_to_string(context: &Context) -> Result<String, Error>;
+# }
+#
+# pub trait StringParser<Context> {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error>;
+# }
+#
+# impl<Context> CanFormatToString for Context
+# where
+#     Context: HasProvider,
+#     Context::Provider: StringFormatter<Context>,
+# {
+#     fn format_to_string(&self) -> Result<String, Error> {
+#         Context::Provider::format_to_string(self)
+#     }
+# }
+#
+# impl<Context> CanParseFromString for Context
+# where
+#     Context: HasProvider,
+#     Context::Provider: StringParser<Context>,
+# {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error> {
+#         Context::Provider::parse_from_string(raw)
+#     }
+# }
+#
+# pub struct FormatAsJsonString;
+#
+# impl<Context> StringFormatter<Context> for FormatAsJsonString
+# where
+#     Context: Serialize,
+# {
+#     fn format_to_string(context: &Context) -> Result<String, Error> {
+#         Ok(serde_json::to_string(context)?)
+#     }
+# }
+#
+# impl<Context> IsProviderFor<StringFormatterComponent, Context> for FormatAsJsonString
+# where
+#     Context: Serialize,
+# { }
+#
+# pub struct ParseFromJsonString;
+#
+# impl<Context> StringParser<Context> for ParseFromJsonString
+# where
+#     Context: for<'a> Deserialize<'a>,
+# {
+#     fn parse_from_string(json_str: &str) -> Result<Context, Error> {
+#         Ok(serde_json::from_str(json_str)?)
+#     }
+# }
+#
+# impl<Context> IsProviderFor<StringParserComponent, Context> for ParseFromJsonString
+# where
+#     Context: for<'a> Deserialize<'a>,
+# { }
+#
+# pub trait DelegateComponent<Name> {
+#     type Delegate;
+# }
+#
+# pub struct StringFormatterComponent;
+#
+# pub struct StringParserComponent;
+#
+# impl<Context, Component> StringFormatter<Context> for Component
+# where
+#     Component: DelegateComponent<StringFormatterComponent>,
+#     Component::Delegate: StringFormatter<Context>,
+# {
+#     fn format_to_string(context: &Context) -> Result<String, Error> {
+#         Component::Delegate::format_to_string(context)
+#     }
+# }
+#
+# impl<Context, Component> StringParser<Context> for Component
+# where
+#     Component: DelegateComponent<StringParserComponent>,
+#     Component::Delegate: StringParser<Context>,
+# {
+#     fn parse_from_string(raw: &str) -> Result<Context, Error> {
+#         Component::Delegate::parse_from_string(raw)
+#     }
+# }
+# // Note: We pretend to forgot to derive Serialize here
+# #[derive(Deserialize, Debug, Eq, PartialEq)]
+# pub struct Person {
+#     pub first_name: String,
+#     pub last_name: String,
+# }
+#
+# pub struct PersonComponents;
+#
+# impl HasProvider for Person {
+#     type Provider = PersonComponents;
+# }
+#
+# impl DelegateComponent<StringFormatterComponent> for PersonComponents {
+#     type Delegate = FormatAsJsonString;
+# }
+#
+# impl DelegateComponent<StringParserComponent> for PersonComponents {
+#     type Delegate = ParseFromJsonString;
+# }
+#
+
+```
+
 
 ## Check Traits
 

From 2a479555c13378e2d02d6229c16f304c5bae8aa0 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 19:13:54 +0000
Subject: [PATCH 07/19] Adding more writings for IsProviderFor

---
 .rustfmt.toml                |   4 +
 content/debugging-support.md | 164 +++++++++++------------------------
 src/lib.rs                   | 154 ++++++++++++++++++++++++++++++++
 3 files changed, 208 insertions(+), 114 deletions(-)
 create mode 100644 .rustfmt.toml

diff --git a/.rustfmt.toml b/.rustfmt.toml
new file mode 100644
index 0000000..5e4c2e8
--- /dev/null
+++ b/.rustfmt.toml
@@ -0,0 +1,4 @@
+max_width = 80
+reorder_imports = true
+group_imports = "StdExternalCrate"
+imports_granularity = "Module"
\ No newline at end of file
diff --git a/content/debugging-support.md b/content/debugging-support.md
index 829eaac..2531e96 100644
--- a/content/debugging-support.md
+++ b/content/debugging-support.md
@@ -412,6 +412,14 @@ We can think of `IsProviderFor` trait to act as a "carrier" for the hidden const
 of provider traits. With it, instead of trying to check each provider trait implementation,
 we only need to check for the implementation of one trait, `IsProviderFor`.
 
+## Propagating `IsProviderFor` Constraints
+
+Now that we have captured our constraints using `IsProviderFor`, we need to somehow propagate the
+constraint upward through the delegation chain, so that the context provider `PersonComponents`
+also implements `IsProviderFor` with the same constraints as its delegate, `FormatAsJsonString`.
+
+We would do that by modifying the provider trait definition, so that `IsProviderFor` becomes a
+_supertrait_ of the provider trait:
 
 ```rust
 # extern crate anyhow;
@@ -423,129 +431,57 @@ we only need to check for the implementation of one trait, `IsProviderFor`.
 #
 # pub trait IsProviderFor<Component, Context, Params = ()> {}
 #
-# pub trait HasProvider {
-#     type Provider;
-# }
-#
-# pub trait CanFormatToString {
-#     fn format_to_string(&self) -> Result<String, Error>;
-# }
-#
-# pub trait CanParseFromString: Sized {
-#     fn parse_from_string(raw: &str) -> Result<Self, Error>;
-# }
-#
-# pub trait StringFormatter<Context> {
-#     fn format_to_string(context: &Context) -> Result<String, Error>;
-# }
-#
-# pub trait StringParser<Context> {
-#     fn parse_from_string(raw: &str) -> Result<Context, Error>;
-# }
-#
-# impl<Context> CanFormatToString for Context
-# where
-#     Context: HasProvider,
-#     Context::Provider: StringFormatter<Context>,
-# {
-#     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Provider::format_to_string(self)
-#     }
-# }
-#
-# impl<Context> CanParseFromString for Context
-# where
-#     Context: HasProvider,
-#     Context::Provider: StringParser<Context>,
-# {
-#     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Provider::parse_from_string(raw)
-#     }
-# }
-#
-# pub struct FormatAsJsonString;
-#
-# impl<Context> StringFormatter<Context> for FormatAsJsonString
-# where
-#     Context: Serialize,
-# {
-#     fn format_to_string(context: &Context) -> Result<String, Error> {
-#         Ok(serde_json::to_string(context)?)
-#     }
-# }
-#
-# impl<Context> IsProviderFor<StringFormatterComponent, Context> for FormatAsJsonString
-# where
-#     Context: Serialize,
-# { }
-#
-# pub struct ParseFromJsonString;
-#
-# impl<Context> StringParser<Context> for ParseFromJsonString
-# where
-#     Context: for<'a> Deserialize<'a>,
-# {
-#     fn parse_from_string(json_str: &str) -> Result<Context, Error> {
-#         Ok(serde_json::from_str(json_str)?)
-#     }
-# }
-#
-# impl<Context> IsProviderFor<StringParserComponent, Context> for ParseFromJsonString
-# where
-#     Context: for<'a> Deserialize<'a>,
-# { }
-#
 # pub trait DelegateComponent<Name> {
 #     type Delegate;
 # }
 #
 # pub struct StringFormatterComponent;
 #
-# pub struct StringParserComponent;
-#
-# impl<Context, Component> StringFormatter<Context> for Component
-# where
-#     Component: DelegateComponent<StringFormatterComponent>,
-#     Component::Delegate: StringFormatter<Context>,
-# {
-#     fn format_to_string(context: &Context) -> Result<String, Error> {
-#         Component::Delegate::format_to_string(context)
-#     }
-# }
-#
-# impl<Context, Component> StringParser<Context> for Component
-# where
-#     Component: DelegateComponent<StringParserComponent>,
-#     Component::Delegate: StringParser<Context>,
-# {
-#     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Component::Delegate::parse_from_string(raw)
-#     }
-# }
-# // Note: We pretend to forgot to derive Serialize here
-# #[derive(Deserialize, Debug, Eq, PartialEq)]
-# pub struct Person {
-#     pub first_name: String,
-#     pub last_name: String,
-# }
-#
-# pub struct PersonComponents;
-#
-# impl HasProvider for Person {
-#     type Provider = PersonComponents;
-# }
-#
-# impl DelegateComponent<StringFormatterComponent> for PersonComponents {
-#     type Delegate = FormatAsJsonString;
-# }
-#
-# impl DelegateComponent<StringParserComponent> for PersonComponents {
-#     type Delegate = ParseFromJsonString;
-# }
-#
+pub trait StringFormatter<Context>: IsProviderFor<StringFormatterComponent, Context> {
+    fn format_to_string(context: &Context) -> Result<String, Error>;
+}
+
+impl<Context, Component> StringFormatter<Context> for Component
+where
+    Component: DelegateComponent<StringFormatterComponent>
+      + IsProviderFor<StringFormatterComponent, Context>,
+    Component::Delegate: StringFormatter<Context>,
+{
+    fn format_to_string(context: &Context) -> Result<String, Error> {
+        Component::Delegate::format_to_string(context)
+    }
+}
+```
+
+We make it a requirement that in order for a provider to implement `StringFormatter<Context>`, the provider
+also needs to implement `IsProviderFor<StringFormatterComponent, Context>`.
+The supertrait constraint not only makes sure that we don't forget to always implement `IsProviderFor`,
+but also triggers Rust to show any unsatisfied constraints that were hidden previously.
+
+Additionally, we also modify the blanket implementation of `StringFormatter`, so that when a provider like
+`PersonComponents` delegates the implementation, it would need to explicitly implement
+`IsProviderFor<StringFormatterComponent, Context>` in addition to implementing `DelegateComponent<StringFormatterComponent>`.
+
+With the new requirements in place, when we delegate `PersonComponents`'s provider implementation of `StringFormatterComponent`,
+we would also write an implementation of `IsProviderFor` for it as follows:
 
+```rust,ignore
+impl DelegateComponent<StringFormatterComponent> for PersonComponents {
+    type Delegate = FormatAsJsonString;
+}
+
+impl<Context> IsProviderFor<StringFormatterComponent, Context>
+   for PersonComponents
+where
+    FormatAsJsonString: IsProviderFor<StringFormatterComponent, Context>
+{
+}
 ```
 
+Notice here that when implementing `IsProviderFor` for `PersonComponents`, we add a constraint that
+directly requires `FormatAsJsonString` to also implement `IsProviderFor` with the same generic parameters.
+By doing so, we resurface the constraints to Rust, so that it would recursively look into the
+`IsProviderFor` trait bounds, and print out any unsatisfied constraints in the error messages.
 
 ## Check Traits
 
diff --git a/src/lib.rs b/src/lib.rs
index 8b13789..6d6cbc5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1 +1,155 @@
+use anyhow::Error;
+use serde::{Deserialize, Serialize};
 
+pub trait IsProviderFor<Component, Context, Params = ()> {}
+
+pub trait HasProvider {
+    type Provider;
+}
+
+pub trait DelegateComponent<Name> {
+    type Delegate;
+}
+
+pub struct StringFormatterComponent;
+
+pub struct StringParserComponent;
+
+pub trait CanFormatToString {
+    fn format_to_string(&self) -> Result<String, Error>;
+}
+
+pub trait CanParseFromString: Sized {
+    fn parse_from_string(raw: &str) -> Result<Self, Error>;
+}
+
+pub trait StringFormatter<Context>:
+    IsProviderFor<StringFormatterComponent, Context>
+{
+    fn format_to_string(context: &Context) -> Result<String, Error>;
+}
+
+pub trait StringParser<Context>:
+    IsProviderFor<StringParserComponent, Context>
+{
+    fn parse_from_string(raw: &str) -> Result<Context, Error>;
+}
+
+impl<Context> CanFormatToString for Context
+where
+    Context: HasProvider,
+    Context::Provider: StringFormatter<Context>,
+{
+    fn format_to_string(&self) -> Result<String, Error> {
+        Context::Provider::format_to_string(self)
+    }
+}
+
+impl<Context> CanParseFromString for Context
+where
+    Context: HasProvider,
+    Context::Provider: StringParser<Context>,
+{
+    fn parse_from_string(raw: &str) -> Result<Context, Error> {
+        Context::Provider::parse_from_string(raw)
+    }
+}
+
+impl<Context, Component> StringFormatter<Context> for Component
+where
+    Component: DelegateComponent<StringFormatterComponent>
+        + IsProviderFor<StringFormatterComponent, Context>,
+    Component::Delegate: StringFormatter<Context>,
+{
+    fn format_to_string(context: &Context) -> Result<String, Error> {
+        Component::Delegate::format_to_string(context)
+    }
+}
+
+impl<Context, Component> StringParser<Context> for Component
+where
+    Component: DelegateComponent<StringParserComponent>
+        + IsProviderFor<StringParserComponent, Context>,
+    Component::Delegate: StringParser<Context>,
+{
+    fn parse_from_string(raw: &str) -> Result<Context, Error> {
+        Component::Delegate::parse_from_string(raw)
+    }
+}
+
+pub struct FormatAsJsonString;
+
+impl<Context> StringFormatter<Context> for FormatAsJsonString
+where
+    Context: Serialize,
+{
+    fn format_to_string(context: &Context) -> Result<String, Error> {
+        Ok(serde_json::to_string(context)?)
+    }
+}
+
+impl<Context> IsProviderFor<StringFormatterComponent, Context>
+    for FormatAsJsonString
+where
+    Context: Serialize,
+{
+}
+
+pub struct ParseFromJsonString;
+
+impl<Context> StringParser<Context> for ParseFromJsonString
+where
+    Context: for<'a> Deserialize<'a>,
+{
+    fn parse_from_string(json_str: &str) -> Result<Context, Error> {
+        Ok(serde_json::from_str(json_str)?)
+    }
+}
+
+impl<Context> IsProviderFor<StringParserComponent, Context>
+    for ParseFromJsonString
+where
+    Context: for<'a> Deserialize<'a>,
+{
+}
+
+// Note: We pretend to forgot to derive Serialize here
+#[derive(Deserialize, Debug, Eq, PartialEq)]
+pub struct Person {
+    pub first_name: String,
+    pub last_name: String,
+}
+
+pub struct PersonComponents;
+
+impl HasProvider for Person {
+    type Provider = PersonComponents;
+}
+
+impl DelegateComponent<StringFormatterComponent> for PersonComponents {
+    type Delegate = FormatAsJsonString;
+}
+
+impl<Context> IsProviderFor<StringFormatterComponent, Context>
+    for PersonComponents
+where
+    FormatAsJsonString: IsProviderFor<StringFormatterComponent, Context>,
+{
+}
+
+impl DelegateComponent<StringParserComponent> for PersonComponents {
+    type Delegate = ParseFromJsonString;
+}
+
+impl<Context> IsProviderFor<StringParserComponent, Context> for PersonComponents where
+    ParseFromJsonString: IsProviderFor<StringParserComponent, Context>
+{
+}
+
+pub trait CanUsePersonComponents:
+    IsProviderFor<StringFormatterComponent, Person>
+    + IsProviderFor<StringParserComponent, Person>
+{
+}
+
+impl CanUsePersonComponents for PersonComponents {}

From 41be3d1616aec6a4df6be57967445f9cdb55ccdb Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 19:46:28 +0000
Subject: [PATCH 08/19] Add section for CanUseComponent

---
 content/debugging-support.md | 426 ++++++++---------------------------
 src/lib.rs                   |  21 +-
 2 files changed, 114 insertions(+), 333 deletions(-)

diff --git a/content/debugging-support.md b/content/debugging-support.md
index 2531e96..107a006 100644
--- a/content/debugging-support.md
+++ b/content/debugging-support.md
@@ -485,360 +485,132 @@ By doing so, we resurface the constraints to Rust, so that it would recursively
 
 ## Check Traits
 
-We have learned that CGP lazily resolve dependencies and implements consumer
-traits on a concrete context only when they are actively used. However,
-when defining a concrete context, we would like to be able to eagerly check
-that the consumer traits are implemented, so that no confusing error
-should arise when the context is being used.
+Now that we have the wirings for `IsProviderFor` in place, we can implement _check traits_ to check
+on whether the provider traits that we want to use with `Person` are implemented by its provider,
+`PersonComponents`.
 
-By convention, the best approach for implementing such checks is to define
-a _check trait_, which asserts that a concrete context implements all
-consumer traits that we intended to implement. the check trait would be
-defined as follows:
-
-```rust,compile_fail
-# extern crate anyhow;
-# extern crate serde;
-# extern crate serde_json;
-# extern crate cgp;
-#
-# use cgp::prelude::*;
-# use anyhow::Error;
-# use serde::{Serialize, Deserialize};
-#
-# #[cgp_component {
-#    name: StringFormatterComponent,
-#    provider: StringFormatter,
-#    context: Context,
-# }]
-# pub trait CanFormatToString {
-#     fn format_to_string(&self) -> Result<String, Error>;
-# }
-#
-# #[cgp_component {
-#    name: StringParserComponent,
-#    provider: StringParser,
-#    context: Context,
-# }]
-# pub trait CanParseFromString: Sized {
-#     fn parse_from_string(raw: &str) -> Result<Self, Error>;
-# }
-#
-# pub struct FormatAsJsonString;
-#
-# #[cgp_provider(StringFormatterComponent)]
-# impl<Context> StringFormatter<Context> for FormatAsJsonString
-# where
-#     Context: Serialize,
-# {
-#     fn format_to_string(context: &Context) -> Result<String, Error> {
-#         Ok(serde_json::to_string(context)?)
-#     }
-# }
-#
-# pub struct ParseFromJsonString;
-#
-# #[cgp_provider(StringParserComponent)]
-# impl<Context> StringParser<Context> for ParseFromJsonString
-# where
-#     Context: for<'a> Deserialize<'a>,
-# {
-#     fn parse_from_string(json_str: &str) -> Result<Context, Error> {
-#         Ok(serde_json::from_str(json_str)?)
-#     }
-# }
-#
-# // Note: We forgot to derive Serialize here
-# #[derive(Deserialize, Debug, Eq, PartialEq)]
-# pub struct Person {
-#     pub first_name: String,
-#     pub last_name: String,
-# }
-#
-# pub struct PersonComponents;
-#
-# impl HasProvider for Person {
-#     type Provider = PersonComponents;
-# }
-#
-# delegate_components! {
-#     PersonComponents {
-#         StringFormatterComponent: FormatAsJsonString,
-#         StringParserComponent: ParseFromJsonString,
-#     }
-# }
-#
-pub trait CanUsePerson:
-    CanFormatToString
-    + CanParseFromString
-{}
+```rust,ignore
+pub trait CanUsePersonComponents:
+    IsProviderFor<StringFormatterComponent, Person>
+    + IsProviderFor<StringParserComponent, Person>
+{
+}
 
-impl CanUsePerson for Person {}
+impl CanUsePersonComponents for PersonComponents {}
 ```
 
-By convention, a check trait has the name starts with `CanUse`, followed by
-the name of the concrete context. We list all the consumer traits that
-the concrete context should implement as the super trait. The check trait
-has an empty body, followed by a blanket implementation for the target
-concrete context.
+To put it simply, a check trait is defined just for checking whether a type implements other traits that we are
+interested to use with that type. For our case, we want to check that
+`PersonComponents: IsProviderFor<StringFormatterComponent, Person>`
+and `IsProviderFor<StringParserComponent, Person>`, since we expect `PersonComponents` to implement
+`StringFormatter<Person>` and `StringParser<Person>`. So we define a check trait called `CanUsePersonComponents`,
+and put the `IsProviderFor` constraints as the supertrait.
 
-In the example above, we define the check trait `CanUsePerson`, which is used
-to check that the concrete context `Person` implements `CanFormatToString` and
-`CanParseFromString`. If we try to compile the check trait with the
-same example code as before, we would get the following error message:
+The check trait is then followed by an implementation of `CanUsePersonComponents` for `PersonComponents`,
+which acts as an _assertion_ that `PersonComponents` implements all the supertraits that we specified.
 
-```text
-error[E0277]: the trait bound `FormatAsJsonString: StringFormatter<Person>` is not satisfied
-  --> debugging-techniques.md:330:23
-   |
-77 | impl CanUsePerson for Person {}
-   |                       ^^^^^^ the trait `StringFormatter<Person>` is not implemented for `FormatAsJsonString`, which is required by `Person: CanFormatToString`
-   |
-   = help: the trait `StringFormatter<Context>` is implemented for `FormatAsJsonString`
-note: required for `PersonComponents` to implement `StringFormatter<Person>`
-  --> debugging-techniques.md:265:1
-   |
-12 | / #[cgp_component {
-13 | |    name: StringFormatterComponent,
-14 | |    provider: StringFormatter,
-15 | |    context: Context,
-16 | | }]
-   | |__^
-note: required for `Person` to implement `CanFormatToString`
-  --> debugging-techniques.md:265:1
-   |
-12 | / #[cgp_component {
-13 | |    name: StringFormatterComponent,
-14 | |    provider: StringFormatter,
-15 | |    context: Context,
-   | |             ^^^^^^^
-16 | | }]
-   | |__^
-note: required by a bound in `CanUsePerson`
-  --> debugging-techniques.md:326:5
-   |
-72 | pub trait CanUsePerson:
-   |           ------------ required by a bound in this trait
-73 |     CanFormatToString
-   |     ^^^^^^^^^^^^^^^^^ required by this bound in `CanUsePerson`
-   = note: `CanUsePerson` is a "sealed trait", because to implement it you also need to implement `main::_doctest_main_debugging_techniques_md_255_0::CanFormatToString`, which is not accessible; this is usually done to force you to use one of the provided types that already implement it
-   = help: the following type implements the trait:
-             Context
-   = note: this error originates in the attribute macro `cgp_component` (in Nightly builds, run with -Z macro-backtrace for more info)
+With the checks in place, we now get a compile error message that shows us exactly what we need to fix,
+which is to implement `Serialize` for `Person`:
 
-error: aborting due to 1 previous error
+```text
+error[E0277]: the trait bound `Person: Serialize` is not satisfied
+   --> src/lib.rs:155:33
+    |
+155 | impl CanUsePersonComponents for PersonComponents {}
+    |                                 ^^^^^^^^^^^^^^^^ the trait `Serialize` is not implemented for `Person`
+    |
+    = note: for local types consider adding `#[derive(serde::Serialize)]` to your `Person` type
+    = note: for types from other crates check whether the crate offers a `serde` feature flag
+    = help: the following other types implement trait `Serialize`:
+              &'a T
+              &'a mut T
+              ()
+              (T,)
+              (T0, T1)
+              (T0, T1, T2)
+              (T0, T1, T2, T3)
+              (T0, T1, T2, T3, T4)
+            and 131 others
+note: required for `FormatAsJsonString` to implement `IsProviderFor<StringFormatterComponent, Person>`
+   --> src/lib.rs:91:15
+    |
+91  | impl<Context> IsProviderFor<StringFormatterComponent, Context>
+    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+92  |     for FormatAsJsonString
+    |         ^^^^^^^^^^^^^^^^^^
+93  | where
+94  |     Context: Serialize,
+    |              --------- unsatisfied trait bound introduced here
+    = note: 1 redundant requirement hidden
+    = note: required for `PersonComponents` to implement `IsProviderFor<StringFormatterComponent, Person>`
+note: required by a bound in `CanUsePersonComponents`
+   --> src/lib.rs:150:5
+    |
+149 | pub trait CanUsePersonComponents:
+    |           ---------------------- required by a bound in this trait
+150 |     IsProviderFor<StringFormatterComponent, Person>
+    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `CanUsePersonComponents`
 ```
 
-The error message is still pretty confusing, but it is slightly more informative
-than the previous error. Here, we can see that the top of the error says that
-`StringFormatter<Person>` is not implemented for `FormatAsJsonString`.
-Although it does not point to the root cause, at least we are guided to look
-into the implementation of `FormatAsJsonString` to find out what went wrong there.
+As we can see, the use of `IsProviderFor` helps make it possible for us to debug our CGP programs again.
+This significantly improves the developer experience for CGP, which was significantly harder to debug
+prior to the introduction of this technique in v0.4.0.
 
-At the moment, there is no better way to simplify debugging further, and
-we need to manually look into `FormatAsJsonString` to check why it could not
-implement `StringFormatter` for the `Person` context. Here, the important
-thing to look for is the additional constraints that `FormatAsJsonString`
-requires on the context, which in this case is `Serialize`.
+## `CanUseComponent` Trait
 
-We can make use of the check trait to further track down all the indirect
-dependencies of the providers that the concrete context uses. In this case,
-we determine that `Serialize` is needed for `FormatAsJsonString`, and
-`Deserialize` is needed for `ParseFromJsonString`. So we add them into
-the super trait of `CanUsePerson` as follows:
+Although we can directly check for the implementation of `IsProviderFor`, the definition is not as straightforward as
+defining checks directly with the `Person` context. Furthermore, the context type `Person` needs to be repeatedly
+specified for each supertrait, which becomes tedious and adds noise.
 
-```rust,compile_fail
-# extern crate anyhow;
-# extern crate serde;
-# extern crate serde_json;
-# extern crate cgp;
-#
-# use cgp::prelude::*;
-# use anyhow::Error;
-# use serde::{Serialize, Deserialize};
-#
-# #[cgp_component {
-#    name: StringFormatterComponent,
-#    provider: StringFormatter,
-#    context: Context,
-# }]
-# pub trait CanFormatToString {
-#     fn format_to_string(&self) -> Result<String, Error>;
-# }
-#
-# #[cgp_component {
-#    name: StringParserComponent,
-#    provider: StringParser,
-#    context: Context,
-# }]
-# pub trait CanParseFromString: Sized {
-#     fn parse_from_string(raw: &str) -> Result<Self, Error>;
-# }
-#
-# pub struct FormatAsJsonString;
-#
-# #[cgp_provider(StringFormatterComponent)]
-# impl<Context> StringFormatter<Context> for FormatAsJsonString
-# where
-#     Context: Serialize,
-# {
-#     fn format_to_string(context: &Context) -> Result<String, Error> {
-#         Ok(serde_json::to_string(context)?)
-#     }
-# }
-#
-# pub struct ParseFromJsonString;
-#
-# #[cgp_provider(StringParserComponent)]
-# impl<Context> StringParser<Context> for ParseFromJsonString
-# where
-#     Context: for<'a> Deserialize<'a>,
-# {
-#     fn parse_from_string(json_str: &str) -> Result<Context, Error> {
-#         Ok(serde_json::from_str(json_str)?)
-#     }
-# }
-#
-# // Note: We forgot to derive Serialize here
-# #[derive(Deserialize, Debug, Eq, PartialEq)]
-# pub struct Person {
-#     pub first_name: String,
-#     pub last_name: String,
-# }
-#
-# pub struct PersonComponents;
-#
-# impl HasProvider for Person {
-#     type Provider = PersonComponents;
-# }
-#
-# delegate_components! {
-#     PersonComponents {
-#         StringFormatterComponent: FormatAsJsonString,
-#         StringParserComponent: ParseFromJsonString,
-#     }
+We can improve the check definitions by introducing a helper `CanUseComponent` trait that is defined as follows:
+
+```rust
+# pub trait HasProvider {
+#     type Provider;
 # }
 #
-pub trait CanUsePerson:
-    Serialize
-    + for<'a> Deserialize<'a>
-    + CanFormatToString
-    + CanParseFromString
-{}
-
-impl CanUsePerson for Person {}
-```
+pub trait IsProviderFor<Component, Context, Params = ()> {}
 
-When we try to compile `CanUsePerson` again, we would see a different error
-message at the top:
+pub trait CanUseComponent<Component, Params = ()> {}
 
-```text
-error[E0277]: the trait bound `Person: Serialize` is not satisfied
-   |
-71 | impl CanUsePerson for Person {}
-   |                       ^^^^^^ the trait `Serialize` is not implemented for `Person`
-   |
-   = note: for local types consider adding `#[derive(serde::Serialize)]` to your `Person` type
-   = note: for types from other crates check whether the crate offers a `serde` feature flag
+impl<Context, Component, Params> CanUseComponent<Component, Params> for Context
+where
+    Context: HasProvider,
+    Context::Provider: IsProviderFor<Component, Context, Params>,
+{
+}
 ```
 
-This tells us that we have forgotten to implement `Serialize` for Person.
-We can then take our action to properly fill in the missing dependencies.
+Instead of being implemented by a provider, `CanUseComponent` is intended to be implemented by a context type that
+implements `HasProvider`. Compared to `IsProviderFor`, there is no need to specify an explicit `Context` parameter.
 
-## Debugging Check Traits
+`CanUseComponent` also has a blanket implementation, making it automatically implemented for any `Context` type
+that implements `HasProvider`, with `Context::Provider` implementing `IsProviderFor`.
 
-Due to the need for check traits, the work for implementing a concrete context often
-involves wiring up the providers, and then checking that the providers and all their
-dependencies are implemented. As the number of components increase, the number of
-dependencies we need to check also increase accordingly.
+In other words, we are using `CanUseComponent` as a _trait alias_ to `IsProviderFor`, with improved ergonomics
+that we can check directly against a context type.
 
-When encountering errors in the check traits, it often helps to comment out a large
-portion of the dependencies, to focus on resolving the errors arise from a specific
-dependency. For example, in the check trait we can temporarily check for the
-implementation of `CanFormatToString` by commenting out all other constraints as follows:
+Using `CanUseComponent`, we can re-define our check trait much simply as follows:
 
 ```rust,ignore
 pub trait CanUsePerson:
-    Sized
-    // + Serialize
-    // + for<'a> Deserialize<'a>
-    + CanFormatToString
-    // + CanParseFromString
-{}
-```
-
-We add a dummy constaint like `Sized` in the beginning of the super traits for
-`CanUsePerson`, so that we can easily comment out individual lines and not worry
-about whether it would lead to a dangling `+` sign.
-We can then pin point the error to a specific provider, and then continue
-tracing the missing dependencies from there. We would then notice that
-`FormatAsJsonString` requires `Serialize`, which we can then update the
-commented code to:
+    CanUseComponent<StringFormatterComponent>
+    + CanUseComponent<StringParserComponent>
+{
+}
 
-```rust,ignore
-pub trait CanUsePerson:
-    Sized
-    + Serialize
-    // + for<'a> Deserialize<'a>
-    // + CanFormatToString
-    // + CanParseFromString
-{}
+impl CanUsePerson for Person {}
 ```
 
-This technique can hopefully help speed up the debugging process, and determine
-which dependency is missing.
-
-## Improving The Compiler Error Message
-
-The need of manual debugging using check traits is probably one of the major blockers
-for spreading CGP for wider adoption. However, it is possible to improve the error
-messages returned from the Rust compiler so that we can more easily find out what
-went wrong.
-
-When Rust fails to resolve the constraints for `Person: CanFormatString`, it in fact
-knows that the reason for the failure is caused by unsatisfied _indirect_ constraints
-such as `Person: Serialize`. So what we need to do is to make Rust prints out the
-unsatisfied constraints.
-
-This has been reported as [issue #134346](https://github.com/rust-lang/rust/issues/134346)
-at the Rust project, with a pending fix available as
-[pull request #134348](https://github.com/rust-lang/rust/pull/134348).
-But until the patch is merged and stabilized, you can try to use our custom fork of the
-Rust compiler to debug any CGP error.
-
-Following are the steps to use the modified Rust compiler:
-
-- Clone our fork of the Rust compiler at `https://github.com/contextgeneric/rust.git`, or add it as a secondary git remote.
-- Checkout the branch `cgp`, which applies the error reporting patch to the latest stable Rust.
-- Build the Rust compiler following the [official guide](https://rustc-dev-guide.rust-lang.org/building/how-to-build-and-run.html). The steps should be something as follows:
-   - Run `./x setup`
-   - Run `./x build`
-   - Run `./x build proc-macro-srv-cli`, if you wan to use the forked compiler with Rust Analyzer.
-   - Optionally, run `./x build --stage 2` and `./x build --stage 2 proc-macro-srv-cli`, if you want to use the stage 2 compiler.
-- Link the compiled custom compiler using `rustup link`, aliasing it to a custom name like `cgp`. e.g. `rustup toolchain link cgp build/host/stage1`.
-   - Link with `build/host/stage2` if you want to use the stage 2 compiler.
-- Run your project using the custom compiler, e.g. `cargo +cgp check`.
-- To use this with Rust Analyzer, set `channel = "cgp"` inside your project's `rust-toolchain.toml` file.
-
-If everything is working, you should see similar error messages as before, but with additional information included:
+Compared to before, we define the check trait `CanUsePerson` directly on `Person` instead of `PersonComponents`.
+When we try compiling, we would still get the same error message that shows us the required information
+to fix the error:
 
 ```text
-error[E0277]: the trait bound `FormatAsJsonString: StringFormatter<Person>` is not satisfied
-  --> content/debugging-techniques.md:330:23
-   |
-77 | impl CanUsePerson for Person {}
-   |                       ^^^^^^ the trait `StringFormatter<Person>` is not implemented for `FormatAsJsonString`
-   |
-   = help: the following constraint is not satisfied: `Person: Serialize`
-   = help: the trait `StringFormatter<Context>` is implemented for `FormatAsJsonString`
-note: required for `PersonComponents` to implement `StringFormatter<Person>`
+error[E0277]: the trait bound `Person: CanUseComponent<StringFormatterComponent>` is not satisfied
+   --> src/lib.rs:164:23
+    |
+164 | impl CanUsePerson for Person {}
+    |                       ^^^^^^ the trait `Serialize` is not implemented for `Person`
+...
 ```
-
-After the main error is shown, we can also see an extra help hint that says:
-`the following constraint is not satisfied: Person: Serialize`. Thanks to that,
-we can now much more easily pin point the source of error, and proceed to fix
-our CGP program.
-
-We hope that our patch will soon be accepted by the Rust project, so that future
-versions of Rust will be more accessible for CGP. When that happens, we will
-update this chapter to reflect the changes.
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
index 6d6cbc5..509fe82 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,16 +1,25 @@
 use anyhow::Error;
 use serde::{Deserialize, Serialize};
 
-pub trait IsProviderFor<Component, Context, Params = ()> {}
-
 pub trait HasProvider {
     type Provider;
 }
 
+pub trait IsProviderFor<Component, Context, Params = ()> {}
+
 pub trait DelegateComponent<Name> {
     type Delegate;
 }
 
+pub trait CanUseComponent<Component, Params = ()> {}
+
+impl<Context, Component, Params> CanUseComponent<Component, Params> for Context
+where
+    Context: HasProvider,
+    Context::Provider: IsProviderFor<Component, Context, Params>,
+{
+}
+
 pub struct StringFormatterComponent;
 
 pub struct StringParserComponent;
@@ -146,10 +155,10 @@ impl<Context> IsProviderFor<StringParserComponent, Context> for PersonComponents
 {
 }
 
-pub trait CanUsePersonComponents:
-    IsProviderFor<StringFormatterComponent, Person>
-    + IsProviderFor<StringParserComponent, Person>
+pub trait CanUsePerson:
+    CanUseComponent<StringFormatterComponent>
+    + CanUseComponent<StringParserComponent>
 {
 }
 
-impl CanUsePersonComponents for PersonComponents {}
+impl CanUsePerson for Person {}

From c31c8b8e2db16bb9fd9bcbf46ad732879056760d Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 20:29:53 +0000
Subject: [PATCH 09/19] Finish updating debugging chapter

---
 content/debugging-support.md | 215 ++++++++++++++++++++++++++++++++++-
 1 file changed, 213 insertions(+), 2 deletions(-)

diff --git a/content/debugging-support.md b/content/debugging-support.md
index 107a006..017809e 100644
--- a/content/debugging-support.md
+++ b/content/debugging-support.md
@@ -483,6 +483,21 @@ directly requires `FormatAsJsonString` to also implement `IsProviderFor` with th
 By doing so, we resurface the constraints to Rust, so that it would recursively look into the
 `IsProviderFor` trait bounds, and print out any unsatisfied constraints in the error messages.
 
+At this point, you may wonder why not link the provider trait directly within the delegated implementation of `IsProviderFor`, such as:
+
+```rust,ignore
+impl<Context> IsProviderFor<StringFormatterComponent, Context>
+   for PersonComponents
+where
+    FormatAsJsonString: StringFormatter<Context>,
+{
+}
+```
+
+The main reason to _not_ do this is that it requires direct access to the provider trait, which is not as simple dealing with simple types. Furthermore, the provider trait may contain additional where clauses, which would also need to be propagated explicitly.
+
+By making use of `IsProviderFor`, we are essentially "erasing" everything at the trait level, and use a single trait to represent all other provider traits. After all, the only thing that we are interested here is to propagate the constraints for the purpose of showing better error messages.
+
 ## Check Traits
 
 Now that we have the wirings for `IsProviderFor` in place, we can implement _check traits_ to check
@@ -553,8 +568,6 @@ note: required by a bound in `CanUsePersonComponents`
 ```
 
 As we can see, the use of `IsProviderFor` helps make it possible for us to debug our CGP programs again.
-This significantly improves the developer experience for CGP, which was significantly harder to debug
-prior to the introduction of this technique in v0.4.0.
 
 ## `CanUseComponent` Trait
 
@@ -614,3 +627,201 @@ error[E0277]: the trait bound `Person: CanUseComponent<StringFormatterComponent>
     |                       ^^^^^^ the trait `Serialize` is not implemented for `Person`
 ...
 ```
+
+## Limitations
+
+The use of `IsProviderFor` significantly improves the developer experience for CGP, which was significantly harder
+to debug prior to the introduction of this technique in v0.4.0.
+
+At this point, you might be concerned of the additional boilerplate required to implement and propagate the constraints for `IsProviderFor`. However, as we will see in the [next chapter](./component-macros.md), the CGP macros will automate the bulk of the implementation of `IsProviderFor`, and only require lightweight attribute macros to be applied to enable the code generation.
+
+It is worth noting that the `IsProviderFor` trait is introduced as a workaround to improve the error messages of CGP code in Rust. Hypothetically, if Rust could provide better support of showing the relevant error messages, we could entirely remove the use of `IsProviderFor` in future versions of CGP.
+
+On the other hand, the use of `IsProviderFor` can serve as a great showcase to the Rust compiler team on what error messages should have been shown by default, and make it easier to evaluate what should be the official fix in the Rust compiler.
+
+That said, the error messages shown via `IsProviderFor` can sometimes be too verbose, especially when an application contains many providers with deeply nested dependencies. The reason is that any unsatisfied constraint from deeply nested dependencies can propagate all the way up through chains of `IsProviderFor` implementations. Although this can help us pinpoint the root cause, it could generate too much noise when showing all errors from the intermediary layers.
+
+When encountering heap of error messages generated from `IsProviderFor`, a useful tip is that the relevant error message may be hiding near the bottom. So it may be useful to read from the bottom up instead of top down.
+
+## Interactive Debugging with Argus
+
+A potential improvement that we are currently exploring is to make use of [Argus](https://cel.cs.brown.edu/paper/an-interactive-debugger-for-rust-trait-errors/) to help navigate error messages generated from CGP code. Argus provides an interactive debugger for trait-related errors, which may be well suited to be used for debugging CGP code.
+
+We will add further details in the future to share potential integration with Argus. For now, interested readers are encouraged to check out the project, and perhaps make contribution to make such integration possible.
+
+## Conclusion
+
+In this chapter, we have learned how CGP makes use of the `IsProviderFor` trait to help show relevant error messages when encountering unsatisfied constraints. In the next chapter, we will walk through how to automate the generation of all the relevant boilerplates that we have learned so far, and write succint CGP code using macros.
+
+We will show the full example that we have walked through earlier, with the addition of `IsProviderFor` into the code:
+
+```rust,compile_fail
+# extern crate anyhow;
+# extern crate serde;
+# extern crate serde_json;
+#
+use anyhow::Error;
+use serde::{Deserialize, Serialize};
+
+pub trait HasProvider {
+    type Provider;
+}
+
+pub trait IsProviderFor<Component, Context, Params = ()> {}
+
+pub trait DelegateComponent<Name> {
+    type Delegate;
+}
+
+pub trait CanUseComponent<Component, Params = ()> {}
+
+impl<Context, Component, Params> CanUseComponent<Component, Params> for Context
+where
+    Context: HasProvider,
+    Context::Provider: IsProviderFor<Component, Context, Params>,
+{
+}
+
+pub struct StringFormatterComponent;
+
+pub struct StringParserComponent;
+
+pub trait CanFormatToString {
+    fn format_to_string(&self) -> Result<String, Error>;
+}
+
+pub trait CanParseFromString: Sized {
+    fn parse_from_string(raw: &str) -> Result<Self, Error>;
+}
+
+pub trait StringFormatter<Context>:
+    IsProviderFor<StringFormatterComponent, Context>
+{
+    fn format_to_string(context: &Context) -> Result<String, Error>;
+}
+
+pub trait StringParser<Context>:
+    IsProviderFor<StringParserComponent, Context>
+{
+    fn parse_from_string(raw: &str) -> Result<Context, Error>;
+}
+
+impl<Context> CanFormatToString for Context
+where
+    Context: HasProvider,
+    Context::Provider: StringFormatter<Context>,
+{
+    fn format_to_string(&self) -> Result<String, Error> {
+        Context::Provider::format_to_string(self)
+    }
+}
+
+impl<Context> CanParseFromString for Context
+where
+    Context: HasProvider,
+    Context::Provider: StringParser<Context>,
+{
+    fn parse_from_string(raw: &str) -> Result<Context, Error> {
+        Context::Provider::parse_from_string(raw)
+    }
+}
+
+impl<Context, Component> StringFormatter<Context> for Component
+where
+    Component: DelegateComponent<StringFormatterComponent>
+        + IsProviderFor<StringFormatterComponent, Context>,
+    Component::Delegate: StringFormatter<Context>,
+{
+    fn format_to_string(context: &Context) -> Result<String, Error> {
+        Component::Delegate::format_to_string(context)
+    }
+}
+
+impl<Context, Component> StringParser<Context> for Component
+where
+    Component: DelegateComponent<StringParserComponent>
+        + IsProviderFor<StringParserComponent, Context>,
+    Component::Delegate: StringParser<Context>,
+{
+    fn parse_from_string(raw: &str) -> Result<Context, Error> {
+        Component::Delegate::parse_from_string(raw)
+    }
+}
+
+pub struct FormatAsJsonString;
+
+impl<Context> StringFormatter<Context> for FormatAsJsonString
+where
+    Context: Serialize,
+{
+    fn format_to_string(context: &Context) -> Result<String, Error> {
+        Ok(serde_json::to_string(context)?)
+    }
+}
+
+impl<Context> IsProviderFor<StringFormatterComponent, Context>
+    for FormatAsJsonString
+where
+    Context: Serialize,
+{
+}
+
+pub struct ParseFromJsonString;
+
+impl<Context> StringParser<Context> for ParseFromJsonString
+where
+    Context: for<'a> Deserialize<'a>,
+{
+    fn parse_from_string(json_str: &str) -> Result<Context, Error> {
+        Ok(serde_json::from_str(json_str)?)
+    }
+}
+
+impl<Context> IsProviderFor<StringParserComponent, Context>
+    for ParseFromJsonString
+where
+    Context: for<'a> Deserialize<'a>,
+{
+}
+
+// Note: We pretend to forgot to derive Serialize here
+#[derive(Deserialize, Debug, Eq, PartialEq)]
+pub struct Person {
+    pub first_name: String,
+    pub last_name: String,
+}
+
+pub struct PersonComponents;
+
+impl HasProvider for Person {
+    type Provider = PersonComponents;
+}
+
+impl DelegateComponent<StringFormatterComponent> for PersonComponents {
+    type Delegate = FormatAsJsonString;
+}
+
+impl<Context> IsProviderFor<StringFormatterComponent, Context>
+    for PersonComponents
+where
+    FormatAsJsonString: IsProviderFor<StringFormatterComponent, Context>,
+{
+}
+
+impl DelegateComponent<StringParserComponent> for PersonComponents {
+    type Delegate = ParseFromJsonString;
+}
+
+impl<Context> IsProviderFor<StringParserComponent, Context> for PersonComponents where
+    ParseFromJsonString: IsProviderFor<StringParserComponent, Context>
+{
+}
+
+pub trait CanUsePerson:
+    CanUseComponent<StringFormatterComponent>
+    + CanUseComponent<StringParserComponent>
+{
+}
+
+impl CanUsePerson for Person {}
+```
\ No newline at end of file

From ee71d12d5f9aeb8c67830a3d1dc7de67045ac7a2 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Tue, 6 May 2025 21:24:31 +0000
Subject: [PATCH 10/19] Finish updating Components Macros chapter

---
 content/component-macros.md | 245 +++++++++++++++++++++++++++++-------
 src/lib.rs                  | 164 ------------------------
 2 files changed, 197 insertions(+), 212 deletions(-)

diff --git a/content/component-macros.md b/content/component-macros.md
index 2e48358..d590179 100644
--- a/content/component-macros.md
+++ b/content/component-macros.md
@@ -13,6 +13,9 @@ Syntactically, all CGP components follow the same pattern. The pattern is
 roughly as follows:
 
 ```rust,ignore
+// Component name
+pub struct ActionPerformerComponent;
+
 // Consumer trait
 pub trait CanPerformAction<GenericA, GenericB, ...>:
     ConstraintA + ConstraintB + ...
@@ -26,7 +29,8 @@ pub trait CanPerformAction<GenericA, GenericB, ...>:
 }
 
 // Provider trait
-pub trait ActionPerformer<Context, GenericA, GenericB, ...>
+pub trait ActionPerformer<Context, GenericA, GenericB, ...>:
+    IsProviderFor<ActionPerformerComponent, Context, (GenericA, GenericB, ...)>
 where
     Context: ConstraintA + ConstraintB + ...,
 {
@@ -38,9 +42,6 @@ where
     ) -> Output;
 }
 
-// Component name
-pub struct ActionPerformerComponent;
-
 // Blanket implementation for consumer trait
 impl<Context, GenericA, GenericB, ...>
     CanPerformAction<GenericA, GenericB, ...> for Context
@@ -64,7 +65,8 @@ impl<Context, Component, GenericA, GenericB, ...>
     for Component
 where
     Context: ConstraintA + ConstraintB + ...,
-    Component: DelegateComponent<ActionPerformerComponent>,
+    Component: DelegateComponent<ActionPerformerComponent>
+        + IsProviderFor<ActionPerformerComponent, Context, (GenericA, GenericB, ...)>,
     Component::Delegate: ActionPerformer<Context, GenericA, GenericB, ...>,
 {
     fn perform_action(
@@ -78,7 +80,7 @@ where
 }
 ```
 
-## `cgp_component` Macro
+## `#[cgp_component]` Macro
 
 With the repetitive pattern, it makes sense that we should be able to
 just define the consumer trait, and make use of Rust macros to generate
@@ -124,10 +126,7 @@ be omited. When omitted, the `context` field will default to `Context`,
 and the `name` field will default to `{provider}Component`.
 So the same example above could be simplified to:
 
-
 ```rust,ignore
-use cgp::prelude::*;
-
 #[cgp_component {
     provider: ActionPerformer,
 }]
@@ -143,8 +142,24 @@ pub trait CanPerformAction<GenericA, GenericB, ...>:
 }
 ```
 
+When only the provider name is specified, we can also omit the `key: value` syntax, and specify only the provider name:
+
+```rust,ignore
+#[cgp_component(ActionPerformer)]
+pub trait CanPerformAction<GenericA, GenericB, ...>:
+    ConstraintA + ConstraintB + ...
+{
+    fn perform_action(
+        &self,
+        arg_a: ArgA,
+        arg_b: ArgB,
+        ...
+    ) -> Output;
+}
+```
+
 
-## `delegate_components` Macro
+## `delegate_components!` Macro
 
 In addition to the `cgp_component` macro, `cgp` also provides the
 `delegate_components!` macro that can be used to automatically implement
@@ -175,29 +190,177 @@ impl DelegateComponent<ComponentA> for TargetProvider {
     type Delegate = ProviderA;
 }
 
+impl<Context, Params> IsProviderFor<ComponentA, Context, Params>
+    for TargetProvider
+where
+    ProviderA: IsProviderFor<ComponentA, Context, Params>,
+{
+}
+
 impl DelegateComponent<ComponentB> for TargetProvider {
     type Delegate = ProviderB;
 }
 
+impl<Context, Params> IsProviderFor<ComponentB, Context, Params>
+    for TargetProvider
+where
+    ProviderB: IsProviderFor<ComponentB, Context, Params>,
+{
+}
+
 impl DelegateComponent<ComponentC1> for TargetProvider {
     type Delegate = ProviderC;
 }
 
+impl<Context, Params> IsProviderFor<ComponentC1, Context, Params>
+    for TargetProvider
+where
+    ProviderC: IsProviderFor<ComponentC1, Context, Params>,
+{
+}
+
 impl DelegateComponent<ComponentC2> for TargetProvider {
     type Delegate = ProviderC;
 }
+
+impl<Context, Params> IsProviderFor<ComponentC2, Context, Params>
+    for TargetProvider
+where
+    ProviderC: IsProviderFor<ComponentC2, Context, Params>,
+{
+}
 ```
 
 The `delegate_components!` macro accepts an argument to an existing type,
 `TargetProvider`, which is expected to be defined outside of the macro.
 It is followed by an open brace, and contain entries that look like
-key-value pairs. For a key-value pair `ComponentA: ProviderA`, the type
-`ComponentA` is used as the component name, and `ProviderA` refers to
-the provider implementation.
+key-value pairs.
+
+For a key-value pair `ComponentA: ProviderA`, the type `ComponentA` is used as the component name, and `ProviderA` refers to the provider implementation.
 When multiple keys map to the same value, i.e. multiple components are
 delegated to the same provider implementation, the array syntax can be
 used to further simplify the mapping.
 
+Instead of defining the provider struct on our own, we can also instruct `delegate_components!` to also define the provider struct for us, by adding a `new` keyword in front:
+
+```rust,ignore
+delegate_components! {
+    new TargetProvider {
+        ComponentA: ProviderA,
+        ComponentB: ProviderB,
+        [
+            ComponentC1,
+            ComponentC2,
+            ...
+        ]: ProviderC,
+    }
+}
+```
+
+## `#[cgp_provider]` Macro
+
+When implementing a provider, the `#[cgp_provider]` macro needs to be used to automatically implement the `IsProviderFor` implementation, with all constraints within the `impl` block copied over.
+
+Given a provider trait implementation with the pattern:
+
+```rust,ignore
+pub struct Provider;
+
+#[cgp_provider(ActionPerformerComponent)]
+impl<Context, GenericA, GenericB, ...>
+    ActionPerformer<Context, GenericA, GenericB, ...>
+    for Provider
+where
+    Context: ConstraintA + ConstraintB + ...,
+    Context::Assoc: ConstraintC + ConstraintD + ...,
+{ ... }
+```
+
+`#[cgp_provider]` would generate an `IsProviderFor` implementation that follows the pattern:
+
+```rust,ignore
+impl<Context, GenericA, GenericB, ...>
+    IsProviderFor<ActionPerformerComponent, Context, GenericA, GenericB, ...>
+    for Provider
+where
+    Context: ConstraintA + ConstraintB + ...,
+    Context::Assoc: ConstraintC + ConstraintD + ...,
+{ }
+```
+
+If the component name for the provider trait follows the format `"{ProviderTraitName}Component"`, then the component name can be omitted in the attribute argument for `#[cgp_provider]`, simplifying the code to:
+
+```rust,ignore
+pub struct Provider;
+
+#[cgp_provider]
+impl<Context, GenericA, GenericB, ...>
+    ActionPerformer<Context, GenericA, GenericB, ...>
+    for Provider
+where
+    Context: ConstraintA + ConstraintB + ...,
+    Context::Assoc: ConstraintC + ConstraintD + ...,
+{ ... }
+```
+
+Note, however, that the generated code would require the component type `"{ProviderTraitName}Component"` to be imported into scope. If the component name is not specified, IDEs like Rust Analyzer may not provide quick fix for auto importing the component. As a result, it may still be preferrable to include the component name attribute, especially when writing new code.
+
+There is also a variant of the macro, `#[cgp_new_provider]`, which would also automatically define the struct for the provider. With that, the code can be defined with the `struct` definition omitted:
+
+```rust,ignore
+#[cgp_new_provider]
+impl<Context, GenericA, GenericB, ...>
+    ActionPerformer<Context, GenericA, GenericB, ...>
+    for Provider
+where
+    Context: ConstraintA + ConstraintB + ...,
+    Context::Assoc: ConstraintC + ConstraintD + ...,
+{ ... }
+```
+
+`#[cgp_new_provider]` is mainly useful in cases where a provider only implements one provider trait. When definining a provider with multiple provider trait implementations, it may be more clear to define the provider struct explicitly, or only use `#[cgp_new_provider]` for the first `impl` block of the provider.
+
+## `check_components!` Macro
+
+To help with debugging CGP code, the `check_components!` macro is provided to allow us to quickly write compile-time tests on the component wiring.
+
+Given the following code pattern:
+
+```rust,ignore
+check_components! {
+    CanUseContext for Context {
+        ComponentA,
+        ComponentB,
+        ComponentC: GenericA,
+        [
+            ComponentD,
+            ComponentE,
+        ]: [
+            (GenericB1, GenericB2, ...),
+            (GenericC1, GenericC2, ...),
+        ],
+    }
+}
+```
+
+The following check trait would be generated:
+
+```rust,ignore
+pub trait CanUseContext:
+    CanUseComponent<ComponentA>
+    + CanUseComponent<ComponentB>
+    + CanUseComponent<ComponentC, GenericA>
+    + CanUseComponent<ComponentD, (GenericB1, GenericB2, ...)>
+    + CanUseComponent<ComponentD, (GenericC1, GenericC2, ...)>
+    + CanUseComponent<ComponentE, (GenericB1, GenericB2, ...)>
+    + CanUseComponent<ComponentE, (GenericC1, GenericC2, ...)>
+{}
+
+impl CanUseContext for Context {}
+```
+
+The `check_components!` macro allows the use of array syntax at either the key or value position, when there are multiple components that share the same set of generic parameters.
+
 ## Example Use
 
 To illustrate how `cgp_component` and `delegate_components` can be
@@ -219,29 +382,19 @@ use serde::{Serialize, Deserialize};
 
 // Component definitions
 
-#[cgp_component {
-    name: StringFormatterComponent,
-    provider: StringFormatter,
-    context: Context,
-}]
+#[cgp_component(StringFormatter)]
 pub trait CanFormatToString {
     fn format_to_string(&self) -> Result<String, Error>;
 }
 
-#[cgp_component {
-    name: StringParserComponent,
-    provider: StringParser,
-    context: Context,
-}]
+#[cgp_component(StringParser)]
 pub trait CanParseFromString: Sized {
     fn parse_from_string(raw: &str) -> Result<Self, Error>;
 }
 
 // Provider implementations
 
-pub struct FormatAsJsonString;
-
-#[cgp_provider(StringFormatterComponent)]
+#[cgp_new_provider]
 impl<Context> StringFormatter<Context> for FormatAsJsonString
 where
     Context: Serialize,
@@ -251,9 +404,7 @@ where
     }
 }
 
-pub struct ParseFromJsonString;
-
-#[cgp_provider(StringParserComponent)]
+#[cgp_new_provider]
 impl<Context> StringParser<Context> for ParseFromJsonString
 where
     Context: for<'a> Deserialize<'a>,
@@ -279,31 +430,29 @@ impl HasProvider for Person {
 
 delegate_components! {
     PersonComponents {
-        StringFormatterComponent: FormatAsJsonString,
-        StringParserComponent: ParseFromJsonString,
+        StringFormatterComponent:
+            FormatAsJsonString,
+        StringParserComponent:
+            ParseFromJsonString,
     }
 }
 
-# let person = Person { first_name: "John".into(), last_name: "Smith".into() };
-# let person_str = r#"{"first_name":"John","last_name":"Smith"}"#;
-#
-# assert_eq!(
-#     person.format_to_string().unwrap(),
-#     person_str
-# );
-#
-# assert_eq!(
-#     Person::parse_from_string(person_str).unwrap(),
-#     person
-# );
+check_components! {
+    CanUsePerson for Person {
+        StringFormatterComponent,
+        StringParserComponent,
+    }
+}
 ```
 
 As we can see, the new code is significantly simpler and more readable than before.
-Using `cgp_component`, we no longer need to explicitly define the provider
-traits `StringFormatter` and `StringParser`, and the blanket implementations
-can be omitted. We also make use of `delegate_components!` on `PersonComponents`
-to delegate `StringFormatterComponent` to `FormatAsJsonString`, and
-`StringParserComponent` to `ParseFromJsonString`.
+Using `#[cgp_component]`, we no longer need to explicitly define the provider traits `StringFormatter` and `StringParser`, and the blanket implementations can be omitted.
+
+With `#[cgp_new_provider]`, the `IsProviderFor` implementations for `FormatAsJsonString` and `ParseFromJsonString` are automatically implemented, together with the struct definitions.
+
+We also make use of `delegate_components!` on `PersonComponents` to delegate `StringFormatterComponent` to `FormatAsJsonString`, and `StringParserComponent` to `ParseFromJsonString`.
+
+Finally, the `check_components!` macro helps us check that we can in fact use `StringFormatterComponent` and `StringParserComponent` with the `Person` context.
 
 ## CGP Macros as Language Extension
 
diff --git a/src/lib.rs b/src/lib.rs
index 509fe82..e69de29 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,164 +0,0 @@
-use anyhow::Error;
-use serde::{Deserialize, Serialize};
-
-pub trait HasProvider {
-    type Provider;
-}
-
-pub trait IsProviderFor<Component, Context, Params = ()> {}
-
-pub trait DelegateComponent<Name> {
-    type Delegate;
-}
-
-pub trait CanUseComponent<Component, Params = ()> {}
-
-impl<Context, Component, Params> CanUseComponent<Component, Params> for Context
-where
-    Context: HasProvider,
-    Context::Provider: IsProviderFor<Component, Context, Params>,
-{
-}
-
-pub struct StringFormatterComponent;
-
-pub struct StringParserComponent;
-
-pub trait CanFormatToString {
-    fn format_to_string(&self) -> Result<String, Error>;
-}
-
-pub trait CanParseFromString: Sized {
-    fn parse_from_string(raw: &str) -> Result<Self, Error>;
-}
-
-pub trait StringFormatter<Context>:
-    IsProviderFor<StringFormatterComponent, Context>
-{
-    fn format_to_string(context: &Context) -> Result<String, Error>;
-}
-
-pub trait StringParser<Context>:
-    IsProviderFor<StringParserComponent, Context>
-{
-    fn parse_from_string(raw: &str) -> Result<Context, Error>;
-}
-
-impl<Context> CanFormatToString for Context
-where
-    Context: HasProvider,
-    Context::Provider: StringFormatter<Context>,
-{
-    fn format_to_string(&self) -> Result<String, Error> {
-        Context::Provider::format_to_string(self)
-    }
-}
-
-impl<Context> CanParseFromString for Context
-where
-    Context: HasProvider,
-    Context::Provider: StringParser<Context>,
-{
-    fn parse_from_string(raw: &str) -> Result<Context, Error> {
-        Context::Provider::parse_from_string(raw)
-    }
-}
-
-impl<Context, Component> StringFormatter<Context> for Component
-where
-    Component: DelegateComponent<StringFormatterComponent>
-        + IsProviderFor<StringFormatterComponent, Context>,
-    Component::Delegate: StringFormatter<Context>,
-{
-    fn format_to_string(context: &Context) -> Result<String, Error> {
-        Component::Delegate::format_to_string(context)
-    }
-}
-
-impl<Context, Component> StringParser<Context> for Component
-where
-    Component: DelegateComponent<StringParserComponent>
-        + IsProviderFor<StringParserComponent, Context>,
-    Component::Delegate: StringParser<Context>,
-{
-    fn parse_from_string(raw: &str) -> Result<Context, Error> {
-        Component::Delegate::parse_from_string(raw)
-    }
-}
-
-pub struct FormatAsJsonString;
-
-impl<Context> StringFormatter<Context> for FormatAsJsonString
-where
-    Context: Serialize,
-{
-    fn format_to_string(context: &Context) -> Result<String, Error> {
-        Ok(serde_json::to_string(context)?)
-    }
-}
-
-impl<Context> IsProviderFor<StringFormatterComponent, Context>
-    for FormatAsJsonString
-where
-    Context: Serialize,
-{
-}
-
-pub struct ParseFromJsonString;
-
-impl<Context> StringParser<Context> for ParseFromJsonString
-where
-    Context: for<'a> Deserialize<'a>,
-{
-    fn parse_from_string(json_str: &str) -> Result<Context, Error> {
-        Ok(serde_json::from_str(json_str)?)
-    }
-}
-
-impl<Context> IsProviderFor<StringParserComponent, Context>
-    for ParseFromJsonString
-where
-    Context: for<'a> Deserialize<'a>,
-{
-}
-
-// Note: We pretend to forgot to derive Serialize here
-#[derive(Deserialize, Debug, Eq, PartialEq)]
-pub struct Person {
-    pub first_name: String,
-    pub last_name: String,
-}
-
-pub struct PersonComponents;
-
-impl HasProvider for Person {
-    type Provider = PersonComponents;
-}
-
-impl DelegateComponent<StringFormatterComponent> for PersonComponents {
-    type Delegate = FormatAsJsonString;
-}
-
-impl<Context> IsProviderFor<StringFormatterComponent, Context>
-    for PersonComponents
-where
-    FormatAsJsonString: IsProviderFor<StringFormatterComponent, Context>,
-{
-}
-
-impl DelegateComponent<StringParserComponent> for PersonComponents {
-    type Delegate = ParseFromJsonString;
-}
-
-impl<Context> IsProviderFor<StringParserComponent, Context> for PersonComponents where
-    ParseFromJsonString: IsProviderFor<StringParserComponent, Context>
-{
-}
-
-pub trait CanUsePerson:
-    CanUseComponent<StringFormatterComponent>
-    + CanUseComponent<StringParserComponent>
-{
-}
-
-impl CanUsePerson for Person {}

From 5f5cb717321b74a9e62e6a5fc1c8bbe465aaaeac Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Thu, 8 May 2025 10:39:15 +0000
Subject: [PATCH 11/19] Rename HasProvider to HasCgpProvider

---
 Cargo.lock                        | 34 ++++++------
 content/associated-types.md       |  2 +-
 content/component-macros.md       | 10 ++--
 content/consumer-provider-link.md | 44 +++++++--------
 content/debugging-support.md      | 76 +++++++++++++-------------
 content/provider-delegation.md    | 90 +++++++++++++++----------------
 content/provider-traits.md        |  2 +-
 7 files changed, 129 insertions(+), 129 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bb703f6..2e66b17 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -101,7 +101,7 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "cgp"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-async",
  "cgp-core",
@@ -111,7 +111,7 @@ dependencies = [
 [[package]]
 name = "cgp-async"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-async-macro",
  "cgp-sync",
@@ -120,7 +120,7 @@ dependencies = [
 [[package]]
 name = "cgp-async-macro"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -130,12 +130,12 @@ dependencies = [
 [[package]]
 name = "cgp-component"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 
 [[package]]
 name = "cgp-core"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -148,7 +148,7 @@ dependencies = [
 [[package]]
 name = "cgp-error"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -159,7 +159,7 @@ dependencies = [
 [[package]]
 name = "cgp-error-anyhow"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "anyhow",
  "cgp-core",
@@ -168,7 +168,7 @@ dependencies = [
 [[package]]
 name = "cgp-error-extra"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-core",
 ]
@@ -176,7 +176,7 @@ dependencies = [
 [[package]]
 name = "cgp-extra"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-error-extra",
  "cgp-inner",
@@ -187,7 +187,7 @@ dependencies = [
 [[package]]
 name = "cgp-field"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-component",
  "cgp-macro",
@@ -197,7 +197,7 @@ dependencies = [
 [[package]]
 name = "cgp-inner"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-component",
  "cgp-macro",
@@ -206,7 +206,7 @@ dependencies = [
 [[package]]
 name = "cgp-macro"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-macro-lib",
  "syn",
@@ -215,7 +215,7 @@ dependencies = [
 [[package]]
 name = "cgp-macro-lib"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "itertools",
  "prettyplease",
@@ -242,7 +242,7 @@ dependencies = [
 [[package]]
 name = "cgp-run"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -253,7 +253,7 @@ dependencies = [
 [[package]]
 name = "cgp-runtime"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-core",
 ]
@@ -261,7 +261,7 @@ dependencies = [
 [[package]]
 name = "cgp-sync"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-async-macro",
 ]
@@ -269,7 +269,7 @@ dependencies = [
 [[package]]
 name = "cgp-type"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#759bd220bf52ea5fe6ebfc4490322d63a6085f9f"
+source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
 dependencies = [
  "cgp-component",
  "cgp-macro",
diff --git a/content/associated-types.md b/content/associated-types.md
index 6ff5d9a..c1925a7 100644
--- a/content/associated-types.md
+++ b/content/associated-types.md
@@ -159,7 +159,7 @@ pub trait HasAuthTokenType {
 
 Here, we define the `HasTimeType` trait with an associated type `Time`, which is constrained to types that implement `Eq` and `Ord` so that they can be compared. Similarly, the `HasAuthTokenType` trait defines an associated type `AuthToken`, without any additional constraints.
 
-Similar to regular trait methods, CGP allows us to auto-derive blanket implementations that delegate the associated types to providers using `HasProvider` and `DelegateComponent`. Therefore, we can use `#[cgp_component]` on traits containing associated types as well.
+Similar to regular trait methods, CGP allows us to auto-derive blanket implementations that delegate the associated types to providers using `HasCgpProvider` and `DelegateComponent`. Therefore, we can use `#[cgp_component]` on traits containing associated types as well.
 
 With these type traits in place, we can now update our authentication components to leverage abstract types within the trait methods:
 
diff --git a/content/component-macros.md b/content/component-macros.md
index d590179..06f8b00 100644
--- a/content/component-macros.md
+++ b/content/component-macros.md
@@ -6,7 +6,7 @@ In summary, a CGP component is consist of the following building blocks:
 - A consumer trait.
 - A provider trait.
 - A component name type.
-- A blanket implementation of the consumer trait using `HasProvider`.
+- A blanket implementation of the consumer trait using `HasCgpProvider`.
 - A blanket implementation of the provider trait using `DelegateComponent`.
 
 Syntactically, all CGP components follow the same pattern. The pattern is
@@ -46,7 +46,7 @@ where
 impl<Context, GenericA, GenericB, ...>
     CanPerformAction<GenericA, GenericB, ...> for Context
 where
-    Context: HasProvider + ConstraintA + ConstraintB + ...,
+    Context: HasCgpProvider + ConstraintA + ConstraintB + ...,
     Context::Components: ActionPerformer<Context>,
 {
     fn perform_action(
@@ -111,7 +111,7 @@ pub trait CanPerformAction<GenericA, GenericB, ...>:
 
 To use the macro, the bulk import statement `use cgp::prelude::*` has to
 be used to bring all CGP constructs into scope. This includes the
-`HasProvider` and `DelegateComponent` traits, which are also provided
+`HasCgpProvider` and `DelegateComponent` traits, which are also provided
 by the `cgp` crate.
 
 We then use `cgp_component` as an attribute proc macro, with several
@@ -424,8 +424,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasProvider for Person {
-    type Provider = PersonComponents;
+impl HasCgpProvider for Person {
+    type CgpProvider = PersonComponents;
 }
 
 delegate_components! {
diff --git a/content/consumer-provider-link.md b/content/consumer-provider-link.md
index 5b72051..8d62461 100644
--- a/content/consumer-provider-link.md
+++ b/content/consumer-provider-link.md
@@ -89,8 +89,8 @@ chosen provider. We would define the blanket implementation for `CanFormatString
 as follows:
 
 ```rust
-pub trait HasProvider {
-    type Provider;
+pub trait HasCgpProvider {
+    type CgpProvider;
 }
 
 pub trait CanFormatString {
@@ -103,27 +103,27 @@ pub trait StringFormatter<Context> {
 
 impl<Context> CanFormatString for Context
 where
-    Context: HasProvider,
-    Context::Provider: StringFormatter<Context>,
+    Context: HasCgpProvider,
+    Context::CgpProvider: StringFormatter<Context>,
 {
     fn format_string(&self) -> String {
-        Context::Provider::format_string(self)
+        Context::CgpProvider::format_string(self)
     }
 }
 ```
 
-First of all, we define a new `HasProvider` trait that contains an associated
-type `Provider`. The `Provider` type would be specified by a context to
+First of all, we define a new `HasCgpProvider` trait that contains an associated
+type `CgpProvider`. The `CgpProvider` type would be specified by a context to
 choose a provider that it would use to forward all implementations of consumer
 traits. Following that, we add a blanket implementation for `CanFormatString`,
-which would be implemented for any `Context` that implements `HasProvider`,
-provided that `Context::Provider` implements `StringFormatter<Context>`.
+which would be implemented for any `Context` that implements `HasCgpProvider`,
+provided that `Context::CgpProvider` implements `StringFormatter<Context>`.
 
 To explain in simpler terms - if a context has a provider that implements
 a provider trait for that context, then the consumer trait for that context
 is also automatically implemented.
 
-With the new blanket implementation in place, we can now implement `HasProvider`
+With the new blanket implementation in place, we can now implement `HasCgpProvider`
 for the `Person` context, and it would now help us to implement `CanFormatString`
 for free:
 
@@ -142,16 +142,16 @@ impl Display for Person {
     }
 }
 
-impl HasProvider for Person {
-    type Provider = FormatStringWithDisplay;
+impl HasCgpProvider for Person {
+    type CgpProvider = FormatStringWithDisplay;
 }
 
 let person = Person { first_name: "John".into(), last_name: "Smith".into() };
 
 assert_eq!(person.format_string(), "John Smith");
 #
-# pub trait HasProvider {
-#     type Provider;
+# pub trait HasCgpProvider {
+#     type CgpProvider;
 # }
 #
 # pub trait CanFormatString {
@@ -164,11 +164,11 @@ assert_eq!(person.format_string(), "John Smith");
 #
 # impl<Context> CanFormatString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringFormatter<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringFormatter<Context>,
 # {
 #     fn format_string(&self) -> String {
-#         Context::Provider::format_string(self)
+#         Context::CgpProvider::format_string(self)
 #     }
 # }
 #
@@ -184,24 +184,24 @@ assert_eq!(person.format_string(), "John Smith");
 # }
 ```
 
-Compared to before, the implementation of `HasProvider` is much shorter than
+Compared to before, the implementation of `HasCgpProvider` is much shorter than
 implementing `CanFormatString` directly, since we only need to specify the provider
 type without any function definition.
 
 At the moment, because the `Person` context only implements one consumer trait, we
-can set `FormatStringWithDisplay` directly as `Person::Provider`. However, if there
+can set `FormatStringWithDisplay` directly as `Person::CgpProvider`. However, if there
 are other consumer traits that we would like to use with `Person`, we would need to
-define `Person::Provider` with a separate provider that implements multiple provider
+define `Person::CgpProvider` with a separate provider that implements multiple provider
 traits. This will be covered in the next chapter, which we would talk about how to
 link multiple providers of different provider traits together.
 
 ## Component System
 
 You may have noticed that the trait for specifying the provider for a context is called
-`HasProvider` instead of `HasProviders`. This is to generalize the idea of a pair of
+`HasCgpProvider` instead of `HasCgpProviders`. This is to generalize the idea of a pair of
 consumer trait and provider trait working together, forming a _component_.
 
 In context-generic programming, we use the term _component_ to refer to a consumer-provider
 trait pair. The consumer trait and the provider trait are linked together through blanket
-implementations and traits such as `HasProvider`. These constructs working together to
+implementations and traits such as `HasCgpProvider`. These constructs working together to
 form the basis for a _component system_ for CGP.
\ No newline at end of file
diff --git a/content/debugging-support.md b/content/debugging-support.md
index 017809e..c7e3f2c 100644
--- a/content/debugging-support.md
+++ b/content/debugging-support.md
@@ -34,8 +34,8 @@ Consider if we made a mistake and forgot to implement `Serialize` for `Person`:
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# pub trait HasProvider {
-#     type Provider;
+# pub trait HasCgpProvider {
+#     type CgpProvider;
 # }
 #
 # pub trait CanFormatToString {
@@ -56,21 +56,21 @@ Consider if we made a mistake and forgot to implement `Serialize` for `Person`:
 #
 # impl<Context> CanFormatToString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringFormatter<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Provider::format_to_string(self)
+#         Context::CgpProvider::format_to_string(self)
 #     }
 # }
 #
 # impl<Context> CanParseFromString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringParser<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Provider::parse_from_string(raw)
+#         Context::CgpProvider::parse_from_string(raw)
 #     }
 # }
 #
@@ -132,8 +132,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasProvider for Person {
-    type Provider = PersonComponents;
+impl HasCgpProvider for Person {
+    type CgpProvider = PersonComponents;
 }
 
 impl DelegateComponent<StringFormatterComponent> for PersonComponents {
@@ -162,8 +162,8 @@ call `format_to_string`, and check if it works:
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# pub trait HasProvider {
-#     type Provider;
+# pub trait HasCgpProvider {
+#     type CgpProvider;
 # }
 #
 # pub trait CanFormatToString {
@@ -184,21 +184,21 @@ call `format_to_string`, and check if it works:
 #
 # impl<Context> CanFormatToString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringFormatter<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Provider::format_to_string(self)
+#         Context::CgpProvider::format_to_string(self)
 #     }
 # }
 #
 # impl<Context> CanParseFromString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringParser<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Provider::parse_from_string(raw)
+#         Context::CgpProvider::parse_from_string(raw)
 #     }
 # }
 #
@@ -260,8 +260,8 @@ call `format_to_string`, and check if it works:
 #
 # pub struct PersonComponents;
 #
-# impl HasProvider for Person {
-#     type Provider = PersonComponents;
+# impl HasCgpProvider for Person {
+#     type CgpProvider = PersonComponents;
 # }
 #
 # impl DelegateComponent<StringFormatterComponent> for PersonComponents {
@@ -578,8 +578,8 @@ specified for each supertrait, which becomes tedious and adds noise.
 We can improve the check definitions by introducing a helper `CanUseComponent` trait that is defined as follows:
 
 ```rust
-# pub trait HasProvider {
-#     type Provider;
+# pub trait HasCgpProvider {
+#     type CgpProvider;
 # }
 #
 pub trait IsProviderFor<Component, Context, Params = ()> {}
@@ -588,17 +588,17 @@ pub trait CanUseComponent<Component, Params = ()> {}
 
 impl<Context, Component, Params> CanUseComponent<Component, Params> for Context
 where
-    Context: HasProvider,
-    Context::Provider: IsProviderFor<Component, Context, Params>,
+    Context: HasCgpProvider,
+    Context::CgpProvider: IsProviderFor<Component, Context, Params>,
 {
 }
 ```
 
 Instead of being implemented by a provider, `CanUseComponent` is intended to be implemented by a context type that
-implements `HasProvider`. Compared to `IsProviderFor`, there is no need to specify an explicit `Context` parameter.
+implements `HasCgpProvider`. Compared to `IsProviderFor`, there is no need to specify an explicit `Context` parameter.
 
 `CanUseComponent` also has a blanket implementation, making it automatically implemented for any `Context` type
-that implements `HasProvider`, with `Context::Provider` implementing `IsProviderFor`.
+that implements `HasCgpProvider`, with `Context::CgpProvider` implementing `IsProviderFor`.
 
 In other words, we are using `CanUseComponent` as a _trait alias_ to `IsProviderFor`, with improved ergonomics
 that we can check directly against a context type.
@@ -663,8 +663,8 @@ We will show the full example that we have walked through earlier, with the addi
 use anyhow::Error;
 use serde::{Deserialize, Serialize};
 
-pub trait HasProvider {
-    type Provider;
+pub trait HasCgpProvider {
+    type CgpProvider;
 }
 
 pub trait IsProviderFor<Component, Context, Params = ()> {}
@@ -677,8 +677,8 @@ pub trait CanUseComponent<Component, Params = ()> {}
 
 impl<Context, Component, Params> CanUseComponent<Component, Params> for Context
 where
-    Context: HasProvider,
-    Context::Provider: IsProviderFor<Component, Context, Params>,
+    Context: HasCgpProvider,
+    Context::CgpProvider: IsProviderFor<Component, Context, Params>,
 {
 }
 
@@ -708,21 +708,21 @@ pub trait StringParser<Context>:
 
 impl<Context> CanFormatToString for Context
 where
-    Context: HasProvider,
-    Context::Provider: StringFormatter<Context>,
+    Context: HasCgpProvider,
+    Context::CgpProvider: StringFormatter<Context>,
 {
     fn format_to_string(&self) -> Result<String, Error> {
-        Context::Provider::format_to_string(self)
+        Context::CgpProvider::format_to_string(self)
     }
 }
 
 impl<Context> CanParseFromString for Context
 where
-    Context: HasProvider,
-    Context::Provider: StringParser<Context>,
+    Context: HasCgpProvider,
+    Context::CgpProvider: StringParser<Context>,
 {
     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-        Context::Provider::parse_from_string(raw)
+        Context::CgpProvider::parse_from_string(raw)
     }
 }
 
@@ -793,8 +793,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasProvider for Person {
-    type Provider = PersonComponents;
+impl HasCgpProvider for Person {
+    type CgpProvider = PersonComponents;
 }
 
 impl DelegateComponent<StringFormatterComponent> for PersonComponents {
diff --git a/content/provider-delegation.md b/content/provider-delegation.md
index c14b517..c20ea43 100644
--- a/content/provider-delegation.md
+++ b/content/provider-delegation.md
@@ -1,10 +1,10 @@
 # Provider Delegation
 
-In the previous chapter, we learned to make use of the `HasProvider` trait
+In the previous chapter, we learned to make use of the `HasCgpProvider` trait
 to define a blanket implementation for a consumer trait like `CanFormatString`,
 so that a context would automatically delegate the implementation to a provider
 trait like `StringFormatter`. However, because there can only be one `Components`
-type defined for `HasProvider`, this means that the given provider needs to
+type defined for `HasCgpProvider`, this means that the given provider needs to
 implement _all_ provider traits that we would like to use for the context.
 
 In this chapter, we will learn to combine multiple providers that each implements
@@ -46,8 +46,8 @@ Next, we also define the provider traits as follows:
 #
 # use anyhow::Error;
 #
-# pub trait HasProvider {
-#     type Provider;
+# pub trait HasCgpProvider {
+#     type CgpProvider;
 # }
 #
 # pub trait CanFormatToString {
@@ -68,27 +68,27 @@ pub trait StringParser<Context> {
 
 impl<Context> CanFormatToString for Context
 where
-    Context: HasProvider,
-    Context::Provider: StringFormatter<Context>,
+    Context: HasCgpProvider,
+    Context::CgpProvider: StringFormatter<Context>,
 {
     fn format_to_string(&self) -> Result<String, Error> {
-        Context::Provider::format_to_string(self)
+        Context::CgpProvider::format_to_string(self)
     }
 }
 
 impl<Context> CanParseFromString for Context
 where
-    Context: HasProvider,
-    Context::Provider: StringParser<Context>,
+    Context: HasCgpProvider,
+    Context::CgpProvider: StringParser<Context>,
 {
     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-        Context::Provider::parse_from_string(raw)
+        Context::CgpProvider::parse_from_string(raw)
     }
 }
 ```
 
 Similar to the previous chapter, we make use of blanket implementations
-and `HasProvider` to link the consumer traits `CanFormatToString`
+and `HasCgpProvider` to link the consumer traits `CanFormatToString`
 and `CanParseFromString` with their respective provider traits, `StringFormatter`
 and `StringParser`.
 
@@ -171,8 +171,8 @@ and `StringParser` by delegating the call to the actual providers.
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# pub trait HasProvider {
-#     type Provider;
+# pub trait HasCgpProvider {
+#     type CgpProvider;
 # }
 #
 # pub trait CanFormatToString {
@@ -193,21 +193,21 @@ and `StringParser` by delegating the call to the actual providers.
 #
 # impl<Context> CanFormatToString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringFormatter<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Provider::format_to_string(self)
+#         Context::CgpProvider::format_to_string(self)
 #     }
 # }
 #
 # impl<Context> CanParseFromString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringParser<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Provider::parse_from_string(raw)
+#         Context::CgpProvider::parse_from_string(raw)
 #     }
 # }
 #
@@ -241,8 +241,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasProvider for Person {
-    type Provider = PersonComponents;
+impl HasCgpProvider for Person {
+    type CgpProvider = PersonComponents;
 }
 
 impl StringFormatter<Person> for PersonComponents {
@@ -277,7 +277,7 @@ later on.
 
 We then define a dummy struct `PersonComponents`,
 which would be used to aggregate the providers for `Person`. Compared to the
-previous chapter, we implement `HasProvider` for `Person` with `PersonComponents`
+previous chapter, we implement `HasCgpProvider` for `Person` with `PersonComponents`
 as the provider.
 
 We then implement the provider traits `StringFormatter` and `StringParser`
@@ -296,7 +296,7 @@ The main differences between the two implementation boilerplate is that
 we want to choose `FormatAsJsonString` as the provider for `StringFormatter`,
 and `ParseFromJsonString` as the provider for `StringParser`.
 
-Similar to how we can use `HasProvider` with blanket implementations to link
+Similar to how we can use `HasCgpProvider` with blanket implementations to link
 a consumer with a provider, we can reduce the boilerplate required by using
 similar pattern to link a provider with _another_ provider:
 
@@ -350,7 +350,7 @@ where
 }
 ```
 
-The `DelegateComponent` is similar to the `HasProvider` trait, but it is intended
+The `DelegateComponent` is similar to the `HasCgpProvider` trait, but it is intended
 to be implemented by providers instead of concrete contexts. It also has an extra
 generic `Name` type that is used to differentiate which component the provider
 delegation is intended for.
@@ -378,7 +378,7 @@ different `Delegate` to be used depending on the `Name`.
 ## Using `DelegateComponent`
 
 It may take a while to fully understand how the blanket implementations with
-`DelegateComponent` and `HasProvider` work. But since the same pattern will
+`DelegateComponent` and `HasCgpProvider` work. But since the same pattern will
 be used everywhere, it would hopefully become clear as we see more examples.
 It would also help to see how the blanket implementation is used, by going
 back to the example of implementing the concrete context `Person`.
@@ -391,8 +391,8 @@ back to the example of implementing the concrete context `Person`.
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# pub trait HasProvider {
-#     type Provider;
+# pub trait HasCgpProvider {
+#     type CgpProvider;
 # }
 #
 # pub trait CanFormatToString {
@@ -413,21 +413,21 @@ back to the example of implementing the concrete context `Person`.
 #
 # impl<Context> CanFormatToString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringFormatter<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Provider::format_to_string(self)
+#         Context::CgpProvider::format_to_string(self)
 #     }
 # }
 #
 # impl<Context> CanParseFromString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringParser<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Provider::parse_from_string(raw)
+#         Context::CgpProvider::parse_from_string(raw)
 #     }
 # }
 #
@@ -488,8 +488,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasProvider for Person {
-    type Provider = PersonComponents;
+impl HasCgpProvider for Person {
+    type CgpProvider = PersonComponents;
 }
 
 impl DelegateComponent<StringFormatterComponent> for PersonComponents {
@@ -579,8 +579,8 @@ which provider to use in each concrete context implementation.
 # use anyhow::Error;
 # use serde::{Serialize, Deserialize};
 #
-# pub trait HasProvider {
-#     type Provider;
+# pub trait HasCgpProvider {
+#     type CgpProvider;
 # }
 #
 # pub trait CanFormatToString {
@@ -601,21 +601,21 @@ which provider to use in each concrete context implementation.
 #
 # impl<Context> CanFormatToString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringFormatter<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringFormatter<Context>,
 # {
 #     fn format_to_string(&self) -> Result<String, Error> {
-#         Context::Provider::format_to_string(self)
+#         Context::CgpProvider::format_to_string(self)
 #     }
 # }
 #
 # impl<Context> CanParseFromString for Context
 # where
-#     Context: HasProvider,
-#     Context::Provider: StringParser<Context>,
+#     Context: HasCgpProvider,
+#     Context::CgpProvider: StringParser<Context>,
 # {
 #     fn parse_from_string(raw: &str) -> Result<Context, Error> {
-#         Context::Provider::parse_from_string(raw)
+#         Context::CgpProvider::parse_from_string(raw)
 #     }
 # }
 #
@@ -687,8 +687,8 @@ pub struct Person {
 
 pub struct PersonComponents;
 
-impl HasProvider for Person {
-    type Provider = PersonComponents;
+impl HasCgpProvider for Person {
+    type CgpProvider = PersonComponents;
 }
 
 impl DelegateComponent<StringFormatterComponent> for PersonComponents {
diff --git a/content/provider-traits.md b/content/provider-traits.md
index 7dd73fe..478cfdf 100644
--- a/content/provider-traits.md
+++ b/content/provider-traits.md
@@ -202,7 +202,7 @@ assert_eq!(
 
 Our `Person` struct is defined with both `Debug` and `Display` implementations.
 When using `format_string` on a value `person: Person`, we cannot just call
-`person.format_string()`. Instead, we have to explicitly pick a provider `Provider`,
+`person.format_string()`. Instead, we have to explicitly pick a provider `CgpProvider`,
 and call it with `Provider::format_string(&person)`.
 On the other hand, thanks to the explicit syntax, we can use both `FormatStringWithDisplay`
 and `FormatStringWithDebug` on `Person` without any issue.

From 3981b41a9faad5ab6aee1a5247c6011858992188 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Thu, 8 May 2025 11:03:42 +0000
Subject: [PATCH 12/19] Use delegate_and_checks! to simplify examples

---
 content/associated-types.md | 19 +++--------
 content/component-macros.md | 63 ++++++++++++++++++++++++++++++-------
 content/error-handling.md   |  9 ++----
 3 files changed, 58 insertions(+), 33 deletions(-)

diff --git a/content/associated-types.md b/content/associated-types.md
index c1925a7..df44602 100644
--- a/content/associated-types.md
+++ b/content/associated-types.md
@@ -84,7 +84,8 @@ pub mod contexts {
         pub auth_tokens_store: BTreeMap<String, u64>,
     }
 
-    delegate_components! {
+    delegate_and_check_components! {
+        CanUseMockApp for MockApp;
         MockAppComponents {
             CurrentTimeGetterComponent: GetSystemTimestamp,
             AuthTokenValidatorComponent: ValidateTokenIsNotExpired,
@@ -104,12 +105,6 @@ pub mod contexts {
                 .ok_or_else(|| anyhow!("invalid auth token"))
         }
     }
-
-    check_components! {
-        CanUseMockApp for MockApp {
-            AuthTokenValidatorComponent,
-        }
-    }
 }
 #
 # }
@@ -663,7 +658,8 @@ pub mod contexts {
         pub auth_tokens_store: BTreeMap<String, LocalDateTime>,
     }
 
-    delegate_components! {
+    delegate_and_check_components! {
+        CanUseMockApp for MockApp;
         MockAppComponents {
             [
                 TimeTypeProviderComponent,
@@ -687,13 +683,6 @@ pub mod contexts {
                 .ok_or_else(|| anyhow!("invalid auth token"))
         }
     }
-
-
-    check_components! {
-        CanUseMockApp for MockApp {
-            AuthTokenValidatorComponent,
-        }
-    }
 }
 #
 # }
diff --git a/content/component-macros.md b/content/component-macros.md
index 06f8b00..cc207a2 100644
--- a/content/component-macros.md
+++ b/content/component-macros.md
@@ -361,6 +361,55 @@ impl CanUseContext for Context {}
 
 The `check_components!` macro allows the use of array syntax at either the key or value position, when there are multiple components that share the same set of generic parameters.
 
+## `delegate_and_check_components!` Macro
+
+The `delegate_and_check_components!` macro combines both calls to `delegate_components!` and `check_components!`, so that wiring checks are done as soon as a delegate entry is added. This can simplify the boilerplate required to duplicate the code of listing all components in both delegate and check entries.
+
+Given the following:
+
+```rust,ignore
+delegate_and_check_components! {
+    CanUseContext for Context;
+    ContextComponents {
+        ComponentA: ProviderA,
+        ComponentB: ProviderB,
+        [
+            ComponentC1,
+            ComponentC2,
+            ...
+        ]: ProviderC,
+    }
+}
+```
+
+The macro would expand into the equivalent of:
+
+```rust,ignore
+delegate_components! {
+    ContextComponents {
+        ComponentA: ProviderA,
+        ComponentB: ProviderB,
+        [
+            ComponentC1,
+            ComponentC2,
+            ...
+        ]: ProviderC,
+    }
+}
+
+check_components! {
+    CanUseContext for Context {
+        ComponentA,
+        ComponentB,
+        ComponentC1,
+        ComponentC2,
+    }
+}
+```
+
+You may wonder why we need define a separate macro, instead of always checking the wiring directly inside `delegate_components!`. The main reason is that while `delegate_and_check_components!` can work for the simple cases, it is more limited and cannot handle well on advanced cases where the CGP traits contain additional generic parameters. For such cases, it is still better to call `delegate_components!` and `check_components!` separately.
+
+
 ## Example Use
 
 To illustrate how `cgp_component` and `delegate_components` can be
@@ -428,7 +477,8 @@ impl HasCgpProvider for Person {
     type CgpProvider = PersonComponents;
 }
 
-delegate_components! {
+delegate_and_check_components! {
+    CanUsePerson for Person;
     PersonComponents {
         StringFormatterComponent:
             FormatAsJsonString,
@@ -436,13 +486,6 @@ delegate_components! {
             ParseFromJsonString,
     }
 }
-
-check_components! {
-    CanUsePerson for Person {
-        StringFormatterComponent,
-        StringParserComponent,
-    }
-}
 ```
 
 As we can see, the new code is significantly simpler and more readable than before.
@@ -450,9 +493,7 @@ Using `#[cgp_component]`, we no longer need to explicitly define the provider tr
 
 With `#[cgp_new_provider]`, the `IsProviderFor` implementations for `FormatAsJsonString` and `ParseFromJsonString` are automatically implemented, together with the struct definitions.
 
-We also make use of `delegate_components!` on `PersonComponents` to delegate `StringFormatterComponent` to `FormatAsJsonString`, and `StringParserComponent` to `ParseFromJsonString`.
-
-Finally, the `check_components!` macro helps us check that we can in fact use `StringFormatterComponent` and `StringParserComponent` with the `Person` context.
+We also make use of `delegate_and_check_components!` on `PersonComponents` to delegate `StringFormatterComponent` to `FormatAsJsonString`, and `StringParserComponent` to `ParseFromJsonString`, and then check to ensure that the wirings are implemented correctly for the `Person` context.
 
 ## CGP Macros as Language Extension
 
diff --git a/content/error-handling.md b/content/error-handling.md
index c65df71..9c1730e 100644
--- a/content/error-handling.md
+++ b/content/error-handling.md
@@ -497,7 +497,8 @@ pub mod contexts {
         pub auth_tokens_store: BTreeMap<String, LocalDateTime>,
     }
 
-    delegate_components! {
+    delegate_and_check_components! {
+        CanUseMockApp for MockApp;
         MockAppComponents {
             ErrorTypeProviderComponent:
                 UseAnyhowError,
@@ -525,12 +526,6 @@ pub mod contexts {
                 .ok_or_else(|| anyhow!("invalid auth token"))
         }
     }
-
-    check_components! {
-        CanUseMockApp for MockApp {
-            AuthTokenValidatorComponent,
-        }
-    }
 }
 #
 # }

From c035d6435f2ae36e1a8aaef6a3319c498ab522a6 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Thu, 8 May 2025 13:01:44 +0000
Subject: [PATCH 13/19] Add section for #[cgp_context] macro

---
 content/component-macros.md | 42 ++++++++++++++++++++++++++++++-------
 1 file changed, 34 insertions(+), 8 deletions(-)

diff --git a/content/component-macros.md b/content/component-macros.md
index cc207a2..46d6987 100644
--- a/content/component-macros.md
+++ b/content/component-macros.md
@@ -257,6 +257,38 @@ delegate_components! {
 }
 ```
 
+## `#[cgp_context]` Macro
+
+The `#[cgp_context]` macro can be applied on a context struct, to automatically define the provider struct for the context and implement `HasCgpProvider` for the context.
+
+Given the following context definition:
+
+```rust,ignore
+#[cgp_context(MyContextComponents)]
+pub struct MyContext {
+    ...
+}
+```
+
+The macro will generate the following constructs:
+
+```rust,ignore
+pub struct MyContextComponents;
+
+impl HasCgpProvider for MyContext {
+    type CgpProvider = MyContextComponents;
+}
+```
+
+If the context provider name follows the pattern `{ContextName}Components`, then the macro attribute argument can be omitted, and the code can be simplified to:
+
+```rust,ignore
+#[cgp_context]
+pub struct MyContext {
+    ...
+}
+```
+
 ## `#[cgp_provider]` Macro
 
 When implementing a provider, the `#[cgp_provider]` macro needs to be used to automatically implement the `IsProviderFor` implementation, with all constraints within the `impl` block copied over.
@@ -464,19 +496,13 @@ where
 }
 
 // Concrete context and wiring
-
+#[cgp_context]
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 pub struct Person {
     pub first_name: String,
     pub last_name: String,
 }
 
-pub struct PersonComponents;
-
-impl HasCgpProvider for Person {
-    type CgpProvider = PersonComponents;
-}
-
 delegate_and_check_components! {
     CanUsePerson for Person;
     PersonComponents {
@@ -519,4 +545,4 @@ how context-generic programming can be done in Rust, and how it can help
 build better Rust applications.
 
 In the chapters that follow, we will make heavy use of `cgp` and its
-macros to dive further into the world of context-generic programming.
\ No newline at end of file
+macros to dive further into the world of context-generic programming.

From fc9354fc079ae8720191462968b962871ad131e6 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Fri, 9 May 2025 12:36:35 +0000
Subject: [PATCH 14/19] Revise associated type sections

---
 content/associated-types.md | 66 ++++++++++++++-----------------------
 1 file changed, 24 insertions(+), 42 deletions(-)

diff --git a/content/associated-types.md b/content/associated-types.md
index df44602..545e1a8 100644
--- a/content/associated-types.md
+++ b/content/associated-types.md
@@ -253,73 +253,55 @@ where
 
 This example shows how CGP enables us to define context-generic providers that are not just generic over the context itself, but also over its associated types. Unlike traditional generic programming, where all generic parameters are specified positionally, CGP allows us to parameterize abstract types using _names_ via associated types.
 
-## Defining Abstract Type Traits with `cgp_type!`
+## Defining Abstract Type Traits with `#[cgp_type]`
 
-The type traits `HasTimeType` and `HasAuthTokenType` share a similar structure, and as you define more abstract types, this boilerplate can become tedious. To streamline the process, the `cgp` crate provides the `cgp_type!` macro, which simplifies type trait definitions.
+The type traits `HasTimeType` and `HasAuthTokenType` share a similar structure, and as you define more abstract types, this boilerplate can become tedious. To streamline the process, the `cgp` crate provides the `#[cgp_type]` macro, which simplifies type trait definitions.
 
-Here's how you can define the same types with `cgp_type!`:
+Here's how you can define the same types with `#[cgp_type]`:
 
 ```rust
 # extern crate cgp;
 #
 use cgp::prelude::*;
 
-#[cgp_type]
+#[cgp_type {
+    provider: TimeTypeProvider,
+}]
 pub trait HasTimeType {
     type Time: Eq + Ord;
 }
 
-#[cgp_type]
+#[cgp_type {
+    provider: TimeTypeProvider,
+}]
 pub trait HasAuthTokenType {
     type AuthToken;
 }
 ```
 
-The `cgp_type!` macro accepts the name of an abstract type, `$name`, along with any applicable constraints for that type. It then automatically generates the same implementation as the `cgp_component` macro: a consumer trait named `Has{$name}Type`, a provider trait named `Provide{$name}Type`, and a component name type named `${name}TypeComponent`. Each of the generated traits includes an associated type defined as `type $name: $constraints;`.
-In addition, `cgp_type!` also derives some other implementations, which we'll explore in later chapters.
-
-## Trait Minimalism
-
-At first glance, it might seem overly verbose to define multiple type traits and require each to be explicitly included as a supertrait of a method interface. For instance, you might be tempted to consolidate the methods and types into a single trait, like this:
+The `#[cgp_type]` macro works with a CGP trait that contains a single non-generic associated type. It is an extension over `#[cgp_component]`, and generate additional constructs that make it easy to work with abstract types in CGP. When no argument is given, `#[cgp_type]` would default to generate a provider with name `{Type}TypeProvider`, and a component name `{Type}TypeProviderComponent`, where `{Type}` is the name of the associated type in the trait. So the above example can be shortened to:
 
 ```rust
 # extern crate cgp;
-# extern crate anyhow;
 #
-# use cgp::prelude::*;
-# use anyhow::Error;
-#
-#[cgp_component(AppImpl)]
-pub trait AppTrait {
+use cgp::prelude::*;
+
+#[cgp_type]
+pub trait HasTimeType {
     type Time: Eq + Ord;
+}
 
+#[cgp_type]
+pub trait HasAuthTokenType {
     type AuthToken;
-
-    fn validate_auth_token(&self, auth_token: &Self::AuthToken) -> Result<(), Error>;
-
-    fn fetch_auth_token_expiry(&self, auth_token: &Self::AuthToken) -> Result<Self::Time, Error>;
-
-    fn current_time(&self) -> Result<Self::Time, Error>;
 }
 ```
 
-While this approach might seem simpler, it introduces unnecessary _coupling_ between
-potentially unrelated types and methods. For example, an application implementing
-token validation might delegate this functionality to an external microservice.
-In such a case, it is redundant to require the application to specify a Time type that
-it doesn’t actually use.
-
-In practice, we find the practical benefits of defining many _minimal_ traits often
-outweight any theoretical advantages of combining multiple items into one trait.
-As we will demonstrate in later chapters, having traits that contain only one type
-or method would also enable more advanced CGP patterns to be applied, including
-the use of `cgp_type!` that we have just covered.
-
-We encourage readers to embrace minimal traits without concern for theoretical overhead. However, during the early phases of a project, you might prefer to consolidate items to reduce cognitive overload while learning or prototyping. As the project matures, you can always refactor and decompose larger traits into smaller, more focused ones, following the techniques outlined in this book.
+We will explore in a moment how using `#[cgp_type]` with a single associated type bring more convenience, as compared to alternative approaches.
 
 ## Impl-Side Associated Type Constraints
 
-The minimalism philosophy of CGP extends to the constraints placed on associated types within type traits. Consider the earlier definition of `HasTimeType`:
+The dependency-injection capabilities of CGP opens up new choices of how to design the abstract type interfaces. Consider the earlier definition of `HasTimeType`:
 
 ```rust
 # extern crate cgp;
@@ -369,7 +351,7 @@ pub trait HasTimeType {
 # pub trait HasCurrentTime: HasTimeType {
 #     fn current_time(&self) -> Result<Self::Time, Error>;
 # }
-#
+
 #[cgp_new_provider]
 impl<Context> AuthTokenValidator<Context> for ValidateTokenIsNotExpired
 where
@@ -399,7 +381,7 @@ By applying constraints on the implementation side, we can conditionally require
 
 In some cases, it can still be convenient to include constraints (e.g., `Debug`) directly on an associated type, especially if those constraints are nearly universal across providers. Additionally, current Rust error reporting often produces clearer error messages when constraints are defined at the associated type level, as opposed to being deferred to the implementation.
 
-As a guideline, we recommend that readers begin by defining type traits without placing constraints on associated types, relying instead on implementation-side constraints wherever possible. However, readers may choose to apply global constraints to associated types when appropriate, particularly for simple and widely applicable traits like `Debug` and `Eq`.
+Ultimately, CGP does not prevent its users from preferring one design approach over another. The minimalistic abstract type design is one that you will likely see often in CGP code, particularly in this book. However, do not hesitate to include addititional trait bounds based on your requirements and preferences!
 
 ## Type Providers
 
@@ -507,11 +489,11 @@ impl<Context> AuthTokenTypeProvider<Context> for UseStringAuthToken {
 }
 ```
 
-Compared to the newtype pattern, we can use plain `String` values directly, without wrapping them in a newtype struct. Contrary to common wisdom, in CGP, we place less emphasis on wrapping every domain type in a newtype. This is particularly true when most of the application is written in a context-generic style. The rationale is that abstract types and their accompanying interfaces already fulfill the role of newtypes by encapsulating and "protecting" raw values, reducing the need for additional wrapping.
+## Comparison to Newtype Pattern
 
-That said, readers are free to define newtypes and use them alongside abstract types. For beginners, this can be especially useful, as later chapters will explore methods to properly restrict access to underlying concrete types in context-generic code. Additionally, newtypes remain valuable when the raw values are also used in non-context-generic code, where access to the concrete types is unrestricted.
+Abstract types serve as an alternative to the newtype pattern. Compared to the newtype pattern, we can use plain `String` values directly, without wrapping them in a newtype struct. Contrary to common wisdom, in CGP, we place less emphasis on wrapping every domain type in a newtype. This is particularly true when most of the application is written in a context-generic style. The rationale is that abstract types and their accompanying interfaces already fulfill the role of newtypes by encapsulating and "protecting" raw values, reducing the need for additional wrapping.
 
-Throughout this book, we will primarily use plain types to implement abstract types, without additional newtype wrapping. However, we will revisit the comparison between newtypes and abstract types in later chapters, providing further guidance on when each approach is most appropriate.
+Ultimately, there is no right or wrong whether one should use abstract types, new types, or both together. It is up to your own preference, experience, and requirements, to decide which approach is best suited for you. Just take note that abstract types will be a commonly used pattern in CGP, particularly in this book.
 
 ## The `UseType` Pattern
 

From 9283386998f037f4f5d33faea1b8df0880fffaf9 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Fri, 9 May 2025 12:52:05 +0000
Subject: [PATCH 15/19] Revise field-accessors

---
 content/associated-types.md | 22 +++++++++++++++++++--
 content/field-accessors.md  | 39 +++++--------------------------------
 2 files changed, 25 insertions(+), 36 deletions(-)

diff --git a/content/associated-types.md b/content/associated-types.md
index 545e1a8..cdf53f5 100644
--- a/content/associated-types.md
+++ b/content/associated-types.md
@@ -491,9 +491,27 @@ impl<Context> AuthTokenTypeProvider<Context> for UseStringAuthToken {
 
 ## Comparison to Newtype Pattern
 
-Abstract types serve as an alternative to the newtype pattern. Compared to the newtype pattern, we can use plain `String` values directly, without wrapping them in a newtype struct. Contrary to common wisdom, in CGP, we place less emphasis on wrapping every domain type in a newtype. This is particularly true when most of the application is written in a context-generic style. The rationale is that abstract types and their accompanying interfaces already fulfill the role of newtypes by encapsulating and "protecting" raw values, reducing the need for additional wrapping.
+Let's talk about abstract types and how they compare to the well-known newtype pattern in Rust. Abstract types provide a compelling alternative.
 
-Ultimately, there is no right or wrong whether one should use abstract types, new types, or both together. It is up to your own preference, experience, and requirements, to decide which approach is best suited for you. Just take note that abstract types will be a commonly used pattern in CGP, particularly in this book.
+A key difference is that abstract types often allow you to work directly with plain, convenient types like `String`, whereas the newtype pattern typically requires wrapping your value within a dedicated struct.
+
+Within the CGP philosophy, we lean towards a different approach than the common advice to strictly newtype *every* domain concept. This is particularly true when you're writing highly context-generic code.
+
+The reason is simple: abstract types, defined by traits that specify their required behavior and structure, effectively provide the same level of encapsulation and type safety that newtypes offer. They protect the underlying raw values through their defined interfaces, often making the extra layer of newtype wrapping unnecessary boilerplate.
+
+The choice between abstract types, newtypes, or using both together isn't about a rigid "right" or "wrong." It's a flexible decision based on your specific project requirements, team conventions, and personal preference – choosing the best tool for the job at hand.
+
+Just keep in mind that abstract types are a core and widely used pattern in the CGP ecosystem, and you'll see them frequently demonstrated throughout this book.
+
+## Comparison to Newtype Pattern
+
+Abstract types serve as an alternative to the newtype pattern. Compared to the newtype pattern, we can use plain `String` values directly, without wrapping them in a newtype struct.
+
+Contrary to common wisdom, in CGP, we place less emphasis on wrapping every domain type in a newtype. This is particularly true when most of the application is written in a context-generic style. The reason is simple: abstract types, when used within generic code, effectively provide the same level of encapsulation and type safety that newtypes offer. They protect the underlying raw values through their defined interfaces, often making the extra layer of newtype wrapping unnecessary boilerplate.
+
+The choice between abstract types, newtypes, or using both together isn't about a rigid "right" or "wrong." It's a flexible decision based on your specific project requirements, team conventions, and personal preference – choosing the best tool for the job at hand.
+
+Just keep in mind that abstract types are a core and widely used pattern in the CGP ecosystem, and you'll see them frequently demonstrated throughout this book.
 
 ## The `UseType` Pattern
 
diff --git a/content/field-accessors.md b/content/field-accessors.md
index d7c6779..f68bce8 100644
--- a/content/field-accessors.md
+++ b/content/field-accessors.md
@@ -312,9 +312,9 @@ where
 
 In this updated code, we use the [`bearer_auth`](https://docs.rs/reqwest/latest/reqwest/blocking/struct.RequestBuilder.html#method.bearer_auth) method from the `reqwest` library to include the authentication token in the HTTP header. In this case, the provider only requires that `Context::AuthToken` implement the `Display` trait, allowing it to work with custom `AuthToken` types, not limited to `String`.
 
-## Accessor Method Minimalism
+## Traits with Multiple Getter Methods
 
-When creating providers like `ReadMessageFromApi`, which often need to use both `HasApiBaseUrl` and `HasAuthToken`, it might seem tempting to combine these two traits into a single one, containing both accessor methods:
+When creating providers like `ReadMessageFromApi`, which often need to use both `HasApiBaseUrl` and `HasAuthToken`, an alternative design would be to combine these two traits into a single one, containing both accessor methods:
 
 ```rust
 # extern crate cgp;
@@ -334,41 +334,12 @@ pub trait HasApiClientFields: HasAuthTokenType {
 }
 ```
 
-While this approach works, it introduces unnecessary coupling between the `api_base_url` and `auth_token` fields. If a provider only requires `api_base_url` but not `auth_token`, it would still need to include the unnecessary `auth_token` dependency. Additionally, this design prevents us from implementing separate providers that could provide the `api_base_url` and `auth_token` fields independently, each with its own logic.
-
-This coupling also makes future changes more challenging. For example, if we switch to a different authentication method, like public key cryptography, we would need to remove the auth_token method and replace it with a new one. This change would affect all code dependent on `HasApiClientFields`. Instead, it's much easier to add a new getter trait and gradually transition providers to the new trait while keeping the old one intact.
-
-As applications grow in complexity, it’s common to need many accessor methods. A trait like `HasApiClientFields`, with dozens of methods, could quickly become a bottleneck, making the application harder to evolve. Moreover, it's often unclear upfront which accessor methods are related, and trying to theorize about logical groupings can be a distraction.
-
-From real-world experience using CGP, we’ve found that defining one accessor method per trait is the most effective approach for rapidly iterating on application development. This method simplifies the process of adding or removing accessor methods and reduces cognitive overload, as developers don’t need to spend time deciding or debating which method should belong to which trait. Over time, it's almost inevitable that a multi-method accessor trait will need to be broken up as some methods become irrelevant to parts of the application.
-
-In future chapters, we’ll explore how breaking accessor methods down into individual traits can enable new design patterns that work well with single-method traits.
-
-However, CGP doesn’t prevent developers from creating accessor traits with multiple methods and types. For those new to CGP, it might feel more comfortable to define non-minimal traits, as this has been a mainstream practice in programming for decades. So, feel free to experiment and include as many types and methods in a CGP trait as you prefer.
 
-As an alternative to defining multiple accessor methods, you could define an inner struct containing all the common fields you’ll use across most providers:
-
-```rust
-# extern crate cgp;
-#
-# use cgp::prelude::*;
-#
-pub struct ApiClientFields {
-    pub api_base_url: String,
-    pub auth_token: String,
-}
-
-#[cgp_component(ApiClientFieldsGetter)]
-pub trait HasApiClientFields {
-    fn api_client_fields(&self) -> &ApiClientFields;
-}
-```
-
-In this example, we define an `ApiClientFields` struct that groups both the `api_base_url` and `auth_token` fields. The `HasApiClientFields` trait now only needs one getter method, returning the `ApiClientFields` struct.
+While this approach works, it introduces unnecessary coupling between the `api_base_url` and `auth_token` fields. If a provider only requires `api_base_url` but not `auth_token`, it would still need to include the unnecessary `auth_token` dependency. Additionally, this design prevents us from implementing separate providers that could provide the `api_base_url` and `auth_token` fields independently, each with its own logic.
 
-One downside to this approach is that we can no longer use abstract types within the struct. For instance, the `ApiClientFields` struct stores the `auth_token` as a concrete `String` rather than as an abstract `AuthToken` type. As a result, this approach works best when your providers don’t rely on abstract types for their fields.
+Furthermore, traits that contain only one method can benefit from the [`UseField`](./use-field-pattern.md) pattern that will be introduced later, which helps to simplify the boilerplate required to implement accessor traits, as well as allowing reusable accessor providers to be defined.
 
-For the purposes of this book, we will continue to use minimal traits, as this encourages best practices and provides readers with a clear reference for idiomatic CGP usage.
+Ultimately, CGP does not prevent you from defining multiple accessor methods into one trait, or even mix the trait with other items such as associated types or non-getter methods. It is your own decision of how to design CGP traits. Just keep in mind that it is common in CGP to see accessor traits that each contain only one getter method.
 
 ## Implementing Accessor Providers
 

From 726e01d60730597600bd19344c50c01880876059 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Fri, 9 May 2025 13:04:42 +0000
Subject: [PATCH 16/19] AI-revise section

---
 content/field-accessors.md | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/content/field-accessors.md b/content/field-accessors.md
index f68bce8..a5649a5 100644
--- a/content/field-accessors.md
+++ b/content/field-accessors.md
@@ -314,7 +314,9 @@ In this updated code, we use the [`bearer_auth`](https://docs.rs/reqwest/latest/
 
 ## Traits with Multiple Getter Methods
 
-When creating providers like `ReadMessageFromApi`, which often need to use both `HasApiBaseUrl` and `HasAuthToken`, an alternative design would be to combine these two traits into a single one, containing both accessor methods:
+As you build providers that need access to various pieces of data – like a `ReadMessageFromApi` provider that requires both an `api_base_url` and an `auth_token` – you might initially consider grouping these accessors into a single trait.
+
+Here's an example of how you *could* define a trait with multiple getter methods for API client fields:
 
 ```rust
 # extern crate cgp;
@@ -335,11 +337,15 @@ pub trait HasApiClientFields: HasAuthTokenType {
 ```
 
 
-While this approach works, it introduces unnecessary coupling between the `api_base_url` and `auth_token` fields. If a provider only requires `api_base_url` but not `auth_token`, it would still need to include the unnecessary `auth_token` dependency. Additionally, this design prevents us from implementing separate providers that could provide the `api_base_url` and `auth_token` fields independently, each with its own logic.
+While this approach is syntactically valid, it introduces unnecessary coupling. If a provider only needs the `api_base_url`, it still inherits a dependency on the `auth_token`. This could potentially impact modularity and reusability.
+
+Furthermore, this design prevents you from defining separate, independent providers for `api_base_url` and `auth_token`, each potentially with its own distinct logic for obtaining that data.
+
+Traits containing only one method also unlock powerful patterns like the [`UseField`](./use-field-pattern.md) pattern (which we'll introduce later). This pattern significantly simplifies the boilerplate required to implement accessor traits and enables the creation of reusable accessor providers.
 
-Furthermore, traits that contain only one method can benefit from the [`UseField`](./use-field-pattern.md) pattern that will be introduced later, which helps to simplify the boilerplate required to implement accessor traits, as well as allowing reusable accessor providers to be defined.
+Ultimately, CGP provides the flexibility to design your traits in a way that suits your needs. You are not strictly prevented from defining multiple accessor methods within a single trait, or even mixing getters with associated types or other methods.
 
-Ultimately, CGP does not prevent you from defining multiple accessor methods into one trait, or even mix the trait with other items such as associated types or non-getter methods. It is your own decision of how to design CGP traits. Just keep in mind that it is common in CGP to see accessor traits that each contain only one getter method.
+However, you may find that defining accessor traits that each contain only one getter method is a frequently used pattern, often chosen for its potential benefits in modularity, reusability, and compatibility with helper patterns like UseField. You'll see this pattern frequently demonstrated throughout this book.
 
 ## Implementing Accessor Providers
 

From 8544c38c00720be1c35d9407116630f15232a37f Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Fri, 9 May 2025 13:15:52 +0000
Subject: [PATCH 17/19] Revise introduction

---
 content/introduction.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/content/introduction.md b/content/introduction.md
index d5cbc5f..55cde39 100644
--- a/content/introduction.md
+++ b/content/introduction.md
@@ -45,17 +45,17 @@ useful design patterns that can be used in any programming situation.
 This book is currently a work in progress. A majority of the chapter is yet to be written.
 Please come back later to check out a completed version of this book.
 
-## Scope of This Book
+## Whom is This Book For
 
-This book is written in the style of a reference material for readers with all levels of expertise.
-As a result, it may not be as easy to understand for beginners who need a little more introduction
-to more basic programming techniques in Rust.
+This book tries to explain how CGP works by building the majority of its constructs from the ground up. However, many of the explained concepts are not immediately useful for writing CGP code, in particularly at the beginner level. This is because CGP already provides high enough abstraction, that one can write highly productive CGP code without understanding all the underlying details.
 
-A separate book will be written in the future, to provide beginner-friendly tutorials for learning context-generic programming.
+<div class="warning">
+Because of the above reasons, _you may not benefit much from reading this book_ if your goal is to get started with writing CGP as soon as possible.
+</div>
 
-For brievity, this book also does not cover motivation or concrete examples of _why_ you should
-learn and use context-generic programming. We will cover that in blog posts, and a separate book
-that covers real world use of CGP.
+On the other hand, the book is mainly useful for those who wish to understand better what happens behind the macros, after they have started using CGP for some time. This book would also be useful for users to understand better on what went wrong when encountering CGP-related error messages, so that they can fix the errors more effectively.
+
+A separate book will be written in the future, to provide beginner-friendly tutorials for getting started with CGP more quickly.
 
 ## Chapter Outlines
 
@@ -81,4 +81,4 @@ Anyone is welcome to contribute by submitting [pull requests](https://github.com
 for grammatical correction, content improvement, or adding new design patterns.
 
 A [GitHub Discussions](https://github.com/contextgeneric/cgp-patterns/discussions) forum is available for readers
-to ask questions or have discussions for topics covered in this book.
\ No newline at end of file
+to ask questions or have discussions for topics covered in this book.

From 8be1730fbe4df176d184eecba097a34ed7f1c4e2 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Fri, 9 May 2025 13:19:12 +0000
Subject: [PATCH 18/19] AI-revise section

---
 content/introduction.md | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/content/introduction.md b/content/introduction.md
index 55cde39..43e9af8 100644
--- a/content/introduction.md
+++ b/content/introduction.md
@@ -45,17 +45,22 @@ useful design patterns that can be used in any programming situation.
 This book is currently a work in progress. A majority of the chapter is yet to be written.
 Please come back later to check out a completed version of this book.
 
-## Whom is This Book For
+## Who This Book Is For
 
-This book tries to explain how CGP works by building the majority of its constructs from the ground up. However, many of the explained concepts are not immediately useful for writing CGP code, in particularly at the beginner level. This is because CGP already provides high enough abstraction, that one can write highly productive CGP code without understanding all the underlying details.
+This book takes a deep dive into how CGP works, building and explaining its core constructs from the ground up.
+
+However, it's worth noting that many of the concepts explained here are not immediately essential for simply writing working CGP code, particularly when you are just starting out. This is because CGP provides a high level of abstraction, allowing developers to write highly productive code without needing to understand all the underlying details.
 
 <div class="warning">
-Because of the above reasons, _you may not benefit much from reading this book_ if your goal is to get started with writing CGP as soon as possible.
+If your primary goal is to start writing CGP code and become productive as quickly as possible, this book might not be the most direct path.
 </div>
 
-On the other hand, the book is mainly useful for those who wish to understand better what happens behind the macros, after they have started using CGP for some time. This book would also be useful for users to understand better on what went wrong when encountering CGP-related error messages, so that they can fix the errors more effectively.
+On the other hand, this book is primarily intended for those who wish to gain a better understanding of what happens "behind the macros" after they have gained some experience using CGP.
+
+It will also be a valuable resource for users encountering CGP-related error messages, providing the knowledge needed to understand the root cause and fix issues more effectively.
 
-A separate book will be written in the future, to provide beginner-friendly tutorials for getting started with CGP more quickly.
+For beginners looking for a faster start, a separate book is planned for the future, which will provide more beginner-friendly tutorials focused on quickly getting started with CGP.
+book will be written in the future, to provide beginner-friendly tutorials for getting started with CGP more quickly.
 
 ## Chapter Outlines
 

From 6d886e67ae43b7a9f39b04229201b29b126ba999 Mon Sep 17 00:00:00 2001
From: Soares Chen <soares.chen@maybevoid.com>
Date: Fri, 9 May 2025 14:11:03 +0000
Subject: [PATCH 19/19] Update to published version of `cgp`

---
 Cargo.lock                  | 51 ++++++++++++++++++++++++-------------
 Cargo.toml                  | 34 ++++++++++++-------------
 content/associated-types.md |  2 +-
 3 files changed, 52 insertions(+), 35 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2e66b17..2f0b45c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -101,7 +101,8 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "cgp"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3d555a86484a22b3233de8248b980a482d8f92190e4823061a5d41250b74537"
 dependencies = [
  "cgp-async",
  "cgp-core",
@@ -111,7 +112,8 @@ dependencies = [
 [[package]]
 name = "cgp-async"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb185d91812fb0cf811ef592279010c817462c0c722562b09e987bef800e432"
 dependencies = [
  "cgp-async-macro",
  "cgp-sync",
@@ -120,7 +122,8 @@ dependencies = [
 [[package]]
 name = "cgp-async-macro"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0620dfb16be4b6087562ba9b38f67a67ab7a848cde2eb32241f3f606afe3560a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -130,12 +133,14 @@ dependencies = [
 [[package]]
 name = "cgp-component"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "674d048a0c12498626259d710899dad116d47a90498259209c9f7d412ce254b4"
 
 [[package]]
 name = "cgp-core"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cf2a22653dca218ae625f611223a5e0b27f54285f6d075fc7d7a96a942dfd64"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -148,7 +153,8 @@ dependencies = [
 [[package]]
 name = "cgp-error"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e754473b5da401e55bede80efda8b6da07b78acac87c284a492a350156d6e6a1"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -159,7 +165,8 @@ dependencies = [
 [[package]]
 name = "cgp-error-anyhow"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9dd2600d79e7607f6bae56057a44884e2ee672ab87aee14d4a8bbdda96fd58e"
 dependencies = [
  "anyhow",
  "cgp-core",
@@ -168,7 +175,8 @@ dependencies = [
 [[package]]
 name = "cgp-error-extra"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d19650e17295e4a1aec5b2d3bd35cee8a98f1dc138715d46fbfe50eeaeab5ff4"
 dependencies = [
  "cgp-core",
 ]
@@ -176,7 +184,8 @@ dependencies = [
 [[package]]
 name = "cgp-extra"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21fa7c3e40fdb7d1b21331e33b38262504449146e23b370f1533c80ea3ecaf52"
 dependencies = [
  "cgp-error-extra",
  "cgp-inner",
@@ -187,7 +196,8 @@ dependencies = [
 [[package]]
 name = "cgp-field"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f585da1ae8aa7182cce2474329a324df18b75bea738113295ba8048af8bee9f"
 dependencies = [
  "cgp-component",
  "cgp-macro",
@@ -197,7 +207,8 @@ dependencies = [
 [[package]]
 name = "cgp-inner"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8e9ad8fc246dd919e514a889704aea9a82093f42e7877eed03a2afe964c884b"
 dependencies = [
  "cgp-component",
  "cgp-macro",
@@ -206,7 +217,8 @@ dependencies = [
 [[package]]
 name = "cgp-macro"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4df8aef8d3b32725b6b088bb41b6f96a212f945b9993f78760b79ba038e0194"
 dependencies = [
  "cgp-macro-lib",
  "syn",
@@ -215,7 +227,8 @@ dependencies = [
 [[package]]
 name = "cgp-macro-lib"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bc6d7d6235b0673071150bd45b01818ca8402e0b005936d3d8f14170a0a71e5"
 dependencies = [
  "itertools",
  "prettyplease",
@@ -242,7 +255,8 @@ dependencies = [
 [[package]]
 name = "cgp-run"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "309ebfa7a9d0190f82c75b59c59d651c158473f9613289bb26950fbca39278ab"
 dependencies = [
  "cgp-async",
  "cgp-component",
@@ -253,7 +267,8 @@ dependencies = [
 [[package]]
 name = "cgp-runtime"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76183a413398fab9230fd6f7ebf17411bf4e20e787c5b01ca3cb02309ec6873b"
 dependencies = [
  "cgp-core",
 ]
@@ -261,7 +276,8 @@ dependencies = [
 [[package]]
 name = "cgp-sync"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15a52ca0d8647252e4a07a72a63364ee56353deeaa98926b2f5e7d65ab3c385c"
 dependencies = [
  "cgp-async-macro",
 ]
@@ -269,7 +285,8 @@ dependencies = [
 [[package]]
 name = "cgp-type"
 version = "0.4.0"
-source = "git+https://github.com/contextgeneric/cgp.git#01141984062760d14e3033396c3bec3b61f70d29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aabb2927728ed5b4b4e76ba3e054d9d772af64dd0140d4748aa766f7dbad914"
 dependencies = [
  "cgp-component",
  "cgp-macro",
diff --git a/Cargo.toml b/Cargo.toml
index 2f37435..1069dd3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,20 +15,20 @@ datetime            = { version = "0.5.2" }
 sha1                = { version = "0.10.6" }
 
 [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" }
+# 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" }
diff --git a/content/associated-types.md b/content/associated-types.md
index cdf53f5..7cffbb1 100644
--- a/content/associated-types.md
+++ b/content/associated-types.md
@@ -272,7 +272,7 @@ pub trait HasTimeType {
 }
 
 #[cgp_type {
-    provider: TimeTypeProvider,
+    provider: AuthTokenTypeProvider,
 }]
 pub trait HasAuthTokenType {
     type AuthToken;