Update book chapters outline (#12)

Author: soareschen

content/SUMMARY.md

@@ -2,13 +2,13 @@
 
 - [Introduction](introduction.md)
 
-# Core Concepts
+# Terminology
 
 - [Context](context.md)
 - [Consumer](consumer.md)
 - [Provider](provider.md)
 
-# Basic Patterns
+# Core Concepts
 
 - [Blanket Implementations](blanket-implementations.md)
 - [Impl-side Dependencies](impl-side-dependencies.md)
@@ -20,35 +20,43 @@
 
 # Design Patterns
 
-- [Context-Generic Providers](context-generic-providers.md)
-- [Provider Middleware](provider-middleware.md)
-- [Associated Contexts](associated-contexts.md)
-    - [Impl-side Generic Types](impl-side-generic-types.md)
-    - [Associated Type Specialization](associated-type-specialization.md)
-- [Async Generic](async-generic.md)
-- [Fully Abstract Programs](fully-abstract-programs.md)
+- [Associated Types]()
+    - [Parameterized Associated Types]()
+    - [Impl-side Generic Types]()
+    - [Associated Type Specialization]()
+    - [`HasType`]()
+- [Error Handling]()
+    - [`HasErrorType`]()
+    - [From Errors]()
+    - [`CanRaiseError`]()
+- [Provider Composition]()
+    - [Provider Middleware]()
+- [Generalized Providers]()
+    - [`WithProvider`]()
+    - [`UseContext`]()
+    - [`UseType`]()
+    - [`UseDelegate`]()
+- [Field Accessors]()
+    - [`HasField`]()
+    - [`HasFieldMut`]()
+    - [Field Macros]()
+- [Context-Generic Dispatch]()
+    - [App-Specific Associated Types]()
+- [Async Generic]()
+- [Fully Abstract Programs]()
 
 # Domain-Specific Patterns
 
-- [Error Handling](error-handling.md)
-    - [Abstract Error Types](abstract-error-types.md)
-    - [From Errors](from-errors.md)
-    - [Error Raisers](error-raisers.md)
-    - [Error Detail Types](error-detail-types.md)
-    - [Error Handler Delegation](error-handler-delegation.md)
-
-- [Logging and Telemetry](logging-and-telemetry.md)
-    - [Abstract Logger](abstract-logger.md)
-    - [Logging Entry Types](logging-entry-types.md)
-    - [Logger Delegation](logger-delegation.md)
+- [Logging and Telemetry]()
+- [Encoding]()
 
 # Related Concepts
 
-- [Object-Oriented Programming](object-oriented-programming.md)
-- [Dependency Injection](dependency-injection.md)
-- [Dynamic-Typed Programming](dynamic-typed-programming.md)
-- [Functional Programming](functional-programming.md)
-    - [New Type Wrappers](new-type-wrappers.md)
-    - [Monad](monad.md)
-    - [Algebraic Effects](algebraic-effects.md)
-- [ML Modules](ml-modules.md)
+- [Object-Oriented Programming]()
+- [Dependency Injection]()
+- [Dynamic-Typed Programming]()
+- [Functional Programming]()
+    - [New Type Wrappers]()
+    - [Monad]()
+    - [Algebraic Effects]()
+- [ML Modules]()

content/associated-contexts.md

@@ -0,0 +1 @@
+# Associated Types

content/associated-types.md

@@ -2,8 +2,8 @@
 
 By leveraging [impl-side dependencies](./impl-side-dependencies.md), CGP providers
 are able to include additional dependencies that are not specified in the provider
-trait. We have already seen this in action in the [previous chapter](./provider-delegation.md),
-for example where the provider `FormatAsJsonString` is able to require `Context`
+trait. We have already seen this in action in the [previous chapter](./provider-delegation.md), for example,
+where the provider `FormatAsJsonString` is able to require `Context`
 to implement `Serialize`, while that is not specified anywhere in the provider
 trait `StringFormatter`.
 
@@ -22,8 +22,8 @@ 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
-`PersonContext` as the [previous chapter](./component-macros.md#example-use).
-Consider if we made a mistake and forgot to implement `Serialize` for `PersonContext`:
+`Person` context as the [previous chapter](./component-macros.md#example-use).
+Consider if we made a mistake and forgot to implement `Serialize` for `Person`:
 
 ```rust
 # extern crate anyhow;
@@ -88,9 +88,9 @@ delegate_components! {
 }
 ```
 
-We know that `PersonContext` uses `PersonComponents` to implement `CanFormatToString`,
+We know that `Person` uses `PersonComponents` to implement `CanFormatToString`,
 and `PersonComponents` delegates the provider implementation to `FormatAsJsonString`.
-However, since `FormatAsJsonString` requires `PersonContext` to implement `Serialize`,
+However, since `FormatAsJsonString` requires `Person` to implement `Serialize`,
 without it `CanFormatToString` cannot be implemented on `PersonContext`.
 
 However, notice that the above code still compiles successfully. This is because we

content/debugging-techniques.md

@@ -6,13 +6,13 @@ to be implemented and composed in a modular, generic, and type-safe way.
 
 ## What is Context-Generic Programming
 
-At its core, CGP makes use of Rust's trait system to build generic _interfaces_
-decouple code that _consumes_ an interface from code that _implements_ an
-interface. Through this decoupling, code can be written to be generic over
-any context, and then be wired to be used on a concrete context by writing
-few lines of code. CGP makes use of Rust's strong type system to help ensure
-that any such wiring is _type-safe_, catching any unsatisfied dependencies
-as compile-time errors.
+At its core, CGP makes use of Rust's trait system to build generic
+component _interfaces_ that decouple code that _consumes_ an interface
+from code that _implements_ an interface.
+Through this decoupling, code can be written to be generic over any context,
+and then be wired to be used on a concrete context by writing few lines of code.
+CGP makes use of Rust's strong type system to help ensure that any such
+wiring is _type-safe_, catching any unsatisfied dependencies as compile-time errors.
 
 CGP shares some similarities with other modular programming patterns, such as
 OCaml modules, Scala implicits, mixins, and dependency injection. Compared to
@@ -21,6 +21,19 @@ while also being type-safe and concise. With Rust as its host language, CGP
 also allows high-performance and low-level code to be written in a modular
 way, without requiring complex runtime support.
 
+CGP is designed to solve a wide range of common problems in programming,
+including error handling, logging, encoding, and modular dispatch.
+In particular, it allows writing static-typed Rust programs to be almost
+as expressive as writing dynamic-typed programs, but with the additional
+type safety guarantees.
+If you ever feel that Rust's type system is restricting your ability to reuse
+code, or be forced to duplicate code through copy-pasting or macros, then
+CGP may be of help to solve your problem.
+
+That said, programming in CGP is as expressive, but not as easy,
+as dynamic-typed programming. There may be a steep learning curve
+in learning how to program in a generic way, and this book aims to help
+make that learning process more approachable.
 Thoughout this book, we will slowly understand how CGP works, and learn about
 useful design patterns that can be used in any programming situation.
 
@@ -43,11 +56,11 @@ that covers real world use of CGP.
 
 ## Chapter Outlines
 
-The first section of this book, _Core Concepts_, will introduce core concepts of CGP.
+The first section of this book, _Terminology_, will introduce common terms to be used to understand CGP.
 We will learn about what is a context, and what are consumer and provider traits.
 
-In the next section, _Basic Patterns_, we will cover the basic design patterns that enable us to write
-context-generic code.
+In the next section, _Core Concepts_, we will cover the core concepts and the Rust-specific
+design patterns that we use to enable context-generic programming.
 
 Following that, _Design Patterns_ will introduce general design patterns that are built on top of the
 foundation of context-generic programming.