liveBookmanning.com

What you will learn in Learn Rust in a Month of Lunches

by Dave MacLeod

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• closureA closure is an anonymous Rust function-like value that can capture variables from its surrounding environment and be passed as an argument.
• iteratorAn iterator is a Rust value implementing the Iterator trait that produces a sequence of items, typically through repeated calls to next.
• RustRust is a compiled systems programming language emphasizing memory safety, performance, and explicit control over low-level data representation.
• referenceReferencing is the operation of creating a Rust reference with the & operator.
• ownershipOwnership is Rust's rule-based model in which each value has a responsible binding that controls the value's lifetime and access.
• macroA Rust macro generates or transforms source code during compilation.
• attributeA struct field is a named or positional component of a Rust struct whose visibility can be declared independently of the struct type.
• async/awaitasync is a Rust language construct for defining computations that produce futures and can suspend while awaiting asynchronous results.
• stringA string is a programming-language value representing an ordered sequence of characters or character units as text.
• slicingA slice is a dynamically sized borrowed view of a contiguous sequence of values.
• println! macroThe println! macro formats its arguments and writes the resulting text followed by a newline to standard output.
• lifetimeA variable lifetime is the interval during which a variable binding is valid and accessible.
• genericsA generic function is a Rust function parameterized by one or more type parameters and usable with multiple concrete types.
• testA test function is a Rust function executed by the test framework to check program behavior and normally takes no arguments.
• data transformationmap is an iterator adaptor that applies a transformation to each item and returns a new iterator producing the transformed items.
• mutable referenceA mutable reference is a Rust reference that permits modification of its referent and must be the sole active reference to that referent.
• arrayAn array is a fixed-size Rust collection whose length is known at compile time and whose elements have one type.
• FnFn is a Rust trait for closures and callable values that can be called repeatedly through shared access without consuming or mutating their captured environment.
• integerAn integer is a whole-number numeric value without a fractional part.
• FnMutFnMut is a Rust callable trait for closures and function-like values that can be invoked through mutable access and may mutate their captured environment.
• char(n)Rust's char type represents one Unicode scalar value and occupies four bytes.
• CargoCargo is Rust's package manager and build tool for creating, configuring, compiling, running, and managing Rust projects and their dependencies.
• pointer-sized integerA pointer-sized integer is a Rust signed or unsigned integer whose width matches the computer architecture.
• indexingIndexing selects elements in an ordered collection by their numeric positions.
• HTTP GETHTTP GET is a request method for retrieving a resource or representation from a server.
• cargo runcargo run is a Cargo subcommand that builds and runs a Rust binary target while resolving its dependencies.
• traitA Rust trait is an abstract interface that defines capabilities or behavior a type can provide.
• command-line argumentA command-line argument is a value supplied to a program when it is launched through a command-line interface.
• primitive data typeA primitive type is a built-in Rust type representing a basic value such as a number or Boolean.
• BoxBox is Rust's owning smart pointer that stores a value on the heap while keeping a fixed-size pointer on the stack.
• FnOnceFnOnce is a Rust callable trait for closures and function-like values that may consume their captured environment and therefore can be called at most once.
• question mark operatorThe question mark operator is Rust syntax that propagates an error from a Result or absence from an Option.
• binary representationBinary representation expresses values using a base-two numeral system and corresponding bit patterns.
• moveMove semantics is the behavior in which transferring a non-Copy value transfers its ownership and prevents use of the original binding.
• chronochrono is a Rust date-and-time library providing temporal types, arithmetic, formatting, and time-zone support.
• unsafe RustUnsafe Rust is the part of Rust that permits operations whose memory-safety conditions cannot be fully verified by the compiler and therefore require programmer responsibility.
• unsigned integerAn unsigned integer type represents nonnegative whole numbers without a sign.
• as operatorThe as operator performs explicit primitive-type conversions in Rust.
• bitA bit is a binary digit representing one of two possible values in digital computation.
• data conversionType casting explicitly converts a value from one Rust type to another compatible type.
• macro repetitionMacro repetition is declarative macro syntax for matching or expanding zero or more or one or more repeated token sequences with optional separators.
• bytesA byte is a fixed-size unit of digital information consisting of eight bits in conventional modern systems.
• UnicodeUnicode is a character encoding standard that assigns code points to characters across writing systems and symbols.
• collectcollect is a Rust iterator method that gathers produced items into a collection or another type inferred or specified by the program.
• test-driven developmentTest-driven development is a software development technique in which tests are written before implementation code and guide the implementation toward passing behavior.
• derive macroA derive attribute is a Rust attribute that requests automatic implementation of specified traits for a type.
• enumAn enum is a Rust user-defined type whose values are one of a fixed set of named variants, optionally carrying associated data.
• impl blockAn impl block is Rust syntax that defines methods or trait implementations associated with a type.
• structA struct is a composite data type or structure that groups related fields or values into a single unit.
• panicA panic is Rust's unrecoverable failure behavior that stops ordinary execution and reports diagnostic information.
• crateAn external crate is a Rust compilation unit published outside the current project for other programs to depend on.
• Copy traitA copy type is a Rust type whose values can be duplicated implicitly by copying their bits rather than transferring ownership.
• futureA Future is a Rust abstraction representing an asynchronous computation whose result may become available later and which can be polled for readiness.
• builder patternThe builder pattern is a construction pattern that uses a separate configurable object to assemble and validate the parameters needed to create another type.
• trait boundA trait bound is a Rust constraint requiring a type to implement one or more specified traits before it can be used in a bounded context.
• compilerA compiler is a program that translates source code into an executable or another lower-level representation while checking it against the language's rules.
• methodA method is a function associated with a type that is invoked through an instance or type and may receive the instance through self, &self, or &mut self.
• DefaultDefault is the Rust standard trait that defines how to construct a default value for a type.
• DerefDeref is the Rust standard trait that defines immutable dereferencing and enables automatic dereference coercions for method and field access.
• anyAny is a Rust standard-library trait for values that can support runtime type inspection and downcasting when they satisfy the required lifetime conditions.
• patternPattern is a Rust string-matching trait implemented by supported search patterns such as string slices, characters, and closures.
• Okok is a Rust Result method that converts an Ok value to Some and an Err value to None, discarding the error.
• DisplayDisplay printing formats a Rust value using its user-facing Display formatting behavior.
• pollpoll is the operation by which an asynchronous runtime advances a future toward completion and obtains its current state or output.
• into_iterinto_iter is a Rust method that converts a collection or other iterable value into an iterator, with item ownership determined by the receiver.
• iterator methoditer is a Rust collection method that returns an iterator yielding immutable references to the collection's items.
• result typeResult is a Rust enum type representing either a successful value or an error from an operation that may fail.
• cargo.tomlCargo.toml is the manifest file that declares a Rust package's metadata and dependencies, including external crates and their versions.
• keyA key is a value used to identify and look up an associated value in a map collection.
• optionAn option type is a type that explicitly represents either a value of a specified type or the absence of a value.
• tupleA tuple is a fixed-size Rust composite value whose elements may have different types and are accessed by position.
• dbg! macroThe dbg! macro evaluates an expression, prints its source and value for debugging, and returns the value.
• referenceAn immutable reference is a Rust reference through which the referent cannot be modified and which can coexist with other immutable references.
• cargo checkcargo check is a Cargo command that analyzes a Rust package for compilation errors without producing a runnable executable.
• loopA for loop is Rust iteration syntax that repeatedly executes a block for each item produced by an iterable value.
• nextnext is the iterator method that advances iteration and returns an Option containing the next item or indicating that iteration has ended.
• bindingA variable is a named program binding that refers to a value and may permit reassignment according to its declaration.
• MapA map is an associative data structure that stores key-value pairs and supports retrieving values by key.
• downcast_refdowncast_ref is a method on an Error trait object that attempts to obtain a shared reference to the value as a specified concrete error type.
• blanket implementationA blanket implementation is an implementation of a trait for every type satisfying specified bounds or implementing another trait.
• unit typeA unit type is a type with exactly one value, commonly written (), that represents the absence of meaningful information or a meaningful result.
• assert_eqassert_eq! is a Rust macro that panics when two expressions evaluate to unequal values and reports both values.
• intervalAn interval is a connected set or span of values between specified lower and upper endpoints, with endpoint inclusion determined by its definition.
• associated typeAn associated type is a type declaration attached to a Rust trait whose concrete value is specified for each implementation.
• iter_mutiter_mut is a Rust collection method that returns an iterator yielding mutable references to the collection's items.
• RcRc is Rust's reference-counting smart pointer type for shared ownership of data while tracking the number of active owning references.
• documentationDocumentation is explanatory material that describes how code works and how it can be used.
• const genericsConst generics are Rust generics that parameterize types or implementations with compile-time constant values.
• const qualifierA const qualifier is a language feature that restricts modification or reassignment of a value or binding according to the language’s rules.
• cargo buildcargo build is a Cargo command that compiles a Rust program into an executable artifact.
• monomorphizationMonomorphization generates a separate concrete function or type implementation for each concrete type used with generic code.
• mpscA channel is a communication abstraction with one or more sending endpoints and one receiving endpoint for transferring information between parts of a program.
• feature flagA feature flag is a configuration option that conditionally enables code, dependencies, or capabilities during compilation.
• InstantInstant is a Rust standard-library type representing a monotonic point on a system's elapsed-time clock, typically measured from system boot.
• panic hookA panic hook is a globally registered callback invoked when a Rust panic occurs before the runtime performs its panic strategy.
• TryFromTryFrom is a Rust trait for fallible conversion between types that may fail for some input values.
• DerefMutDerefMut is a Rust standard trait that defines mutable dereferencing behavior for a type and requires the type to implement Deref.
• lifetime annotationA lifetime annotation is Rust syntax that names relationships among the lifetimes of references and values in a type or function signature.
• todo!todo! is a Rust standard-library macro that marks unfinished code and panics if the marked code is executed.
• type signatureA function signature is the declaration-level specification of a function's parameters and return type, including the corresponding specification for a method.
• BTreeMapBTreeMap is Rust's ordered map collection that associates keys with values and iterates them in key order.
• functionA function is a named unit of executable code that can accept inputs and produce a result.
• int32An int32 is a signed integer type represented using exactly 32 bits.
• conditional compilationA conditional compilation attribute instructs the Rust compiler to include or exclude an item according to a configuration condition.
• printPrinting is the operation of writing textual or formatted data to an output stream.
• commentA comment is source text that the compiler ignores as program instructions and that can contain explanatory or documentation text.
• smart pointerA smart pointer is a pointer-like data structure that manages an owned or referenced value and provides behavior beyond raw address storage.
• semicolonA semicolon is Rust syntax that terminates an expression statement and changes the value behavior of a block expression.
• guardA match guard is an additional Boolean condition attached to a Rust match arm after its pattern matches.
• format! macroThe format! macro constructs a formatted String instead of writing formatted output.
• expression fragment specifierAn expression fragment specifier matches a Rust expression as macro input.
• fragment specifierA fragment specifier is a macro pattern annotation that declares what syntactic category of token input a metavariable can match.
• identifier fragment specifierAn identifier fragment specifier matches a Rust identifier such as a variable or function name as macro input.
• declarative macromacro_rules! is Rust syntax for defining declarative macros by matching token sequences and expanding them into source code.
• tokenA token is a lexical unit of source input, such as a number, identifier, punctuation mark, or other syntactic element.
• token-tree fragment specifierA token-tree fragment specifier matches a token tree, allowing a broad range of syntactic input in a macro pattern.
• ErrorError is the Rust standard trait that classifies error types and supports human-readable descriptions and error-source relationships.
• moduleA module is a distinct, bounded software unit that groups related code or functionality and provides an organizational or interaction boundary within a larger system.
• static lifetimeThe static lifetime is a Rust lifetime that lasts for the entire duration of the program.
• randrand is a Rust crate that provides random-number generation facilities and related randomization utilities.
• PanicInfoPanicInfo is a Rust structure containing contextual information about a panic, including its location and payload.
• set_hookset_hook is a Rust standard-library function that installs a global panic hook.
• std::panicstd::panic is the Rust standard-library module that provides panic hooks and related panic-handling facilities.
• reqwest::ClientA reqwest Client is an HTTP client handle that executes requests and manages client-side request configuration and resources.
• impl Traitimpl Trait is Rust syntax for specifying an opaque type constrained by one or more traits, with the concrete type selected by the compiler or function implementation.
• blockA code block is a delimited sequence of Rust statements and expressions that forms a lexical scope and produces a value.
• if letif let is Rust conditional pattern-matching syntax that executes a block when a value matches a specified pattern and otherwise continues without executing that block.
• escape sequenceAn escape sequence is a character sequence in a string literal that represents a special character or encoding instruction.
• formattingFormatting is the arrangement or transformation of content, data, or code according to specified structural, stylistic, or presentation conventions.
• ownership transferOwnership transfer is the movement of a value's controlling ownership from one binding or function to another.
• Unicode escapeA Unicode escape is a string-literal notation that represents a Unicode character using a hexadecimal code point.
• threadA thread is an independently scheduled execution path within a program that can run concurrently with other threads.
• From traitThe From trait defines conversion of one Rust type into another specified type.
• PartialOrdPartialOrd is the Rust trait that provides partial ordering and comparison operations for values.
• destructuring assignmentDestructuring is Rust syntax that binds the components of a composite value to separate variables through a matching pattern.
• public visibilityVisibility is the Rust access-control property that determines whether an item or field can be referenced from a given module or crate.
• environment variableAn environment variable is a named operating-system or process setting represented as a string key and string value.
• reqwestreqwest is a Rust library for making HTTP requests, including through asynchronous clients.
• downcastingDowncasting is the attempted conversion of a dynamically typed or trait-object value back to a specific concrete type.
• trait objectA trait object is a dynamically typed Rust value represented through a trait interface, allowing the concrete implementing type to be hidden.
• pattern matchingPattern matching is the process of comparing a value against structural patterns and handling the matching case.
• durationA duration is an amount or span of time, expressed as an interval or in temporal units.
• std::timestd::time is the Rust standard-library module containing basic types and functions for measuring elapsed time and system-clock time.
• SystemTimeSystemTime is a Rust standard-library type representing measurements from the system clock for interaction with external entities such as files and processes.
• Unix epochThe Unix epoch is the reference instant at 00:00:00 UTC on January 1, 1970, from which Unix time is measured.
• add traitThe Rust Add trait defines how a type participates in addition with another value.
• blank identifierA blank identifier is a language-defined name or symbol that receives or matches a value without binding it to a usable variable.
• allow attributeAn allow attribute suppresses compiler diagnostics for specified lint conditions.
• deprecationThe deprecated attribute marks a Rust item as discouraged for use and causes the compiler to issue a warning when it is used.
• inner attributeAn inner attribute is a Rust attribute written with #! that applies to the contents of its enclosing file or module.
• no_std programThe no_std attribute prevents a Rust program from linking the standard library by default.
• non_exhaustive attributeThe non_exhaustive attribute marks a Rust type as potentially gaining additional fields or enum variants in future versions.
• outer attributeAn outer attribute is a Rust attribute written with # that applies to the item immediately following it.
• senderSender is a Rust standard-library channel handle that transmits values to a corresponding receiver.
• ParseIntErrorParseIntError is the Rust standard-library error type returned when text cannot be parsed as an integer.
• DebugDebug is the Rust trait for producing programmer-oriented representations of values.
• CrosstermCrossterm is a Rust cross-platform terminal I/O library for handling events such as keyboard input, mouse input, and terminal resizing.
• const fnA const fn is a Rust function eligible for evaluation at compile time when called in a compile-time context.
• JoinHandleJoinHandle is a Rust standard-library handle representing a spawned thread and allowing the program to wait for that thread to finish.
• filter_mapfilter_map is a Rust iterator adaptor that applies a function to each item and yields the values from results that are Some, discarding None results.
• read_to_stringread_to_string is a filesystem operation that reads a file's contents into a String during program execution.
• vectorA vector is Rust's growable, heap-allocated sequence type whose elements share a type.
• allAn all operation returns a Boolean indicating whether every item in a collection satisfies a condition, or is truthy when no condition is specified.
• AxumAxum is a Rust web framework for building HTTP services with routing, request extraction, and asynchronous handlers.
• shadowingShadowing is the Rust language feature that creates a new variable with the same name as an existing variable, hiding the earlier binding within the current scope.
• infinite iteratorAn infinite iterator is an iterator that has no end and can continue producing items indefinitely.
• ArcArc is Rust's atomically reference-counted smart pointer for sharing ownership of a value safely across threads.
• stack traceA backtrace is a record of the call stack showing the sequence of function calls leading to a program point or failure.
• filteringFiltering is the iterator operation of retaining only items that satisfy a condition.
• runtime logic errorA logic bug is a defect in a program's intended behavior that does not necessarily prevent the code from running.
• static fieldA Rust program item representing a value stored at a fixed memory location for the entire program lifetime.
• dotted notationDot notation is Rust syntax that accesses a tuple element or object member by placing a period before its selector.
• OnceCellOnceCell is a type that permits a value to be initialized once and subsequently accessed without repeated initialization.
• macro recursionMacro recursion is a macro-expansion technique in which a macro invokes itself to process or handle additional input.
• token treeA token tree is a syntactic token or delimited group of tokens that can be matched and repeated by a Rust macro.
• cargo doccargo doc is the Cargo command-line tool that generates documentation for Rust packages and their dependencies, with --open optionally opening the generated documentation.
• spawnspawn is a Rust standard-library function that starts a new thread to execute a supplied closure and returns a handle for that thread.
• unwrapunwrap is a Rust method that extracts a contained success or present value and panics when the value represents failure or absence.
• rayonRayon is a Rust library for data-parallel programming that automatically distributes iterator-based work across threads.
• thiserrorthiserror is a Rust library crate that provides derive macros for defining custom error types with standard error-trait implementations.
• Compiler ExplorerGodbolt is an online compiler-explorer service that displays compiler-generated assembly for source code under selectable compiler and optimization settings.
• select macroThe select! macro concurrently polls multiple futures and executes the branch corresponding to the first future that completes.
• clientReceiver is a Rust standard-library channel handle that obtains values transmitted by corresponding senders.
• for_eachfor_each is a Rust iterator method that applies a closure to every item and produces no meaningful result.
• CowCow is a Rust standard-library clone-on-write enum that can represent either borrowed data or owned data and create an owned copy when necessary.
• compile timeCompile time is the phase before program execution in which source code is analyzed and transformed into executable code.
• lazy_staticlazy_static is a Rust crate that provides statics initialized on first runtime access when compile-time constant initialization is insufficient.
• once_cellonce_cell is a Rust crate that provides lazily initialized single-assignment and mutable cell abstractions for values that cannot be initialized as compile-time constants.
• concrete typeA concrete type is a specific Rust type rather than an abstract type parameter or trait description.
• unsafe blockAn unsafe block is a Rust code block that permits operations requiring the programmer to uphold safety invariants that the compiler cannot verify.
• assertionA software assertion is an executable check of an expected condition or property that signals failure when the check does not hold.
• assert_neassert_ne! is a Rust macro that panics when two values are equal.
• expectexpect is a Rust method that extracts the value from an Option or Result and panics with a supplied message when the value represents absence or failure.
• unwrap_orunwrap_or is a Rust method that returns an Option or Result value when present or successful and otherwise returns a specified fallback value without panicking.
• scoped threadA scoped thread is a thread whose lifetime is bounded by a lexical scope, allowing it to borrow non-'static data and requiring it to finish before the scope ends.
• serverA server is a program that listens for client requests and provides responses over a network.
• cargo addcargo add is a Cargo command that adds an external crate dependency to a package manifest.
• deadlockA deadlock is a state in which threads or operations wait indefinitely for access held by one another.
• join!join! is an asynchronous macro that concurrently drives multiple futures and completes when all of them complete.
• pollingPolling is the process of repeatedly checking asynchronous computations for progress or completion.
• try_join macroThe try_join! macro concurrently joins futures and returns an error as soon as one of them fails.
• anyhowanyhow is a Rust library for simplifying error handling by representing diverse failure causes through a single dynamically composed error type.
• static mutA static mut is a Rust static value that can be directly modified, but accessing it requires unsafe code because unsynchronized access can violate aliasing rules or cause data races.
• associated constantAn associated constant is a constant value defined within a Rust type or trait and accessed through that type or trait.
• ok_orok_or is a Rust Option method that converts Some to Ok and None to Err using a supplied error value.
• ok_or_elseok_or_else is a Rust Option method that converts Some to Ok and computes the Err value lazily for None with a closure.
• atomicityAn atomic operation is an indivisible computer operation that appears to other threads as either fully completed or not performed.
• entry pointThe main function is the entry-point function that Rust starts when running an executable program.
• return typeA return type is the type of value that a function produces when it completes.
• dynamically sized typeA dynamically sized type is a type whose size is not known at compile time and may vary between values.
• OpenOptionsOpenOptions is a Rust standard-library builder type for configuring how a filesystem file is opened or created.
• lockingMutual exclusion is a concurrency property that allows at most one thread to access a protected resource at a time.
• diverging codeDiverging code is Rust code whose execution does not continue to the following statement because it exits the current control-flow path.
• let elselet else is Rust binding syntax that requires a pattern match to succeed and requires the alternative branch to diverge when it fails.
• anonymous lifetimeAn anonymous lifetime is Rust's inferred lifetime notation, written as `'_'`, for a reference whose specific lifetime name does not need to be written.
• refcellRefCell is a Rust standard-library container that enforces borrowing rules at run time and permits mutation through an immutable access path.
• async runtimeAn async runtime is software that schedules asynchronous tasks, drives Future polling, and determines when suspended computations are polled again.
• TokioTokio is a Rust asynchronous runtime and library for scheduling tasks, polling futures, and performing asynchronous I/O.
• undefined behaviorUndefined behavior is program execution whose effects are not constrained by the language specification because a required safety invariant has been violated.
• heapThe heap is a region of memory used for dynamically allocated data whose size or lifetime is not limited to a call frame.
• stackThe stack is a memory region that stores values with a known size and releases them in last-in, first-out order as execution leaves scopes or functions.
• terminal user interfaceA terminal user interface is an interactive text-based interface rendered in a terminal rather than a graphical window.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.