Caution

You’re reading a draft of the Ferrocene Language Specification. Some parts of this document might be missing, incomplete or incorrect. Our aim is to have the specification ready by the end of 2022.

Note

The contents of this page are informational.

B. Glossary

B.1. ABI

B.1:1 For ABI, see Application Binary Interface.

B.2. ABI kind

B.2:1 The ABI kind indicates the ABI of a construct.

B.2:2 See AbiKind.

B.3. abort

B.3:1 Abort is the immediate termination of a program.

B.4. abstract data type

B.4:1 An abstract data type is a collection of other types.

B.5. active attribute

B.5:1 An active attribute is an attribute that is removed from the item it decorates.

B.6. addition assignment

B.6:1 For addition assignment, see addition assignment expression.

B.7. addition assignment expression

B.7:1 An addition assignment expression is a compound assignment expression that uses addition.

B.7:2 See AdditionAssignmentExpression.

B.8. addition expression

B.8:1 An addition expression is an arithmetic expression that uses addition.

B.8:2 See AdditionExpression.

B.9. adjusted call operand

B.9:1 An adjusted call operand is a call operand with possible auto dereferencing adjustments.

B.10. alignment

B.10:1 The alignment of a value specifies which addresses are valid for storing the value.

B.11. all configuration predicate

B.11:1 An all configuration predicate is a configuration predicate that models existential quantifier ALL.

B.11:2 See ConfigurationPredicateAll.

B.12. anonymous loop

B.12:1 An anonymous loop is a loop expression without a label.

B.13. anonymous return type

B.13:1 An anonymous return type is an impl trait type ascribed to a function return type.

B.14. anonymous type parameter

B.14:1 An anonymous type parameter is an impl trait type ascribed to a function parameter.

B.15. any configuration predicate

B.15:1 An any configuration predicate is a configuration predicate that models existential quantifier ANY.

B.15:2 See ConfigurationPredicateAny.

B.16. Application Binary Interface

B.16:1 Application Binary Interface is a set of conventions that dictate how data and computation cross language boundaries.

B.16:2 See AbiSpecification.

B.17. argument operand

B.17:1 An argument operand is an operand which is used as an argument in a call expression or a method call expression.

B.18. arithmetic expression

B.18:1 An arithmetic expression is an expression that computes a value from two operands using arithmetic.

B.18:2 See ArithmeticExpression.

B.19. arithmetic operator

B.19:1 An arithmetic operator is the operator of an arithmetic expression.

B.20. arithmetic overflow

B.20:1 arithmetic overflow occurs if an arithmetic expression computes a value of a scalar type that lies outside of the range of valid values for the scalar type.

B.21. arity

B.21:1 An arity is the number of tuple fields in a tuple type.

B.22. array

B.22:1 An array is a value of an array type.

B.23. array element constructor

B.23:1 An array element constructor is an array expression that lists all elements of the array being constructed.

B.23:2 See ArrayElementConstructor.

B.24. array expression

B.24:1 An array expression is an expression that constructs an array.

B.24:2 See ArrayExpression.

B.25. array repetition constructor

B.25:1 An array repetition constructor is an array expression that specifies how many times an element is repeated in the array being constructed.

B.25:2 See ArrayRepetitionConstructor.

B.26. array type

B.26:1 An array type is a sequence type that represents a fixed sequence of elements.

B.26:2 See ArrayTypeSpecification.

B.27. assigned operand

B.27:1 An assigned operand is the target operand of a compound assignment expression.

B.27:2 See AssignedOperand.

B.28. assignee expression

B.28:1 An assignee expression is an expression that appears as the left operand of an assignment expression.

B.29. assignee operand

B.29:1 An assignee operand is the target operand of an assignment expression.

B.29:2 See AssigneeOperand.

B.30. assignment

B.30:1 See assignment expression.

B.31. assignment expression

B.31:1 An assignment expression is an expression that assigns the value of a value operand to an assignee operand.

B.31:2 See AssignmentExpression.

B.32. associated constant

B.32:1 An associated constant is a constant that appears as an associated item.

B.33. associated function

B.33:1 An associated function is a function that appears as an associated item.

B.34. associated implementation constant

B.34:1 An associated implementation constant is an associated constant that appears within an implementation.

B.35. associated implementation function

B.35:1 An associated implementation function is an associated function that appears within an implementation.

B.36. associated implementation type

B.36:1 An associated implementation type is an associated type that appears within an implementation.

B.37. associated item

B.37:1 An associated item is an item that appears within an implementation or a trait.

B.37:2 See AssociatedItem.

B.38. associated trait constant

B.38:1 An associated trait constant is an associated constant that appears within a trait.

B.39. associated trait function

B.39:1 An associated trait function is an associated function that appears within a trait.

B.40. associated trait type

B.40:1 An associated trait type is an associated type that appears within a trait.

B.41. associated type

B.41:1 An associated type is a type alias that appears as an associated item.

B.42. associativity

B.42:1 Associativity is the order by which operands are evaluated within a single expression.

B.43. async block

B.43:1 For async block, see async block expression.

B.44. async block expression

B.44:1 An async block expression is a block expression that is specified with keyword async and encapsulates behavior which is executed in an asynchronous manner.

B.44:2 See AsyncBlockExpression.

B.45. async control flow boundary

B.45:1 An async control flow boundary is a control flow boundary that additionally allows the suspension of execution via await expressions.

B.46. async function

B.46:1 An async function is a function subject to keyword async.

B.47. atomic

B.47:1 See atomic type.

B.48. atomic type

B.48:1 An atomic type is a type defined in module core::sync::atomic.

B.49. attribute

B.49:1 An attribute is a general, free-form metadatum that is interpreted based on its name, convention, language, and tool.

B.50. attribute content

B.50:1 An attribute content is a construct that provides the content of an attribute.

B.50:2 See AttributeContent.

B.51. attribute macro

B.51: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.52. auto trait

B.52:1 An auto trait is a trait declared with keyword auto.

B.53. await expression

B.53:1 An await expression is an expression that polls a future, suspending the execution of the future until the future is ready.

B.53:2 See AwaitExpression.

B.54. base initializer

B.54: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.54:2 See BaseInitializer.

B.55. basic assignment

B.55:1 A basic assignment is an assignment expression that is not a destructuring assignment.

B.56. binary crate

B.56:1 A binary crate is a crate that contains a main function.

B.57. binary literal

B.57:1 A binary literal is an integer literal in base 2.

B.57:2 See BinaryLiteral.

B.58. binary operator

B.58:1 A binary operator is an operator that operates on two operands.

B.59. binding

B.59:1 A binding of a binding pattern binds a matched value to a name.

B.59:2 See Binding.

B.60. binding argument

B.60:1 A binding argument is a generic argument that supplies the type of an associated trait type.

B.61. binding mode

B.61:1 Binding mode is the mechanism by which a matched value is bound to a binding of a pattern.

B.62. binding pattern

B.62:1 A binding pattern is either an identifier pattern or a shorthand deconstructor.

B.63. bit and assignment

B.63:1 For bit and assignment, see bit and assignment expression.

B.64. bit and assignment expression

B.64:1 A bit and assignment expression is a compound assignment expression that uses bit and arithmetic.

B.64:2 See BitAndAssignmentExpression.

B.65. bit and expression

B.65:1 A bit and expression is a bit expression that uses bit and arithmetic.

B.65:2 See BitAndExpression.

B.66. bit expression

B.66:1 A bit expression is an expression that computes a value from two operands using bit arithmetic.

B.66:2 See BitExpression.

B.67. bit or assignment

B.67:1 For bit or assignment, see bit or assignment expression.

B.68. bit or assignment expression

B.68:1 A bit or assignment expression is a compound assignment expression that uses bit or arithmetic.

B.68:2 See BitOrAssignmentExpression.

B.69. bit or expression

B.69:1 A bit or expression is a bit expression that uses bit or arithmetic.

B.69:2 See BitOrExpression.

B.70. bit xor assignment

B.70:1 For bit xor assignment, see bit xor assignment expression.

B.71. bit xor assignment expression

B.71:1 A bit xor assignment expression is a compound assignment expression that uses bit exclusive or arithmetic.

B.71:2 See BitXorAssignmentExpression.

B.72. bit xor expression

B.72:1 A bit xor expression is a bit expression that uses bit exclusive or arithmetic.

B.72:2 See BitXorExpression.

B.73. block comment

B.73:1 A block comment is a comment that spans one or more lines.

B.73:2 See BlockComment.

B.74. block expression

B.74:1 A block expression is an expression that sequences expressions and statements.

B.74:2 See BlockExpression.

B.75. bool

B.75:1 bool is a type whose values denote the truth values of logic and Boolean algebra.

B.76. boolean literal

B.76:1 A boolean literal is a literal that denotes the truth values of logic and Boolean algebra.

B.76:2 See BooleanLiteral.

B.77. borrow

B.77:1 A borrow is a reference produced by borrowing.

B.78. borrow expression

B.78: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.78:2 See BorrowExpression.

B.79. borrowed

B.79:1 A memory location is borrowed when it acts as the operand of a borrow expression. This explanation is not good enough.

B.80. borrowing

B.80:1 Borrowing is the process of temporarily associating a reference with a value without transferring ownership permanently.

B.81. bound

B.81:1 A bound imposes a constraint on a generic parameter by limiting the set of possible generic substitutions.

B.81:2 See TypeBound.

B.82. bound pattern

B.82:1 A bound pattern is a pattern that imposes a constraint on a related identifier pattern.

B.82:2 See BoundPattern.

B.83. break expression

B.83:1 A break expression is an expression that terminates a loop expression.

B.83:2 See BreakExpression.

B.84. break type

B.84:1 Break type is the type of the operand of a break expression.

B.85. break value

B.85:1 Break value is the value of the operand of a break expression.

B.86. built-in attribute

B.86:1 A built-in attribute is a language-defined attribute.

B.86:2 See InnerBuiltinAttribute, OuterBuiltinAttribute.

B.87. built-in trait

B.87:1 A built-in trait is a language-defined trait.

B.88. by copy type

B.88:1 A by copy type is a type that implements the core::marker::Copy trait.

B.89. by move type

B.89:1 A by move type is a type that does not implement the core::marker::Copy trait.

B.90. byte literal

B.90:1 A byte literal is a literal that denotes a fixed byte value.

B.90:2 See ByteLiteral.

B.91. byte string literal

B.91:1 A byte string literal is a literal that consists of multiple AsciiCharacters.

B.91:2 See ByteStringLiteral.

B.92. C

B.92:1 C is the programming language described in the ISO/IEC 9899:2018 International Standard.

B.93. C representation

B.93:1 C representation is a type representation that lays out types such that they are interoperable with the C language.

B.94. Call conformance

B.94:1 Call conformance measures the compatibility between a set of argument operands and a set if function parameters or fields.

B.95. call expression

B.95:1 A call expression is an expression that invokes a function or constructs a tuple struct value or tuple enum variant value.

B.95:2 See CallExpression.

B.96. call operand

B.96: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.96:2 See CallOperand.

B.97. call site hygiene

B.97:1 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.98. callee type

B.98:1 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 core::ops::Fn, core::ops::FnMut, or core::ops::FnOnce traits.

B.99. canonical path

B.99:1 A canonical path is a path that fully qualifies a name starting from the current crate.

B.100. capture mode

B.100:1 Capture mode is the mechanism by which a capture target is captured.

B.101. capture target

B.101:1 A capture target is either a binding or a field of a binding.

B.102. capturing

B.102:1 Capturing is the process of saving the capture targets of a capturing expression's capturing environment.

B.103. capturing environment

B.103:1 The capturing environment of a capturing expression consists of all capture targets that are defined outside the capturing expression.

B.104. capturing expression

B.104:1 A capturing expression is either an async block expression or a closure expression.

B.105. cast

B.105:1 Cast or casting is the process of changing the type of an expression.

B.106. char

B.106:1 char is a type whose values denote Unicode characters.

B.107. character literal

B.107:1 A character literal is a literal that denotes a fixed Unicode character.

B.107:2 See CharacterLiteral.

B.108. closure body

B.108:1 A closure body is a construct that represents the executable portion of a closure expression.

B.108:2 See ClosureBody, ClosureBodyWithReturnType.

B.109. closure expression

B.109:1 A closure expression is an expression that defines a closure type and constructs a value of that type.

B.109:2 See ClosureExpression.

B.110. closure parameter

B.110:1 A closure parameter is a construct that matches an input value at the site of a call expression or a method call expression to a pattern.

B.111. closure type

B.111:1 A closure type is a unique anonymous function type that encapsulates all capture targets of a closure expression.

B.112. code point

B.112:1 In Unicode, a code point is a numeric value that maps to a character.

B.113. comment

B.113:1 A comment is a lexical element that acts as an annotation or an explanation in program text.

B.113:2 See Comment.

B.114. comparison expression

B.114:1 A comparison expression is an expression that compares the values of two operands.

B.114:2 See ComparisonExpression.

B.115. compilation root

B.115:1 A compilation root is an input to a compilation performed by a tool.

B.116. compound assignment

B.116:1 For compound assignment, see compound assignment expression.

B.117. compound assignment expression

B.117: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.117:2 See CompoundAssignmentExpression.

B.118. concrete type

B.118:1 A concrete type is a type described by a type specification.

B.119. conditional compilation

B.119:1 Conditional compilation is the process of compiling conditionally-compiled source code.

B.120. conditionally-compiled source code

B.120: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.121. configuration predicate

B.121:1 A configuration predicate is a construct that evaluates statically to either true or false, and controls conditional compilation.

B.121:2 See ConfigurationPredicate.

B.122. constant

B.122:1 A constant is an immutable value whose uses are substituted by the value.

B.122:2 See ConstantDeclaration.

B.123. constant argument

B.123:1 A constant argument is a generic argument that supplies the value of a constant parameter.

B.123:2 See ConstantArgument.

B.124. constant context

B.124:1 A constant context is a construct that requires a constant expression.

B.125. constant expression

B.125:1 A constant expression is an expression that can be evaluated statically.

B.126. constant function

B.126:1 A constant function is a function subject to keyword const.

B.127. constant initializer

B.127:1 A constant initializer is a construct that provides the value of its related constant.

B.127:2 See ConstantInitializer.

B.128. constant parameter

B.128:1 A constant parameter is a generic parameter for a constant.

B.128:2 See ConstantParameter.

B.129. constant parameter initializer

B.129:1 A constant parameter initializer is a construct that provides the default :t:`value of its related constant parameter.

B.129:2 See ConstantParameterInitializer.

B.130. constant promotion

B.130:1 Constant promotion is the process of converting a value expression into a constant.

B.131. constrain

B.131:1 A generic parameter is said to constrain an implementation if it makes the implementation's applicability more narrow.

B.132. construct

B.132:1 A construct is a piece of program text that is an instance of a syntactic category.

B.133. constructee

B.133:1 A constructee indicates the enum variant, struct or union whose value is being constructed by a struct expression.

B.134. container operand

B.134:1 A container operand is an operand that indicates the value whose field is selected in a field access expression.

B.134:2 See ContainerOperand.

B.135. continue expression

B.135:1 A continue expression is an expression that first terminates and then restarts a loop expression.

B.135:2 See ContinueExpression.

B.136. control flow boundary

B.136: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.137. crate

B.137:1 A crate is a unit of compilation and linking.

B.138. crate import

B.138:1 A crate import specifies a dependency on an external crate.

B.138:2 See ExternalCrateImport.

B.139. crate indication

B.139:1 A crate indication is a construct that indicates a crate.

B.139:2 See CrateIndication.

B.140. crate public modifier

B.140:1 A crate public modifier is a visibility modifier that grants a name public visibility within the current crate only.

B.140:2 See CratePublicModifier.

B.141. crate root

B.141:1 A crate root is an entry point into a crate.

B.142. crate root module

B.142:1 A crate root module is the root of the nested module scopes tree of a crate.

B.143. dangling

B.143:1 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.144. data race

B.144:1 A data race is a scenario where two or more threads access a shared memory location concurrently.

B.145. decimal literal

B.145:1 A decimal literal is an integer literal in base 10.

B.145:2 See DecimalLiteral.

B.146. declaration

B.146:1 A declaration specifies the name and describes the structure of a construct.

B.147. declarative macro

B.147:1 A declarative macro is a macro that associates a name with a set of syntactic transformation rules.

B.147:2 See MacroRulesDeclaration.

B.148. deconstructee

B.148:1 A deconstructee indicates the enum variant or type that is being deconstructed by a struct pattern.

B.148:2 See Deconstructee.

B.149. default representation

B.149:1 Default representation is a type representation that does not make any guarantees about layout.

B.150. definition site hygiene

B.150:1 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.151. dereference

B.151:1 A dereference is the memory location produced by evaluating a dereference expression.

B.152. dereference expression

B.152:1 A dereference expression is an expression that obtains the pointed-to memory location of its operand.

B.152:2 See DereferenceExpression.

B.153. derive macro

B.153:1 A derive macro is a procedural macro that consumes a stream of tokens and produces a stream of tokens, and is invoked via attribute derive.

B.154. destruction

B.154:1 Destruction is the process of recovering resources associated with a value as it goes out of scope.

B.155. destructor

B.155:1 A destructor is a function that is invoked immediately before the destruction of a value of a drop type.

B.156. destructuring assignment

B.156: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.157. discriminant

B.157:1 A discriminant is an opaque integer that identifies an enum variant.

B.158. discriminant initializer

B.158:1 A discriminant initializer provides the value of a discriminant.

B.158:2 See DiscriminantInitializer.

B.159. discriminant type

B.159:1 A discriminant type is the type of a discriminant.

B.160. division assignment

B.160:1 For division assignment, see division assignment expression.

B.161. division assignment expression

B.161:1 A division assignment expression is a compound assignment expression that uses division.

B.161:2 See DivisionAssignmentExpression.

B.162. division expression

B.162:1 A division expression is an arithmetic expression that uses division.

B.162:2 See DivisionExpression.

B.163. doc comment

B.163:1 A doc comment is a comment class that includes inner block docs, inner line docs, outer block docs, and outer line docs.

B.164. drop construct

B.164:1 A drop construct is a construct that employs a drop scope.

B.165. drop order

B.165:1 Drop order is the order by which values are dropped when a drop scope is left.

B.166. drop scope

B.166:1 A drop scope is a region of program text that governs the dropping of values.

B.167. drop scope extension

B.167: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.168. drop type

B.168:1 A drop type is a type that implements the core::ops::Drop trait or contains a field that has a destructor.

B.169. dropping

B.169:1 Dropping a value is the act of invoking the destructor of the related type.

B.170. dynamically sized type

B.170:1 A dynamically sized type is a type that does not implement the core::marker::Sized trait.

B.171. elaboration

B.171:1 Elaboration is the process by which a declaration achieves its runtime effects.

B.172. element type

B.172:1 An element type is the type of the elements of an array type or a slice type.

B.172:2 See ElementType.

B.173. elided

B.173:1 For elided, see elided lifetime.

B.174. elided lifetime

B.174: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.175. else expression

B.175:1 An else expression is an expression that represents either a block expression, an if expression, or an if let expression.

B.175:2 See ElseExpression.

B.176. empty statement

B.176:1 An empty statement is a statement expressed as character 0x3B (semicolon).

B.177. entity

B.177:1 An entity is a construct that can be referred to within a program by using a path.

B.178. enum

B.178:1 An enum is an item that declares an enum type.

B.179. enum type

B.179:1 An enum type is an abstract data type that contains enum variants.

B.179:2 See EnumDeclaration.

B.180. enum value

B.180:1 An enum value is a value of an enum type.

B.181. enum variant

B.181:1 An enum variant is a construct that declares one of the possible variations of an enum.

B.181:2 See EnumVariant.

B.182. enum variant value

B.182:1 An enum variant value is the enum value of the corresponding enum of the enum variant.

B.183. equals expression

B.183:1 An equals expression is a comparison expression that tests equality.

B.183:2 See EqualsExpression.

B.184. error propagation expression

B.184: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.184:2 See ErrorPropagationExpression.

B.185. escaped character

B.185:1 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 tabulation).

B.186. evaluated

B.186:1 See evaluation.

B.187. evaluation

B.187:1 Evaluation is the process by which an expression achieves its runtime effects.

B.188. executed

B.188:1 See execution.

B.189. execution

B.189:1 Execution is the process by which a statement achieves its runtime effects.

B.190. exported function

B.190:1 An exported function is an export of a function.

B.191. exported static

B.191:1 An exported static is an export of a static.

B.192. expression

B.192:1 An expression is a construct that produces a value, and may have side effects at run-time.

B.192:2 See Expression.

B.193. expression statement

B.193:1 An expression statement is an expression whose result is ignored.

B.193:2 See ExpressionStatement.

B.194. expression-with-block

B.194:1 An expression-with-block is an expression whose structure involves a block expression.

B.194:2 See ExpressionWithBlock.

B.195. expression-without-block

B.195:1 An expression-without-block is an expression whose structure does not involve a block expression.

B.195:2 See ExpressionWithoutBlock.

B.196. external block

B.196:1 An external block is a construct that provides the declarations of foreign functions as unchecked imports.

B.196:2 See ExternalBlock.

B.197. external function

B.197:1 An external function is an unchecked import of a foreign function.

B.198. external function item type

B.198:1 An external function item type is a function item type where the related function is an external function.

B.199. external static

B.199:1 An external static is an import of a foreign variable.

B.200. f32

B.200:1 f32 is a floating-point type equivalent to the IEEE 754-2008 binary32 type.

B.201. f64

B.201:1 f64 is a floating-point type equivalent to the IEEE 754-2008 binary64 type.

B.202. fat pointer

B.202:1 A fat pointer is a value of a fat pointer type.

B.203. fat pointer type

B.203:1 A fat pointer type is an indirection type that refers to a dynamically sized type.

B.204. FFI

B.204:1 For FFI, see Foreign Function Interface.

B.205. field

B.205:1 A field is an element of an abstract data type.

B.206. field access expression

B.206:1 A field access expression is an expression that accesses a field of a value.

B.206:2 See FieldAccessExpression.

B.207. field index

B.207: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.207:2 See FieldIndex.

B.208. field list

B.208:1 A field list is a RecordStructFieldList or TupleStructFieldList.

B.209. field selector

B.209:1 A field selector is a construct that selects the field to be accessed in a field access expression.

B.209:2 See FieldSelector.

B.210. final match arm

B.210:1 A final match arm is the last match arm of a match expression.

B.210:2 See FinalMatchArm.

B.211. fixed sized type

B.211:1 A fixed sized type is a type that implements the core::marker::Sized trait.

B.212. float literal

B.212:1 A float literal is a numeric literal that denotes a fractional number.

B.212:2 See FloatLiteral.

B.213. float suffix

B.213:1 A float suffix is a component of a float literal that specifies an explicit floating-point type.

B.213:2 See FloatSuffix.

B.214. floating-point type

B.214:1 A floating-point type is a numeric type whose values denote fractional numbers.

B.215. floating-point type variable

B.215:1 A floating-point type variable is a type variable that can refer only to floating-point types.

B.216. floating-point value

B.216:1 A floating-point value is a value of a floating-point type.

B.217. for loop

B.217:1 For for loop, see for loop expression.

B.218. for loop expression

B.218:1 A for loop expression is a loop expression that continues to evaluate its block expression as long as its subject expression yields a value.

B.218:2 See ForLoopExpression.

B.219. Foreign Function Interface

B.219:1 Foreign Function Interface employs ABI, attributes, external block, external functions, linkage, and type layout to interface a Rust program with foreign code.

B.220. fragment specifier

B.220:1 A fragment specifier is a construct that indicates the type of a metavariable.

B.220:2 See MacroFragmentSpecifier.

B.221. full range expression

B.221:1 A full range expression is a range expression that covers the full range of a type.

B.222. function

B.222:1 A function is a value of a function type that models a behavior.

B.222:2 See FunctionDeclaration.

B.223. function body

B.223:1 A function body is the block expression of a function.

B.223:2 See FunctionBody.

B.224. function item type

B.224:1 A function item type is a unique anonymous function type that identifies a function.

B.225. function lifetime elision

B.225:1 Function lifetime elision is a form of lifetime elision that applies to functions, function pointer type parameters and paths resolving to one of the core::ops::Fn, core::ops::FnMut, and core::ops::FnOnce traits.

B.226. function parameter

B.226:1 A function parameter is a construct that matches an input value at the site of a call expression or a method call expression to a pattern.

B.226:2 See FunctionParameterList.

B.227. function pointer type

B.227:1 A function pointer type is an indirection type that refers to a function.

B.227:2 See FunctionPointerTypeSpecification.

B.228. function pointer type parameter

B.228:1 A function pointer type parameter is a function parameter of a function pointer type.

B.228:2 See FunctionPointerTypeParameter.

B.229. function qualifier

B.229:1 A function qualifier is a construct that determines the role of a function.

B.229:2 See FunctionQualifierList.

B.230. function signature

B.230: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.231. function type

B.231:1 A function type is either a closure type or a function item type.

B.232. function-like macro

B.232: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.233. future

B.233:1 A future represents a value of a type that implements the core::future::Future trait which may not have finished computing yet.

B.234. future operand

B.234:1 A future operand is an operand whose future is being awaited by an await expression.

B.234:2 See FutureOperand.

B.235. generic argument

B.235:1 A generic argument supplies a static input for an associated trait type or a generic parameter.

B.235:2 See GenericArgumentList.

B.236. generic conformance

B.236:1 Generic conformance measures the compatibility between a set of generic parameters and a set of generic arguments.

B.237. generic enum

B.237:1 A generic enum is an enum with generic parameters.

B.238. generic function

B.238:1 A generic function is a function with generic parameters.

B.239. generic implementation

B.239:1 A generic implementation is an implementation with generic parameters.

B.240. generic parameter

B.240: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.240:2 See GenericParameterList.

B.241. generic struct

B.241:1 A generic struct is a struct with generic parameters.

B.242. generic substitution

B.242:1 A generic substitution is the replacement of a generic parameter with a generic argument.

B.243. generic trait

B.243:1 A generic trait is a trait with generic parameters.

B.244. generic type

B.244:1 A generic type is a type with a generic parameter.

B.245. generic type alias

B.245:1 A generic type alias is a type alias with generic parameters.

B.246. generic union

B.246:1 A generic union is a union with generic parameters.

B.247. glob import

B.247:1 A glob import is a use import that brings all names with public visibility prefixed by its path prefix into scope.

B.247:2 See GlobImport.

B.248. global path

B.248:1 A global path is a path that starts with namespace qualifier ::.

B.249. global type variable

B.249:1 A global type variable is a type variable that can refer to any type.

B.250. greater-than expression

B.250:1 A greater-than expression is a comparison expression that tests for a greater-than relationship.

B.250:2 See GreaterThanExpression.

B.251. greater-than-or-equals expression

B.251:1 A greater-than-or-equals expression is a comparison expression that tests for a greater-than-or-equals relationship.

B.251:2 See GreaterThanOrEqualsExpression.

B.252. half-open range pattern

B.252:1 A half-open range pattern is a range pattern with only a range pattern low bound.

B.252:2 See HalfOpenRangePattern.

B.253. hexadecimal literal

B.253:1 A hexadecimal literal is an integer literal in base 16.

B.253:2 See HexadecimalLiteral.

B.254. higher-ranked trait bound

B.254:1 A higher-ranked trait bound is a bound that specifies an infinite list of bounds for all possible lifetimes.

B.254:2 See ForGenericParameterList.

B.255. hygiene

B.255: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.256. hygienic

B.256:1 An identifier is hygienic when it has definition site hygiene.

B.257. i8

B.257:1 i8 is a signed integer type whose values range from - (27) to 27 - 1, all inclusive.

B.258. i16

B.258:1 i16 is a signed integer type whose values range from - (215) to 215 - 1, all inclusive.

B.259. i32

B.259:1 i32 is a signed integer type whose values range from - (231) to 231 - 1, all inclusive.

B.260. i64

B.260:1 i64 is a signed integer type whose values range from - (263) to 263 - 1, all inclusive.

B.261. i128

B.261:1 i128 is a signed integer type whose values range from - (2127) to 2127 - 1, all inclusive.

B.262. identifier

B.262:1 An identifier is a lexical element that refers to a name.

B.262:2 See Identifier.

B.263. identifier pattern

B.263:1 An identifier pattern is a pattern that binds the value it matches to a binding.

B.263:2 See IdentifierPattern.

B.264. if expression

B.264: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.264:2 See IfExpression.

B.265. if let expression

B.265: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.265:2 See IfLetExpression.

B.266. immutable

B.266:1 A value is immutable when it cannot be modified.

B.267. immutable borrow

B.267:1 An immutable borrow is an immutable reference produced by borrowing.

B.268. immutable borrow expression

B.268:1 An immutable borrow expression is a borrow expression that lacks keyword mut.

B.269. immutable place expression

B.269:1 An immutable place expression is a place expression whose memory location cannot be modified.

B.270. immutable place expression context

B.270:1 An immutable place expression context is a place expression context whose memory location cannot be modified.

B.271. immutable raw pointer type

B.271:1 An immutable raw pointer type is a raw pointer type subject to keyword const.

B.272. immutable reference

B.272:1 An immutable reference is a value of a shared reference type, and prevents the mutation of its referent.

B.273. immutable static

B.273:1 An immutable static is a static whose value cannot be modified.

B.274. immutable variable

B.274:1 An immutable variable is a variable whose value cannot be modified.

B.275. impl trait type

B.275:1 An impl trait type is a type that implements a trait, where the type is known at compile time.

B.275:2 See ImplTraitTypeSpecification, ImplTraitTypeSpecificationOneBound.

B.276. implementation

B.276:1 An implementation is an item that supplements an implementing type by extending its functionality.

B.276:2 See Implementation.

B.277. implementation coherence

B.277:1 A trait implementation exhibits implementation coherence when it is valid and does not overlap with another trait implementation.

B.278. implementation conformance

B.278:1 Implementation conformance measures the compatibility between a trait implementation and the implemented trait.

B.279. implemented trait

B.279:1 An implemented trait is a trait whose functionality has been implemented by an implementating type.

B.279:2 See ImplementedTrait.

B.280. implementing type

B.280:1 An implementing type is the type that the associated items of an implementation are associated with.

B.280:2 See ImplementingType.

B.281. implicit borrow

B.281:1 An implicit borrow is a borrow that is not present syntactically in program text.

B.282. in scope

B.282:1 A name is in scope when it can be referred to.

B.283. inclusive range pattern

B.283:1 An inclusive range pattern is a range pattern with both a range pattern low bound and a range pattern high bound.

B.283:2 See InclusiveRangePattern.

B.284. incomplete associated constant

B.284:1 An incomplete associated constant is an associated constant without a constant initializer.

B.285. incomplete associated function

B.285:1 An incomplete associated function is an associated function without a function body.

B.286. incomplete associated type

B.286:1 An incomplete associated type is an associated type without an initialization type.

B.287. index expression

B.287:1 An index expression is an expression that indexes into a value of a type.

B.287:2 See IndexExpression.

B.288. indexable type

B.288:1 A indexable type is a type that implements core::ops::Index.

B.289. indexed deconstructor

B.289:1 An indexed deconstructor is a construct that matches the position of a tuple field.

B.289:2 See IndexedDeconstructor.

B.290. indexed field selector

B.290:1 An indexed field selector is a field selector where the selected field is indicated by an index.

B.290:2 See IndexedFieldSelector.

B.291. indexed initializer

B.291:1 An indexed initializer is a construct that specifies the index and initial value of a field in a struct expression.

B.291:2 See IndexedInitializer.

B.292. indexed operand

B.292:1 An indexed operand is an operand which indicates the value of a type implementing core::ops::Index being indexed into by an index expression.

B.292:2 See IndexedOperand.

B.293. indexing operand

B.293:1 An indexing operand is an operand which specifies the index for the indexed operand being indexed into by an index expression.

B.293:2 See IndexingOperand.

B.294. indirection type

B.294:1 An indirection type is a type whose values refer to memory locations.

B.295. inert attribute

B.295:1 An inert attribute is an attribute that remains with the item it decorates.

B.296. inferred type

B.296:1 An inferred type is a placeholder for a type deduced by type inference.

B.296:2 See InferredType.

B.297. infinite loop

B.297:1 For infinite loop, see infinite loop expression.

B.298. infinite loop expression

B.298:1 An infinite loop expression is a loop expression that continues to evaluate its block expression indefinitely unless terminated with a break expression or a return expression.

B.298:2 See InfiniteLoopExpression.

B.299. inherent implementation

B.299:1 An inherent implementation is an implementation that adds direct functionality.

B.299:2 See InherentImplementation.

B.300. initialization

B.300:1 Initialization is the act of supplying an initial value to a constant, a static, or a variable.

B.301. initialization expression

B.301:1 An initialization expression is either a constant initializer or a static initializer.

B.302. initialization type

B.302:1 An initialization type is the type a type alias defines a name for.

B.302:2 See InitializationType.

B.303. inline module

B.303:1 An inline module is a module with an InlineModuleSpecification.

B.303:2 See InlineModuleSpecification.

B.304. inner attribute

B.304:1 An inner attribute is an attribute that applies to an enclosing item.

B.304:2 See InnerAttribute.

B.305. inner block doc

B.305:1 An inner block doc is a block comment that applies to an enclosing non-comment construct.

B.305:2 See InnerBlockDoc.

B.306. inner doc comment

B.306:1 An inner doc comment is either an inner block doc or an inner line doc.

B.307. inner line doc

B.307:1 An inner line doc is a line comment that applies to an enclosing non-comment construct.

B.307:2 See InnerLineDoc.

B.308. integer literal

B.308:1 An integer literal is a numeric literal that denotes a whole number.

B.308:2 See IntegerLiteral.

B.309. integer suffix

B.309:1 An integer suffix is a component of an integer literal that specifies an explicit integer type.

B.309:2 See IntegerSuffix.

B.310. integer type

B.310:1 An integer type is a numeric type whose values denote whole numbers.

B.311. integer type variable

B.311:1 An integer type variable is a type variable that can refer only to integer types.

B.312. interior mutability

B.312:1 Interior mutability is a property of types whose values can be modified through immutable references.

B.313. intermediate match arm

B.313:1 An intermediate match arm is any non-final match arm of a match expression.

B.313:2 See IntermediateMatchArm.

B.314. irrefutable

B.314:1 For irrefutable, see irrefutable pattern.

B.315. irrefutable constant

B.315:1 An irrefutable constant is a constant of an irrefutable type.

B.316. irrefutable pattern

B.316:1 An irrefutable pattern is a pattern that always matches the value it is being matched against.

B.317. irrefutable type

B.317:1 An irrefutable type is a type that has at most one value.

B.318. isize

B.318:1 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.319. item

B.319: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.319:2 See Item.

B.320. item statement

B.320:1 An item statement is a statement that is expressed as an item.

B.321. iteration expression

B.321:1 An iteration expression is an expression that provides the criterion of a while loop expression.

B.321:2 See IterationExpression.

B.322. keyword

B.322:1 A keyword is a word in program text that has special meaning.

B.322:2 See Keyword.

B.323. label

B.323:1 A label is the name of a loop expression.

B.323:2 See Label.

B.324. label indication

B.324:1 A label indication is a construct that indicates a label.

B.324:2 See LabelIndication.

B.325. layout

B.325:1 Layout specifies the alignment, size, and the relative offset of fields in a type.

B.326. lazy and expression

B.326:1 A lazy and expression is a lazy boolean expression that uses short circuit and arithmetic.

B.326:2 See LazyAndExpression.

B.327. lazy boolean expression

B.327:1 A lazy boolean expression is an expression that performs short circuit Boolean arithmetic.

B.327:2 See LazyBooleanExpression.

B.328. lazy or expression

B.328:1 A lazy or expression is a lazy boolean expression that uses short circuit or arithmetic.

B.328:2 See LazyOrExpression.

B.329. left operand

B.329:1 A left operand is an operand that appears on the left-hand side of a binary operator.

B.329:2 See LeftOperand.

B.330. less-than expression

B.330:1 A less-than expression is a comparison expression that tests for a less-than relationship.

B.330:2 See LessThanExpression.

B.331. less-than-or-equals expression

B.331:1 A less-than-or-equals expression is a comparison expression that tests for a less-than-or-equals relationship.

B.331:2 See LessThanOrEqualsExpression.

B.332. let statement

B.332:1 A let statement is a statement that introduces new variables given by the bindings produced by its pattern-without-alternation.

B.332:2 See LetStatement.

B.333. lexical element

B.333:1 A lexical element is the most basic syntactic element in program text.

B.334. library crate

B.334:1 A library crate is either a crate without a main function or a crate subject to attribute no_main.

B.335. lifetime

B.335:1 A lifetime specifies the expected longevity of a reference.

B.335:2 See Lifetime.

B.336. lifetime argument

B.336:1 A lifetime argument is a generic argument that supplies the value of a lifetime parameter.

B.336:2 See LifetimeArgument.

B.337. lifetime bound

B.337:1 A lifetime bound is a bound that imposes a constraint on the lifetimes of generic parameters.

B.337:2 See LifetimeIndication.

B.338. lifetime elision

B.338:1 Lifetime elision is a set of relaxations on the use of lifetimes.

B.339. lifetime parameter

B.339:1 A lifetime parameter is a generic parameter for a lifetime.

B.339:2 See LifetimeParameter.

B.340. line

B.340:1 A line is a sequence of zero or more characters followed by an end of line.

B.341. line comment

B.341:1 A line comment is a comment that spans exactly one line.

B.341:2 See LineComment.

B.342. literal

B.342:1 A literal is a fixed value in program text.

B.342:2 See Literal.

B.343. literal expression

B.343:1 A literal expression is an expression that denotes a literal.

B.343:2 See LiteralExpression.

B.344. literal pattern

B.344:1 A literal pattern is a pattern that matches a literal.

B.344:2 See LiteralPattern.

B.345. local trait

B.345:1 A local trait is a trait that is defined in the current crate.

B.346. local type

B.346:1 A local type is a type that is defined in the current crate.

B.347. local variable

B.347:1 For local variable, see variable.

B.348. loop

B.348:1 For loop, see loop expression.

B.349. loop expression

B.349:1 A loop expression is an expression that evaluates a block expression continuously as long as some criterion holds true.

B.349:2 See LoopExpression.

B.350. macro

B.350:1 A macro is a custom definition that extends Rust by defining callable syntactic transformations.

B.351. macro expansion

B.351:1 Macro expansion is the process of statically executing a macro invocation and replacing it with the produced output of the macro invocation.

B.352. macro implementation function

B.352:1 A macro implementation function is the function that encapsulates the syntactic transformations of a procedural macro.

B.353. macro invocation

B.353: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.353:2 See MacroInvocation.

B.354. macro match

B.354:1 A macro match is the most basic form of a satisfied macro matcher.

B.354:2 See MacroMatch.

B.355. macro matcher

B.355:1 A macro matcher is a construct that describes a syntactic pattern that a macro must match.

B.355:2 See MacroMatcher.

B.356. macro matching

B.356:1 Macro matching is the process of performing rule matching and token matching.

B.357. macro repetition

B.357:1 A macro repetition is either a macro repetition in matching or a macro repetition in transcription.

B.358. macro repetition in matching

B.358:1 A macro repetition in matching allows for a syntactic pattern to be matched zero or multiple times during macro matching.

B.358:2 See MacroRepetitionMatch.

B.359. macro repetition in transcription

B.359:1 A macro repetition in transcription allows for a syntactic pattern to be transcribed zero or multiple times during macro transcription.

B.359:2 See MacroRepetitionTranscriber.

B.360. macro rule

B.360:1 A macro rule is a construct that consists of a macro matcher and a macro transcriber.

B.360:2 See MacroRule.

B.361. macro statement

B.361:1 A macro statement is a statement expressed as a terminated macro invocation.

B.362. macro transcriber

B.362:1 A macro transcriber is a construct that describes the replacement syntax of a macro.

B.362:2 See MacroTranscriber.

B.363. macro transcription

B.363:1 Macro transcription is the process of producing the expansion of a declarative macro.

B.364. main function

B.364:1 A main function is a function that acts as an entry point into a program.

B.365. match arm

B.365:1 A match arm is a construct that consists of a match arm matcher and a match arm body.

B.366. match arm body

B.366:1 A match arm body is the operand of a match arm.

B.367. match arm guard

B.367:1 A match arm guard is a construct that provides additional filtering to a match arm matcher.

B.367:2 See MatchArmGuard.

B.368. match arm matcher

B.368:1 A match arm matcher is a construct that consists of a pattern and a match arm guard.

B.368:2 See MatchArmMatcher.

B.369. match expression

B.369: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.369:2 See MatchExpression.

B.370. metavariable

B.370:1 A metavariable is a macro match that describes a variable.

B.370:2 See MacroMetavariable.

B.371. metavariable indication

B.371:1 A metavariable indication is a construct that indicates a metavariable.

B.371:2 See MacroMetavariableIndication.

B.372. method

B.372:1 A method is an associated function with a receiver.

B.373. method call expression

B.373:1 A method call expression is an expression that invokes a method of a variable.

B.373:2 See MethodCallExpression.

B.374. mixed site hygiene

B.374:1 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.375. modifying operand

B.375:1 A modifying operand is an operand that supplies the value that is used in the calculation of a compound assignment expression.

B.375:2 See ModifyingOperand.

B.376. module

B.376:1 A module is a container for zero or more items.

B.376:2 See ModuleDeclaration.

B.377. multiplication assignment

B.377:1 For multiplication assignment, see multiplication assignment expression.

B.378. multiplication assignment expression

B.378:1 A multiplication assignment expression is a compound assignment expression that uses multiplication.

B.378:2 See MultiplicationAssignmentExpression.

B.379. multiplication expression

B.379:1 A multiplication expression is an arithmetic expression that uses multiplication.

B.379:2 See MultiplicationExpression.

B.380. mutability

B.380:1 Mutability determines whether a construct can modify a value.

B.381. mutable

B.381:1 A value is mutable when it can be modified.

B.382. mutable assignee expression

B.382:1 A mutable assignee expression is an assignee expression whose value can be modified.

B.383. mutable binding

B.383:1 A mutable binding is a binding whose value can be modified.

B.384. mutable borrow

B.384:1 A mutable borrow is a mutable reference produced by borrowing.

B.385. mutable borrow expression

B.385:1 A mutable borrow expression is a borrow expression that has keyword mut.

B.386. mutable place expression

B.386:1 A mutable place expression is a place expression whose memory location can be modified.

B.387. mutable place expression context

B.387:1 A mutable place expression context is a place expression context that may evaluate its operand as a mutable memory location.

B.388. mutable raw pointer type

B.388:1 A mutable raw pointer type is a raw pointer type subject to keyword mut.

B.389. mutable reference

B.389:1 A mutable reference is a value of a mutable reference type, and allows the mutation of its referent.

B.390. mutable reference type

B.390:1 A mutable reference type is a reference type subject to keyword mut.

B.391. mutable static

B.391:1 A mutable static is a static whose value can be modified.

B.392. mutable variable

B.392:1 A mutable variable is a variable whose value can be modified.

B.393. name

B.393:1 A name identifies an entity within the program text.

B.393:2 See Name.

B.394. named deconstructor

B.394:1 A named deconstructor is a construct that matches the name of a field.

B.394:2 See NamedDeconstructor.

B.395. named field selector

B.395:1 A named field selector is a field selector where the selected field is indicated by an identifier.

B.395:2 See NamedFieldSelector.

B.396. named initializer

B.396:1 A named initializer is a construct that specifies the name and initial value of a field in a struct expression.

B.396:2 See NamedInitializer.

B.397. named loop

B.397:1 A named loop is a loop expression with a label.

B.398. negation expression

B.398:1 A negation expression is an expression that negates its operand.

B.398:2 See NegationExpression.

B.399. nesting import

B.399:1 A nesting import is a use import that provides a common path prefix for its nested use imports.

B.399:2 See NestingImport.

B.400. never type

B.400:1 The never type is a type that represents the result of a computation that never completes.

B.400:2 See NeverType.

B.401. non-reference pattern

B.401:1 A non-reference pattern is any pattern except non-binding patterns, path patterns, reference patterns, and underscore patterns.

B.402. not configuration predicate

B.402:1 A not configuration predicate is a configuration predicate that negates the Boolean value of its nested configuration predicate.

B.402:2 See ConfigurationPredicateNot.

B.403. not-equals expression

B.403:1 A not-equals expression is a comparison expression that tests for inequality.

B.403:2 See NotEqualsExpression.

B.404. null

B.404:1 A null value denotes a tool-defined address.

B.405. numeric literal

B.405:1 A numeric literal is a literal that denotes a number.

B.405:2 See NumericLiteral.

B.406. numeric type

B.406:1 A numeric type is a type whose values denote numbers.

B.407. object safe

B.407:1 A trait is object safe when it can be used as a trait object type.

B.408. object safety

B.408:1 Object safety is the process of determining whether a trait can be used as a trait object type.

B.409. obsolete range pattern

B.409:1 An obsolete range pattern is a range pattern that uses obsolete syntax to express an inclusive range pattern.

B.409:2 See ObsoleteRangePattern.

B.410. octal literal

B.410:1 An octal literal is an integer literal in base 8.

B.410:2 See OctalLiteral.

B.411. operand

B.411:1 An operand is an expression nested within an expression.

B.411:2 See Operand.

B.412. operator expression

B.412:1 An operator expression is an expression that involves an operator.

B.412:2 See OperatorExpression.

B.413. opt-out trait bound

B.413:1 An opt-out trait bound is a trait bound which negates the implementation of a trait.

B.414. outer attribute

B.414:1 An outer attribute is an attribute that applies to a subsequent item.

B.414:2 See OuterAttribute.

B.415. outer block doc

B.415:1 An outer block doc is a block comment that applies to a subsequent non-comment construct.

B.415:2 See OuterBlockDoc.

B.416. outer doc comment

B.416:1 An outer doc comment is either an outer block doc or an outer line doc.

B.417. outer line doc

B.417:1 An outer line doc is a line comment that applies to a subsequent non-comment construct.

B.417:2 See OuterLineDoc.

B.418. outline module

B.418:1 An outline module is a module with an OutlineModuleSpecification.

B.418:2 See OutlineModuleSpecification.

B.419. overlap

B.419:1 Two values overlap when their memory locations overlap, or both values are elements of the same array.

B.420. owner

B.420:1 An owner is a value holder that holds a value.

B.421. ownership

B.421:1 Ownership is a property of values that is central to the resource management model of Rust.

B.422. panic

B.422:1 A panic is an abnormal program state caused by invoking macro core::panic.

B.423. parenthesized expression

B.423:1 A parenthesized expression is an expression that groups other expressions.

B.423:2 See ParenthesizedExpression.

B.424. parenthesized pattern

B.424:1 A parenthesized pattern is a pattern that controls the precedence of its subpatterns.

B.424:2 See ParenthesizedPattern.

B.425. parenthesized type

B.425:1 A parenthesized type is a type that disambiguates the interpretation of lexical elements.

B.425:2 See ParenthesizedTypeSpecification.

B.426. partially hygienic

B.426:1 An identifier is partially hygienic when it has mixed site hygiene.

B.427. passing convention

B.427:1 A passing convention is a mechanism by which a value is passed to and from a function.

B.428. path

B.428:1 A path is a sequence of path segments logically separated by namespace qualifier :: that resolves to a name.

B.429. path expression

B.429:1 A path expression is an expression that denotes a path.

B.429:2 See PathExpression.

B.430. path pattern

B.430: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.430:2 See PathPattern.

B.431. path segment

B.431:1 A path segment is a constituent of a path.

B.431:2 See PathSegment, SimplePathSegment, TypePathSegment.

B.432. path-in-expression

B.432:1 A path-in-expression is a path that appears in an expression context.

B.432:2 See PathInExpression.

B.433. pattern

B.433:1 A pattern is a construct that matches a value which satisfies all the criteria of the pattern.

B.433:2 See Pattern.

B.434. pattern matching

B.434:1 Pattern matching is the process of matching a pattern against a value.

B.435. pattern-without-alternation

B.435:1 A pattern-without-alternation is a pattern that cannot be alternated.

B.435:2 See PatternWithoutAlternation.

B.436. pattern-without-range

B.436:1 A pattern-without-range is a pattern-without-alternation that excludes range patterns.

B.436:2 See PatternWithoutRange.

B.437. place expression

B.437:1 A place expression is an expression that represents a memory location.

B.438. place expression context

B.438:1 A place expression context is a construct that may evaluate its operand as a memory location.

B.439. plane

B.439:1 In Unicode, a plane is a continuous group of 65,536 code points.

B.440. pointer

B.440:1 A pointer is a value of a pointer type.

B.441. pointer type

B.441:1 A pointer type is a type whose values indicate memory locations.

B.442. precedence

B.442:1 Precedence is the order by which expressions are evaluated in the presence of other expressions.

B.443. primitive representation

B.443:1 Primitive representation is the type representation of integer types.

B.444. primitive type

B.444:1 A primitive type is a type class that includes the never type, scalar types, and type str.

B.444: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.445. private visibility

B.445: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.446. proc-macro crate

B.446:1 A proc-macro crate is a crate that contains procedural macros.

B.447. procedural macro

B.447:1 A procedural macro is a macro that encapsulates syntactic transformations in a function.

B.448. public visibility

B.448:1 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 M.

B.449. punctuator

B.449:1 A punctuator is a character or a sequence of characters in category Punctuation.

B.450. pure identifier

B.450:1 A pure identifier is an identifier that does not include weak keywords.

B.451. qualified path-in-expression

B.451:1 A qualified path-in-expression is a path-in-expression that contains a qualified type.

B.452. range expression

B.452:1 A range expression is an expression that constructs a range.

B.452:2 See RangeExpression.

B.453. range expression high bound

B.453:1 A range expression high bound is an operand that specifies the end of a range.

B.453:2 See RangeExpressionHighBound.

B.454. range expression low bound

B.454:1 A range expression low bound is an operand that specifies the start of a range.

B.454:2 See RangeExpressionLowBound.

B.455. range pattern

B.455:1 A range pattern is a pattern that matches values which fall within a range.

B.455:2 See RangePattern.

B.456. range pattern bound

B.456:1 A range pattern bound is a constraint on the range of a range pattern.

B.456:2 See RangePatternBound.

B.457. range pattern high bound

B.457:1 A range pattern high bound is a range pattern bound that specifies the end of a range.

B.457:2 See RangePatternHighBound.

B.458. range pattern low bound

B.458:1 A range pattern low bound is a range pattern bound that specifies the start of a range.

B.458:2 See RangePatternLowBound.

B.459. range-from expression

B.459:1 A range-from expression is a range expression that specifies an included range expression low bound.

B.459:2 See RangeFromExpression.

B.460. range-from-to expression

B.460: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.460:2 See RangeFromToExpression.

B.461. range-full expression

B.461:1 A range-full expression is a range expression that covers the whole range of a type.

B.461:2 See RangeFullExpression.

B.462. range-inclusive expression

B.462: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.462:2 See RangeInclusiveExpression.

B.463. range-to expression

B.463:1 A range-to expression is a range expression that specifies an excluded range expression high bound.

B.463:2 See RangeToExpression.

B.464. range-to-inclusive expression

B.464:1 A range-to-inclusive expression is a range expression that specifies an included range expression high bound.

B.464:2 See RangeToInclusiveExpression.

B.465. raw byte string literal

B.465:1 A raw byte string literal is a simple byte string literal that does not recognize escaped characters.

B.465:2 See RawByteStringLiteral.

B.466. raw pointer

B.466:1 A raw pointer is a pointer of a raw pointer type.

B.467. raw pointer type

B.467:1 A raw pointer type is an indirection type without safety and liveness guarantees.

B.467:2 See RawPointerTypeSpecification.

B.468. raw string literal

B.468:1 A raw string literal is a simple string literal that does not recognize escaped characters.

B.468:2 See RawStringLiteral.

B.469. receiver

B.469:1 For receiver, see self parameter.

B.470. receiver operand

B.470:1 A receiver operand is an operand that denotes the value whose method is being invoked by a method call expression.

B.470:2 See ReceiverOperand.

B.471. record enum variant

B.471:1 A record enum variant is an enum variant with a RecordStructFieldList.

B.472. record struct

B.472:1 A record struct is a struct with a RecordStructFieldList.

B.472:2 See RecordStructDeclaration.

B.473. record struct field

B.473:1 A record struct field is a field of a record struct type.

B.473:2 See RecordStructField.

B.474. record struct pattern

B.474:1 A record struct pattern is a pattern that matches a enum variant value, a struct value, or a union value.

B.474:2 See RecordStructPattern.

B.475. record struct type

B.475:1 A record struct type is the type of a record struct.

B.476. record struct value

B.476:1 A record struct value is a value of a record struct type.

B.477. recursive type

B.477:1 A recursive type is a type that may define other types within its type specification.

B.478. reference

B.478:1 A reference is a value of a reference type.

B.479. reference identifier pattern

B.479:1 A reference identifier pattern is an identifier pattern with keyword ref.

B.480. reference pattern

B.480:1 A reference pattern is a pattern that dereferences a pointer that is being matched.

B.480:2 See ReferencePattern.

B.481. reference type

B.481:1 A reference type is an indirection type with ownership.

B.481:2 See ReferenceTypeSpecification.

B.482. referent

B.482:1 A referent is the value pointed-to by a reference.

B.483. refutability

B.483:1 Refutability is a property of patterns that expresses the ability to match all possible values of a type.

B.484. refutable

B.484:1 For refutable, see refutable pattern.

B.485. refutable constant

B.485:1 A refutable constant is a constant of a refutable type.

B.486. refutable pattern

B.486:1 A refutable pattern is a pattern that has a possibility of not matching the value it is being matched against.

B.487. refutable type

B.487:1 A refutable type is a type that has more than one value.

B.488. remainder assignment

B.488:1 For remainder assignment, see remainder assignment expression.

B.489. remainder assignment expression

B.489:1 A remainder assignment expression is a compound assignment expression that uses remainder division.

B.489:2 See RemainderAssignmentExpression.

B.490. remainder expression

B.490:1 A remainder expression is an arithmetic expression that uses remainder division.

B.490:2 See RemainderExpression.

B.491. renaming

B.491:1 A renaming provides an alternative name for an existing name.

B.491:2 See Renaming.

B.492. repeat operand

B.492:1 A repeat operand is an operand that specifies the element being repeated in an array repetition constructor.

B.492:2 See RepeatOperand.

B.493. repetition operator

B.493: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.493:2 See MacroRepetitionOperator.

B.494. representation

B.494:1 See type representation.

B.495. reserved keyword

B.495:1 A reserved keyword is a keyword that is not yet in use.

B.495:2 See ReservedKeyword.

B.496. rest pattern

B.496:1 A rest pattern is a pattern that matches zero or more elements that have not already been matched.

B.496:2 See RestPattern.

B.497. return expression

B.497:1 A return expression is an expression that optionally yields a value and causes control flow to return to the caller.

B.497:2 See ReturnExpression.

B.498. return type

B.498:1 A return type is the type of the result a function returns.

B.498:2 See ReturnType.

B.499. right operand

B.499:1 A right operand is an operand that appears on the right-hand side of a binary operator.

B.499:2 See RightOperand.

B.500. rule matching

B.500:1 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.501. rustc

B.501:1 Rust-c (or rustc) is a compiler that implements the Ferrocene Language Specification.

B.502. safety invariant

B.502:1 A safety invariant is an invariant that when violated may result in undefined behavior.

B.503. scalar type

B.503:1 A scalar type is either a bool type, a char type, or a numeric type.

B.504. scope

B.504:1 A scope is a region of program text where a name can be referred to.

B.505. selected field

B.505:1 A selected field is a field that is selected by a field access expression.

B.506. Self

B.506:1 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.507. self parameter

B.507:1 A self parameter is a function parameter expressed by keyword self.

B.508. self public modifier

B.508:1 A self public modifier is a visibility modifier that grants a name private visibility.

B.508:2 See SelfPublicModifier.

B.509. send type

B.509:1 A send type is a type that implements the core::marker::Send trait.

B.510. separator

B.510:1 A separator is a character or a string that separates adjacent lexical elements.

B.511. sequence type

B.511:1 A sequence type represents a sequence of elements.

B.512. shared borrow

B.512:1 A shared borrow is a borrow produced by evaluating an immutable borrow expression.

B.513. shared reference

B.513:1 A shared reference is a value of a shared reference type.

B.514. shared reference type

B.514:1 A shared reference type is a reference type not subject to keyword mut.

B.515. shift left assignment

B.515:1 For shift left assignment, see shift left assignment expression.

B.516. shift left assignment expression

B.516:1 A shift left assignment expression is a compound assignment expression that uses bit shift left arithmetic.

B.516:2 See ShiftLeftAssignmentExpression.

B.517. shift left expression

B.517:1 A shift left expression is a bit expression that uses bit shift left arithmetic.

B.517:2 See ShiftLeftExpression.

B.518. shift right assignment

B.518:1 For shift right assignment, see shift right assignment expression.

B.519. shift right assignment expression

B.519:1 A shift right assignment expression is a compound assignment expression that uses bit shift right arithmetic.

B.519:2 See ShiftRightAssignmentExpression.

B.520. shift right expression

B.520:1 A shift right expression is a bit expression that uses bit shift right arithmetic.

B.520:2 See ShiftRightExpression.

B.521. shorthand deconstructor

B.521: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.521:2 See ShorthandDeconstructor.

B.522. shorthand initializer

B.522:1 A shorthand initializer is a construct that specifies the name of a field in a struct expression.

B.522:2 See ShorthandInitializer.

B.523. signed integer type

B.523:1 A signed integer type is an integer type whose values denote negative whole numbers, zero, and positive whole numbers.

B.524. simple byte string literal

B.524:1 A simple byte string literal is a byte string literal that consists of multiple AsciiCharacters.

B.524:2 See SimpleByteStringLiteral.

B.525. simple import

B.525:1 A simple import is a use import that binds a simple path to a local name by using an optional renaming.

B.525:2 See SimpleImport.

B.526. simple path

B.526:1 A simple path is a path whose path segments consist of either identifiers or certain keywords.

B.526:2 See SimplePath.

B.527. simple path public modifier

B.527:1 A simple path public modifier is a visibility modifier that grants a name public visibility within the provided simple path only.

B.527:2 See SimplePathPublicModifier.

B.528. simple public modifier

B.528:1 A simple public modifier is a visibility modifier that grants a name public visibility.

B.528:2 See SelfPublicModifier.

B.529. simple string literal

B.529:1 A simple string literal is a string literal where the characters are Unicode characters.

B.529:2 See SimpleStringLiteral.

B.530. size

B.530: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.531. size operand

B.531:1 A size operand is an operand that specifies the size of an array or an array type.

B.531:2 See SizeOperand.

B.532. sized type

B.532:1 A sized type is a type with statically known size.

B.533. slice

B.533:1 A slice is a value of a slice type.

B.534. slice pattern

B.534:1 A slice pattern is a pattern that matches arrays of fixed size and slices of dynamic size.

B.534:2 See SlicePattern.

B.535. slice type

B.535:1 A slice type is a sequence type that provides a view into a sequence of elements.

B.535:2 See SliceTypeSpecification.

B.536. source file

B.536:1 A source file contains the program text of inner attributes, inner doc comments, and items.

B.536:2 See SourceFile.

B.537. statement

B.537:1 A statement is a component of a block expression.

B.537:2 See Statement.

B.538. static

B.538:1 A static is a value that is associated with a specific memory location.

B.538:2 See StaticDeclaration.

B.539. static initializer

B.539:1 A static initializer is a construct that provides the value of its related static.

B.539:2 See StaticInitializer.

B.540. static lifetime elision

B.540:1 Static lifetime elision is a form of lifetime elision that applies to constants and statics.

B.541. str

B.541:1 str is a sequence type that represents a slice of 8-bit unsigned bytes.

B.542. strict keyword

B.542:1 A strict keyword is a keyword that always holds its special meaning.

B.542:2 See StrictKeyword.

B.543. string literal

B.543:1 A string literal is a literal that consists of multiple characters.

B.543:2 See StringLiteral.

B.544. struct

B.544:1 A struct is an item that declares a struct type.

B.545. struct expression

B.545:1 A struct expression is an expression that constructs an enum value, a struct value, or a union value.

B.545:2 See StructExpression.

B.546. struct field

B.546:1 A struct field is a field of a struct type.

B.547. struct pattern

B.547:1 A struct pattern is a pattern that matches an enum value, a struct value, or a union value.

B.547:2 See StructPattern.

B.548. struct type

B.548:1 A struct type is an abstract data type that is a product of other types.

B.548:2 See StructDeclaration.

B.549. struct value

B.549:1 A struct value is a value of a struct type.

B.550. structurally equal

B.550:1 A type is structurally equal when its values can be compared for equality by structure.

B.551. subexpression

B.551:1 A subexpression is an expression nested within another expression.

B.552. subject expression

B.552:1 A subject expression is an expression that controls for loops, if expressions, and match expressions.

B.552:2 See SubjectExpression.

B.553. subject let expression

B.553:1 A subject let expression is an expression that controls if let expressions and while let loops.

B.553:2 See SubjectLetExpression.

B.554. subpattern

B.554:1 A subpattern is a pattern nested within another pattern.

B.555. subtraction assignment

B.555:1 For subtraction assignment, see subtraction assignment.

B.556. subtraction assignment expression

B.556:1 A subtraction assignment expression is a compound assignment expression that uses subtraction.

B.556:2 See SubtractionAssignmentExpression.

B.557. subtraction expression

B.557:1 A subtraction expression is an arithmetic expression that uses subtraction.

B.557:2 See SubtractionExpression.

B.558. subtrait

B.558:1 A subtrait is a trait with a supertrait.

B.559. subtype

B.559:1 A subtype is a type with additional constraints.

B.560. subtyping

B.560:1 Subtyping is a property of types, allowing one type to be used where another type is expected.

B.561. suffixed float

B.561:1 A suffixed float is a float literal with a float suffix.

B.562. suffixed integer

B.562:1 A suffixed integer is an integer literal with an integer suffix.

B.563. super public modifier

B.563:1 A super public modifier is a visibility modifier that grants a name public visibility within the parent module only.

B.563:2 See SuperPublicModifier.

B.564. supertrait

B.564:1 A supertrait is a transitive trait that a type must additionally implement.

B.565. sync type

B.565:1 A sync type is a type that implements the core::marker::Sync trait.

B.566. syntactic category

B.566:1 A syntactic category is a nonterminal in the Backus-Naur Form grammar definition of the Rust programming language.

B.567. tail expression

B.567:1 A tail expression is the last expression within a block expression.

B.568. temporary

B.568:1 A temporary is an anonymous variable produced by some intermediate computation.

B.569. terminated

B.569:1 A loop expression is terminated when its block expression is no longer evaluated.

B.570. terminated macro invocation

B.570:1 A terminated macro invocation is a macro invocation that may be used as a statement.

B.570:2 See TerminatedMacroInvocation.

B.571. textual type

B.571:1 A textual type is a type class that includes type char and type str.

B.572. thin pointer

B.572:1 A thin pointer is a value of a thin pointer type.

B.573. thin pointer type

B.573:1 A thin pointer type is an indirection type that refers to a fixed sized type.

B.574. token matching

B.574:1 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.575. tokens

B.575:1 Tokens are a subset of lexical elements consumed by macros.

B.576. trait

B.576:1 A trait is an item that describes an interface a type can implement.

B.576:2 See TraitDeclaration.

B.577. trait bound

B.577:1 A trait bound is a bound that imposes a constraint on the traits of generic parameters.

B.577:2 See TraitBound.

B.578. trait implementation

B.578:1 A trait implementation is an implementation that adds functionality specified by a trait.

B.578:2 See TraitImplementation.

B.579. trait object lifetime elision

B.579:1 Trait object lifetime elision is a form of lifetime elision that applies to trait object types.

B.580. trait object type

B.580:1 A trait object type is a type that implements a trait, where the type is not known at compile time.

B.580:2 See TraitObjectTypeSpecification, TraitObjectTypeSpecificationOneBound.

B.581. trait type

B.581:1 A trait type is either an impl trait type or a trait object type.

B.582. transparent representation

B.582:1 Transparent representation is a type representation that ???.

B.583. trivial predicate

B.583: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.584. tuple

B.584:1 A tuple is a value of a tuple type.

B.585. tuple enum variant

B.585:1 A tuple enum variant is an enum variant with a TupleStructFieldList.

B.586. tuple enum variant value

B.586:1 A tuple enum variant value is a value of a tuple enum variant.

B.587. tuple expression

B.587:1 A tuple expression is an expression that constructs a tuple.

B.587:2 See TupleExpression.

B.588. tuple field

B.588:1 A tuple field is a field of a tuple type.

B.589. tuple initializer

B.589:1 A tuple initializer is an operand that provides the value of a tuple field in a tuple expression.

B.590. tuple pattern

B.590:1 A tuple pattern is a pattern that matches a tuple which satisfies all criteria defined by its subpatterns.

B.590:2 See TuplePattern.

B.591. tuple struct

B.591:1 A tuple struct is a struct with a TupleStructFieldList.

B.591:2 See TupleStructDeclaration.

B.592. tuple struct call expression

B.592:1 A tuple struct call expression is a call expression where the call operand resolves to a tuple struct.

B.593. tuple struct field

B.593:1 A tuple struct field is a field of a tuple struct type.

B.593:2 See TupleStructField.

B.594. tuple struct pattern

B.594:1 A tuple struct pattern is a pattern that matches a tuple enum variant value or a tuple struct value.

B.594:2 See TupleStructPattern.

B.595. tuple struct type

B.595:1 A tuple struct type is the type of a tuple struct.

B.596. tuple struct value

B.596:1 A tuple struct value is a value of a tuple struct type.

B.597. tuple type

B.597:1 A tuple type is a sequence type that represents a heterogeneous list of other types.

B.597:2 See TupleTypeSpecification.

B.598. type

B.598:1 A type defines a set of values and a set of operations that act on those values.

B.599. type alias

B.599:1 A type alias is an item that defines a name for a type.

B.599:2 See TypeAliasDeclaration.

B.600. type argument

B.600:1 A type argument is a generic argument that supplies the value of a type parameter.

B.600:2 See TypeArgument.

B.601. type ascription

B.601:1 A type ascription specifies the type of a construct.

B.601:2 See TypeAscription.

B.602. type cast expression

B.602:1 A type cast expression is an expression that changes the type of an operand.

B.602:2 See TypeCastExpression.

B.603. type coercion

B.603:1 Type coercion is an implicit operation that changes the type of a value.

B.604. type inference

B.604:1 Type inference is the process of deducing the expected type of an arbitrary value.

B.605. type parameter

B.605:1 A type parameter is a generic parameter for a type.

B.605:2 See TypeParameter.

B.606. type parameter initializer

B.606:1 A type parameter initializer is a construct that provides the default value of its related type parameter.

B.606:2 See TypeParameterInitializer.

B.607. type representation

B.607:1 Type representation specifies the layout of fields of abstract data types.

B.608. type specification

B.608:1 A type specification describes the structure of a type.

B.608:2 See TypeSpecification.

B.609. type unification

B.609:1 Type unification is a measure of compatibility between two types.

B.610. type variable

B.610:1 A type variable is a placeholder for a type.

B.611. u8

B.611:1 u8 is an unsigned integer type whose values range from 0 to 28 - 1, all inclusive.

B.612. u16

B.612:1 u16 is an unsigned integer type whose values range from 0 to 216 - 1, all inclusive.

B.613. u32

B.613:1 u32 is an unsigned integer type whose values range from 0 to 232 - 1, all inclusive.

B.614. u64

B.614:1 u64 is an unsigned integer type whose values range from 0 to 264 - 1, all inclusive.

B.615. u128

B.615:1 u128 is an unsigned integer type whose values range from 0 to 2128 - 1, all inclusive.

B.616. unary operator

B.616:1 A unary operator operates on one operand.

B.617. undefined behavior

B.617:1 Undefined behavior is a situation that results in an unbounded error.

B.618. underscore expression

B.618:1 An underscore expression is an expression that acts as a placeholder in a destructuring assignment.

B.618:2 See UnderscoreExpression.

B.619. underscore pattern

B.619:1 An underscore pattern is a pattern that matches any single value.

B.619:2 See UnderscorePattern.

B.620. unhygienic

B.620:1 An identifier is unhygienic when it has call site hygiene.

B.621. Unicode

B.621:1 Unicode is the colloquial name for the ISO/IEC 10646:2017 Universal Coded Character Set standard.

B.622. unifiable

B.622:1 For unifiable, see unify.

B.623. unifiable types

B.623:1 Two types that unify are said to be unifiable types.

B.624. unified type

B.624:1 A unified type is a type produced by type unification.

B.625. unify

B.625:1 A type is said to unify with another type when the domains, ranges, and structures of both types are compatible.

B.626. union

B.626:1 A union is an item that declares a union type.

B.627. union field

B.627:1 A union field is a field of a union type.

B.628. union type

B.628:1 A union type is an abstract data type similar to a C-like union.

B.628:2 See UnionDeclaration.

B.629. union value

B.629:1 A union value is a value of a union type.

B.630. unique immutable reference

B.630: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.631. unit enum variant

B.631:1 A unit enum variant is an enum variant without a field list.

B.632. unit struct

B.632:1 A unit struct is a struct without a field list.

B.632:2 See UnitStructDeclaration.

B.633. unit struct constant

B.633:1: A unit struct constant is a constant implicitly created by a unit struct.

B.634. unit struct type

B.634:1 A unit struct type is the type of a unit struct.

B.635. unit struct value

B.635:1 A unit struct value is a value of a unit struct type.

B.636. unit tuple

B.636:1 A unit tuple is a value of the unit type.

B.637. unit type

B.637:1 The unit type is a tuple type of zero arity.

B.638. unit value

B.638:1 The unit value is the value of a unit type.

B.639. unnamed constant

B.639:1 An unnamed constant is a constant declared with character 0x5F (low line).

B.640. unnamed lifetime

B.640:1 An unnamed lifetime is a lifetime declared with character 0x5F (low line).

B.641. unsafe block

B.641:1 For unsafe block, see unsafe block expression.

B.642. unsafe block expression

B.642:1 An unsafe block expression is a block expression that is specified with keyword unsafe.

B.642:2 See UnsafeBlockExpression.

B.643. unsafe context

B.643:1 An unsafe context is either an unsafe block or an unsafe function.

B.644. unsafe function

B.644:1 An unsafe function is a function subject to keyword unsafe.

B.645. unsafe function item type

B.645:1 An unsafe function item type is a function item type where the related function is an unsafe function.

B.646. unsafe function pointer type

B.646:1 An unsafe function pointer type is a function pointer type subject to keyword unsafe.

B.647. unsafe module

B.647:1 An unsafe module is a module subject to keyword unsafe.

B.648. unsafe operation

B.648:1 An unsafe operation is an operation that can potentially violate the memory-safety guarantees of Rust.

B.649. unsafe Rust

B.649:1 For unsafe Rust, see unsafe operations.

B.650. unsafe trait

B.650:1 An unsafe trait is a trait subject to keyword unsafe

B.651. unsafe trait implementation

B.651:1 An unsafe trait implementation is a trait implementation subject to keyword unsafe.

B.652. unsafety

B.652:1 Unsafety is the presence of unsafe operations in program text.

B.653. unsigned integer type

B.653:1 An unsigned integer type is an integer type whose values denote zero and positive whole numbers.

B.654. unsized coercion

B.654:1 An unsized coercion is a type coercion that converts a sized type into an unsized type.

B.655. unsized type

B.655:1 An unsized type is a type with statically unknown size.

B.656. unsuffixed float

B.656:1 An unsuffixed float is a float literal without a float suffix.

B.657. unsuffixed integer

B.657:1 An unsuffixed integer is an integer literal without an integer suffix.

B.658. use import

B.658:1 A use import brings names into scope within the module or block expression where the use import resides.

B.658:2 See UseImport.

B.659. usize

B.659:1 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.660. valid

B.660:1 A variable is valid when it has been initialized by all reachable control flow paths.

B.661. validity invariant

B.661:1 A validity invariant is an invariant that when violated results in immediate undefined behavior.

B.662. value

B.662: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.663. value expression

B.663:1 A value expression is an expression that represents a value.

B.664. value expression context

B.664:1 A value expression context is an expression context that is not a place expression context.

B.665. value holder

B.665:1 A value holder is either a constant, a static, or a variable.

B.666. value operand

B.666:1 A value operand is an operand that supplies the value that is assigned to an assignee operand by an assignment expression.

B.666:2 See ValueOperand.

B.667. variable

B.667:1 A variable is a placeholder for a value that is allocated on the stack.

B.668. variadic part

B.668:1 A variadic part indicates the presence of C-like optional parameters.

B.668:2 See VariadicPart.

B.669. variance

B.669: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.670. visibility

B.670:1 Visibility is a property of items that determines which modules can refer to the name of an item.

B.671. visibility modifier

B.671:1 A visibility modifier sets the visibility of the name of an item.

B.672. weak keyword

B.672:1 A weak keyword is a keyword whose special meaning depends on the context.

B.672:2 See WeakKeyword.

B.673. where clause

B.673:1 A where clause is a construct that specifies bounds on lifetime parameters and type parameters.

B.673:2 See WhereClause.

B.674. where clause predicate

B.674:1 A where clause predicate is a construct that specifies lifetime bounds on lifetime parameters as well as lifetime bounds and trait bounds on types.

B.674:2 See WhereClausePredicate.

B.675. while let loop

B.675:1 For while let loop, see while let loop expression.

B.676. while let loop expression

B.676:1 A while let loop expression is a loop expression that continues to evaluate its block expression as long as its subject let expression yields a value that can be matched against its pattern.

B.676:2 See WhileLetLoopExpression.

B.677. while loop

B.677:1 For while loop, see while loop expression.

B.678. while loop expression

B.678:1 A while loop expression is a loop expression that continues to evaluate its block expression as long as its iteration expression holds true.

B.678:2 See WhileLoopExpression.

B.679. whitespace string

B.679:1 A whitespace string is a string that consists of one or more whitespace characters.

B.680. zero-sized type

B.680:1 A zero-sized type is a fixed sized type with size zero.

B.681. zero-variant enum type

B.681:1 A zero-variant enum type is an enum type without any enum variants.