1. result<T, EC>
  2. Gentle introduction to writing code with simple success-or-failure return types.

    1. Inspecting result<T, EC>
    2. TRY operations
  3. outcome<T, EC, EP>
  4. Success-or-failure return types where failure can take two forms, expected/handled failure and unexpected/abort failure.

    1. Inspecting outcome<T, EC, EP>
  5. Custom payloads
  6. Success-or-failure return types where extra information in addition to the error code accompanies failure.

    1. The Filesystem TS
    2. Upgrading the Filesystem TS
    3. Auto-throwing filesystem_error
  7. Default actions
  8. The default rules for handling different categories of failure type

    1. User defined error types
    2. -- What happens?
    3. Error code enums
    4. -- What happens?
    5. -- Now what happens?
    6. error_code
    7. exception_ptr
    8. void
    9. unchecked<T, E> and checked<T, E>
  9. Result returning constructors
  10. How to metaprogram construction of objects which use result<T, EC> to return failure instead of throwing a C++ exception.

    1. Two phase construction
    2. A file handle
    3. Phase 2 construction
    4. Phase 3
    5. construct<T>
    6. Alternatives
  11. Hooking events
  12. Intercepting useful events such as initial construction, copies and moves so you can capture backtraces, fire debug breakpoints etc.

    1. Keeping state
    2. ADL bridging
    3. Hook result
    4. Custom exception ptr
    5. Hook outcome
  13. Policies
  14. Defining your own NoValuePolicy policies, plus an overview of the precanned policies which come in the Outcome source code.

    1. Anatomy of a policy
    2. Casting workaround
    3. Built-in policies
  15. Using result<T> from C code
  16. Interacting with result<T, EC> returning C++ functions from C code.

    1. Limitations
    2. Example C++ function
    3. Calling it from C
    4. Variations
  17. Interoperation
  18. Interoperating with std::expected<T, E> and other ValueOrError concept matching types.

    1. Incommensurate E types
    2. ValueOrError Concept
    3. The HTTP library
    4. The HTMLTidy library
    5. The File I/O library
    6. The Application
    7. Mapping the HTTP library into the Application 1/2
    8. Mapping the HTTP library into the Application 2/2
    9. Mapping the File I/O library into the Application
    10. Mapping the HTMLTidy library into the Application
    11. In use
    12. Conclusion
  19. Custom error codes
  20. Illustrates how you can hook into the std::error_code system from the Standard Library in order to work with your own set of error codes.