The contents of this page are informational.
B.1:1 For ABI, see Application Binary Interface.
B.2. ABI clobber¶
An ABI clobber is an argument to macro
indicates that the values of selected registers might be
overwritten during the execution of an assembly code block.
B.3. ABI kind¶
B.3:1 The ABI kind indicates the ABI of a construct.
B.4:1 Abort is the immediate termination of a program.
B.5. abstract data type¶
B.5:1 An abstract data type is a collection of other types.
B.6. active attribute¶
B.6:1 An active attribute is an attribute that is removed from the item it decorates.
B.7. addition assignment¶
B.7:1 For addition assignment, see addition assignment expression.
B.8. addition assignment expression¶
B.8:1 An addition assignment expression is a compound assignment expression that uses addition.
B.9. addition expression¶
B.9:1 An addition expression is an arithmetic expression that uses addition.
B.10. adjusted call operand¶
B.10:1 An adjusted call operand is a call operand with possible auto dereferencing adjustments.
B.11:1 The alignment of a value specifies which addresses are valid for storing the value.
B.12. all configuration predicate¶
B.12:1 An all configuration predicate is a configuration predicate that models existential quantifier ALL.
B.13. anonymous block expression¶
B.13:1 An anonymous block expression is a block expression without a label.
B.14. anonymous loop expression¶
B.14:1 An anonymous loop expression is a loop expression without a label.
B.15. anonymous return type¶
B.15:1 An anonymous return type is an impl trait type ascribed to a function return type.
B.16. anonymous type parameter¶
B.16:1 An anonymous type parameter is an impl trait type ascribed to a function parameter.
B.17. any configuration predicate¶
B.17:1 An any configuration predicate is a configuration predicate that models existential quantifier ANY.
B.18. Application Binary Interface¶
B.18:1 Application Binary Interface is a set of conventions that dictate how data and computation cross language boundaries.
B.19. argument operand¶
B.19:1 An argument operand is an operand which is used as an argument in a call expression or a method call expression.
B.20. arithmetic expression¶
B.20:1 An arithmetic expression is an expression that computes a value from two operands using arithmetic.
B.21. arithmetic operator¶
B.21:1 An arithmetic operator is the operator of an arithmetic expression.
B.22. arithmetic overflow¶
B.22:1 An arithmetic overflow occurs if an arithmetic expression or a negation expression computes a value of a scalar type that lies outside of the range of valid values for the scalar type.
B.23:1 An arity is the number of tuple fields in a tuple type.
B.24:1 An array is a value of an array type.
B.25. array element constructor¶
B.25:1 An array element constructor is an array expression that lists all elements of the array being constructed.
B.26. array expression¶
B.26:1 An array expression is an expression that constructs an array.
B.27. array repetition constructor¶
B.27:1 An array repetition constructor is an array expression that specifies how many times an element is repeated in the array being constructed.
B.28. array type¶
B.28:1 An array type is a sequence type that represents a fixed sequence of elements.
B.29. assembly code block¶
B.29:1 An assembly code block is a sequence of assembly instructions.
B.30. assembly directive¶
B.30:1 An assembly directive is a request to the assembler to perform a particular action or change a setting.
B.31. assembly instruction¶
B.31:1 An assembly instruction is a string literal that represents a low-level assembly operation or an assembly directive.
B.32. assembly option¶
B.32:1 An assembly option is used to specify a characteristic of or a restriction on the related assembly code block.
B.33. assigned operand¶
B.33:1 An assigned operand is the target operand of a compound assignment expression.
B.34. assignee expression¶
B.34:1 An assignee expression is an expression that appears as the left operand of an assignment expression.
B.35. assignee operand¶
B.35:1 An assignee operand is the target operand of an assignment expression.
B.36:1 See assignment expression.
B.37. assignment expression¶
B.37:1 An assignment expression is an expression that assigns the value of a value operand to an assignee operand.
B.38. associated constant¶
B.38:1 An associated constant is a constant that appears as an associated item.
B.39. associated function¶
B.39:1 An associated function is a function that appears as an associated item.
B.40. associated implementation constant¶
B.40:1 An associated implementation constant is an associated constant that appears within an implementation.
B.41. associated implementation function¶
B.41:1 An associated implementation function is an associated function that appears within an implementation.
B.42. associated implementation type¶
B.42:1 An associated implementation type is an associated type that appears within an implementation.
B.43. associated item¶
B.43:1 An associated item is an item that appears within an implementation or a trait.
B.44. associated trait constant¶
B.44:1 An associated trait constant is an associated constant that appears within a trait.
B.45. associated trait function¶
B.45:1 An associated trait function is an associated function that appears within a trait.
B.46. associated trait type¶
B.46:1 An associated trait type is an associated type that appears within a trait.
B.47. associated type¶
B.47:1 An associated type is a type alias that appears as an associated item.
B.48. associated type projection¶
An associated type projection is a qualified type path of the form
<type as trait>::associated_type, where
type is a type,
is a qualifying trait, and
associated type is an associated type.
B.49:1 Associativity is the order by which operands are evaluated within a single expression.
B.50. async block¶
B.50:1 For async block, see async block expression.
B.51. async block expression¶
An async block expression is a block expression that is specified
async and encapsulates behavior which is executed in
an asynchronous manner.
B.52. async control flow boundary¶
B.52:1 An async control flow boundary is a control flow boundary that additionally allows the suspension of execution via await expressions.
B.53. async function¶
An async function is a function subject to keyword
B.54:1 See atomic type.
B.55. atomic type¶
An atomic type is a type defined in module
B.56:1 An attribute is a general, free-form metadatum that is interpreted based on its name, convention, language, and tool.
B.57. attribute content¶
B.57:1 An attribute content is a construct that provides the content of an attribute.
B.58. attribute macro¶
B.58:1 An attribute macro is a procedural macro that consumes two streams of tokens to produce a stream of tokens, and defines a new outer attribute that can be attached to items.
B.59. auto trait¶
B.59:1 An auto trait is a trait that is implicitly and automatically implemented by a type when the types of its constituent fields implement the trait.
B.60. await expression¶
B.60:1 An await expression is an expression that polls a future, suspending the execution of the future until the future is ready.
B.61. base initializer¶
B.61:1 A base initializer is a construct that specifies an enum value, a struct value, or a union value to be used as a base for construction in a struct expression.
B.62. basic assignment¶
B.62:1 A basic assignment is an assignment expression that is not a destructuring assignment.
B.63. binary crate¶
B.63:1 A binary crate is a crate that contains a main function.
B.64. binary literal¶
B.64:1 A binary literal is an integer literal in base 2.
B.65. binary operator¶
B.65:1 A binary operator is an operator that operates on two operands.
B.66:1 A binding of a binding pattern binds a matched value to a name.
B.67. binding argument¶
B.67:1 A binding argument is a generic argument that supplies the type of an associated trait type.
B.68. binding mode¶
B.68:1 Binding mode is the mechanism by which a matched value is bound to a binding of a pattern.
B.69. binding pattern¶
B.69:1 A binding pattern is either an identifier pattern or a shorthand deconstructor.
B.70. binding scope¶
B.71. bit and assignment¶
B.71:1 For bit and assignment, see bit and assignment expression.
B.72. bit and assignment expression¶
B.72:1 A bit and assignment expression is a compound assignment expression that uses bit and arithmetic.
B.73. bit and expression¶
B.73:1 A bit and expression is a bit expression that uses bit and arithmetic.
B.74. bit expression¶
B.74:1 A bit expression is an expression that computes a value from two operands using bit arithmetic.
B.75. bit or assignment¶
B.75:1 For bit or assignment, see bit or assignment expression.
B.76. bit or assignment expression¶
B.76:1 A bit or assignment expression is a compound assignment expression that uses bit or arithmetic.
B.77. bit or expression¶
B.77:1 A bit or expression is a bit expression that uses bit or arithmetic.
B.78. bit xor assignment¶
B.78:1 For bit xor assignment, see bit xor assignment expression.
B.79. bit xor assignment expression¶
B.79:1 A bit xor assignment expression is a compound assignment expression that uses bit exclusive or arithmetic.
B.80. bit xor expression¶
B.80:1 A bit xor expression is a bit expression that uses bit exclusive or arithmetic.
B.81. block comment¶
B.81:1 A block comment is a comment that spans one or more lines.
B.82. block expression¶
B.82:1 A block expression is an expression that sequences expressions and statements.
bool is a type whose values denote the truth values of logic
and Boolean algebra.
B.84. boolean literal¶
B.84:1 A boolean literal is a literal that denotes the truth values of logic and Boolean algebra.
B.86. borrow expression¶
B.86:1 A borrow expression is an expression that borrows the value of its operand and creates a reference to the memory location of its operand.
B.87:1 A memory location is borrowed when it acts as the operand of a borrow expression. This explanation is not good enough.
B.88:1 Borrowing is the process of temporarily associating a reference with a value without transferring ownership permanently.
B.89:1 A bound imposes a constraint on a generic parameter by limiting the set of possible generic substitutions.
B.90. bound pattern¶
B.90:1 A bound pattern is a pattern that imposes a constraint on a related identifier pattern.
B.91. break expression¶
B.91:1 A break expression is an expression that terminates a loop expression or a named block expression.
B.92. break type¶
B.92:1 Break type is the type of the operand of a break expression.
B.93. break value¶
B.93:1 Break value is the value of the operand of a break expression.
B.94. built-in attribute¶
B.94:1 A built-in attribute is a language-defined attribute.
B.95. built-in trait¶
B.95:1 A built-in trait is a language-defined trait.
B.96. byte literal¶
B.96:1 A byte literal is a literal that denotes a fixed byte value.
B.97. byte string literal¶
A byte string literal is a literal that consists of multiple
B.98:1 C is the programming language described in the ISO/IEC 9899:2018 International Standard.
B.99. C representation¶
B.99:1 C representation is a type representation that lays out types such that they are interoperable with the C language.
B.100. Call conformance¶
B.100:1 Call conformance measures the compatibility between a set of argument operands and a set if function parameters or fields.
B.101. call expression¶
B.101:1 A call expression is an expression that invokes a function or constructs a tuple struct value or tuple enum variant value.
B.102. call operand¶
B.102:1 A call operand is the function being invoked or the tuple struct value or tuple enum variant value being constructed by a call expression.
B.103. call site hygiene¶
Call site hygiene is a type of hygiene which resolves to the
MacroInvocation site. Identifiers with call site hygiene can
reference the environment of the
MacroRulesDeclaration, can reference the
environment of the
MacroInvocation, and are considered unhygienic.
B.104. callee type¶
A callee type is either a function item type, a
function pointer type, a tuple struct type, a tuple enum variant
or a type that implements any of the
B.105. capture mode¶
B.105:1 Capture mode is the mechanism by which a capture target is captured.
B.106. capture target¶
B.106:1 A capture target is either a binding or a field of a binding.
B.107:1 Capturing is the process of saving the capture targets of a capturing expression's capturing environment.
B.108. capturing environment¶
B.108:1 The capturing environment of a capturing expression consists of all capture targets that are defined outside the capturing expression.
B.109. capturing expression¶
B.109:1 A capturing expression is either an async block expression or a closure expression.
B.110:1 Cast or casting is the process of changing the type of an expression.
char is a type whose values denote Unicode characters.
B.112. character literal¶
B.112:1 A character literal is a literal that denotes a fixed Unicode character.
B.113. closure body¶
B.113:1 A closure body is a construct that represents the executable portion of a closure expression.
B.114. closure expression¶
B.114:1 A closure expression is an expression that defines a closure type and constructs a value of that type.
B.115. closure parameter¶
B.115:1 A closure parameter is a construct that yields a set of bindings that bind matched input values to names at the site of a call expression or a method call expression.
B.116. closure type¶
B.116:1 A closure type is a unique anonymous function type that encapsulates all capture targets of a closure expression.
B.117. code point¶
B.117:1 In Unicode, a code point is a numeric value that maps to a character.
B.118:1 A comment is a lexical element that acts as an annotation or an explanation in program text.
B.119. comparison expression¶
B.119:1 A comparison expression is an expression that compares the values of two operands.
B.120. compilation root¶
B.120:1 A compilation root is an input to a compilation performed by a tool.
B.121. compound assignment¶
B.121:1 For compound assignment, see compound assignment expression.
B.122. compound assignment expression¶
B.122:1 A compound assignment expression is an expression that first computes a value from two operands and then assigns the value to an assigned operand.
B.123. concrete type¶
B.123:1 A concrete type is a type described by a type specification.
B.124. conditional compilation¶
B.124:1 Conditional compilation is the process of compiling conditionally-compiled source code.
B.125. conditionally-compiled source code¶
B.125:1 Conditionally-compiled source code is source code that may or may not be considered a part of a Rust program depending on certain conditions.
B.126. configuration predicate¶
A configuration predicate is a construct that evaluates statically
false, and controls conditional compilation.
B.127:1 A constant is an immutable value whose uses are substituted by the value.
B.128. constant argument¶
B.128:1 A constant argument is a generic argument that supplies the value of a constant parameter.
B.129. constant context¶
B.129:1 A constant context is a construct that requires a constant expression.
B.130. constant expression¶
B.130:1 A constant expression is an expression that can be evaluated statically.
B.131. constant function¶
A constant function is a function subject to keyword
B.132. constant initializer¶
B.132:1 A constant initializer is a construct that provides the value of its related constant.
B.133. constant parameter¶
B.133:1 A constant parameter is a generic parameter for a constant.
B.134. constant parameter initializer¶
B.134:1 A constant parameter initializer is a construct that provides the default :t:`value of its related constant parameter.
B.135. constant promotion¶
B.135:1 Constant promotion is the process of converting a value expression into a constant.
B.136:1 A generic parameter is said to constrain an implementation if it makes the implementation's applicability more narrow.
B.137:1 A construct is a piece of program text that is an instance of a syntactic category.
B.138:1 A constructee indicates the enum variant, struct or union whose value is being constructed by a struct expression.
B.139. container operand¶
B.139:1 A container operand is an operand that indicates the value whose field is selected in a field access expression.
B.140. continue expression¶
B.140:1 A continue expression is an expression that first terminates and then restarts a loop expression.
B.141. control flow boundary¶
B.141:1 A control flow boundary is a construct that limits control flow from returning beyond the construct, and acts as the target of control flow returning operations.
B.142. copy type¶
A copy type is a type that implements the
B.143:1 A crate is a unit of compilation and linking that contains a tree of nested modules.
B.144. crate import¶
B.144:1 A crate import specifies a dependency on an external crate.
B.145. crate indication¶
B.145:1 A crate indication is a construct that indicates a crate.
B.146. crate public modifier¶
B.146:1 A crate public modifier is a visibility modifier that grants a name public visibility within the current crate only.
B.147. crate root¶
B.147:1 A crate root is an entry point into a crate.
B.148. crate root module¶
B.148:1 A crate root module is the root of the nested module tree of a crate.
A value of an indirection type is dangling if it is either
null or not all of the bytes at the referred memory location are part of
the same allocation.
B.150. data race¶
B.150:1 A data race is a scenario where two or more threads access a shared memory location concurrently.
B.151. decimal literal¶
B.151:1 A decimal literal is an integer literal in base 10.
B.152:1 A declaration is a construct that introduces a name for an entity.
B.153. declarative macro¶
B.153:1 A declarative macro is a macro that associates a name with a set of syntactic transformation rules.
B.154:1 A deconstructee indicates the enum variant or type that is being deconstructed by a struct pattern.
B.155. default representation¶
B.155:1 Default representation is a type representation that does not make any guarantees about layout.
B.156. definition site hygiene¶
Definition site hygiene is a type of hygiene which resolves to the
MacroRulesDeclaration site. Identifiers with
definition site hygiene cannot reference the environment of the
MacroRulesDeclaration, cannot be referenced by the environment of a
MacroInvocation, and are considered hygienic.
B.157:1 A dereference is the memory location produced by evaluating a dereference expression.
B.158. dereference expression¶
B.158:1 A dereference expression is an expression that obtains the pointed-to memory location of its operand.
B.159. dereference type¶
A dereference type is either a reference type or a type that
B.160. dereference type chain¶
B.160:1 A dereference type chain is a sequence of dereference types.
B.161. derive macro¶
A derive macro is a procedural macro that consumes a stream of
tokens and produces a stream of tokens, and is invoked via attribute
B.162:1 Destruction is the process of recovering resources associated with a value as it goes out of scope.
B.163:1 A destructor is a function that is invoked immediately before the destruction of a value of a drop type.
B.164. destructuring assignment¶
B.164:1 A destructuring assignment is an assignment expression where the assignee operand is either an array expression, a struct expression, or a tuple expression.
B.165. direction modifier¶
B.165:1 A direction modifier is a construct that indicates whether a register argument initializes a register, assigns the value of a register to an expression, or both.
B.166:1 A discriminant is an opaque integer that identifies an enum variant.
B.167. discriminant initializer¶
B.167:1 A discriminant initializer provides the value of a discriminant.
B.168. discriminant type¶
B.168:1 A discriminant type is the type of a discriminant.
B.169. diverging expression¶
B.169:1 A diverging expression is an expression whose evaluation causes program flow to diverge from the normal evaluation order.
B.170. diverging type variable¶
B.170:1 A diverging type variable is a type variable that can refer to any type and originates from a diverging expression.
B.171. division assignment¶
B.171:1 For division assignment, see division assignment expression.
B.172. division assignment expression¶
B.172:1 A division assignment expression is a compound assignment expression that uses division.
B.173. division expression¶
B.173:1 A division expression is an arithmetic expression that uses division.
B.174. doc comment¶
B.174:1 A doc comment is a comment class that includes inner block docs, inner line docs, outer block docs, and outer line docs.
B.175. drop construct¶
B.175:1 A drop construct is a construct that employs a drop scope.
B.176. drop order¶
B.176:1 Drop order is the order by which values are dropped when a drop scope is left.
B.177. drop scope¶
B.177:1 A drop scope is a region of program text that governs the dropping of values.
B.178. drop scope extension¶
B.178:1 Drop scope extension is the process of extending a drop scope associated with a temporary to prevent the premature dropping of the temporary.
B.179. drop type¶
A drop type is a type that implements the
trait or contains a field that has a destructor.
B.180:1 Dropping a value is the act of invoking the destructor of the related type.
B.181. dynamically sized type¶
A dynamically sized type is a type that does not implement the
B.182:1 Elaboration is the process by which a declaration achieves its runtime effects.
B.183. element type¶
B.183:1 An element type is the type of the elements of an array type or a slice type.
B.184:1 For elided, see elided lifetime.
B.185. elided lifetime¶
B.185:1 An elided lifetime is either an unnamed lifetime or a lifetime that has been explicitly omitted from a function signature or an implementation.
B.186. else expression¶
B.186:1 An else expression is an expression that represents either a block expression, an if expression, or an if let expression.
B.187. empty statement¶
B.187:1 An empty statement is a statement expressed as character 0x3B (semicolon).
B.188:1 An entity is a construct that can be referred to within program text, usually via a field access expression or a path.
B.190. enum field¶
B.190:1 An enum field is a field of an enum variant.
B.191. enum type¶
B.191:1 An enum type is an abstract data type that contains enum variants.
B.192. enum value¶
B.193. enum variant¶
B.193:1 An enum variant is a construct that declares one of the possible variations of an enum.
B.194. enum variant value¶
B.194:1 An enum variant value is the enum value of the corresponding enum of the enum variant.
B.195. equals expression¶
B.195:1 An equals expression is a comparison expression that tests equality.
B.196. error propagation expression¶
B.196:1 An error propagation expression is an expression that either evaluates to a value of its operand or returns a value to the next control flow boundary.
B.197. escaped character¶
An escaped character is the textual representation for a character with
special meaning. An escaped character consists of character 0x5C (reverse
solidus), followed by the single character encoding of the special meaning
character. For example,
\t is the escaped character for 0x09 (horizontal
B.198:1 See evaluation.
B.199:1 Evaluation is the process by which an expression achieves its runtime effects.
B.200:1 See execution.
B.201:1 Execution is the process by which a statement achieves its runtime effects.
B.202. explicit register argument¶
B.202:1 An explicit register argument is a register argument that uses an explicit register name.
B.203. explicit register name¶
B.203:1 An explicit register name is a target-specific string that identifies a register.
B.204. explicitly declared entity¶
B.204:1 An explicitly declared entity is an entity that has a declaration.
B.205. exported function¶
B.205:1 An exported function is an export of a function.
B.206. exported static¶
B.206:1 An exported static is an export of a static.
B.207:1 An expression is a construct that produces a value, and may have side effects at run-time.
B.208. expression statement¶
B.208:1 An expression statement is an expression whose result is ignored.
B.209:1 An expression-with-block is an expression whose structure involves a block expression.
B.210:1 An expression-without-block is an expression whose structure does not involve a block expression.
B.211. external block¶
B.211:1 An external block is a construct that provides the declarations of foreign functions as unchecked imports.
B.212. external function¶
B.212:1 An external function is an unchecked import of a foreign function.
B.213. external function item type¶
B.213:1 An external function item type is a function item type where the related function is an external function.
B.214. external static¶
B.214:1 An external static is an import of a foreign variable.
f32 is a floating-point type equivalent to the IEEE 754-2008
f64 is a floating-point type equivalent to the IEEE 754-2008
B.217. fat pointer¶
B.217:1 A fat pointer is a value of a fat pointer type.
B.218. fat pointer type¶
B.218:1 A fat pointer type is an indirection type that refers to a dynamically sized type.
B.219:1 For FFI, see Foreign Function Interface.
B.220:1 A field is an element of an abstract data type.
B.221. field access expression¶
B.221:1 A field access expression is an expression that accesses a field of a value.
B.222. field index¶
B.222:1 A field index is the position of a field within a tuple struct type or tuple enum variant. The first field has a field index of zero, the Nth field has a field index of N-1.
B.223. field list¶
A field list is a
B.224. field resolution¶
B.224:1 Field resolution is a form of resolution that applies to a field access expression.
B.225. field selector¶
B.225:1 A field selector is a construct that selects the field to be accessed in a field access expression.
B.226. final match arm¶
B.226:1 A final match arm is the last match arm of a match expression.
B.227. fixed sized type¶
A fixed sized type is a type that implements the
B.228. float literal¶
B.228:1 A float literal is a numeric literal that denotes a fractional number.
B.229. float suffix¶
B.229:1 A float suffix is a component of a float literal that specifies an explicit floating-point type.
B.230. floating-point type¶
B.230:1 A floating-point type is a numeric type whose values denote fractional numbers.
B.231. floating-point type variable¶
B.231:1 A floating-point type variable is a type variable that can refer only to floating-point types.
B.232. floating-point value¶
B.232:1 A floating-point value is a value of a floating-point type.
B.233. for loop¶
B.233:1 For for loop, see for loop expression.
B.234. for loop expression¶
B.234:1 A for loop expression is a loop expression that continues to evaluate its loop body as long as its subject expression yields a value.
B.235. Foreign Function Interface¶
B.235:1 Foreign Function Interface employs ABI, attributes, external block, external functions, linkage, and type layout to interface a Rust program with foreign code.
B.236. fragment specifier¶
B.236:1 A fragment specifier is a construct that indicates the type of a metavariable.
B.237. full range expression¶
B.237:1 A full range expression is a range expression that covers the full range of a type.
B.238:1 A function is a value of a function type that models a behavior.
B.239. function body¶
B.239:1 A function body is the block expression of a function.
B.240. function item type¶
B.240:1 A function item type is a unique anonymous function type that identifies a function.
B.241. function lifetime elision¶
Function lifetime elision is a form of lifetime elision that applies
to functions, function pointer type parameters and paths
resolving to one of the
B.242. function parameter¶
B.242:1 A function parameter is a construct that yields a set of bindings that bind matched input values to names at the site of a call expression or a method call expression.
B.243. function pointer type¶
B.243:1 A function pointer type is an indirection type that refers to a function.
B.244. function pointer type parameter¶
B.244:1 A function pointer type parameter is a function parameter of a function pointer type.
B.245. function qualifier¶
B.245:1 A function qualifier is a construct that determines the role of a function.
B.246. function signature¶
B.246:1 A function signature is a unique identification of a function that encompasses of its function qualifiers, name, generic parameters, function parameters, return type, and where clause.
B.247. function type¶
B.247:1 A function type is either a closure type or a function item type.
B.248. function-like macro¶
B.248:1 A function-like macro is a procedural macro that consumes a stream of tokens and produces a stream of tokens, and is invoked directly.
B.249:1 A trait or type is fundamental when its implementation coherence rules are relaxed and the trait or type is always treated as if it was a local trait or a local type.
A future represents a value of a type that implements the
core::future::Future trait which may not have finished computing
B.251. future operand¶
B.251:1 A future operand is an operand whose future is being awaited by an await expression.
B.252. generic argument¶
B.252:1 A generic argument supplies a static input for an associated trait type or a generic parameter.
B.253. generic associated type¶
B.253:1 A generic associated type is an associated type with generic parameters.
B.254. generic conformance¶
B.254:1 Generic conformance measures the compatibility between a set of generic parameters and a set of generic arguments.
B.255. generic enum¶
B.255:1 A generic enum is an enum with generic parameters.
B.256. generic function¶
B.256:1 A generic function is a function with generic parameters.
B.257. generic implementation¶
B.257:1 A generic implementation is an implementation with generic parameters.
B.258. generic parameter¶
B.258:1 A generic parameter is a placeholder for a constant, a lifetime, or a type whose value is supplied statically by a generic argument.
B.259. generic parameter scope¶
B.259:1 A generic parameter scope is a scope for generic parameters.
B.260. generic struct¶
B.260:1 A generic struct is a struct with generic parameters.
B.261. generic substitution¶
B.261:1 A generic substitution is the replacement of a generic parameter with a generic argument.
B.262. generic trait¶
B.262:1 A generic trait is a trait with generic parameters.
B.263. generic type¶
B.263:1 A generic type is a type with a generic parameter.
B.264. generic type alias¶
B.264:1 A generic type alias is a type alias with generic parameters.
B.265. generic union¶
B.265:1 A generic union is a union with generic parameters.
B.266. glob import¶
B.266:1 A glob import is a use import that brings all names with public visibility prefixed by its path prefix into scope.
B.267. global path¶
A global path is a path that starts with namespace qualifier
B.268. global type variable¶
B.268:1 A global type variable is a type variable that can refer to any type.
B.269. greater-than expression¶
B.269:1 A greater-than expression is a comparison expression that tests for a greater-than relationship.
B.270. greater-than-or-equals expression¶
B.270:1 A greater-than-or-equals expression is a comparison expression that tests for a greater-than-or-equals relationship.
B.271. half-open range pattern¶
B.271:1 A half-open range pattern is a range pattern with only a range pattern low bound.
B.272. hexadecimal literal¶
B.272:1 A hexadecimal literal is an integer literal in base 16.
B.273. higher-ranked trait bound¶
B.273:1 A higher-ranked trait bound is a bound that specifies an infinite list of bounds for all possible lifetimes.
B.274:1 Hygiene is a property of macros and identifiers` that appear within them, which aims to eliminate the syntactic interference between a macro and its environment.
B.275:1 An identifier is hygienic when it has definition site hygiene.
i8 is a signed integer type whose values range from - (27) to 27 - 1, all inclusive.
i16 is a signed integer type whose values range from - (215) to 215 - 1, all inclusive.
i32 is a signed integer type whose values range from - (231) to 231 - 1, all inclusive.
i64 is a signed integer type whose values range from - (263) to 263 - 1, all inclusive.
i128 is a signed integer type whose values range from - (2127) to 2127 - 1, all inclusive.
B.281:1 An identifier is a lexical element that refers to a name.
B.282. identifier pattern¶
B.282:1 An identifier pattern is a pattern that binds the value it matches to a binding.
B.283. if expression¶
B.283:1 An if expression is an expression that evaluates either a block expression or an else expression depending on the value of its subject expression.
B.284. if let expression¶
B.284:1 An if let expression is an expression that evaluates either a block expression or an else expression depending on whether its pattern can be matched against its subject let expression.
B.285:1 A value is immutable when it cannot be modified.
B.286. immutable borrow¶
B.286:1 An immutable borrow is an immutable reference produced by borrowing.
B.287. immutable borrow expression¶
An immutable borrow expression is a borrow expression that lacks
B.288. immutable place expression¶
B.288:1 An immutable place expression is a place expression whose memory location cannot be modified.
B.289. immutable place expression context¶
B.289:1 An immutable place expression context is a place expression context whose memory location cannot be modified.
B.290. immutable raw pointer type¶
An immutable raw pointer type is a raw pointer type subject to
B.291. immutable reference¶
B.291:1 An immutable reference is a value of a shared reference type, and prevents the mutation of its referent.
B.292. immutable static¶
B.292:1 An immutable static is a static whose value cannot be modified.
B.293. immutable variable¶
B.293:1 An immutable variable is a variable whose value cannot be modified.
B.294. impl header lifetime elision¶
B.294:1 Impl header lifetime elision is a form of lifetime elision that applies to the implementing type and implemented trait (if any) of an implementation.
B.295. impl trait type¶
B.295:1 An impl trait type is a type that implements a trait, where the type is known at compile time.
B.296:1 An implementation is an item that supplements an implementing type by extending its functionality.
B.297. implementation body¶
B.297:1 An implementation body is a construct that encapsulates the associated items, inner attributes, and inner doc comments of an implementation.
B.298. implementation coherence¶
B.298:1 A trait implementation exhibits implementation coherence when it is valid and does not overlap with another trait implementation.
B.299. implementation conformance¶
B.299:1 Implementation conformance measures the compatibility between a trait implementation and the implemented trait.
B.300. implemented trait¶
B.300:1 An implemented trait is a trait whose functionality has been implemented by an implementing type.
B.301. implementing type¶
B.301:1 An implementing type is the type that the associated items of an implementation are associated with.
B.302. implicit borrow¶
B.302:1 An implicit borrow is a borrow that is not present syntactically in program text.
B.303. implicitly declared entity¶
B.303:1 An implicitly declared entity is an entity that lacks an explicit declaration.
B.304. implied bound¶
B.304:1 An implied bound is a bound that is not expressed in syntax, but is is the byproduct of relations between lifetime parameters and function parameters, between lifetime parameters and a return type, and between lifetime parameters and fields.
B.305. in scope¶
B.305:1 A name is in scope when it can be referred to.
B.306. inclusive range pattern¶
B.306:1 An inclusive range pattern is a range pattern with both a range pattern low bound and a range pattern high bound.
B.307. incomplete associated constant¶
B.307:1 An incomplete associated constant is an associated constant without a constant initializer.
B.308. incomplete associated function¶
B.308:1 An incomplete associated function is an associated function without a function body.
B.309. incomplete associated type¶
B.309:1 An incomplete associated type is an associated type without an initialization type.
B.310. index expression¶
B.310:1 An index expression is an expression that indexes into a value of a type.
B.311. indexable type¶
A indexable type is a type that implements the
B.312. indexed deconstructor¶
B.312:1 An indexed deconstructor is a construct that matches the position of a tuple field.
B.313. indexed field selector¶
B.313:1 An indexed field selector is a field selector where the selected field is indicated by an index.
B.314. indexed initializer¶
B.314:1 An indexed initializer is a construct that specifies the index and initial value of a field in a struct expression.
B.315. indexed operand¶
An indexed operand is an operand which indicates the value of a
core::ops::Index being indexed into by an
B.316. indexing operand¶
B.316:1 An indexing operand is an operand which specifies the index for the indexed operand being indexed into by an index expression.
B.317. indirection type¶
B.317:1 An indirection type is a type whose values refer to memory locations.
B.318. inert attribute¶
B.318:1 An inert attribute is an attribute that remains with the item it decorates.
B.319. inferred type¶
B.319:1 An inferred type is a placeholder for a type deduced by type inference.
B.320. infinite loop¶
B.320:1 For infinite loop, see infinite loop expression.
B.321. infinite loop expression¶
B.321:1 An infinite loop expression is a loop expression that continues to evaluate its loop body indefinitely.
B.322. inherent implementation¶
B.322:1 An inherent implementation is an implementation that adds direct functionality.
B.323:1 Initialization is the act of supplying an initial value to a constant, a static, or a variable.
B.324. initialization expression¶
B.324:1 An initialization expression is either a constant initializer or a static initializer.
B.325. initialization type¶
B.325:1 An initialization type is the type a type alias defines a name for.
B.326. inline assembly¶
B.326:1 Inline assembly is hand-written assembly code that is integrated into a Rust program.
B.327. inline module¶
An inline module is a module with an
B.328. inner attribute¶
B.328:1 An inner attribute is an attribute that applies to an enclosing item.
B.329. inner block doc¶
B.329:1 An inner block doc is a block comment that applies to an enclosing non-comment construct.
B.330. inner doc comment¶
B.330:1 An inner doc comment is either an inner block doc or an inner line doc.
B.331. inner line doc¶
B.331:1 An inner line doc is a line comment that applies to an enclosing non-comment construct.
B.332. input register¶
An input register is a register whose register name is used in
a register argument subject to direction modifier
B.333. input register expression¶
B.333:1 An input register expression is an expression that provides the initial value of a register.
B.334. input-output register expression¶
B.334:1 An input-output register expression is a construct that specifies both an input register expression and an output register expression.
B.335. integer literal¶
B.335:1 An integer literal is a numeric literal that denotes a whole number.
B.336. integer suffix¶
B.336:1 An integer suffix is a component of an integer literal that specifies an explicit integer type.
B.337. integer type¶
B.337:1 An integer type is a numeric type whose values denote whole numbers.
B.338. integer type variable¶
B.338:1 An integer type variable is a type variable that can refer only to integer types.
B.339. interior mutability¶
B.339:1 Interior mutability is a property of types whose values can be modified through immutable references.
B.340. intermediate match arm¶
B.340:1 An intermediate match arm is any non-final match arm of a match expression.
B.341. irrefutable constant¶
B.341:1 An irrefutable constant is a constant of a type that has at most one value.
B.342. irrefutable pattern¶
B.342:1 An irrefutable pattern is a pattern that always matches the value it is being matched against.
isize is a signed integer type with the same number of bits as the
platform’s pointer type, and is at least 16-bits wide.
B.344:1 An item is the most basic semantic element in program text. An item defines the compile- and run-time semantics of a program.
B.345. item scope¶
B.346. item statement¶
B.346:1 An item statement is a statement that is expressed as an item.
B.347. iteration expression¶
B.347:1 An iteration expression is an expression that provides the criterion of a while loop expression.
B.348:1 A keyword is a word in program text that has special meaning.
B.349:1 A label is the name of a loop expression.
B.350. label indication¶
B.350:1 A label indication is a construct that indicates a label.
B.351. label scope¶
B.352:1 Layout specifies the alignment, size, and the relative offset of fields in a type.
B.353. lazy and expression¶
B.353:1 A lazy and expression is a lazy boolean expression that uses short circuit and arithmetic.
B.354. lazy boolean expression¶
B.354:1 A lazy boolean expression is an expression that performs short circuit Boolean arithmetic.
B.355. lazy or expression¶
B.355:1 A lazy or expression is a lazy boolean expression that uses short circuit or arithmetic.
B.356. left operand¶
B.356:1 A left operand is an operand that appears on the left-hand side of a binary operator.
B.357. less-than expression¶
B.357:1 A less-than expression is a comparison expression that tests for a less-than relationship.
B.358. less-than-or-equals expression¶
B.358:1 A less-than-or-equals expression is a comparison expression that tests for a less-than-or-equals relationship.
B.359. let initializer¶
B.359:1 A let initializer is a construct that provides the value of the bindings of the let statement using an expression, or alternatively executes a block expression.
B.360. let statement¶
B.360:1 A let statement is a statement that introduces new variables given by the bindings produced by its pattern-without-alternation that are optionally initialized to a value.
B.361. lexical element¶
B.361:1 A lexical element is the most basic syntactic element in program text.
B.362. library crate¶
A library crate is either a crate without a main function or a
crate subject to attribute
B.363:1 A lifetime specifies the expected longevity of a reference.
B.364. lifetime argument¶
B.364:1 A lifetime argument is a generic argument that supplies the value of a lifetime parameter.
B.365. lifetime bound¶
B.365:1 A lifetime bound is a bound that imposes a constraint on the lifetimes of generic parameters.
B.366. lifetime bound predicate¶
B.366:1 A lifetime bound predicate is a construct that specifies lifetime bounds on a lifetime parameter.
B.367. lifetime elision¶
B.367:1 Lifetime elision is a set of rules that automatically insert lifetime parameters and/or lifetime arguments when they are elided in the source code.
B.368. lifetime parameter¶
B.368:1 A lifetime parameter is a generic parameter for a lifetime.
B.369:1 A line is a sequence of zero or more characters followed by an end of line.
B.370. line comment¶
B.370:1 A line comment is a comment that spans exactly one line.
B.371:1 A literal is a fixed value in program text.
B.372. literal expression¶
B.372:1 A literal expression is an expression that denotes a literal.
B.373. literal pattern¶
B.373:1 A literal pattern is a pattern that matches a literal.
B.374. local trait¶
B.374:1 A local trait is a trait that is defined in the current crate.
B.375. local type¶
B.375:1 A local type is a type that is defined in the current crate.
B.376. local variable¶
B.376:1 For local variable, see variable.
B.377:1 For loop, see loop expression.
B.378. loop body¶
B.378:1 A loop body is the block expression of a loop expression.
B.379. loop expression¶
B.379:1 A loop expression is an expression that evaluates a block expression continuously as long as some criterion holds true.
B.380:1 A macro is a custom definition that extends Rust by defining callable syntactic transformations.
B.381. macro expansion¶
B.381:1 Macro expansion is the process of statically executing a macro invocation and replacing it with the produced output of the macro invocation.
B.382. macro implementation function¶
B.382:1 A macro implementation function is the function that encapsulates the syntactic transformations of a procedural macro.
B.383. macro invocation¶
B.383:1 A macro invocation is a call of a declarative macro or function-like macro that is expanded statically and replaced with the result of the macro.
B.384. macro match¶
B.384:1 A macro match is the most basic form of a satisfied macro matcher.
B.385. macro matcher¶
B.385:1 A macro matcher is a construct that describes a syntactic pattern that a macro must match.
B.386. macro matching¶
B.386:1 Macro matching is the process of performing rule matching and token matching.
B.387. macro repetition¶
B.387:1 A macro repetition is either a macro repetition in matching or a macro repetition in transcription.
B.388. macro repetition in matching¶
B.388:1 A macro repetition in matching allows for a syntactic pattern to be matched zero or multiple times during macro matching.
B.389. macro repetition in transcription¶
B.389:1 A macro repetition in transcription allows for a syntactic pattern to be transcribed zero or multiple times during macro transcription.
B.390. macro rule¶
B.390:1 A macro rule is a construct that consists of a macro matcher and a macro transcriber.
B.391. macro statement¶
B.391:1 A macro statement is a statement expressed as a terminated macro invocation.
B.392. macro transcriber¶
B.392:1 A macro transcriber is a construct that describes the replacement syntax of a macro.
B.393. macro transcription¶
B.393:1 Macro transcription is the process of producing the expansion of a declarative macro.
B.394. main function¶
B.394:1 A main function is a function that acts as an entry point into a program.
B.395. match arm¶
B.395:1 A match arm is a construct that consists of a match arm matcher and a match arm body.
B.396. match arm body¶
B.397. match arm guard¶
B.397:1 A match arm guard is a construct that provides additional filtering to a match arm matcher.
B.398. match arm matcher¶
B.398:1 A match arm matcher is a construct that consists of a pattern and a match arm guard.
B.399. match expression¶
B.399:1 A match expression is an expression that tries to match one of its multiple patterns against its subject expression and if it succeeds, evaluates an operand.
B.400:1 A metavariable is a macro match that describes a variable.
B.401. metavariable indication¶
B.401:1 A metavariable indication is a construct that indicates a metavariable.
B.402:1 A method is an associated function with a receiver.
B.403. method call expression¶
B.403:1 A method call expression is an expression that invokes a method of a variable.
B.404. method operand¶
B.404:1 A method operand is an operand that denotes the method being invoked by a method call expression.
B.405. method resolution¶
B.405:1 Method resolution is a kind of resolution that applies to a method call expression.
B.406. mixed site hygiene¶
Mixed site hygiene is a type of hygiene which resolves to the
MacroRulesDeclaration site for variables, labels, and the
$crate metavariable, and to the
MacroInvocation site otherwise,
and is considered partially hygienic.
B.407. modifying operand¶
B.407:1 A modifying operand is an operand that supplies the value that is used in the calculation of a compound assignment expression.
B.408:1 A module is a container for zero or more items.
B.409. move type¶
A move type is a type that implements the
trait and that is not a copy type.
B.410. multi segment path¶
B.410:1 A multi segment path is a path consisting of more than one path segment.
B.411. multiplication assignment¶
B.411:1 For multiplication assignment, see multiplication assignment expression.
B.412. multiplication assignment expression¶
B.412:1 A multiplication assignment expression is a compound assignment expression that uses multiplication.
B.413. multiplication expression¶
B.413:1 A multiplication expression is an arithmetic expression that uses multiplication.
B.414:1 Mutability determines whether a construct can modify a value.
B.415:1 A value is mutable when it can be modified.
B.416. mutable assignee expression¶
B.416:1 A mutable assignee expression is an assignee expression whose value can be modified.
B.417. mutable binding¶
B.417:1 A mutable binding is a binding whose value can be modified.
B.418. mutable borrow¶
B.418:1 A mutable borrow is a mutable reference produced by borrowing.
B.419. mutable borrow expression¶
A mutable borrow expression is a borrow expression that has
B.420. mutable place expression¶
B.420:1 A mutable place expression is a place expression whose memory location can be modified.
B.421. mutable place expression context¶
B.421:1 A mutable place expression context is a place expression context that may evaluate its operand as a mutable memory location.
B.422. mutable raw pointer type¶
A mutable raw pointer type is a raw pointer type subject to
B.423. mutable reference¶
B.423:1 A mutable reference is a value of a mutable reference type, and allows the mutation of its referent.
B.424. mutable reference type¶
A mutable reference type is a reference type subject to keyword
B.425. mutable static¶
B.425:1 A mutable static is a static whose value can be modified.
B.426. mutable variable¶
B.426:1 A mutable variable is a variable whose value can be modified.
B.427:1 A name is an identifier that refers to an entity.
B.428. named block expression¶
B.428:1 A named block expression is a block expression with a label.
B.429. named deconstructor¶
B.429:1 A named deconstructor is a construct that matches the name of a field.
B.430. named field selector¶
B.430:1 A named field selector is a field selector where the selected field is indicated by an identifier.
B.431. named initializer¶
B.431:1 A named initializer is a construct that specifies the name and initial value of a field in a struct expression.
B.432. named loop expression¶
B.432:1 A named loop expression is a loop expression with a label.
B.433. named register argument¶
B.433:1 A named register argument is a register argument whose configuration is bound to an identifier.
B.434:1 A namespace is a logical grouping of names such that the occurrence of a name in one namespace does not conflict with an occurrence of the same name in another namespace.
NaN-boxing is a technique for encoding values using the low order
bits of the mantissa of a 64-bit IEEE floating-point
B.436. negation expression¶
B.436:1 A negation expression is an expression that negates its operand.
B.437. nesting import¶
B.437:1 A nesting import is a use import that provides a common path prefix for its nested use imports.
B.438. never type¶
B.438:1 The never type is a type that represents the result of a computation that never completes.
B.439. non-reference pattern¶
B.439:1 A non-reference pattern is any pattern except non-binding patterns, path patterns, reference patterns, and underscore patterns.
B.440. not configuration predicate¶
B.440:1 A not configuration predicate is a configuration predicate that negates the Boolean value of its nested configuration predicate.
B.441. not-equals expression¶
B.441:1 A not-equals expression is a comparison expression that tests for inequality.
null value denotes a tool-defined address.
B.443. numeric literal¶
B.443:1 A numeric literal is a literal that denotes a number.
B.444. numeric type¶
B.444:1 A numeric type is a type whose values denote numbers.
B.445. object safe¶
B.445:1 A trait is object safe when it can be used as a trait object type.
B.446. object safety¶
B.446:1 Object safety is the process of determining whether a trait can be used as a trait object type.
B.447. obsolete range pattern¶
B.447:1 An obsolete range pattern is a range pattern that uses obsolete syntax to express an inclusive range pattern.
B.448. octal literal¶
B.448:1 An octal literal is an integer literal in base 8.
B.449:1 An operand is an expression nested within an expression.
B.450. operator expression¶
B.450:1 An operator expression is an expression that involves an operator.
B.451. opt-out trait bound¶
An opt-out trait bound is a trait bound with
that nullifies an implicitly added trait bound.
B.452. outer attribute¶
B.452:1 An outer attribute is an attribute that applies to a subsequent item.
B.453. outer block doc¶
B.453:1 An outer block doc is a block comment that applies to a subsequent non-comment construct.
B.454. outer doc comment¶
B.454:1 An outer doc comment is either an outer block doc or an outer line doc.
B.455. outer line doc¶
B.455:1 An outer line doc is a line comment that applies to a subsequent non-comment construct.
B.456. outline module¶
An outline module is a module with an
B.457. outlives bound¶
B.457:1 An outlives bound is a trait bound which requires that a generic parameter outlives a lifetime parameter.
B.458. output register¶
An output register is a register whose register name is
used in a register argument subject to direction modifier
B.459. output register expression¶
B.459:1 An output register expression is an expression that is assigned the value of a register.
B.460:1 Two values overlap when their memory locations overlap, or both values are elements of the same array.
B.462:1 Ownership is a property of values that is central to the resource management model of Rust.
A panic is an abnormal program state caused by invoking macro
B.464. parenthesized expression¶
B.464:1 A parenthesized expression is an expression that groups other expressions.
B.465. parenthesized pattern¶
B.465:1 A parenthesized pattern is a pattern that controls the precedence of its subpatterns.
B.466. parenthesized type¶
B.466:1 A parenthesized type is a type that disambiguates the interpretation of lexical elements.
B.467. partially hygienic¶
B.467:1 An identifier is partially hygienic when it has mixed site hygiene.
B.468. passing convention¶
B.468:1 A passing convention is the mechanism that defines how a value is transferred between places.
A path is a sequence of path segments logically separated by
:: that resolves to an entity.
B.470. path expression¶
B.470:1 A path expression is a path that acts as an expression.
B.471. path expression resolution¶
B.471:1 Path expression resolution is a form of path resolution that applies to a path expression.
B.472. path pattern¶
B.472:1 A path pattern is a pattern that matches a constant, a unit enum variant, or a unit struct constant indicated by a path.
B.473. path resolution¶
B.473:1 Path resolution is a form of resolution that applies to a path.
B.474. path segment¶
B.474:1 A path segment is a constituent of a path.
B.475:1 A pattern is a construct that matches a value which satisfies all the criteria of the pattern.
B.476. pattern matching¶
B.476:1 Pattern matching is the process of matching a pattern against a value.
B.477:1 A pattern-without-alternation is a pattern that cannot be alternated.
B.478:1 A pattern-without-range is a pattern-without-alternation that excludes range patterns.
B.479:1 A place is a location where a value resides.
B.480. place expression¶
B.480:1 A place expression is an expression that represents a memory location.
B.481. place expression context¶
B.481:1 A place expression context is a construct that may evaluate its operand as a memory location.
B.482:1 In Unicode, a plane is a continuous group of 65,536 code points.
B.483:1 A pointer is a value of a pointer type.
B.484. pointer type¶
B.484:1 A pointer type is a type whose values indicate memory locations.
B.485. positional register argument¶
B.485:1 A positional register argument is a register argument whose configuration is not bound to an identifier.
B.486:1 Precedence is the order by which expressions are evaluated in the presence of other expressions.
B.487:1 A prelude is a collection of entities that are automatically brought in scope of every module in a crate.
B.488. prelude entity¶
B.488:1 A prelude entity is an entity declared in a prelude.
B.489. prelude name¶
B.489:1 A prelude name is a name of a prelude entity.
B.490. primitive representation¶
B.490:1 Primitive representation is the type representation of integer types.
B.491. primitive type¶
A primitive type is a type class that includes the never type,
scalar types, and type
B.491:2 Setting as a reminder, we’ll have to check the usages of primitive types. It might be that the reference (where I assume we copied some usages from) was referring to a broader set of types as primitives.
B.492. private visibility¶
B.492:1 Private visibility is a kind of visibility that allows a name to be referred to only by the current module of the entity, and its descendant modules.
B.493. proc-macro crate¶
B.493:1 A proc-macro crate is a crate that contains procedural macros.
B.494. procedural macro¶
B.494:1 A procedural macro is a macro that encapsulates syntactic transformations in a function.
B.495. public visibility¶
Public visibility is a kind of visibility that allows a name
to be referred to from arbitrary module
M as long as the ancestor
modules of the related entity can be referred to from
A punctuator is a character or a sequence of characters in category
B.497. pure identifier¶
B.497:1 A pure identifier is an identifier that does not include weak keywords.
B.498. qualified path expression¶
B.498:1 A qualified path expression is a path expression that resolves through a qualified type.
B.499. qualified type¶
B.499:1 A qualified type is a type that is restricted to a set of implementations that exhibit implementation conformance to a qualifying trait.
B.500. qualified type path¶
B.500:1 A qualified type path is a type path that resolves through a qualified type.
B.501. qualifying trait¶
B.501:1 A qualifying trait is a trait that imposes a restriction on a qualified type.
B.502. range expression¶
B.502:1 A range expression is an expression that constructs a range.
B.503. range expression high bound¶
B.503:1 A range expression high bound is an operand that specifies the end of a range.
B.504. range expression low bound¶
B.504:1 A range expression low bound is an operand that specifies the start of a range.
B.505. range pattern¶
B.505:1 A range pattern is a pattern that matches values which fall within a range.
B.506. range pattern bound¶
B.506:1 A range pattern bound is a constraint on the range of a range pattern.
B.507. range pattern high bound¶
B.507:1 A range pattern high bound is a range pattern bound that specifies the end of a range.
B.508. range pattern low bound¶
B.508:1 A range pattern low bound is a range pattern bound that specifies the start of a range.
B.509. range-from expression¶
B.509:1 A range-from expression is a range expression that specifies an included range expression low bound.
B.510. range-from-to expression¶
B.510:1 A range-from-to expression is a range expression that specifies an included range expression low bound and an excluded range expression high bound.
B.511. range-full expression¶
B.511:1 A range-full expression is a range expression that covers the whole range of a type.
B.512. range-inclusive expression¶
B.512:1 A range-inclusive expression is a range expression that specifies an included range expression low bound and an included range expression high bound.
B.513. range-to expression¶
B.513:1 A range-to expression is a range expression that specifies an excluded range expression high bound.
B.514. range-to-inclusive expression¶
B.514:1 A range-to-inclusive expression is a range expression that specifies an included range expression high bound.
B.515. raw byte string literal¶
B.515:1 A raw byte string literal is a simple byte string literal that does not recognize escaped characters.
B.516. raw pointer¶
B.516:1 A raw pointer is a pointer of a raw pointer type.
B.517. raw pointer type¶
B.517:1 A raw pointer type is an indirection type without safety and liveness guarantees.
B.518. raw string literal¶
B.518:1 A raw string literal is a simple string literal that does not recognize escaped characters.
B.519:1 For receiver, see self parameter.
B.520. receiver operand¶
B.520:1 A receiver operand is an operand that denotes the value whose method is being invoked by a method call expression.
B.521. receiver type¶
B.522. record enum variant¶
A record enum variant is an enum variant with a
B.523. record struct¶
A record struct is a struct with a
B.524. record struct field¶
B.524:1 A record struct field is a field of a record struct type.
B.525. record struct pattern¶
B.525:1 A record struct pattern is a pattern that matches a enum variant value, a struct value, or a union value.
B.526. record struct type¶
B.526:1 A record struct type is the type of a record struct.
B.527. record struct value¶
B.527:1 A record struct value is a value of a record struct type.
B.528. recursive type¶
B.528:1 A recursive type is a type that may define other types within its type specification.
B.529:1 A reference is a value of a reference type.
B.530. reference identifier pattern¶
A reference identifier pattern is an identifier pattern with
B.531. reference pattern¶
B.531:1 A reference pattern is a pattern that dereferences a pointer that is being matched.
B.532. reference type¶
B.532:1 A reference type is an indirection type with ownership.
B.534:1 Refutability is a property of patterns that expresses the ability to match all possible values of a type.
B.535. refutable constant¶
B.535:1 A refutable constant is a constant of a refutable type.
B.536. refutable pattern¶
B.536:1 A refutable pattern is a pattern that has a possibility of not matching the value it is being matched against.
B.537. refutable type¶
B.537:1 A refutable type is a type that has more than one value.
B.538:1 A register is a hardware component capable of holding data that can be read and written.
B.539. register argument¶
B.539:1 A register argument is a construct that configures the input and output of a register, and optionally binds the configuration to an identifier.
B.540. register class¶
B.540:1 A register class represents a set of registers.
B.541. register class argument¶
B.541:1 A register class argument is a register argument that uses a register class name.
B.542. register class name¶
B.542:1 A register class name is a target-specific string that identifies a register class.
B.543. register expression¶
B.543:1 A register expression is either an input-output register expression or a simple register expression.
B.544. register name¶
B.544:1 A register name is either the explicit register name of a register, or the register class name of the register class a register belongs to.
B.545. register parameter¶
B.545:1 A register parameter is a substring delimited by characters 0x7B (left curly bracket) and 0x7D (right curly bracket) that is substituted with a register argument in an assembly instruction.
B.546. register parameter modifier¶
B.546:1 A register parameter modifier is a substring that starts with character 0x3A (colon), follows a register parameter, and changes the formatting of the related register parameter.
B.547. remainder assignment¶
B.547:1 For remainder assignment, see remainder assignment expression.
B.548. remainder assignment expression¶
B.548:1 A remainder assignment expression is a compound assignment expression that uses remainder division.
B.549. remainder expression¶
B.549:1 A remainder expression is an arithmetic expression that uses remainder division.
B.550:1 A renaming provides an alternative name for an existing name.
B.551. repeat operand¶
B.551:1 A repeat operand is an operand that specifies the element being repeated in an array repetition constructor.
B.552. repetition operator¶
B.552:1 A repetition operator is a construct that indicates the number of times a macro repetition in matching or a macro repetition in transcription can be repeated.
B.553:1 See type representation.
B.554. reserved keyword¶
B.554:1 A reserved keyword is a keyword that is not yet in use.
B.555:1 Resolution is the process of finding a unique interpretation for a field access expression, a method call expression, or a path.
B.556. rest pattern¶
B.556:1 A rest pattern is a pattern that matches zero or more elements that have not already been matched.
B.557. return expression¶
B.557:1 A return expression is an expression that optionally yields a value and causes control flow to return to the caller.
B.558. return type¶
B.558:1 A return type is the type of the result a function returns.
B.559. right operand¶
B.559:1 A right operand is an operand that appears on the right-hand side of a binary operator.
B.560. rule matching¶
Rule matching is the process of consuming a
TokenTree in an attempt
to fully satisfy the macro matcher of a macro rule that belongs to a
resolved declarative macro.
B.561:1 Rust-c (or rustc) is a compiler that implements the Ferrocene Language Specification.
B.562. safety invariant¶
B.562:1 A safety invariant is an invariant that when violated may result in undefined behavior.
B.563. scalar type¶
A scalar type is either a
bool type, a
char type, or
a numeric type.
B.564:1 A scope is a region of program text where a name can be referred to.
B.565. scope hierarchy¶
B.565:1 The scope hierarchy reflects the nesting of scopes as introduced by scoping constructs.
B.566. selected field¶
B.566:1 A selected field is a field that is selected by a field access expression.
Self is either an implicit type parameter in traits or an
implicit type alias in implementations.
Self refers to the
type that implements a trait.
B.568. self parameter¶
A self parameter is a function parameter expressed by keyword
B.569. self public modifier¶
B.569:1 A self public modifier is a visibility modifier that grants a name private visibility.
B.570. Self scope¶
B.571. send type¶
A send type is a type that implements the
B.572:1 A separator is a character or a string that separates adjacent lexical elements.
B.573. sequence type¶
B.573:1 A sequence type represents a sequence of elements.
B.574:1 Shadowing is a property of names. A name is said to be shadowed when another name with the same characters is introduced in the same scope within the same namespace, effectively hiding it.
B.578. shift left assignment¶
B.578:1 For shift left assignment, see shift left assignment expression.
B.579. shift left assignment expression¶
B.579:1 A shift left assignment expression is a compound assignment expression that uses bit shift left arithmetic.
B.580. shift left expression¶
B.580:1 A shift left expression is a bit expression that uses bit shift left arithmetic.
B.581. shift right assignment¶
B.581:1 For shift right assignment, see shift right assignment expression.
B.582. shift right assignment expression¶
B.582:1 A shift right assignment expression is a compound assignment expression that uses bit shift right arithmetic.
B.583. shift right expression¶
B.583:1 A shift right expression is a bit expression that uses bit shift right arithmetic.
B.584. shorthand deconstructor¶
B.584:1 A shorthand deconstructor is a construct that matches the name of a field and binds the value of the matched field to a binding.
B.585. shorthand initializer¶
B.585:1 A shorthand initializer is a construct that specifies the name of a field in a struct expression.
B.586. signed integer type¶
B.586:1 A signed integer type is an integer type whose values denote negative whole numbers, zero, and positive whole numbers.
B.587. simple byte string literal¶
A simple byte string literal is a byte string literal that consists
B.588. simple import¶
B.588:1 A simple import is a use import that binds a simple path to a local name by using an optional renaming.
B.589. simple path¶
B.589:1 A simple path is a path whose path segments consist of either identifiers or certain keywords.
B.590. simple path prefix¶
B.590:1 A simple path prefix is the leading simple path of a glob import or a nesting import.
B.591. simple path public modifier¶
B.591:1 A simple path public modifier is a visibility modifier that grants a name public visibility within the provided simple path only.
B.592. simple path resolution¶
B.592:1 Simple path resolution is a kind of path resolution that applies to a simple path.
B.593. simple public modifier¶
B.593:1 A simple public modifier is a visibility modifier that grants a name public visibility.
B.594. simple register expression¶
B.594:1 A simple register expression is either an expression or an underscore expression.
B.595. simple string literal¶
B.595:1 A simple string literal is a string literal where the characters are Unicode characters.
B.596. single segment path¶
B.596:1 A single segment path is a path consisting of exactly one path segment.
B.597:1 The size of a value is the offset in bytes between successive elements in an array type with the same element type, including any padding for alignment.
B.598. size operand¶
B.598:1 A size operand is an operand that specifies the size of an array or an array type.
B.599. sized type¶
B.599:1 A sized type is a type with statically known size.
B.600:1 A slice is a value of a slice type.
B.601. slice pattern¶
B.601:1 A slice pattern is a pattern that matches arrays of fixed size and slices of dynamic size.
B.602. slice type¶
B.602:1 A slice type is a sequence type that provides a view into a sequence of elements.
B.603. source file¶
B.603:1 A source file contains the program text of inner attributes, inner doc comments, and items.
B.604:1 A statement is a component of a block expression.
B.605:1 A static is a value that is associated with a specific memory location.
B.606. static initializer¶
B.606:1 A static initializer is a construct that provides the value of its related static.
B.607. static lifetime elision¶
B.607:1 Static lifetime elision is a form of lifetime elision that applies to constants and statics.
str is a sequence type that represents a slice of 8-bit
B.609. strict keyword¶
B.609:1 A strict keyword is a keyword that always holds its special meaning.
B.610. string literal¶
B.610:1 A string literal is a literal that consists of multiple characters.
B.611:1 A struct is an item that declares a struct type.
B.612. struct expression¶
B.612:1 A struct expression is an expression that constructs an enum value, a struct value, or a union value.
B.613. struct field¶
B.613:1 A struct field is a field of a struct type.
B.614. struct pattern¶
B.614:1 A struct pattern is a pattern that matches an enum value, a struct value, or a union value.
B.615. struct type¶
B.615:1 A struct type is an abstract data type that is a product of other types.
B.616. struct value¶
B.616:1 A struct value is a value of a struct type.
B.617. structurally equal¶
B.617:1 A type is structurally equal when its values can be compared for equality by structure.
B.618:1 A subexpression is an expression nested within another expression.
B.619. subject expression¶
B.619:1 A subject expression is an expression that controls for loops, if expressions, and match expressions.
B.620. subject let expression¶
B.620:1 A subject let expression is an expression that controls if let expressions and while let loops.
B.621:1 A subpattern is a pattern nested within another pattern.
B.622. subtraction assignment¶
B.622:1 For subtraction assignment, see subtraction assignment.
B.623. subtraction assignment expression¶
B.623:1 A subtraction assignment expression is a compound assignment expression that uses subtraction.
B.624. subtraction expression¶
B.624:1 A subtraction expression is an arithmetic expression that uses subtraction.
B.625:1 A subtrait is a trait with a supertrait.
B.626:1 A subtype is a type with additional constraints.
B.627:1 Subtyping is a property of types, allowing one type to be used where another type is expected.
B.628. suffixed float¶
B.628:1 A suffixed float is a float literal with a float suffix.
B.629. suffixed integer¶
B.629:1 A suffixed integer is an integer literal with an integer suffix.
B.630. super public modifier¶
B.630:1 A super public modifier is a visibility modifier that grants a name public visibility within the parent module only.
B.631:1 A supertrait is a transitive trait that a type must additionally implement.
B.632. sync type¶
A sync type is a type that implements the
B.633. syntactic category¶
B.633:1 A syntactic category is a nonterminal in the Backus-Naur Form grammar definition of the Rust programming language.
B.634. tail expression¶
B.634:1 A tail expression is the last expression within a block expression.
B.635:1 A temporary is an anonymous variable produced by some intermediate computation.
B.636:1 A loop expression is terminated when its block expression is no longer evaluated.
B.637. terminated macro invocation¶
B.637:1 A terminated macro invocation is a macro invocation that may be used as a statement.
B.638. textual macro scope¶
B.638:1 A textual macro scope is a scope for declarative macros.
B.639. textual type¶
A textual type is a type class that includes type
char and type
B.640. thin pointer¶
B.640:1 A thin pointer is a value of a thin pointer type.
B.641. thin pointer type¶
B.641:1 A thin pointer type is an indirection type that refers to a fixed sized type.
B.642. token matching¶
Token matching is the process of consuming a
TokenTree in an attempt
to fully satisfy a macro match of a selected macro matcher that
belongs to a resolved declarative macro.
B.643:1 Tokens are a subset of lexical elements consumed by macros.
B.644:1 A trait is an item that describes an interface a type can implement.
B.645. trait body¶
B.645:1 A trait body is a construct that encapsulates the associated items, inner attributes, and inner doc comments of a trait.
B.646. trait bound¶
B.646:1 A trait bound is a bound that imposes a constraint on the traits of generic parameters.
B.647. trait implementation¶
B.647:1 A trait implementation is an implementation that adds functionality specified by a trait.
B.648. trait object lifetime elision¶
B.648:1 Trait object lifetime elision is a form of lifetime elision that applies to trait object types.
B.649. trait object type¶
B.649:1 A trait object type is a type that implements a trait, where the type is not known at compile time.
B.650. trait type¶
B.650:1 A trait type is either an impl trait type or a trait object type.
B.651. transparent representation¶
B.651:1 Transparent representation is a type representation that applies only to an enum type with a single enum variant or a struct type where the struct type or enum variant has a single field of non-zero size and any number of fields of size zero and alignment one.
B.652. trivial predicate¶
B.652:1 A trivial predicate is a where clause predicate that does not use the generic parameters or higher-ranked lifetimes of the related construct.
B.653:1 A tuple is a value of a tuple type.
B.654. tuple enum variant¶
A tuple enum variant is an enum variant with a
B.655. tuple enum variant value¶
B.655:1 A tuple enum variant value is a value of a tuple enum variant.
B.656. tuple expression¶
B.656:1 A tuple expression is an expression that constructs a tuple.
B.657. tuple field¶
B.657:1 A tuple field is a field of a tuple type.
B.658. tuple initializer¶
B.658:1 A tuple initializer is an operand that provides the value of a tuple field in a tuple expression.
B.659. tuple pattern¶
B.659:1 A tuple pattern is a pattern that matches a tuple which satisfies all criteria defined by its subpatterns.
B.660. tuple struct¶
A tuple struct is a struct with a
B.661. tuple struct call expression¶
B.661:1 A tuple struct call expression is a call expression where the call operand resolves to a tuple struct.
B.662. tuple struct field¶
B.662:1 A tuple struct field is a field of a tuple struct type.
B.663. tuple struct pattern¶
B.663:1 A tuple struct pattern is a pattern that matches a tuple enum variant value or a tuple struct value.
B.664. tuple struct type¶
B.664:1 A tuple struct type is the type of a tuple struct.
B.665. tuple struct value¶
B.665:1 A tuple struct value is a value of a tuple struct type.
B.666. tuple type¶
B.666:1 A tuple type is a sequence type that represents a heterogeneous list of other types.
B.667:1 A type defines a set of values and a set of operations that act on those values.
B.668. type alias¶
B.668:1 A type alias is an item that defines a name for a type.
B.669. type argument¶
B.669:1 A type argument is a generic argument that supplies the value of a type parameter.
B.670. type ascription¶
B.670:1 A type ascription specifies the type of a construct.
B.671. type bound predicate¶
B.671:1 A type bound predicate is a construct that specifies lifetime bounds and trait bounds on a type.
B.672. type cast expression¶
B.672:1 A type cast expression is an expression that changes the type of an operand.
B.673. type coercion¶
B.673:1 Type coercion is an implicit operation that changes the type of a value.
B.674. type inference¶
B.674:1 Type inference is the process of deducing the expected type of an arbitrary value.
B.675. type inference root¶
B.675:1 A type inference root is a construct whose inner expressions and patterns are subject to type inference independently of other type inference roots.
B.676. type parameter¶
B.676:1 A type parameter is a generic parameter for a type.
B.677. type parameter initializer¶
B.677:1 A type parameter initializer is a construct that provides the default value of its related type parameter.
B.678. type path¶
B.678:1 A type path is a path that acts as a type specification.
B.679. type path resolution¶
B.679:1 Type path resolution is a form of path resolution that applies to a type path.
B.680. type representation¶
B.680:1 Type representation specifies the layout of fields of abstract data types.
B.681. type specification¶
B.681:1 A type specification describes the structure of a type.
B.682. type unification¶
B.682:1 Type unification is the process by which type inference propagates known types across the type inference root and assigns concrete types to type variables, as well as a general mechanism to check for compatibility between two types during method resolution.
B.683. type variable¶
B.683:1 A type variable is a placeholder used during type inference to stand in for an undetermined type of an expression or a pattern.
u8 is an unsigned integer type whose values range from 0 to
28 - 1, all inclusive.
u16 is an unsigned integer type whose values range from 0 to
216 - 1, all inclusive.
u32 is an unsigned integer type whose values range from 0 to
232 - 1, all inclusive.
u64 is an unsigned integer type whose values range from 0 to
264 - 1, all inclusive.
u128 is an unsigned integer type whose values range from 0 to
2128 - 1, all inclusive.
B.689. unary operator¶
B.689:1 A unary operator operates on one operand.
B.690. undefined behavior¶
B.690:1 Undefined behavior is a situation that results in an unbounded error.
B.691. under resolution¶
B.691:1 A construct that is being resolved is said to be under resolution.
B.692. underscore expression¶
B.692:1 An underscore expression is an expression that acts as a placeholder in a destructuring assignment.
B.693. underscore pattern¶
B.693:1 An underscore pattern is a pattern that matches any single value.
B.694:1 An identifier is unhygienic when it has call site hygiene.
B.695:1 Unicode is the colloquial name for the ISO/IEC 10646:2017 Universal Coded Character Set standard.
B.696:1 For unifiable, see unify.
B.697. unifiable types¶
B.697:1 Two types that unify are said to be unifiable types.
B.698. unified type¶
B.698:1 A unified type is a type produced by type unification.
B.699:1 A type is said to unify with another type when the domains, ranges, and structures of both types are compatible.
B.700:1 A union is an item that declares a union type.
B.701. union field¶
B.701:1 A union field is a field of a union type.
B.702. union type¶
B.702:1 A union type is an abstract data type similar to a C-like union.
B.703. union value¶
B.703:1 A union value is a value of a union type.
B.704. unique immutable reference¶
B.704:1 A unique immutable reference is an immutable reference produced by capturing what is asserted to be the only live reference to a value while the reference exists.
B.705. unit enum variant¶
B.705:1 A unit enum variant is an enum variant without a field list.
B.706. unit struct¶
B.706:1 A unit struct is a struct without a field list.
B.707. unit struct constant¶
B.707:1: A unit struct constant is a constant implicitly created by a unit struct.
B.708. unit struct type¶
B.708:1 A unit struct type is the type of a unit struct.
B.709. unit struct value¶
B.709:1 A unit struct value is a value of a unit struct type.
B.710. unit tuple¶
B.711. unit type¶
B.711:1 The unit type is a tuple type of zero arity.
B.712. unit value¶
B.713. unnamed constant¶
B.713:1 An unnamed constant is a constant declared with character 0x5F (low line).
B.714. unnamed lifetime¶
B.714:1 An unnamed lifetime is a lifetime declared with character 0x5F (low line).
B.715. unsafe block¶
B.715:1 For unsafe block, see unsafe block expression.
B.716. unsafe block expression¶
An unsafe block expression is a block expression that is specified
B.717. unsafe context¶
B.717:1 An unsafe context is either an unsafe block or an unsafe function.
B.718. unsafe function¶
An unsafe function is a function subject to keyword
B.719. unsafe function item type¶
B.719:1 An unsafe function item type is a function item type where the related function is an unsafe function.
B.720. unsafe function pointer type¶
An unsafe function pointer type is a function pointer type subject to
B.721. unsafe module¶
An unsafe module is a module subject to keyword
B.722. unsafe operation¶
B.722:1 An unsafe operation is an operation that may result in undefined behavior that is not diagnosed as a static error. Unsafe operations are referred to as unsafe Rust.
B.723. unsafe Rust¶
B.723:1 For unsafe Rust, see unsafe operations.
B.724. unsafe trait¶
An unsafe trait is a trait subject to keyword
B.725. unsafe trait implementation¶
An unsafe trait implementation is a trait implementation subject to
B.726:1 Unsafety is the presence of unsafe operations in program text.
B.727. unsigned integer type¶
B.727:1 An unsigned integer type is an integer type whose values denote zero and positive whole numbers.
B.728. unsized coercion¶
B.728:1 An unsized coercion is a type coercion that converts a sized type into an unsized type.
B.729. unsized type¶
B.729:1 An unsized type is a type with statically unknown size.
B.730. unsuffixed float¶
B.730:1 An unsuffixed float is a float literal without a float suffix.
B.731. unsuffixed integer¶
B.731:1 An unsuffixed integer is an integer literal without an integer suffix.
B.732. use import¶
B.732:1 A use import brings entities in scope within the block expression of an expression-with-block or module where the use import resides.
usize is an unsigned integer type with the same number of bits as
the platform’s pointer type, and is at least 16-bits wide.
B.734:1 A variable is valid when it has been initialized by all reachable control flow paths.
B.735. validity invariant¶
B.735:1 A validity invariant is an invariant that when violated results in immediate undefined behavior.
B.736:1 A value is either a literal or the result of a computation, that may be stored in a memory location, and interpreted based on some type.
B.737. value expression¶
B.737:1 A value expression is an expression that represents a value.
B.738. value expression context¶
B.738:1 A value expression context is an expression context that is not a place expression context.
B.739. value operand¶
B.739:1 A value operand is an operand that supplies the value that is assigned to an assignee operand by an assignment expression.
B.740:1 A variable is a placeholder for a value that is allocated on the stack.
B.741. variadic part¶
B.741:1 A variadic part indicates the presence of C-like optional parameters.
B.742:1 Variance is a property of lifetime parameters and type parameters that describes the circumstances under which a generic type is a subtype of an instantiation of itself with different generic arguments.
B.743:1 Visibility is a property of fields and items that determines which modules can refer to the name of the field or item.
B.744. visibility modifier¶
B.744:1 A visibility modifier sets the visibility of the name of an item.
B.745. weak keyword¶
B.745:1 A weak keyword is a keyword whose special meaning depends on the context.
B.746. where clause¶
B.746:1 A where clause is a construct that specifies bounds on lifetime parameters and type parameters.
B.747. where clause predicate¶
B.747:1 A where clause predicate is either a lifetime bound predicate or a type bound predicate.
B.748. while let loop¶
B.748:1 For while let loop, see while let loop expression.
B.749. while let loop expression¶
B.749:1 A while let loop expression is a loop expression that continues to evaluate its loop body as long as its subject let expression yields a value that can be matched against its pattern.
B.750. while loop¶
B.750:1 For while loop, see while loop expression.
B.751. while loop expression¶
B.751:1 A while loop expression is a loop expression that continues to evaluate its loop body as long as its iteration expression holds true.
B.752. whitespace string¶
B.752:1 A whitespace string is a string that consists of one or more whitespace characters.
B.753. zero-sized type¶
B.753:1 A zero-sized type is a fixed sized type with size zero.
B.754. zero-variant enum type¶
B.754:1 A zero-variant enum type is an enum type without any enum variants.