The Rust Programming Language

A comprehensive guide to the Rust programming language, from ownership, data structures, and error handling through concurrency, smart pointers, and building real programs such as command-line tools and a multithreaded web server. Aimed at developers who want memory safety without giving up performance.

This page is free — overview and chapter list only.
The complete book body is sold separately.

Full book: $0.99 USDC via x402 ·
Per chapter: $0.10 USDC

Buy / open complete book (HTML)
· Complete book Markdown (.md)

Agents: start with free /library/discovery.json, sample free teaser chapters,
then pay for individual chapters or the complete book URL above.
Append .md to any content URL for Markdown with YAML front matter.

Chapters

  1. Who Rust Is For (Free teaser)
  2. How To Use This Book ($0.10)
  3. Hello World ($0.10)
  4. Hello Cargo ($0.10)
  5. Summary ($0.10)
  6. Using A Crate To Get More Functionality ($0.10)
  7. Generating A Random Number ($0.10)
  8. Handling Invalid Input ($0.10)
  9. Compound Types ($0.10)
  10. If Expressions ($0.10)
  11. What Is Ownership ($0.10)
  12. The String Type ($0.10)
  13. References And Borrowing ($0.10)
  14. The Slice Type ($0.10)
  15. Defining And Instantiating Structs ($0.10)
  16. An Example Program Using Structs ($0.10)
  17. Method Syntax ($0.10)
  18. Defining An Enum ($0.10)
  19. The Match Control Flow Operator ($0.10)
  20. Mod And The Filesystem ($0.10)
  21. Controlling Visibility With Pub ($0.10)
  22. Referring To Names In Different Modules ($0.10)
  23. Storing Lists Of Values With Vectors ($0.10)
  24. Using An Enum To Store Multiple Types ($0.10)
  25. Appending To A String With Pushstr And Push ($0.10)
  26. Updating A Hash Map ($0.10)
  27. Unrecoverable Errors With Panic ($0.10)
  28. Recoverable Errors With Result ($0.10)
  29. To Panic Or Not To Panic ($0.10)
  30. In Struct Definitions ($0.10)
  31. Performance Of Code Using Generics ($0.10)
  32. Default Implementations ($0.10)
  33. Using Trait Bounds To Conditionally Implement Methods ($0.10)
  34. Lifetime Annotations In Function Signatures ($0.10)
  35. Lifetime Elision ($0.10)
  36. How To Write Tests ($0.10)
  37. Running A Subset Of Tests By Name ($0.10)
  38. Integration Tests ($0.10)
  39. Saving The Argument Values In Variables ($0.10)
  40. Fixing The Error Handling ($0.10)
  41. Extracting Logic From Main ($0.10)
  42. Writing A Failing Test For The Case Insensitive Search Funct ($0.10)
  43. Creating An Abstraction Of Behavior With Closures ($0.10)
  44. Storing Closures Using Generic Parameters And The Fn Traits ($0.10)
  45. Capturing The Environment With Closures ($0.10)
  46. Creating Our Own Iterators With The Iterator Trait ($0.10)
  47. Making Code Clearer With Iterator Adaptors ($0.10)
  48. Exporting A Convenient Public Api With Pub Use ($0.10)
  49. Adding Metadata To A New Crate ($0.10)
  50. Cargo Workspaces ($0.10)
  51. Using Box To Point To Data On The Heap ($0.10)
  52. Treating Smart Pointers Like Regular References With The Der ($0.10)
  53. Running Code On Cleanup With The Drop Trait ($0.10)
  54. Rc The Reference Counted Smart Pointer ($0.10)
  55. Refcell And The Interior Mutability Pattern ($0.10)
  56. Preventing Reference Cycles Turning An Rc Into A Weak ($0.10)
  57. Using Move Closures With Threads ($0.10)
  58. Channels And Ownership Transference ($0.10)
  59. Using Mutexes To Allow Access To Data From One Thread At A T ($0.10)
  60. Implementing Send And Sync Manually Is Unsafe ($0.10)
  61. Inheritance As A Type System And As Code Sharing ($0.10)
  62. Implementing The Trait ($0.10)
  63. Object Safety Is Required For Trait Objects ($0.10)
  64. Trade Offs Of The State Pattern ($0.10)
  65. All The Places Patterns Can Be Used ($0.10)
  66. Pattern Syntax ($0.10)
  67. Unsafe Rust ($0.10)
  68. Advanced Lifetimes ($0.10)
  69. Advanced Traits ($0.10)
  70. Advanced Types ($0.10)
  71. Advanced Functions And Closures ($0.10)
  72. Building A Single Threaded Web Server ($0.10)
  73. Writing A Response ($0.10)
  74. Building The Threadpool Struct Using Compiler Driven Develop ($0.10)
  75. Implementing The Execute Method ($0.10)
  76. Signaling To The Threads To Stop Listening For Jobs ($0.10)
  77. Oper At Ors And Symbol S ($0.10)
  78. Clone And Copy For Duplicating Values ($0.10)
  79. Procedural Macros For Custom Derive ($0.10)
  80. The Future Of Macros ($0.10)