1. Introduction to Higher-Kinded-J
  2. Quickstart
  3. Cheat Sheet
  4. Where to Start
  5. Effect Path API
    ❱
    1. Quickstart
    2. Core Paths
      ❱
      1. Migration Cookbook
      2. Path Types Overview
      3. MaybePath
      4. EitherPath
      5. TryPath
      6. ValidationPath
      7. EitherOrBothPath
      8. IOPath
      9. VTaskPath
      10. VResultPath
      11. Composition Patterns
      12. ForPath Comprehension
        ❱
        1. ForPath Examples
    4. Optics Integration
      ❱
      1. Capstone: Effects Meet Optics
    6. Advanced Paths
      ❱
      1. IdPath
      2. OptionalPath
      3. GenericPath
      4. TrampolinePath
      5. FreePath
      6. FreeApPath
      7. VStreamPath
      8. ForPath Parallel Composition
      9. ForPath Traverse
      10. Advanced Effects
      11. Effect Contexts
        ❱
        1. ErrorContext
        2. Optional Contexts
        3. ConfigContext
        4. MutableContext
        5. RequestContext
        6. SecurityContext
        7. Context vs ConfigContext
      13. Effect Handlers
        ❱
        1. Effect Handler Reference
      15. Patterns and Recipes
      16. Resilience Patterns
        ❱
        1. Retry
        2. Circuit Breaker
        3. Bulkhead
        4. Saga
        5. Combined Patterns
    8. Reference
      ❱
      1. Type Conversions
      2. Common Compiler Errors
      3. Production Readiness
  7. Optics
    ❱
    1. Quickstart
    2. Annotations at a Glance
    3. Fundamentals
      ❱
      1. What Are Optics?
      2. Lenses
      3. Prisms
        ❱
        1. Prism Toolkit
        2. Validated Prisms
      5. Affines
      6. Isomorphisms
      7. Composition Rules
      8. Coupled Fields
    5. Collections
      ❱
      1. Traversals
      2. Folds
      3. Getters
      4. Setters
      5. Common Data Structures
      6. Limiting Traversals
      7. List Decomposition
    7. Precision and Filtering
      ❱
      1. Filtered Optics
      2. Indexed Optics
        ❱
        1. Indexed Optics: Advanced Patterns
      4. Each Typeclass
      5. String Traversals
      6. Indexed Access
      7. Advanced Prism Patterns
        ❱
        1. Advanced Prism Patterns: Recipes
      9. Profunctor Optics
        ❱
        1. Profunctor Optics: Recipes
    9. Java-Friendly APIs
      ❱
      1. Focus DSL
        ❱
        1. Navigation and Composition
        2. Type Class and Effect Integration
        3. Custom Containers and Code Generation
        4. Focus DSL Reference
      3. Optics for External Types
        ❱
        1. Taming JSON with Jackson
        2. Database Records with JOOQ
        3. Focus DSL with External Libraries
      5. Record Mapping
      6. Kind Field Support
      7. Fluent API
        ❱
        1. Fluent API Field Guide
    11. Integration and Recipes
      ❱
      1. Composing Optics
      2. Core Type Integration
      3. Multi-Edit and Sparse Updates
      4. Optics Extensions
      5. Optic-Driven Batching
      6. Plan Introspection and Guardrails
      7. Cookbook
      8. Auditing Complex Data
    13. Advanced Optics
      ❱
      1. Free Monad DSL
      2. Interpreters
    15. Reference
      ❱
      1. Optic Capabilities
      2. Conversions
      3. Common Compiler Errors
      4. Production Readiness
      5. Decision Trees
  9. Monad Transformers & MTL
    ❱
    1. Path or Transformer?
    2. Quickstart
    3. Transformers at a Glance
    4. Migration Cookbook
    5. Stack Archetypes
    6. Monad Transformers
    7. EitherT
    8. OptionalT
    9. MaybeT
    10. ReaderT
    11. StateT
    12. WriterT
    13. MTL Capabilities
      ❱
      1. MonadReader
      2. MonadState
      3. MonadWriter
      4. Combining Capabilities
    15. Axes of Transformer Transformation
    16. Common Compiler Errors
    17. Capstone: A Multi-Capability Workflow
  11. Foundations
    ❱
    1. One Line, Six Layers
    2. Lifting the Hood
    3. Higher-Kinded Types
      ❱
      1. HKT Introduction
      2. Concepts
      3. Type Arity
      4. Usage Guide
      5. Basic HKT Examples
      6. Quick Reference
      7. Extending
      8. Foundations FAQ
    5. Type Classes
      ❱
      1. Functional Api
      2. Obtaining Instances
      3. Functor
      4. Applicative
      5. Alternative
      6. Monad
      7. MonadError
      8. Semigroup and Monoid
      9. Foldable and Traverse
      10. MonadZero
      11. Selective
      12. Profunctor
      13. Bifunctor
      14. Natural Transformation
      15. For Comprehension
        ❱
        1. Parallel Composition
        2. Traverse Within Comprehensions
        3. Optics Integration
        4. MTL & ForState Bridge
      17. ForState Comprehension
      18. Choosing Abstraction Levels
    7. Core Types
      ❱
      1. Supported Types
      2. CompletableFuture
      3. Either
      4. EitherOrBoth
      5. Identity
      6. IO
      7. Lazy
      8. List
      9. NonEmptyList
      10. Maybe
      11. Optional
      12. Reader
      13. Context
      14. State
      15. Stream
      16. Trampoline
      17. Free
      18. Free Applicative
      19. EitherF
      20. Coyoneda
      21. Try
      22. Validated
        ❱
        1. Accumulating Assembly
      24. VTask
        ❱
        1. Structured Concurrency
        2. Resource Management
      26. VStream
        ❱
        1. HKT and Type Classes
        2. Parallel Operations
        3. Performance
        4. Resource-Safe Streaming
        5. Advanced Features
      28. Writer
      29. Const
  13. Examples Gallery
    ❱
    1. Order Processing Workflow
      ❱
      1. Order Walkthrough
      2. Effect Composition
      3. Production Patterns
      4. Concurrency and Scale
    3. Draughts Game
      ❱
      1. Building the Game
    5. Market Data Pipeline
      ❱
      1. Building the Pipeline
      2. Alerts and Resilience
      3. Quick Reference
    7. Portfolio Risk Analysis
    8. Payment Processing
  15. Hands-On Learning
    ❱
    1. Interactive Tutorials
    2. Core Types
      ❱
      1. Foundations
        ❱
        1. Cheatsheet
      3. Error Handling
      4. Advanced
    4. Effect API
      ❱
      1. Cheatsheet
    6. Monad Transformers
    7. Concurrency
      ❱
      1. VTask
      2. Scope & Resource
    9. Context
    10. Effect Handlers
    11. Optics
      ❱
      1. Lens & Prism
      2. Traversals & Practice
      3. Fluent & Free DSL
      4. Focus DSL
    13. Expression
      ❱
      1. ForState
      2. ForPath Parallel
    15. Resilience Patterns
    16. Capstone: One Line, Six Layers Grows Up
    17. Learning Paths
    18. Solutions Guide
    19. Troubleshooting
  17. Tooling
    ❱
    1. Build Plugins
    2. Manual Gradle and Maven Setup
    3. Compile-Time Checks
    4. Migration Recipes
    5. Diagnostics
    6. Traversal Generator Plugins
    7. PCollections Integration
    8. PCollections Optics
    9. Claude Code Skills
    10. Testing With hkj-test
  19. Spring Integration
    ❱
    1. Spring Boot Integration
    2. Declarative HTTP Clients
    3. Migrating to Functional Errors
    4. EffectBoundary Integration
  21. Reference
    ❱
    1. More Functional Thinking
    2. Glossary
    3. Release History
    4. Benchmarks & Performance
  23. Project Info
    ❱
    1. Contributing
    2. Code of Conduct
    3. License