rust-book.json

[
	{
		"title": "The Rust Programming Language",
		"state": 2
	},
	{
		"title": "Foreword",
		"state": 2
	},
	{
		"title": "Introduction",
		"state": 2
	},
	{
		"title": "1. Getting Started",
		"state": 2
	},
	{
		"title": "1.1. Installation",
		"state": 2
	},
	{
		"title": "1.2. Hello, World!",
		"state": 2
	},
	{
		"title": "1.3. Hello, Cargo!",
		"state": 2
	},
	{
		"title": "2. Programming a Guessing Game",
		"state": 2
	},
	{
		"title": "3. Common Programming Concepts",
		"state": 2
	},
	{
		"title": "3.1. Variables and Mutability",
		"state": 2
	},
	{
		"title": "3.2. Data Types",
		"state": 2
	},
	{
		"title": "3.3. Functions",
		"state": 2
	},
	{
		"title": "3.4. Comments",
		"state": 2
	},
	{
		"title": "3.5. Control Flow",
		"state": 2
	},
	{
		"title": "4. Understanding Ownership",
		"state": 2
	},
	{
		"title": "4.1. What is Ownership?",
		"state": 2
	},
	{
		"title": "4.2. References and Borrowing",
		"state": 2
	},
	{
		"title": "4.3. The Slice Type",
		"state": 2
	},
	{
		"title": "5. Using Structs to Structure Related Data",
		"state": 2
	},
	{
		"title": "5.1. Defining and Instantiating Structs",
		"state": 2
	},
	{
		"title": "5.2. An Example Program Using Structs",
		"state": 2
	},
	{
		"title": "5.3. Method Syntax",
		"state": 2
	},
	{
		"title": "6. Enums and Pattern Matching",
		"state": 2
	},
	{
		"title": "6.1. Defining an Enum",
		"state": 2
	},
	{
		"title": "6.2. The match Control Flow Construct",
		"state": 2
	},
	{
		"title": "6.3. Concise Control Flow with if let",
		"state": 2
	},
	{
		"title": "7. Managing Growing Projects with Packages, Crates, and Modules",
		"state": 2
	},
	{
		"title": "7.1. Packages and Crates",
		"state": 2
	},
	{
		"title": "7.2. Defining Modules to Control Scope and Privacy",
		"state": 2
	},
	{
		"title": "7.3. Paths for Referring to an Item in the Module Tree",
		"state": 2
	},
	{
		"title": "7.4. Bringing Paths Into Scope with the use Keyword",
		"state": 2
	},
	{
		"title": "7.5. Separating Modules into Different Files",
		"state": 2
	},
	{
		"title": "8. Common Collections",
		"state": 2
	},
	{
		"title": "8.1. Storing Lists of Values with Vectors",
		"state": 2
	},
	{
		"title": "8.2. Storing UTF-8 Encoded Text with Strings",
		"state": 2
	},
	{
		"title": "8.3. Storing Keys with Associated Values in Hash Maps",
		"state": 2
	},
	{
		"title": "9. Error Handling",
		"state": 2
	},
	{
		"title": "9.1. Unrecoverable Errors with panic!",
		"state": 2
	},
	{
		"title": "9.2. Recoverable Errors with Result",
		"state": 1
	},
	{
		"title": "9.3. To panic! or Not to panic!",
		"state": 0
	},
	{
		"title": "10. Generic Types, Traits, and Lifetimes",
		"state": 0
	},
	{
		"title": "10.1. Generic Data Types",
		"state": 0
	},
	{
		"title": "10.2. Traits: Defining Shared Behavior",
		"state": 0
	},
	{
		"title": "10.3. Validating References with Lifetimes",
		"state": 0
	},
	{
		"title": "11. Writing Automated Tests",
		"state": 0
	},
	{
		"title": "11.1. How to Write Tests",
		"state": 0
	},
	{
		"title": "11.2. Controlling How Tests Are Run",
		"state": 0
	},
	{
		"title": "11.3. Test Organization",
		"state": 0
	},
	{
		"title": "12. An I/O Project: Building a Command Line Program",
		"state": 0
	},
	{
		"title": "12.1. Accepting Command Line Arguments",
		"state": 0
	},
	{
		"title": "12.2. Reading a File",
		"state": 0
	},
	{
		"title": "12.3. Refactoring to Improve Modularity and Error Handling",
		"state": 0
	},
	{
		"title": "12.4. Developing the Library\u00e2\u0080\u0099s Functionality with Test Driven Development",
		"state": 0
	},
	{
		"title": "12.5. Working with Environment Variables",
		"state": 0
	},
	{
		"title": "12.6. Writing Error Messages to Standard Error Instead of Standard Output",
		"state": 0
	},
	{
		"title": "13. Functional Language Features: Iterators and Closures",
		"state": 0
	},
	{
		"title": "13.1. Closures: Anonymous Functions that Capture Their Environment",
		"state": 0
	},
	{
		"title": "13.2. Processing a Series of Items with Iterators",
		"state": 0
	},
	{
		"title": "13.3. Improving Our I/O Project",
		"state": 0
	},
	{
		"title": "13.4. Comparing Performance: Loops vs. Iterators",
		"state": 0
	},
	{
		"title": "14. More about Cargo and Crates.io",
		"state": 0
	},
	{
		"title": "14.1. Customizing Builds with Release Profiles",
		"state": 0
	},
	{
		"title": "14.2. Publishing a Crate to Crates.io",
		"state": 0
	},
	{
		"title": "14.3. Cargo Workspaces",
		"state": 0
	},
	{
		"title": "14.4. Installing Binaries from Crates.io with cargo install",
		"state": 0
	},
	{
		"title": "14.5. Extending Cargo with Custom Commands",
		"state": 0
	},
	{
		"title": "15. Smart Pointers",
		"state": 0
	},
	{
		"title": "15.1. Using Box<T> to Point to Data on the Heap",
		"state": 0
	},
	{
		"title": "15.2. Treating Smart Pointers Like Regular References with the Deref Trait",
		"state": 0
	},
	{
		"title": "15.3. Running Code on Cleanup with the Drop Trait",
		"state": 0
	},
	{
		"title": "15.4. Rc<T>, the Reference Counted Smart Pointer",
		"state": 0
	},
	{
		"title": "15.5. RefCell<T> and the Interior Mutability Pattern",
		"state": 0
	},
	{
		"title": "15.6. Reference Cycles Can Leak Memory",
		"state": 0
	},
	{
		"title": "16. Fearless Concurrency",
		"state": 0
	},
	{
		"title": "16.1. Using Threads to Run Code Simultaneously",
		"state": 0
	},
	{
		"title": "16.2. Using Message Passing to Transfer Data Between Threads",
		"state": 0
	},
	{
		"title": "16.3. Shared-State Concurrency",
		"state": 0
	},
	{
		"title": "16.4. Extensible Concurrency with the Sync and Send Traits",
		"state": 0
	},
	{
		"title": "17. Object Oriented Programming Features of Rust",
		"state": 0
	},
	{
		"title": "17.1. Characteristics of Object-Oriented Languages",
		"state": 0
	},
	{
		"title": "17.2. Using Trait Objects That Allow for Values of Different Types",
		"state": 0
	},
	{
		"title": "17.3. Implementing an Object-Oriented Design Pattern",
		"state": 0
	},
	{
		"title": "18. Patterns and Matching",
		"state": 0
	},
	{
		"title": "18.1. All the Places Patterns Can Be Used",
		"state": 0
	},
	{
		"title": "18.2. Refutability: Whether a Pattern Might Fail to Match",
		"state": 0
	},
	{
		"title": "18.3. Pattern Syntax",
		"state": 0
	},
	{
		"title": "19. Advanced Features",
		"state": 0
	},
	{
		"title": "19.1. Unsafe Rust",
		"state": 0
	},
	{
		"title": "19.2. Advanced Traits",
		"state": 0
	},
	{
		"title": "19.3. Advanced Types",
		"state": 0
	},
	{
		"title": "19.4. Advanced Functions and Closures",
		"state": 0
	},
	{
		"title": "19.5. Macros",
		"state": 0
	},
	{
		"title": "20. Final Project: Building a Multithreaded Web Server",
		"state": 0
	},
	{
		"title": "20.1. Building a Single-Threaded Web Server",
		"state": 0
	},
	{
		"title": "20.2. Turning Our Single-Threaded Server into a Multithreaded Server",
		"state": 0
	},
	{
		"title": "20.3. Graceful Shutdown and Cleanup",
		"state": 0
	}
]