Table of Contents
Rust in Action, 1st Edition, Index
Return to Rust outline, Rust, Rust bibliography, Rust courses, Rust terms, Rust topics
“ (RiA1)
Fair Use Sources
Symbols
! type 79–90
? operator 275
() type 79–90
- const fn() → () type 406
- const i8 413
- const T 183
- mut i32 183
- mut i8 411–413
- mut T 183
- mut u32 376
- mut u8 376
&dyn Trait 256
&mut dyn Trait 256
&mut T 119
&str type 61, 189, 222, 242, 292, 387
&T 119
&Trait 256
&[u8] 292, 387
- ![allow(unused_variables)] attribute 78
- ![core_intrinsics] attribute 373
- ![no_main] attribute 374
- ![no_mangle] attribute 373, 389
- ![no_std] attribute 373–374, 389
- ![repr(u8]) 389
- [cfg(all(…))] 227
- [cfg(any(…))] 227
- [cfg(not(…))] 227
- [cfg(target_os ! 227
- [derive(…)] block 152
- [derive(Debug)] 98, 272–273
A
abort() function 373
abort exception 391
absolute time 296
abstract classes 40
ActionKV 228, 231
actionkv
conditional compilation 226–228
front-end code 224–228
full code listing 237–241
overview 222–223
ActionKV::load(). open() 228
ActionKV::open() 228–229
activation frames 188
address space 177
add_with_lifetimes() 57
akv_mem executable 223
alloc::raw_vec::RawVec type 187
alloc() 194, 201
allocation records 188
allocator 194
alloc module 187
always on mode 314
Amazon Web Services (AWS) 2
anonymous functions 9, 199, 329–330
application-level protocol 254
Arc 354
Arc<Mutex<_» 363
Arc<Mutex<T» 133, 354
Arc<T> 133, 185
arena::Arena 201
arena::TypedArena 201
arrays, making lists with 64–65
Artist struct 344–345
as keyword 39
asm! macro 395
as operator 39
associative arrays 242
asynchronous interrupts 392
asynchronous programming 362
atomic operations 411
atomic reference counter 133
avatar generator 341–360
generating SVGs 346
input parsing 344
running 342
spawning a thread per logical task 351–353
functional programming style 351–352
parallel iterators 352–353
thread pools 353–360
channels 356
implementing task queues 358–360
one-way communication 354–356
AWS (Amazon Web Services) 2
B
back pressure 354
base 2 (binary) notation 37–38
base 8 (octal) notation 37–38
base 16 (hexadecimal) notation 37–38
b as i32 type cast 39
big endian format 143
BigEndian type 232
bin section 223
bit endianness 143
bit numbering 143
bit patterns and types 137–139
bool 87
boot image 367
bootimage crate 366–367
bootloader 377
borrow checker 107
bounded queues 354
bounds checking 47
Box::new(T) 192
Box<dyn Error> 271–272
Box<dynstd::error::Error> type 255
Box<dyn Trait> 256
Box<T> 187, 191
Box<Trait> 256
break keyword 50, 80
breaking from nested loops 49
overview 48–49
BTreeMap
deciding between 245–246
retrieving values from 244–245
buffered I/O 73
buffer overflow 13
buffers 21
BufReader. BufReader 72
bug 22
build-command 371
byteorder::LittleEndian 232
byteorder::ReadBytesExt trait 232
byteorder::WriteBytesExt trait 232
byteorder crate 232
ByteString type 228
ByteStr type 228
C
cache-friendly data structures 19
capitals 244
capitals[“Tonga”] 245
capitals.index(“Tonga”) 245
captures 330
cargo-binutils crate 366–367
cargo bootimage command 374
cargo build command 371
cargo commands 11
cargo doc –no-deps flag 106
cargo doc utility 18
cargo-edit crate 45
cargo init command 34
cargo new command 6, 18
cargo run command 6, 8, 10, 18, 34, 44, 54, 90, 265
cargo test 154
cargo tool
creating projects with 6, 18
rendering docs with 104–106
testing projects with 154
cargo xbuild 371
carry flag 165
c_char type 182
Cell<T> 185
cfg annotation 326
cfg attribute 226, 250
–cfg ATTRIBUTE command-line argument 227
ch6-particles 200
char type 62
check_status() function 109, 111–112, 115–116
CHIP-8 specification 165
choose() method 257
chrono::Local 299
chunks() option 219
clap::App type 301
clap::Arg type 301
class keyword 84
clear intent 221
Clock::set(t) 313
clock command 302
Clock struct 300, 306
clock synchronization 314
.clone() method 129–130, 153
Clone trait 129–131, 153
close() method 87
closures 9
functions vs. 340–341
overview 330–331
collect() method 351–352
collection 47
Color type 382
Command::Noop 360
command-line arguments, supporting 70–72
command-line utilities 23–24
Common control flow mechanisms 8
compilers 33
compiler target 226, 369
compile time 11
compiling 10
complex numbers 43–45
compound data types
enum
defining 95–96
using to manage internal state 96–98
inline documentation 103–106
rendering docs for crates and dependencies 104–106
rendering docs for single source file 104
modeling files with struct 80–83
plain functions 78–80
protecting private data 102
returning errors 87–94
Result return type 92–94
traits 98–102
creating Read traits 98–99
implementing std::fmt::Display 99–102
computer architecture 206
concurrency 328
anonymous functions 329–330
avatar generator 341–360
spawning a thread per logical task 351–353
thread pools 353–360
closures vs. functions 340–341
task virtualization and 360–363
containers 363
context switches 362
processes 363
reasons for using operating systems 363
threads 362
WebAssembly 363
threads 330–340
closures 330–331
effect of spawning many threads 333
effect of spawning some threads 331–332
reproducing results 335–338
shared variables 338–340
spawning threads 331
thread::yield_now() method 338
conditional branching 49–51
conditional compilation 9, 226
constellation 108
const keyword 88, 91
const USAGE 226
const values 381, 405
containers 363
container variable 45
context switches 362
contiguous layout 194
continue keyword 8, 47
convert() function 345–346
copy semantics 113, 153
Copy trait 111–112, 114, 129–131, 153
implementing 386–387
core::intrinsics::abort() 385
core::ptr::Shared type 187
core::ptr::Unique, core::ptr::Shared type 185
core::ptr::Unique type 187
core module 187
CPU emulation 158–173
CPU 4 173
CPU RIA/1 (Adder) 159–163
defining CPU 159
full code listing 163–164
interpreting opcodes 161–163
loading values into registers 159–160
terminology 159
CPU RIA/2 (Multiplier) 164–167
expanding CPU to support memory 164–165
full code listing 166–167
handling integer overflow 165
reading opcodes from memory 165
CPU RIA/3 (Caller) 167–173
defining functions and loading into memory 168–169
full code listing 170–173
cpu.position_in_memory variable 170
cpu.run() 170
CPU struct 164
CRC32 (cyclic redundancy check returning 32 bits) 235
create() method 219
cryptographic hash function 235
CubeSat 108, 111, 115, 119–120
CubeSat. CubeSat.mailbox 118
CubeSat.messages vector 120
current_instruction field 164
Cursor.print() 383
Cursor struct 382–383
D
dangling pointers 12
data
bit patterns and types 137–139
CPU emulation 158–173
CPU 4 173
CPU RIA/1 (Adder) 159–163
CPU RIA/2 (Multiplier) 164–167
CPU RIA/3 (Caller) 167–173
floating-point numbers 144–152
dissecting 150–152
inner workings of f32 type 144–145
isolating exponent 146–147
isolating mantissa 148–150
isolating sign bit 146
representing decimals 143–144
generating random probabilities from random bytes 157–158
integers
endianness 142–143
integer overflow 139–143
data-oriented programming 19
data processing 24
data races 13
DateTime<FixedOffset> 306
debug_assertions attribute 228
debugging 221
Debug trait 99, 153, 272–273
declaration statements 51
decode_f32_parts() 150
deconstruct_f32() 150
DELETE case 95
delete <key> 224
dereference operator 53, 192
dereferencing a pointer 183
deserialization 249
Deserialize trait 214
desktop applications 25
dive() 408
dns.rs 283
domain_name 264
domain name resolution 261
Drop 115, 132
drop(&mut self) 115
Dwarf struct 257
dynamically-sized types 65, 190, 256
dynamic dispatch 256
dynamic memory allocation 194
defined 194–199
impact of 199–201
dynamic typing 65
E
Elf struct 257
else blocks 49–51
enchant() method 257, 259
encoding 138
endianness 137, 142–143
entry point 377
enumerate() method 63
enums 51, 77, 84, 109
annotating with #[derive(Debug)] 273
controlling in-memory representation of 382
defining 95–98
defining enums that include upstream errors as variants 273
reasons for using 382
using to manage internal state 96–98
EOF (end of file) 230
epochs 296
eprintln! 10
Eq trait 152–153
Err 219
Err(E) 10
Err(err) 270
Err(String) 92
errno 87, 91
error handling 268–277
clock project 313
inability to return multiple error types 269–271
returning errors 87–94
Result return type 92–94
unwrap() and expect() 277
wrapping downstream errors 272–276
annotating with #[derive(Debug)] 273
defining enums that include the upstream errors as variants 273
map_err() 274–276
std::convert::From trait 276
std::error::Error trait 274
Error trait 274
ethernet.rs 283
exceptions 391
defined 391–393
handling 379–380, 411
revising 417
executable 361
_exit() function 377
.expect() method 219, 228, 264, 277, 292
exponents, isolating 146–147
expression statement 51
extending applications 24
extern “C” 374, 411
F
f1_length 81
f1_name 81
f32_from_parts() method 150
f32—i32 139
f32 type 38, 41, 144, 150, 154–155, 232
f4 variable 92
f64 type 38, 41, 155
fast clocks 297
faults 391–392
fearless concurrency 27
fields variable 10
File::create method 220
File::open method 220, 271
<file> command 33
file descriptor 87
File object 84
files and storage
actionkv
conditional compilation 226–228
front-end code 224–228
overview 222–223
file formats
defined 213–214
file operations 219–222
std::fs::Path trait 220–222
hexdump clones 217–219
key-value stores 222–223
actionkv 222–223
key-value model 222
FileState subtype 100
File struct 81
FILETIME 308
File type 81, 96, 100
FledgeOS 365–368
compilation instructions 370
development environment
setting up 366–367
verifying 367–368
exception handling 379–380
first boot 368–369
loops 377–379
panic handling 374–375, 385–387
core::fmt::Write trait 385–387
source code 370–374, 378–380, 383, 387
_start() function 377
text output 381–383
enums 382
printing to screen 383
writing colored text to screen 381
writing to screen with VGA-compatible text mode 375–377
floating-point numbers 36–37, 144–152
dissecting 150–152
inner workings of f32 type 144–145
isolating exponent 146–147
isolating mantissa 148–150
isolating sign bit 146
representing decimals 143–144
flow control 45–52
break keyword
breaking from nested loops 49
overview 48–49
continue keyword 47
else blocks 49–51
for loop
anonymous loops 46
index variable 46–47
overview 45–46
if else blocks 49–51
if keyword 49–51
loop keyword 48
match keyword 51–52
while loop
endless looping 48
overview 47
fmt::Result 100
.fmt() method 100
fn keyword 35, 404–405, 417
fn noop() 406
for item in collection 47
for loop
anonymous loops 46
index variable 46–47
overview 45–46
format! macro 99
frame buffer 374, 376
frames 279
f.read(buffer) function 84
f.read_exact() method 219
free() 194, 201
freestanding applications 363
from() method 220, 276, 318
From<f64> implementation 154
From trait 154, 276, 318–319
functions 56–60
anonymous functions 329–330
calling 35–36
closures vs. 340–341
defining 52
explicit lifetime annotations 56–58
generic functions 58–60
intrinsic functions
defined 411
setting up 409–412
using plain functions to experiment with APIs 78–80
fview 217–218
G
GC (garbage collection) 131
generate_svg() 346
generic functions 58–60
generic type 58
.get() method 245
git clone –depth 90
global variables
using to indicate that shutdown has been initiated 402–405
goto fail 22
goto fail; bug 22–23
goto keyword 49
grep-lite 60–63
grep-lite –help 72
ground station, definition 108
GroundStation type 119–120, 123
H
handlers 338
handlers.pop() 336
handlers vector 336
handle_signals() function 402
handle_sigterm() 404
handle_sigterm as usize 405
handle_sigusr1() 404
hardware interrupts 391, 395
hashes 241
HashMap
deciding between 245–246
retrieving values from 244–245
hash map 242
hash table 241–242
haystack 53
heading 344
HeapAlloc() call 194
HeapFree() 194
Heartbleed 21–22
“Hello, world!” 5–8
hexdump clones 217–219
high accuracy 297
high byte 161
higher-order programming 9
high nibble 161
high resolution 297
hlt x86 instruction 378
hostnames, converting to IP addresses 261–268
HTTP
HTTP GET requests, generating with reqwest library 254–256
raw 283–292
http-equiv attribute 254
http.rs file 283
I
i16 type 38, 232
i32 type 38, 183
i64 type 38
i8 type 38
if else blocks 49–51
if keyword 49–51
if let construct 10
if let Ok(T) 10
impl blocks 78, 84, 130, 274, 276
impl keyword 98
INDEX_KEY value 247
Index trait 245
infix notation 36
inline assembly 379
inline documentation 103–106
rendering docs for crates and dependencies 104–106
rendering docs for single source file 104
insert <key> <value> 224
integers
base 2, base 8, and base 16 notation 37–38
endianness 142–143
integer overflow 139–143
interior mutability 132–133, 185
interrupts
defined 391–393
hardware interrupts 395
signals vs. 391–393
software interrupts 395
.into() method 318
intrinsic functions 373
defined 411
setting up 409–412
intrinsics::abort() 375, 389
IP addresses, converting hostnames to 261–268
ip tuntap list subcommand 283
isize type 38
.iter() method 245
iterator invalidation 13
.iter_mut() variant 245
it object 257
J
jmp_buf type 413
join() function 331, 336
K
kernel 365–368
compilation instructions 370
development environment
setting up 366–367
verifying 367–368
exception handling 379–380
first boot 368–369
loops 377–379
panic handling 374–375, 385–387
core::fmt::Write trait 385–387
source code 378–380, 383, 387
source code listings 370–374
_start() function 377
text output 381–383
enums 382
printing to screen 383
writing colored text to screen 381
writing to screen with VGA-compatible text mode 375–377
.keys() method 245
.keys_mut() variant 245
key-value stores 222–223
actionkv 222–223
key-value model 222
kill command 398–399
L
lambda functions 9, 199, 329
language items 380
Last In, First Out (LIFO) 188
let keyword 91
letters variable 16
lexical scopes 35
libactionkv::ActionKV 228
BTreeMap
deciding between 245–246
retrieving values from 244–245
HashMap
deciding between 245–246
retrieving values from 244–245
initializing ActionKV struct 228–230
libc::SIG_IGN 407
libc::signal() 404, 407
libc::timeval 308
libc library
non-Windows clock code 307–308
setting the time 306–308
type naming conventions 306–307
lifetime 110–112
lifetime elision 57
LIFO (Last In, First Out) 188
linear memory 363
link_name attribute 411
lists 63–67
arrays 64–65
slices 65
vectors 66–67
little endian format 143
LLVM 411–412
llvm.eh.sjlj.setjmp 411
llvm-tools-preview component 367
llvm-tools-preview toolchain component 368
load() 236
long int 298
longjmp 408–409, 412, 414, 417
loop keyword 48, 80, 281
loops
break keyword
breaking from nested loops 49
overview 48–49
continue keyword 47
FledgeOS 377–379
interacting with CPU directly 377–378
source code 378–379
for loop
anonymous loops 46
index variable 46–47
overview 45–46
loop keyword 48
while loop
endless looping 48
overview 47
low byte 161
low-level programming 2
low nibble 161
M
MAC addresses 277–281
macros 36
main.rs file 283
mantissa 144, 148–150
map() method 351–352
map_err() method 272, 274–276
match keyword 51–52, 281
mem::transmute 157
memory
pointers 178–187
pointer ecosystem 185–186
raw pointers 183–185
smart pointer building blocks 186–187
providing programs with 187–201
dynamic memory allocation 194–201
virtual memory 202–211
having processes scan their own memory 203–205
reading from and writing to process memory 211
scanning address spaces 208–210
translating virtual addresses to physical addresses 205–207
memory fragmentation 206
memory management unit (MMU) 203, 206
message ID 263
messages.push() 120
Message struct 263
MessageType 264
message type 263
<meta> HTML tag 254
mkdir <project> 34
MMU (memory management unit) 203, 206
mobile applications 25
mock CubeSat ground station
lifetime issue 110–112
mock_rand() 158
most significant bit 143
most significant byte 143
move keyword 330, 340
move semantics 113, 153
multicast mode 279
Mutex 354
N
NaiveTime 298
name mangling 373
namespaces 363
NAN (Not a Number) values 148
NativeEndian type 232
n_bits 149
networking
error handling 268–277
inability to return multiple error types 269–271
unwrap() and expect() 277
wrapping downstream errors 272–276
generating HTTP GET requests with reqwest 254–256
implementing state machines with enums 281–282
MAC addresses 277–281
overview 252–254
raw HTTP 283–292
TCP 260–268
converting hostnames to IP addresses 261–268
port numbers 261
raw 282
defined 256
function of 256
virtual networking devices 282–283
Network Time Protocol. SeeNTP (Network Time Protocol)
newtype pattern 81
nibbles 161
nightly toolchain 367
nnn variable 161
non-blocking I/O 362
None variant 177
nonlocal control transfer 408
noop() function 406
No Rust 2.0 27
Not a Number (NAN) values 148
Notify opcodes 264
nth() method 219
converting between time representations that use different precisions and epochs 318–319
sending requests and interpreting responses 314–316
NTPResult 316
null pointer 177
num::complex::Complex type 44
numbers 36–45
comparing
complex numbers 43–45
integers
base 2, base 8, and base 16 notation 37–38
rational numbers 43–45
O
offset() method 376–377, 389
Ok state 92
one_at_bit_i 149
OpCode enum 264
opcodes
interpreting 161–163
reading from memory 165
open() method 87, 92, 219
–open cargo doc 105
Operation enum 344
operator overloading 36
Option<&V> 245
Option<T> type 177
Option type 52, 250, 263
-O rustc 141
ownership 115
lifetime issue 110–112
overview 115
resolving issues with 118–133
using fewer long-lived values 123–126
wrapping data within specialty types 131–133
shifting 115–117
P
[package.metadata.bootimage] 371
page fault 202
pages, memory 202, 206
page table 202
panic handling 385–387
core::fmt::Write trait
implementing 386–387
PanicInfo struct 375
parallelism 328
parallel iterators 352–353
.par_bytes() method 353
.par_iter() method 351, 353
parity_bit() function 235
parity checking 235
parse::<f32>() annotation 10
parse::<Ipv6Addr>() 271
parse() function 10, 351, 358
.parse() method 10, 345
PartialEq trait 99, 152–153
Particle struct 195
<path> tag 346
PathBuf value 220
Path trait 220–222
Path value 220–221
pause variable 338
PIC (Programmable Interrupt Controller) 395
PID (process ID) 398
pointers 178–187
pointer ecosystem 185–186
raw pointers 183–185
smart pointer building blocks 186–187
Pointers type 178
polymorphism 256
pop() 336
portability 221
port numbers 261
position_in_memory 164–165, 167, 173
predicates 47
prelude 353
print() method 386
println! 10, 36–37, 98–99, 139, 153, 250
processes 361, 363
process ID (PID) 398
process_record() function 231
process_vm_readv() 211
process_vm_writev() 211
program counter 165
Programmable Interrupt Controller (PIC) 395
programs 361
promotion 39
push() method 360
Q
Q7 154
-q cargo 11
QEMU 366–367
Q format 152
quantizing the model 152
queries 263
Query opcodes 264
Query struct 263
R
radix 144
rand::random() 401
rand::seq::SliceRandom trait 257
random bytes, generating random probabilities from 157–158
rational numbers 43–45
raw pointers 183–185
Raw pointers type 178
Rc<RefCell<T» 132–133, 185
Rc<T> 131–133, 185
Rc<T>. Rc<T> 131
RDTSC instruction 296
read(f, buffer) method 84
read function 78
.read_opcode() method 165
ReadProcessMemory() 211
Read trait 98–99, 219
real memory 202
real-time clock 294, 296
Receiver 354
Receiver<i32> 356
Receiver<T> 356
.recv() method 120, 354
recv(rx) → 356
refactoring 128
RefCell<T> 185
reference counting 18, 91, 131
reference operator 53
References type 178
registers 164
register_signal_handler() function 403
register_signal_handlers() function 402
regular expressions, adding support for 68–69
release build 11
.remove() method 245
render-hex
running 342
generating SVGs 346
input parsing 344
repeat expression 64
report() function 79
ReportingAllocator struct 195
repr attribute 382
request::get(url) method 292
request/response mode 314
reqwest::get() 255
reqwest library, generating HTTP GET requests with 254–256
resource-constrained environments 24–25
resource record type 263
response 314
response.text() method 255
response variable 255
Result 35, 40, 94, 228, 255, 272
Result<File, String> function 92
Result return type 92–94
Result<T, E> 269
Result type 268, 313
ret() method 170
RETURN_HERE mutable static 413
RFC 3339 301
RPC 2822 301
run() method 160
run_command 371
Rust
“Hello, world!” 5–8
advocating for at work 3–4
command-line arguments 70–72
compiling single files with rustc 33
deployments 23–26
command-line utilities 23–24
data processing 24
desktop applications 25
extending applications 24
mobile applications 25
resource-constrained environments 24–25
server-side applications 25
systems programming 26
web browsers 26
downloading source code 8
downsides of 20–21
compile times 20–21
cyclic data structures 20
hype 21
size of language 21
strictness 21
features of 11–12, 19–20
community 26
concurrency 20
memory efficiency 20
performance 19–20
flow control 45–52
break keyword 48–49
conditional branching 49–51
continue keyword 47
for loop 45–47
loop keyword 48
match keyword 51–52
while loop 47–48
functions 52, 56–60
explicit lifetime annotations 56–58
generic functions 58–60
goals of
control 18–19
productivity 16–18
safety 12–16
grep-lite 60–63
lists 63–67
arrays 64–65
slices 65
vectors 66–67
numbers 36–45
base 2, base 8, and base 16 notation 37–38
complex numbers 43–45
integers 36–38
rational 43–45
reading
from stdin 74
references 53–54
syntax
defining variables and calling functions 35–36
overview 34–36
technology leaders and startups that use 2–3
terminology 26–27
text processing 8–11
third-party code 67–70
adding support for regular expressions 68–69
generating the third-party crate documentation locally 69–70
managing toolchains with rustup 70
TLS security case studies 21–23
goto fail 22–23
Heartbleed 21–22
rustc 33, 141, 412
rustc compiler, compiling single files with 33
rustc <file> command 33
rustdoc tool, rendering docs for single source file 104
rust-src component 367
rust-strip 367
rustup default stable command 367
rustup doc 70
rustup install nightly 414
rustup target list 369
rustup tool, managing toolchains with 70
S
-s argument to resolve 262
sat_id 111
save scum 362
segmentation fault 203–204
select! macro 356
self.messages collection 126
semantic versioning 27
send() method 120, 354
Sender 354
Sender<i32> 356
Sender<T> 356
serialization 249
Serialize trait 214
server-side applications 25
set() type 300
SetConsoleCtrlHandler handler function 417
set_extension() method 221
setjmp 408–409, 412, 417
setjmp/longjmp 411
SetSystemTime() 313
settimeofday function 306–308, 313
shared ownership 185
shared variables 338–340
SHUT_DOWN value 401
SIGCONT signal 397, 399–400, 417
SIG_DFL 407
SIGHUP signal 399
SIGINT signal 396, 399
SIGKILL signal 396, 398, 400, 407
applying techniques to platforms without signals 417
defined 391–393
handling 395–400
default behavior 395–396
listing all signals supported by OS 399–400
suspending and resuming program operation 397–399
with custom actions 400–405
interrupts vs. 391–393
sjlj project 409
casting pointers to another type 412–413
compiling 413–414
setting up intrinsics 409–412
sign bit, isolating 146
significand 144
signs 144
SIGQUIT signal 400
SIGSTOP signal 397–398, 400, 407, 417
SIGTERM signal 396, 399
SIGTSTP signal 400
SIGUSR1 405
SIGUSR2 405
Sized 188
sjlj project 409
casting pointers to another type 412–413
compiling 413–414
setting up intrinsics 409–412
slices, making lists with 65
smart pointers 185–187
software interrupts 391, 395
Some(T) variant 177
specialty types, wrapping data within 131–133
spin_loop_hint() instruction 338
src/main.rs 54
SSLVerifySignedServerKeyExchange function 22
stack 18
stack frames 188
_start() function 374, 377, 383
static binaries 24
static dispatch 256
static keyword 401
static methods 44, 84
static mut 88, 401
static values 405
static variable 405
Status opcodes 264
std::arc::Weak type 187
std::cell::RefCell type 187
std::cell::UnsafeCell type 187
std::clone::Clone 128–129
std::cmp::PartialEq 38
std::cmp::PartialOrd 38
std::collections::BTreeMap 246
std::collections::HashMap 224, 246
std::convert::From 153, 174, 270, 272, 276, 318
std::convert::TryFrom 154, 174
std::convert::TryInto 40
std::env::args 219, 301
std::error::Error 274
std::error:Error 255, 292
std::ffi::OsStr 221
std::ffi::OSString 62
std::ffi::OsString 221
std::fmt::Binary 139
std::fmt::Debug 139
std::fs::File type 219
std::fs::OpenOptions 220
std::fs::Path 220–222
std::fs::PathBuf 221
std::io::Error 271–272
std::io::Error::last_os_error() 313
std::io::ErrorKind::UnexpectedEof type 230
std::io::File 232
std::io::prelude 217
std::io::Read 217, 232
std::io::Write 232
std::io trait 217
std::iter::Iterator 353, 364
std::marker::Copy 129
std::marker::Copy. Copy 128
std::mem::drop 192
std::mem::transmute() function 139
std::net::AddrParseError 271
std::net::TcpStream 260
std::ops::Add 59
std::ops::Fn 341, 364
std::ops::FnMut 341
std::ops::FnOnce 340
std::os:raw module 182
std::path::Path 62, 220
std::path::PathBuf 220
std::path::PathBuf type 250
std::path::Path string 221
std::path::Path type 250
std::prelude module 40
std::rc::Rc<T> 129
std::rc::Weak type 185, 187
std::String string 221
std::sync::Arc 354
std::sync::atomic::spin_loop_hint() 338
std::sync::mpsc module 354
std::sync::Mutex 354
std::thread::spawn() 330
std::thread::yield_now() 338
std:rc::Rc. std:rc::Rc wrapper type 131
stdin, reading from 74
steady clock 297
steps variable 352
String 61, 81–82, 118, 183, 189–190, 215, 255
String::from() 81
struct blocks 84
structs
modeling files with 80–83
str value 61, 229
suseconds_t 307
SVGs, generating 346
swapping 202
switch keyword 51
synchronous interrupts 391–392
system clock 296
systems programming 2, 26
SYSTEMTIME 308–309
system time 294
T
target_arch attribute 227
target_endian attribute 227
target_env attribute 227
target_family attribute 227
target_has_atomic attribute 227
target_os attribute 227
target platform 369
target_pointer_width attribute 227
target_vendor attribute 228
task queues, implementing 358–360
tasks 361
task virtualization 360–363
containers 363
context switches 362
processes 363
reasons for using operating systems 363
threads 362
WebAssembly 363
TCP (Transmission Control Protocol) 260–268
converting hostnames to IP addresses 261–268
port numbers 261
raw 282
TcpStream::connect() 261
TcpStream type 232
Terminated 403
test attribute 228
text output 381–383
enums
controlling in-memory representation of 382
reasons for using 382
printing to screen 383
writing colored text to screen 381
text processing 8–11
thetime_t 307
Thing type 257
third-party code 67–70
adding support for regular expressions 68–69
generating the third-party crate documentation locally 69–70
managing toolchains with rustup 70
thread::yield_now() method 338
thread pools 353–360
channels 356
implementing task queues 358–360
one-way communication 354–356
closures 330–331
effect of spawning many threads 333
effect of spawning some threads 331–332
reproducing results 335–338
shared variables 338–340
spawning a thread per logical task 351–353
functional programming style 351–352
parallel iterators 352–353
spawning threads 331
task virtualization 362
thread::yield_now() method 338
time and keeping
definitions 296–297
encoding time 297–298
error handling 313
formatting time 301
full command-line interface 301–303
refactoring clock code to support a wider architecture 300
overview 294–295
representing time zones 298
converting between time representations that use different precisions and epochs 318–319
sending requests and interpreting responses 314–316
setting time 305–310
common behavior 306
for operating systems that use libc 306–308
full code listing 310
sources of time 296
teaching apps to tell time 298–299
timestamp 301
time_t 298
TimeVal 306
timeval 306
time zones 298
TLS (Transport Layer Security) 21–23, 254
goto fail 22–23
Heartbleed 21–22
to_bytes() method 387
todo!() 300
toolchains 70
trait keyword 98
defined 256
function of 256
traits 98–102
Error trait 274
From trait 276
Path trait 220–222
Read trait 98–99
Write trait
implementing 386–387
translation lookaside buffer 206
Transmission Control Protocol. SeeTCP
Transport Layer Security. SeeTLS
traps 391
tree command 6
tree map 242
try! macro 270
turtle variable 345
Type annotations 9
type classes 40
type erasure 272
type keyword 81
type safety 110
U
[u8] type 62, 222, 232, 356
u8 type 38, 80, 382
u16 type 38–39
u32 type 38, 139, 146
UDP (User Datagram Protocol) 262
unbounded queues 354
unicast 279
unikernel 363
unimplemented!() macro 300
unit type 79
UNIX timestamp 301
unsafe() method 40
unsafe blocks 115, 139, 184, 204, 294, 306, 401, 410, 413, 417
unsafe keyword 88, 139, 417
unsigned long int 298
unwinding 379
.unwrap() method 94, 292
unwrap() method 40, 92, 219, 264, 277
UPDATE case 95
update <key> <value> 224
Update opcodes 264
UpstreamError enum 275
use crate:: 364
–use-standard timestamp flag 299
usize integers 413
usize type 38, 65, 165, 177, 185, 406
usize value 404–405
U type 153
V
values
using fewer long-lived 123–126
.values() method 245
.values_mut() variant 245
variable bindings 35
variables
defining 35–36
global variables
using to indicate that shutdown has been initiated 402–405
shared variables 338–340
Vec::new() 81
Vec<Cereal> 13
Vec<Command> 345–346, 360
Vec<Message> 119
Vec<Message> message store 125
Vec<Operation> 345
Vec<Result> 354
Vec<String> 301
Vec<T> 190, 243, 256, 351–352, 373
Vec<T> fields 263
Vec<T> vector 66
Vec<Task> 354
vectors 63–64, 66–67
Vec<u8> type 62, 80, 267
Vec<Vec<(usize, String)» 66–67
version flag 367
virtual addresses 204
virtual memory 202–211
having processes scan their own memory 203–205
reading from and writing to process memory 211
scanning address spaces 208–210
translating virtual addresses to physical addresses 205–207
void function pointer 404
V type 245
W
Wasm (WebAssembly) 363
web browsers 26
while loop 173, 336
endless looping 48
overview 47
window.draw_2d() 199
API integer types 308
clock code 309
representing time in 308
words 202
WORD type 308
World struct 195
wrapping data within specialty types 131–133
WriteProcessMemory() 211
write_str() 386
Write trait
implementing 386–387
write_volatile() method 376
Z
zero-cost abstractions 27, 98
ZST (zero-sized type) 300, 326