Index
A
abs method
abs_quartic_root function
Add trait
age method
args standard library function
Arithmetic operation
adding integer number
breaking literal strings
example
floating-point
statements
as_bytes function
Assignment semantics
B
Bare-metal systems
bool type
Borrow checker
Borrowing/lifetimes
checking validity
C language
Copy trait
example
function
invoked functions
mutable borrow
object lifetimes
program
references
rust compiler
specifiers
use after change, alias errors
use after drop errors
Box
Boxing/unboxing
BtreeSet
bytes function
C
Capturing the environment
C vs. C++
chars function
clone standard function
clone trait
Closures
cmp function
definition
descending order sorting
Rust
sort_by function
statements
syntax
use directive
Communication channel
Composite data types
const keyword
contains variable
continue keyword
Controlling execution flow
conditional expressions
conditional loops
conditional statement
counting loops
infinite loops
variables scopes
Copy trait
Copy semantics
count function
count_lines function
create_s function
D
Data encapsulation
dot notation
functional notation
method declarations
mod/pub keyword
self keyword
type keyword
Data implementation
location of bytes
primitive types
representation
sizes
size of objects
use directive
Data sequences
arrays
copying arrays/vectors
debug print
empty arrays/vectors
multidimensional array
mutable array
objects
panicking
rust compiler
size, array
vectors
Decimal notation/base-ten notation
delete operator
Deterministic destruction
explicit
rust
stack allocation
stack/heap
Disposable functions
Dot notation
double function
draw_text function
draw_text(greeting) statement
Draw trait
dyn keyword
Dynamic environment
E
elapsed method
else keyword
empty function
enumerate function
Enumeration
cases
code
data
if-let/while-let constructs
match construct
match expressions
match with numbers
patterns, match statement
relational operator
type
variant
“enum” keyword
exp exponential method
Explicit deallocation mechanism
exponentiate function
F
filter function
“fmod” function
for keyword
free function
From standard library
From trait
func function
Function
change variable, caller
code
defining/invoking
exit
mutability, references
passing arguments by reference
passing arguments by value
passing arguments to function
references
returning value
return several values
shadowing other functions
G
Garbage collection
Generic functions
arrays/vectors
definition
enums
need
Option<T> Standard Enum
parametric types
Result<T, E> Standard Enum
structs
uses
utility functions
Genericity mechanics
compiling
concrete type
consequences
generic parameters
Rust code
source code
swap function
get_name function
get_third function
greeting variable
H
HashSet
HasSquareRoot trait
Heap allocation
Heap management
Heap object
Heterogeneous data structures
lexical conventions
structs
tuples
tuple-structs
I, J, K
if keyword
impl and self keywords
IndexMut module
IndexMut trait
Infinite loops
Input/output and error handling
command line
console
converting string to value
converting value to string
environment variables
file input/output
processing text files
reading from console
return code
runtime
insert/remove functions
insert library function
into function
into_iter function
is_not_visible method
iter function
Iterators
adapter
all iterator consumer
chains
collect consumer
consumer
count iterator consumer
enumerator iterator adapter
generating references
generators
for loops
loops
map iterator adapter
min/max consumer
with mutation
print statements
scanning string
string characters
sun consumer
vectors/arrays/slices
without mutation
iter_mut function
L
len function
length method
Lexical lifetime
Lexicographical
Lifetime elision
Lifetime specifiers
elision
mutable reference
object-oriented programming, elision
struct
structs declarations
tuple-structs/enums
line function
Linear addressing
Literal string
M
main function
“match” keyword
Memory allocation
min function
mod keyword
move C++ standard function
Move semantics
multiply functions
Multiprogramming systems
mut keyword
N
naming function
Naming objects
associating names to values
boolean expressions
boolean values
compound assignment operators
mutable variables
not mutated mutable variables
standard library
type consistency, assignments
type inference
type/mutability
underscore
uninitialized variables
Noncloneable objects
Number generic type
O
Object-oriented programming
destructors
dynamic dispatch
fallible type converters
implementation, dynamic dispatch references
infallible type converters
inheritance
operator overloading
static dispatch
static vs. dynamic dispatch
open function
Ownership
computer programming
rust language
P
parse function
Pass-by-pointer
Pass-by-reference argument passing mechanism
Primitive types
array/vector types
booleans/characters
constants
empty tuple
explicit conversion
exponential notation
expression
floating-point numeric types
nondecimal/numeric bases
numeric types
signed integers
target-dependent integer number types
type-inference
type suffixes, numeric literals
underscore, numeric literals
unsigned integer number types
Priority queue
Protected mode/kernel mode systems
pub keyword
push and pop functions
Q
quartic_root function
R
Ranges
for loop
for statement syntax
read_line function
read_to_string function
Real-memory systems
ref_to_first variable
_ref_to_n variable
Register allocation
return keyword
Rust
Rust compiler
Rust language
comments
Hello, world!
literal strings
print macro
print integer number
print several lines of text
Rust standard library
Rust toolset
S
s.chars() expression
set_personal_names functions
set_var function
size_of_val function
size_of_val generic function
Slices
argument
drawback
inclusive ranges
min function
mutable
open-ended ranges
out of range
program
static strings
syntax
types
Smart pointer
sort function
sq_root method
sqrt function
sqrt standard library method
Standard library collections
arbitrary insertions/removals
binary heaps
C++/rust
linked lists
measuring execution time
objects
ordered/unordered dictionaries
ordered/unordered sets
queues
vectors
Static allocation
characteristic
code
and deallocation
f1 function
functions, invoked
limitations
machine code
main function
operations
stack pointer
threads
variables/addresses
Static lifetime specifier
std::fmt::Debug standard library trait
std::fmt::Display standard library trait
stdout standard library function
String::new and File::open functions
Strings
concatenating
converting static to dynamic strings
dynamic
implementation
static
struct keyword
T
to_string function
Traits
adding methods, external types
associated types
C++ compiler
definition
display/debug
generic function, no parameter
generic functions
generic parameters, with multiple bounds
HasSquareRoot trait
inheritance
iterator standard
methods
quartic root
real-world software
rust
sqrt
TryInto and the TryFrom traits
Type inference
U
Uncertainty variant
unwrap function
V
VecDeque
Vector allocation
adding items
buffer
cap variable
capacity
efficiency
filling
object structures
push function
Vec:with_capacity
v object
Virtual-memory systems
Virtual table pointer
W, X, Y, Z
while keyword
write_all function
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.