最新章節

• Summary
• Other resources for learning Rust
• OS and embedded system development
• Graphics and games
• Web development
• File formats and databases

• Summary 更新時間：2021-07-02 15:31:03
• Other resources for learning Rust
• OS and embedded system development
• Graphics and games
• Web development
• File formats and databases
• Working with dates and times
• The ecosystem of crates
• The Ecosystem of Crates
• Summary
• Using Rust without the Standard Library
• Filesystem operations
• Error-handling with try!
• Writing a file
• Buffered reading
• Error-handling with try!
• Reading a file
• Paths
• Working with files
• Collections - using hashmaps and hashsets
• Exploring std and the prelude module
• Exploring the Standard Library
• Summary
• Calling Rust from other languages
• Inlining assembly code
• Using a C library
• Interfacing with C
• Raw pointers
• Using std::mem
• When is code unsafe
• Programming at the Boundaries
• Summary
• Synchronous and asynchronous
• Sending references over a channel
• Sending struct values over a channel
• Making a channel
• Sending and receiving data
• Communication through channels
• The Sync trait
• Shared mutable states
• Thread safety
• Panicking threads
• Starting a number of threads
• Setting the thread's stack size
• Creating threads
• Concurrency and threads
• Concurrency - Coding for Multicore Execution
• Summary
• Some other built-in macros
• Using macros from crates
• Some other examples
• Creating a new function
• Repetition
• Developing macros
• Why macros?
• Macros
• Working with random numbers
• Adding external crates to a project
• Exporting a public interface
• Importing external crates
• Importing modules and file hierarchy
• Visibility of items
• Defining a module
• Building crates
• Modules and crates
• Organizing Code and Macros
• Summary
• Overview of pointers
• Reference counting
• Boxes
• Moving closure
• Implementing the Drop trait
• Borrowing a value
• Moving a value
• Ownership
• Ownership and borrowing
• Match struct and ref
• References
• Pointers
• Let's summarize
• Copying and moving values - The copy trait
• Lifetimes
• Stack and heap
• Pointers and references
• Ensuring Memory Safety and Pointers
• Summary
• Using the visitor pattern
• Inheritance with traits
• OOP in Rust
• Built-in traits and operator overloading
• Static and dynamic dispatch
• Using trait constraints
• Traits
• Methods on tuples and enums
• Using a builder pattern
• Using a constructor pattern
• Methods on structs
• Associated functions on structs
• Using Traits and OOP in Rust
• Summary
• The try! macro and the ? operator
• Some more examples of error-handling
• Testing for failure
• Panics
• Error-handling
• Generic data structures and functions
• Consumers and adapters
• Iterators
• Higher order functions and closures
• Higher Order Functions and Error-Handling
• Summary
• Program arguments
• Matching patterns
• Getting input from the console
• Result and Option
• Enums
• Structs
• Tuples
• Strings and arrays
• Slices
• Vectors
• Arrays vectors and slices
• Strings
• Structuring Data and Matching Patterns
• Summary
• The tests module
• Testing with cargo
• Testing
• Conditional compilation
• Attributes
• Documenting a function
• Functions
• Looping
• Branching on a condition
• Using Functions and Control Structures
• Summary
• The stack and the heap
• Expressions
• Aliasing
• Type checking and conversions
• Scope of a variable and shadowing
• Mutable and immutable variables
• Binding variables to values
• Consulting Rust documentation
• Values and primitive types
• Printing with string interpolation
• Global constants
• Comments
• Using Variables and Types
• Summary
• The Standard Library
• Using Sublime Text
• Developer tools
• Working with Cargo
• Our first program
• rustc--the Rust compiler
• Installing Rust
• Servo
• Where to use Rust
• The success of Rust
• The stability of Rust and its evolution
• Comparison with other languages
• The trifecta of Rust - safe fast and concurrent
• The advantages of Rust
• Starting with Rust
• Questions
• Piracy
• Errata
• Downloading the example code
• Customer support
• Conventions
• Who this book is for
• What you need for this book
• What this book covers
• Preface
• Customer Feedback
• Why subscribe?
• www.PacktPub.com
• About the Reviewer
• About the Author
• Credits
• Second Edition
• Rust Essentials
• Copyright
• Second Edition
• Title Page
• coverpage

• coverpage
• Title Page
• Second Edition
• Copyright
• Rust Essentials
• Second Edition
• Credits
• About the Author
• About the Reviewer
• www.PacktPub.com
• Why subscribe?
• Customer Feedback
• Preface
• What this book covers
• What you need for this book
• Who this book is for
• Conventions
• Customer support
• Downloading the example code
• Errata
• Piracy
• Questions
• Starting with Rust
• The advantages of Rust
• The trifecta of Rust - safe fast and concurrent
• Comparison with other languages
• The stability of Rust and its evolution
• The success of Rust
• Where to use Rust
• Servo
• Installing Rust
• rustc--the Rust compiler
• Our first program
• Working with Cargo
• Developer tools
• Using Sublime Text
• The Standard Library
• Summary
• Using Variables and Types
• Comments
• Global constants
• Printing with string interpolation
• Values and primitive types
• Consulting Rust documentation
• Binding variables to values
• Mutable and immutable variables
• Scope of a variable and shadowing
• Type checking and conversions
• Aliasing
• Expressions
• The stack and the heap
• Summary
• Using Functions and Control Structures
• Branching on a condition
• Looping
• Functions
• Documenting a function
• Attributes
• Conditional compilation
• Testing
• Testing with cargo
• The tests module
• Summary
• Structuring Data and Matching Patterns
• Strings
• Arrays vectors and slices
• Vectors
• Slices
• Strings and arrays
• Tuples
• Structs
• Enums
• Result and Option
• Getting input from the console
• Matching patterns
• Program arguments
• Summary
• Higher Order Functions and Error-Handling
• Higher order functions and closures
• Iterators
• Consumers and adapters
• Generic data structures and functions
• Error-handling
• Panics
• Testing for failure
• Some more examples of error-handling
• The try! macro and the ? operator
• Summary
• Using Traits and OOP in Rust
• Associated functions on structs
• Methods on structs
• Using a constructor pattern
• Using a builder pattern
• Methods on tuples and enums
• Traits
• Using trait constraints
• Static and dynamic dispatch
• Built-in traits and operator overloading
• OOP in Rust
• Inheritance with traits
• Using the visitor pattern
• Summary
• Ensuring Memory Safety and Pointers
• Pointers and references
• Stack and heap
• Lifetimes
• Copying and moving values - The copy trait
• Let's summarize
• Pointers
• References
• Match struct and ref
• Ownership and borrowing
• Ownership
• Moving a value
• Borrowing a value
• Implementing the Drop trait
• Moving closure
• Boxes
• Reference counting
• Overview of pointers
• Summary
• Organizing Code and Macros
• Modules and crates
• Building crates
• Defining a module
• Visibility of items
• Importing modules and file hierarchy
• Importing external crates
• Exporting a public interface
• Adding external crates to a project
• Working with random numbers
• Macros
• Why macros?
• Developing macros
• Repetition
• Creating a new function
• Some other examples
• Using macros from crates
• Some other built-in macros
• Summary
• Concurrency - Coding for Multicore Execution
• Concurrency and threads
• Creating threads
• Setting the thread's stack size
• Starting a number of threads
• Panicking threads
• Thread safety
• Shared mutable states
• The Sync trait
• Communication through channels
• Sending and receiving data
• Making a channel
• Sending struct values over a channel
• Sending references over a channel
• Synchronous and asynchronous
• Summary
• Programming at the Boundaries
• When is code unsafe
• Using std::mem
• Raw pointers
• Interfacing with C
• Using a C library
• Inlining assembly code
• Calling Rust from other languages
• Summary
• Exploring the Standard Library
• Exploring std and the prelude module
• Collections - using hashmaps and hashsets
• Working with files
• Paths
• Reading a file
• Error-handling with try!
• Buffered reading
• Writing a file
• Error-handling with try!
• Filesystem operations
• Using Rust without the Standard Library
• Summary
• The Ecosystem of Crates
• The ecosystem of crates
• Working with dates and times
• File formats and databases
• Web development
• Graphics and games
• OS and embedded system development
• Other resources for learning Rust
• Summary 更新時間：2021-07-02 15:31:03