Index
A
- advanced source tree (AST) / Compiler plugins, Implementing a simple trait
- allocation API
- using / Allocation API
- Amount type
- reference / Complex macros
- arithmetic and logical unit (ALU) / Understanding how the CPU works
- asynchronous I/O
- about / Asynchronous I/O in Rust
- Tokio codecs, creating / Creating Tokio codecs
- asynchronous programming
- about / Introduction to asynchronous programming
- I/O architecture, in CPU / Understanding I/O in the CPU
- I/O, controlling with kernel / Getting the kernel to control the I/O
- from programmers perspective / Asynchronous programming from the programmer's perspective
- WebSockets, implementing / WebSockets in Rust
- attributes
- about / Understanding attributes
- trait derivations / Trait derivations
- crate features / Crate features
- configuration attributes / Configuration attributes
B
- benchmark
- considerations / Selecting what to benchmark
- in nightly Rust / Benchmarking in nightly Rust
- in stable Rust / Benchmarking in stable Rust
- continuous integration / Continuous integration for benchmarks
- benchmark statistics
- generating, with Criterion / Benchmark statistics with Criterion
- bigger integers
- using / Using bigger integers
- boilerplate code
- avoiding, for builder pattern with crates / Avoiding boilerplate code for the builder pattern
- borrow checker
- about / Mastering the borrow checker
- allocations / Allocations
- mutability / Mutability, borrowing, and owning
- borrowing / Mutability, borrowing, and owning
- owning / Mutability, borrowing, and owning
- lifetimes / Lifetimes
- BTreeMap / Maps
- BTreeSet / Sets
- build configuration
- about / Build configuration
- profile / Build configuration
- built-in derives / Trait derivations
- byte streams
- parsing / Parsing byte streams
C
- cache
- used, for speeding up memory access / Speeding up memory access with the cache
- cache misses / Cache misses
- cache misses, fixing / How can you fix it?
- Cachegrind / Cachegrind
- cache invalidation / Cache invalidation
- cache pollution / How can you fix it?
- Callgrind / Callgrind
- cell module
- about / The cell module
- Cell / Cells
- RefCell / RefCell
- Central Processing Unit (CPU)
- about / Understanding the hardware
- working / Understanding how the CPU works
- memory access, speeding up with cache / Speeding up memory access with the cache
- pipeline / CPU pipeline
- branch prediction / Branch prediction
- branch prediction, relevance for code / The relevance of branch prediction for our code
- I/O architecture / Understanding I/O in the CPU
- channel-based I/O / Understanding I/O in the CPU
- channels
- about / Channels between threads
- using / Channels between threads
- Clippy
- about / Clippy
- URL / Clippy, Configuration
- installation / Installation
- configuration / Configuration
- lints / Lints
- closures
- used, for avoiding runtime evaluation / Using closures to avoid runtime evaluation
- combinators / Future combinators
- Command-Line Argument Parser (CLAP) / Creating command-line interfaces
- command-line interfaces
- creating, with crates / Creating command-line interfaces
- compile-time checks
- performing / Compile-time checks
- sequential state machines, creating / Sequential state machines
- complex state machines, creating / Complex state machines
- example / Real-life type system check example
- compiler plugins / Compiler plugins, Understanding compiler plugins
- complex derivations
- implementing / Implementing complex derivations
- getters, implementing / Implementing getters
- setters, implementing / Implementing setters
- complex enumerations
- creating / Complex enumerations
- complex macros
- creating / Complex macros
- complex state machines
- creating / Complex state machines
- complex structures
- deserializing / Serializing and deserializing complex structures
- serializing / Serializing and deserializing complex structures
- concurrency
- about / Concurrency in Rust
- Send trait / Understanding the Send and Sync traits
- Sync trait / Understanding the Send and Sync traits, The Sync trait
- types / Other types of concurrency in Rust
- configuration attributes
- about / Configuration attributes
- checking / Configuration attributes
- conservative trait
- returning / Conservative trait return
- constant functions
- using / Constant functions
- continuous integration
- for benchmark / Continuous integration for benchmarks
- Travis-CI integration, configuring / Travis-CI integration
- crate features
- about / Crate features
- defining / Crate features
- crates
- about / Learning about useful small crates
- lazily evaluated statics, creating / Creating lazily evaluated statics
- boilerplate code, avoiding for builder pattern / Avoiding boilerplate code for the builder pattern
- errors, managing / Managing errors
- logging, efficiently in Rust / Logging efficiently in Rust
- command-line interfaces, creating / Creating command-line interfaces
- Criterion
- benchmark statistics, generating / Benchmark statistics with Criterion
- URL / Benchmark statistics with Criterion
- crossbeam crate / Non-blocking data structures
- custom derives / Trait derivations
- custom standard macros
- creating / Creating your own standard macros
- macro variants / Macro variants
- complex macros / Complex macros
- cyclomatic complexity / Cyclomatic complexity, The relevance of branch prediction for our code
D
- data deserialization / Data serialization and deserialization
- data serialization / Data serialization and deserialization
- declarative macros / Declarative macros
- Diesel
- used, for connecting with database / Connecting with a database
E
- End of File (EOF) / Asynchronous I/O in Rust
- errors
- managing, with crates / Managing errors
- exbibytes (EiBs) / Understanding I/O in the CPU
- external data
- working with / Working with external data
- data serialization / Data serialization and deserialization
- data deserialization / Data serialization and deserialization
- complex structures, serializing / Serializing and deserializing complex structures
- complex structures, deserializing / Serializing and deserializing complex structures
- byte streams, parsing / Parsing byte streams
F
- faster crate
- reference / Other types of concurrency in Rust
- FutureExt trait
- reference / Understanding futures
- futures
- about / Understanding futures
- creating / Understanding futures
- combinators / Future combinators
G
- Generators
- about / Understanding the new Generators
- example / Understanding the new Generators
- getters
- implementing / Implementing getters
- gibibytes (GiB) / Understanding I/O in the CPU
- gigabytes (GB) / Understanding I/O in the CPU
H
- Handlebars / Creating extremely efficient templates
- HashMap / Maps
- HashSet / Sets
- High Intermediate Representation (HIR) / Optimizations
I
- I/O
- controlling, with kernel / Getting the kernel to control the I/O
- I/O architecture
- channel-based I/O / Understanding I/O in the CPU
- memory-mapped I/O / Understanding I/O in the CPU
- indexing
- degradations / Indexing degradations
- inline assembly
- writing / Inline assembly and naked functions
- iterator adaptors
- about / Iterator adaptors
- real-life example / Real-life example
- iterators
- using / Using iterators
- specialized adaptors / Specialized adaptors
- adaptors, interaction between / Interaction between adaptors
- itertools / Itertools
K
- kernel
- I/O, controlling / Getting the kernel to control the I/O
L
- lazily evaluated statics
- creating, with crates / Creating lazily evaluated statics
- link-time optimizations (LTOs) / Link-time optimizations
- lint groups, Clippy
- clippy lint group / Lint groups
- clippy_pedantic group / Lint groups
- lints
- about / Using Rust compiler lints, Lints
- anonymous parameters, avoiding / Avoiding anonymous parameters
- heap allocated box pointers, avoiding / Avoiding heap allocated box pointers
- missing implementations, avoiding / Avoiding missing implementations
- documentation, enforcing / Enforcing documentation
- trivial casts, pointing out / Pointing out trivial casts
- unsafe code blocks, linting / Linting unsafe code blocks
- unused lints / Unused lints
- variant size differences / Variant size differences
- lint groups / Lint groups
- lints, Clippy
- URL / Lints, Lint groups
- about / Lints
- casting / Casting
- bad practice / Bad practice
- performance lints / Performance lints
- unwraps / Unwraps
- shadowing / Shadowing
- integer overflow / Integer overflow
- lint groups / Lint groups
- logging
- with crates, in Rust / Logging efficiently in Rust
- Low Level Virtual Machine (LLVM) / Benchmarking in nightly Rust
M
- macros
- about / Macros
- console, printing / Console printing
- string, formatting / String formatting
- for compilation environment / Compilation environment
- byte arrays, loading at compile time / Loading byte arrays and strings at compile time
- strings, loading at compile time / Loading byte arrays and strings at compile time
- code paths / Code paths
- preconditions, checking / Checking preconditions and postconditions
- postconditions, checking / Checking preconditions and postconditions
- compile error, creating / Others
- current position, obtaining in code / Others
- current module, obtaining / Others
- list, obtaining / Others
- macro variables
- expr / Complex macros
- ident / Complex macros
- path / Complex macros
- ty / Complex macros
- pat / Complex macros
- stmt / Complex macros
- block / Complex macros
- item / Complex macros
- meta / Complex macros
- tt / Complex macros
- map hashing
- about / Map hashing
- perfect hash functions / Perfect hash functions
- maps
- memory-mapped I/O / Understanding I/O in the CPU
- memory representation
- about / Memory representation
- alignment / Alignment
- complex enumerations / Complex enumerations
- unions / Unions
- metaprogramming
- in nightly Rust / Metaprogramming in nightly Rust
- compiler plugins / Understanding compiler plugins
- declarative macros / Declarative macros
- Middle Intermediate Representation (MIR) / Optimizations
- move keyword
- using / The move keyword
- multithreading
- about / Understanding multithreading
- threads, creating / Creating threads
- panicking / Panicking in Rust
- multithreading crates
- about / Multithreading crates
- non-blocking data structures, using / Non-blocking data structures
- thread pooling / Thread pooling
- parallel iterators / Parallel iterators
- Mutex / The Sync trait
N
- naked functions
- nightly Rust
- benchmarking / Benchmarking in nightly Rust
- features, checking / Nightly Rust
- conservative trait, returning / Conservative trait return
- constant functions, using / Constant functions
- inline assembly, writing / Inline assembly and naked functions
- naked functions, using / Inline assembly and naked functions
- bigger integers, using / Using bigger integers
- allocation API / Allocation API
- compiler plugins / Compiler plugins
- metaprogramming / Metaprogramming in nightly Rust
- Nom crate
- reference / Parsing byte streams
- non-blocking data structures
- using / Non-blocking data structures
- scoped threads / Scoped threads
O
- OProfile / OProfile
- out of order execution / CPU pipeline
P
- panicking / Panicking in Rust
- parallel iterators / Parallel iterators
- parent stack / Scoped threads
- pebibytes (PiB) / Understanding I/O in the CPU
- perfect hash functions / Perfect hash functions
- performance, tips
- about / Extra performance tips
- closures, used for avoiding runtime evaluation / Using closures to avoid runtime evaluation
- unstable sorting / Unstable sorting
- map hashing / Map hashing
- performance optimization
- about / Optimizations
- build configuration / Build configuration
- performance pitfalls
- about / Asking the Rust compiler about performance
- performance optimization / Optimizations
- procedural macros
- creating / Creating procedural macros
- simple trait, implementing / Implementing a simple trait
- complex derivations, implementing / Implementing complex derivations
- profile, configuration
- optimization level / Optimization level
- debug information / Debug information
- link-time optimizations (LTOs) / Link-time optimizations
- debug assertions / Debug assertions
- panic behavior / Panic behavior
- runtime library paths / Runtime library paths
- profile configuration keywords
- dev / Build configuration
- release / Build configuration
- test / Build configuration
- bench / Build configuration
- doc / Build configuration
- profiling tools
- about / Profiling tools
- Valgrind / Valgrind
- OProfile / OProfile
R
- Random Access Memory (RAM) / Understanding how the CPU works
- rc module / The rc module
- RefCell / RefCell
- register / Understanding how the CPU works
- Rocket
- Rust
- logging, with crates / Logging efficiently in Rust
- used, for web development / Using Rust for web development
- URL, for documentation / Complex macros
- concurrency / Concurrency in Rust
- asynchronous I/O / Asynchronous I/O in Rust
- rustc
- reference / Understanding compiler plugins
- Rust compiler
- lints / Using Rust compiler lints
- rustc_plugin
- reference / Understanding compiler plugins
- Rust web template
S
- scoped threads / Scoped threads
- Send trait
- about / Understanding the Send and Sync traits
- implementing / The Send trait
- sequences / Sequences
- sequential state machines
- creating / Sequential state machines
- serde
- serde.rs
- sets
- setters
- implementing / Implementing setters
- reference / Implementing setters
- shared pointers
- about / Shared pointers
- cell module / The cell module
- rc module / The rc module
- single instruction multiple data (SIMD) / Linting unsafe code blocks, Single instruction multiple data
- stable ordering / Unstable sorting
- stable Rust
- benchmarking / Benchmarking in stable Rust
- stalling / CPU pipeline
- standard library collections
- about / Standard library collections
- sequences / Sequences
- maps / Maps
- sets / Sets
- SUPER Android Analyzer
- URL / Callgrind
- Sync trait
- about / The Sync trait
- implementing / The Sync trait
- syntax
- reference / Understanding compiler plugins
- syntax_pox
- reference / Understanding compiler plugins
T
- templates
- creating / Creating extremely efficient templates
- templating engine
- reference / Creating extremely efficient templates
- Tera / Creating extremely efficient templates
- thread pooling / Thread pooling
- threads
- creating / Creating threads
- data, sending between / Moving data between threads
- move keyword, using / The move keyword
- data, sharing between / Sharing data between threads
- channels, using / Channels between threads
- Tokio codecs
- creating / Creating Tokio codecs
- trait derivations
- built-in derives / Trait derivations
- custom derives / Trait derivations
- example / Trait derivations
- about / Trait derivations
- translation issues
- about / Translation issues
- indexing, degradations / Indexing degradations
- iterators, using / Using iterators
- itertools / Itertools
- degradations, borrowing / Borrowing degradations
- cyclomatic complexity / Cyclomatic complexity
- Travis-CI integration
- configuring / Travis-CI integration
U
- unions / Unions
- unstable feature list, Rust
- reference / Nightly Rust
- unstable sorting / Unstable sorting
V
- Valgrind
- about / Valgrind
- Callgrind / Callgrind
- Cachegrind / Cachegrind
W
- web development
- with Rust / Using Rust for web development
- extremely efficient templates, creating / Creating extremely efficient templates
- database, connecting / Connecting with a database
- web server, creating / Creating a complete web server
- WebSockets
- implementing / WebSockets in Rust
- work stealing / Parallel iterators