舉報 
會員
Mastering Rust
Rustisanempoweringlanguagethatprovidesararecombinationofsafety,speed,andzero-costabstractions.MasteringRust–SecondEditionisfilledwithclearandsimpleexplanationsofthelanguagefeaturesalongwithreal-worldexamples,showingyouhowyoucanbuildrobust,scalable,andreliableprograms.ThissecondeditionofthebookimprovesuponthepreviousoneandtouchesonallaspectsthatmakeRustagreatlanguage.WehaveincludedthefeaturesfromlatestRust2018editionsuchasthenewmodulesystem,thesmartercompiler,helpfulerrormessages,andthestableproceduralmacros.You’lllearnhowRustcanbeusedforsystemsprogramming,networkprogramming,andevenontheweb.You’llalsolearntechniquessuchaswritingmemory-safecode,buildingidiomaticRustlibraries,writingefficientasynchronousnetworkingcode,andadvancedmacros.Thebookcontainsamixoftheoryandhands-ontaskssoyouacquiretheskillsaswellastheknowledge,anditalsoprovidesexercisestohammertheconceptsin.Afterreadingthisbook,youwillbeabletoimplementRustforyourenterpriseprojects,writebettertestsanddocumentation,designforperformance,andwriteidiomaticRustcode.
目錄(363章)
倒序
- coverpage
- Title Page
- Copyright and Credits
- Mastering Rust Second Edition
- About Packt
- Why subscribe?
- Packt.com
- Contributors
- About the author
- About the reviewer
- Packt is searching for authors like you
- Preface
- Who this book is for
- What this book covers
- Getting the most out of this book
- Download the example code files
- Conventions used
- Get in touch
- Reviews
- Getting Started with Rust
- What is Rust and why should you care?
- Installing the Rust compiler and toolchain
- Using rustup.rs
- A tour of the language
- Primitive types
- Declaring variables and immutability
- Functions
- Closures
- Strings
- Conditionals and decision making
- Match expressions
- Loops
- User-defined types
- Structs
- Enums
- Functions and methods on types
- Impl blocks on structs
- Impl blocks for enums
- Modules imports and use statements
- Collections
- Arrays
- Tuples
- Vectors
- Hashmaps
- Slices
- Iterators
- Exercise – fixing the word counter
- Summary
- Managing Projects with Cargo
- Package managers
- Modules
- Nested modules
- File as a module
- Directory as module
- Cargo and crates
- Creating a new Cargo project
- Cargo and dependencies
- Running tests with Cargo
- Running examples with Cargo
- Cargo workspace
- Extending Cargo and tools
- Subcommands and Cargo installation
- cargo-watch
- cargo-edit
- cargo-deb
- cargo-outdated
- Linting code with clippy
- Exploring the manifest file – Cargo.toml
- Setting up a Rust development environment
- Building a project with Cargo – imgtool
- Summary
- Tests Documentation and Benchmarks
- Motivation for testing
- Organizing tests
- Testing primitives
- Attributes
- Assertion macros
- Unit tests
- First unit test
- Running tests
- Isolating test code
- Failing tests
- Ignoring tests
- Integration tests
- First integration test
- Sharing common code
- Documentation
- Writing documentation
- Generating and viewing documentation
- Hosting documentation
- Doc attributes
- Documentation tests
- Benchmarks
- Built-in micro-benchmark harness
- Benchmarking on stable Rust
- Writing and testing a crate – logic gate simulator
- Continuous integration with Travis CI
- Summary
- Types Generics and Traits
- Type systems and why they matter
- Generics
- Creating generic types
- Generic functions
- Generic types
- Generic implementations
- Using generics
- Abstracting behavior with traits
- Traits
- The many forms of traits
- Marker traits
- Simple traits
- Generic traits
- Associated type traits
- Inherited traits
- Using traits with generics – trait bounds
- Trait bounds on types
- Trait bounds on generic functions and impl blocks
- Using + to compose traits as bounds
- Trait bounds with impl trait syntax
- Exploring standard library traits
- True polymorphism using trait objects
- Dispatch
- Trait objects
- Summary
- Memory Management and Safety
- Programs and memory
- How do programs use memory?
- Memory management and its kinds
- Approaches to memory allocation
- The stack
- The heap
- Memory management pitfalls
- Memory safety
- Trifecta of memory safety
- Ownership
- A brief on scopes
- Move and copy semantics
- Duplicating types via traits
- Copy
- Clone
- Ownership in action
- Borrowing
- Borrowing rules
- Borrowing in action
- Method types based on borrowing
- Lifetimes
- Lifetime parameters
- Lifetime elision and the rules
- Lifetimes in user defined types
- Lifetime in impl blocks
- Multiple lifetimes
- Lifetime subtyping
- Specifying lifetime bounds on generic types
- Pointer types in Rust
- References – safe pointers
- Raw pointers
- Smart pointers
- Drop
- Deref and DerefMut
- Types of smart pointers
- Box<T>
- Reference counted smart pointers
- Rc<T>
- Interior mutability
- Cell<T>
- RefCell<T>
- Uses of interior mutability
- Summary
- Error Handling
- Error handling prelude
- Recoverable errors
- Option
- Result
- Combinators on Option/Result
- Common combinators
- Using combinators
- Converting between Option and Result
- Early returns and the ? operator
- Non-recoverable errors
- User-friendly panics
- Custom errors and the Error trait
- Summary
- Advanced Concepts
- Type system tidbits
- Blocks and expressions
- Let statements
- Loop as an expression
- Type clarity and sign distinction in numeric types
- Type inference
- Type aliases
- Strings
- Owned strings – String
- Borrowed strings – &str
- Slicing and dicing strings
- Using strings in functions
- Joining strings
- When to use &str versus String ?
- Global values
- Constants
- Statics
- Compile time functions – const fn
- Dynamic statics using the lazy_static! macro
- Iterators
- Implementing a custom iterator
- Advanced types
- Unsized types
- Function types
- Never type ! and diverging functions
- Unions
- Cow
- Advanced traits
- Sized and ?Sized
- Borrow and AsRef
- ToOwned
- From and Into
- Trait objects and object safety
- Universal function call syntax
- Trait rules
- Closures in depth
- Fn closures
- FnMut closures
- FnOnce closures
- Consts in structs enums and traits
- Modules paths and imports
- Imports
- Re-exports
- Selective privacy
- Advanced match patterns and guards
- Match guards
- Advanced let destructure
- Casting and coercion
- Types and memory
- Memory alignment
- Exploring the std::mem module
- Serialization and deserialization using serde
- Summary
- Concurrency
- Program execution models
- Concurrency
- Approaches to concurrency
- Kernel-based
- User-level
- Pitfalls
- Concurrency in Rust
- Thread basics
- Customizing threads
- Accessing data from threads
- Concurrency models with threads
- Shared state model
- Shared ownership with Arc
- Mutating shared data from threads
- Mutex
- Shared mutability with Arc and Mutex
- RwLock
- Communicating through message passing
- Asynchronous channels
- Synchronous channels
- thread-safety in Rust
- What is thread-safety?
- Traits for thread-safety
- Send
- Sync
- Concurrency using the actor model
- Other crates
- Summary
- Metaprogramming with Macros
- What is metaprogramming?
- When to use and not use Rust macros
- Macros in Rust and their types
- Types of macros
- Creating your first macro with macro_rules!
- Built-in macros in the standard library
- macro_rules! token types
- Repetitions in macros
- A more involved macro – writing a DSL for HashMap initialization
- Macro use case – writing tests
- Exercises
- Procedural macros
- Derive macros
- Debugging macros
- Useful procedural macro crates
- Summary
- Unsafe Rust and Foreign Function Interfaces
- What is safe and unsafe really?
- Unsafe functions and blocks
- Unsafe traits and implementations
- Calling C code from Rust
- Calling Rust code from C
- Using external C/C++ libraries from Rust
- Creating native Python extensions with PyO3
- Creating native extensions in Rust for Node.js
- Summary
- Logging
- What is logging and why do we need it?
- The need for logging frameworks
- Logging frameworks and their key features
- Approaches to logging
- Unstructured logging
- Structured logging
- Logging in Rust
- log – Rust's logging facade
- The env_logger
- log4rs
- Structured logging using slog
- Summary
- Network Programming in Rust
- Network programming prelude
- Synchronous network I/O
- Building a synchronous redis server
- Asynchronous network I/O
- Async abstractions in Rust
- Mio
- Futures
- Tokio
- Building an asynchronous redis server
- Summary
- Building Web Applications with Rust
- Web applications in Rust
- Typed HTTP with Hyper
- Hyper server APIs – building a URL shortener
- hyper as a client – building a URL shortener client
- Web frameworks
- Actix-web basics
- Building a bookmarks API using Actix-web
- Summary
- Interacting with Databases in Rust
- Why do we need data persistence?
- SQLite
- PostgreSQL
- Connection pooling with r2d2
- Postgres and the diesel ORM
- Summary
- Rust on the Web with WebAssembly
- What is WebAssembly?
- Design goals of WebAssembly
- Getting started with WebAssembly
- Trying it out online
- Ways to generate WebAssembly
- Rust and WebAssembly
- Wasm-bindgen
- Other WebAssembly projects
- Rust
- Other languages
- Summary
- Building Desktop Applications with Rust
- Introduction to GUI development
- GTK+ framework
- Building a hacker news app using gtk-rs
- Exercise
- Other emerging GUI frameworks
- Summary
- Debugging
- Introduction to debugging
- Debuggers in general
- Prerequisites for debugging
- Setting up gdb
- A sample program – buggie
- The gdb basics
- Debugger integration with Visual Studio Code
- RR debugger – a quick overview
- Summary
- Other Books You May Enjoy
- Leave a review - let other readers know what you think 更新時間：2021-07-02 13:36:18
推薦閱讀
- Learning LibGDX Game Development（Second Edition）
- Java逍遙游記
- Web交互界面設計與制作（微課版）
- Spring Cloud、Nginx高并發核心編程
- 程序員修煉之道：通向務實的最高境界（第2版）
- 軟件測試技術指南
- Learning Python Design Patterns
- bbPress Complete
- HTML5從入門到精通 （第2版）
- C++ Fundamentals
- 創意UI：Photoshop玩轉APP設計
- Java 從入門到項目實踐（超值版）
- Instant Apache Camel Messaging System
- Python+Office：輕松實現Python辦公自動化
- Go語言入門經典
- Software-Defined Networking with OpenFlow（Second Edition）
- 讓Python遇上Office：從編程入門到自動化辦公實踐
- Practical Time Series Analysis
- 軟件定義存儲：原理、實踐與生態
- Mastering Python for Data Science
- Python商業數據分析：零售和電子商務案例詳解（雙色）
- Full Stack Development with JHipster
- Android從入門到精通（微視頻精編版）
- Flutter基礎與實戰：從入門到APP跨平臺開發
- Hands-On Functional Programming in Rust
- Visual C#.NET程序設計教程（第2版）
- 自己動手寫網絡爬蟲（修訂版）
- 32位匯編語言程序設計（第3版）
- Hands-On Deep Learning with TensorFlow
- 數據結構（C++語言版）
