Programming Rust. Fast, Safe Systems Development. 3rd Edition Jim Blandy, Jason Orendorff, Leonora F. S. Tindall

Dostępność produktu

Produkt został zweryfikowany pod kątem ułatwień dostępu więcej przeczytasz w deklaracji dostępności.

Spis treści książki

• Preface
  • Who Should Read This Book
  • Why We Wrote This Book
  • Navigating This Book
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• 1. Systems Programmers Can Have Nice Things
  • Rust Shoulders the Load for You
  • Parallel Programming Is Tamed
  • And Yet Rust Is Still Fast
  • Rust Makes Collaboration Easier
• 2. A Tour of Rust
  • rustup and Cargo
  • Rust Functions
  • Writing and Running Unit Tests
  • Handling Command-Line Arguments
  • Serving Pages to the Web
  • Concurrency
    • What the Mandelbrot Set Actually Is
    • Parsing Pair Command-Line Arguments
    • Mapping from Pixels to Complex Numbers
    • Plotting the Set
    • Writing Image Files
    • A Concurrent Mandelbrot Program
    • Safety Is Invisible
• 3. Fundamental Types
  • Numeric Types
    • Integer Types
    • Handling Integer Overflow
    • Floating-Point Types
  • The bool Type
  • Tuples
  • Pointer Types
  • Arrays, Vectors, and Slices
    • Arrays
    • Vectors
    • Slices
  • String and Character Types
    • String and Character Literals
    • Characters and Strings in Memory
    • String
    • Using Strings
    • Other String-Like Types
  • Type Aliases
  • Beyond the Basics
• 4. Ownership and Moves
  • Ownership
  • Moves
    • More Operations That Move
    • Moves and Control Flow
    • Moves and Indexed Content
  • Copy Types: The Exception to Moves
  • Rc and Arc: Shared Ownership
• 5. References
  • Reference Basics
  • Working with References
    • Implicit and Explicit References
    • Assigning References
    • References to References
    • Comparing References
    • References Are Never Null
    • Borrowing References to Arbitrary Expressions
    • Fat Pointers
  • Reference Safety
    • Borrowing a Local Variable
    • Receiving References as Function Arguments
    • Passing References to Functions
    • Returning References
    • Structs Containing References
    • Distinct Lifetime Parameters
    • Omitting Lifetime Parameters
  • Sharing Versus Mutation
  • Taking Arms Against a Sea of Objects
• 6. Expressions
  • An Expression Language
  • Blocks
    • Declarations
    • if and match
    • if let
    • let else
    • Loops
    • break and continue Expressions
    • Labeled Blocks
    • return Expressions
    • Why Rust Has loop
  • const and unsafe Blocks
  • Operators
    • Function and Method Calls
    • Fields and Elements
    • Reference Operators
    • Arithmetic, Bitwise, Comparison, and Logical Operators
    • Assignment
    • Type Casts
    • Closures
  • Onward
• 7. Error Handling
  • Panic
    • Unwinding
    • Aborting
    • The Panic Hook
    • Other Panic Macros
  • Result
    • Catching Errors
    • Printing Errors
    • Propagating Errors
    • Result Methods
    • Result Type Aliases
    • Working with Multiple Error Types
    • A Universal Error Type: anyhow
    • Defining Custom Error Types
    • Dealing with Errors That Cant Happen
    • Ignoring Errors
    • Handling Errors in main()
    • Why Results?
• 8. Crates and Modules
  • Crates
    • Editions
    • Rust Versions
    • Build Profiles
  • Modules
    • Nested Modules
    • Modules in Separate Files
    • Paths and Imports
    • The Standard Prelude
    • Making use Declarations pub
    • Making Struct Fields pub
    • Constants and Statics
  • Turning a Program into a Library
  • The src/bin Directory
  • Attributes
  • Conditional Compilation
  • The Build Environment
  • Including Files
  • Tests and Documentation
    • Integration Tests
    • Documentation
    • Doc-Tests
  • Specifying Dependencies
    • Versions
    • Cargo.lock
  • Build Scripts
  • Publishing Crates to crates.io
  • Workspaces
  • More Nice Things
• 9. Structs
  • Defining Structs
  • Other Kinds of Structs
    • Tuple Structs
    • Unit-Like Structs
  • Struct Layout
  • Defining Methods with impl
    • Passing Self as a Box, Rc, or Arc
    • Nonmethod Associated Functions
  • Associated Constants
  • Generic Structs
  • Generic Structs with Lifetime Parameters
  • Generic Structs with Constant Parameters
  • Deriving Common Traits for Struct Types
  • Interior Mutability
• 10. Enums and Patterns
  • Enums
    • Enums with Data
    • Enums in Memory
    • Rich Data Structures Using Enums
    • Generic Enums
  • Patterns
    • Literals, Variables, and Wildcards in Patterns
    • Tuple and Struct Patterns
    • Matching References
    • Reference Patterns
    • Array and Slice Patterns
    • Match Guards
    • Matching Multiple Possibilities
    • Binding with @ Patterns
    • Where Patterns Are Allowed
    • Populating a Binary Tree
  • Public Enums and Compatibility
  • The Big Picture
• 11. Traits and Generics
  • Using Traits
    • Using dyn
      • dyn reference layout
    • Generic Functions and Type Parameters
    • Which to Use
  • Defining and Implementing Traits
    • Default Methods
    • Traits and Other Peoples Types
    • Self in Traits
    • Subtraits
    • Associated Functions
    • Associated Constants
  • Fully Qualified Method Calls
  • Traits That Define Relationships Between Types
    • Associated Types (or How Iterators Work)
    • Generic Traits (or How Operator Overloading Works)
  • impl Trait
  • Lifetime Bounds
  • use Bounds
  • Reverse-Engineering Bounds
  • Traits as a Foundation
• 12. Operator Overloading
  • Arithmetic and Bitwise Operators
    • Unary Operators
    • Binary Operators
    • Compound Assignment Operators
  • Equivalence Comparisons
    • The Eq Trait (Or: Equality vs. NaN)
  • Ordered Comparisons
  • Index and IndexMut
  • Other Operators
• 13. Utility Traits
  • Drop
  • Sized
  • Clone
  • Copy
  • Deref and DerefMut
  • Default
  • AsRef and AsMut
  • Borrow and BorrowMut
  • From and Into
  • TryFrom and TryInto
  • ToOwned
  • Borrow and ToOwned at Work: The Humble Cow
• 14. Closures
  • Capturing Variables
    • Closures That Borrow
    • Closures That Steal
  • Function and Closure Types
  • Closure Performance
  • Closures and Safety
    • Closures That Kill
    • FnOnce
    • FnMut
    • Copy and Clone for Closures
  • Callbacks
  • Using Closures Effectively
• 15. Iterators
  • The Iterator and IntoIterator Traits
  • Creating Iterators
    • iter and iter_mut Methods
    • IntoIterator Implementations
    • from_fn and successors
    • drain Methods
    • Other Iterator Sources
  • Iterator Adapters
    • map and filter
    • filter_map and flat_map
    • flatten
    • take and take_while
    • skip and skip_while
    • peekable
    • fuse
    • Reversible Iterators and rev
    • inspect
    • chain
    • enumerate
    • zip
    • by_ref
    • cloned, copied
    • cycle
  • Consuming Iterators
    • Simple Accumulation: count, sum, product
    • max, min
    • max_by, min_by
    • max_by_key, min_by_key
    • Comparing Item Sequences
    • any and all
    • position, rposition, and ExactSizeIterator
    • fold and rfold
    • try_fold and try_rfold
    • nth, nth_back
    • last
    • find, rfind, and find_map
    • Building Collections: collect and FromIterator
    • The Extend Trait
    • partition
    • for_each and try_for_each
  • Implementing Your Own Iterators
• 16. Collections
  • Overview
  • Vec<T>
    • Accessing Elements
    • Iteration
    • Length and Capacity
    • Growing and Shrinking Vectors
    • Splitting
    • Swapping
    • Filling
    • Sorting and Searching
    • Comparing Slices
    • Random Elements
    • Rust Rules Out Invalidation Errors
  • VecDeque<T>
  • BinaryHeap<T>
  • HashMap<K, V> and BTreeMap<K, V>
    • Entries
    • Map Iteration
  • HashSet<T> and BTreeSet<T>
    • Set Iteration
    • When Equal Values Are Different
    • Whole-Set Operations
  • Hashing
  • Using a Custom Hashing Algorithm
  • Beyond the Standard Collections
• 17. Strings and Text
  • Some Unicode Background
    • ASCII, Latin-1, and Unicode
    • UTF-8
    • Text Directionality
  • Characters (char)
    • Classifying Characters
    • Handling Digits
    • Case Conversion for Characters
    • Conversions to and from Integers
  • String and str
    • Creating String Values
    • Simple Inspection
    • Appending and Inserting Text
    • Removing and Replacing Text
    • Conventions for Searching and Iterating
    • Patterns for Searching Text
    • Searching and Replacing
    • Iterating over Text
    • Trimming
    • Case Conversion for Strings
    • Parsing Other Types from Strings
    • Converting Other Types to Strings
    • Borrowing as Other Text-Like Types
    • Accessing Text as UTF-8
    • Producing Text from UTF-8 Data
    • Putting Off Allocation
    • Strings as Generic Collections
  • Formatting Values
    • Formatting Text Values
    • Formatting Numbers
    • Formatting Other Types
    • Formatting Values for Debugging
    • Formatting Pointers for Debugging
    • Referring to Arguments by Index or Name
    • Dynamic Widths and Precisions
    • Formatting Your Own Types
    • Using the Formatting Language in Your Own Code
  • Regular Expressions
    • Basic Regex Use
    • Building Regex Values Lazily
• 18. Input and Output
  • Readers and Writers
    • Readers
    • Buffered Readers
    • Reading Lines
    • Collecting Lines
    • Writers
    • Files
    • Seeking
    • Other Reader and Writer Types
    • Binary Data, Compression, and Serialization
  • Files and Directories
    • OsStr and Path
    • Path and PathBuf Methods
    • Filesystem Access Functions
    • Reading Directories
    • Platform-Specific Features
  • Networking
• 19. Threads
  • Fork-Join Parallelism
    • spawn and join
    • Error Handling Across Threads
    • Sharing Immutable Data Across Threads
    • Rayon
    • Revisiting the Mandelbrot Set
  • Channels
    • Sending Values
    • Receiving Values
    • Running the Pipeline
    • Channel Features and Performance
    • Thread Safety: Send and Sync
    • Piping Almost Any Iterator to a Channel
    • Beyond Pipelines
  • Shared Mutable State
    • What Is a Mutex?
    • Mutex<T>
    • mut and Mutex
    • Why Mutexes Are Not Always a Good Idea
    • Deadlock
    • Poisoned Mutexes
    • Multiconsumer Channels Using Mutexes
    • Read/Write Locks (RwLock<T>)
    • Condition Variables (Condvar)
    • Atomics
    • Global Variables
    • Thread-Local Variables
  • What Hacking Concurrent Code in Rust Is Like
• 20. Asynchronous Programming
  • What Asynchronous Code Looks Like
  • Futures
  • Asynchronous Function Future Types
  • async Blocks
  • Future Lifetimes
  • Spawning Asynchronous Tasks
    • Listing a Web Pages Outgoing Links
    • Spidering the Web Concurrently
    • Extracting the Traversals Results
    • Waiting Versus Blocking
  • Asynchronous Versions of Blocking Tools
  • Tasks and static
  • Tasks and Send
  • Asynchronous Closures
  • AsyncFn
  • Asynchronous Functions in Traits
  • Cancellation
    • Cancel Safety
    • Racing Futures with tokio::select!
  • Shutdown
    • Aborting Tasks
    • Shutdown Signals
    • Cancellation Tokens
  • Conclusion
• 21. Futures
  • The Future Trait
  • Implementing and Instantiating Futures
  • How Do We Know When to Poll?
    • Invoking Wakers: spawn_blocking
    • Implementing block_on
  • The Role of Runtimes
    • Implementing I/O Futures
    • Reactors
    • Implementing a Reactor
    • Cooperative Multitasking
    • Tokios Executor
  • Pinning
    • The Two Life Stages of a Future
    • Pinned Pointers
    • The Unpin Trait
  • Conclusion
• 22. Macros
  • Macro Basics
    • Basics of Macro Expansion
    • Unintended Consequences
    • Repetition
  • Built-In Macros
  • Debugging Macros
  • Building the json! Macro
    • Fragment Types
    • Recursion in Macros
    • Using Traits with Macros
    • Scoping and Hygiene
    • Importing and Exporting Macros
  • Beyond macro_rules!
• 23. Unsafe Code
  • Unsafe from What?
  • unsafe Blocks
  • Example: An Efficient ASCII String Type
  • Unsafe Functions
  • Marking Unsafe Code
  • Undefined Behavior
  • Unsafe Traits
  • Raw Pointers
    • Dereferencing Raw Pointers Safely
    • Example: RefWithFlag
    • Null Pointers
    • Type Sizes and Alignments
    • Pointer Arithmetic
    • Moving Into and Out of Memory
    • Example: GapBuffer
    • Panic Safety in Unsafe Code
  • Unions
• 24. Foreign Functions
  • Finding Common Data Representations
  • Declaring Foreign Functions and Variables
  • Using Functions from Libraries
  • A Raw Interface to libgit2
  • A Safe Interface to libgit2
  • Conclusion
• Index

pokaż cały spis treści

ukryj recenzje