B.1. ABI¶

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

B.2. ABI clobber¶

B.2:1 An ABI clobber is an argument to macro core::arch::asm which indicates that the values of selected registers might be overwritten during the execution of an assembly code block.

B.2:2 See AbiClobber.

B.3. ABI kind¶

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

B.3:2 See AbiKind.

B.4. abort¶

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.8:2 See AdditionAssignmentExpression.

B.9. addition expression¶

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

B.9:2 See AdditionExpression.

B.10. adjusted call operand¶

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

B.11. alignment¶

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.12:2 See ConfigurationPredicateAll.

B.13. anonymous loop expression¶

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

B.14. anonymous return type¶

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

B.15. anonymous type parameter¶

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

B.16. any configuration predicate¶

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

B.16:2 See ConfigurationPredicateAny.

B.17. Application Binary Interface¶

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

B.17:2 See AbiSpecification.

B.18. argument operand¶

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

B.19. arithmetic expression¶

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

B.19:2 See ArithmeticExpression.

B.20. arithmetic operator¶

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

B.21. arithmetic overflow¶

B.21: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.22. arity¶

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

B.23. array¶

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

B.24. array element constructor¶

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

B.24:2 See ArrayElementConstructor.

B.25. array expression¶

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

B.25:2 See ArrayExpression.

B.26. array repetition constructor¶

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

B.26:2 See ArrayRepetitionConstructor.

B.27. array type¶

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

B.27:2 See ArrayTypeSpecification.

B.28. assembly code block¶

B.28:1 An assembly code block is a sequence of assembly instructions.

B.28:2 See AssemblyCodeBlock.

B.29. assembly directive¶

B.29:1 An assembly directive is a request to the assembler to perform a particular action or change a setting.

B.30. assembly instruction¶

B.30:1 An assembly instruction is a string literal that represents a low-level assembly operation or an assembly directive.

B.30:2 See AssemblyInstruction.

B.31. assembly option¶

B.31:1 An assembly option is used to specify a characteristic of or a restriction on the related assembly code block.

B.31:2 See AssemblyOption.

B.32. assigned operand¶

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

B.32:2 See AssignedOperand.

B.33. assignee expression¶

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

B.34. assignee operand¶

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

B.34:2 See AssigneeOperand.

B.35. assignment¶

B.35:1 See assignment expression.

B.36. assignment expression¶

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

B.36:2 See AssignmentExpression.

B.37. associated constant¶

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

B.38. associated function¶

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

B.39. associated implementation constant¶

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

B.40. associated implementation function¶

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

B.41. associated implementation type¶

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

B.42. associated item¶

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

B.42:2 See AssociatedItem.

B.43. associated trait constant¶

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

B.44. associated trait function¶

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

B.45. associated trait implementation item¶

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

B.46. associated trait item¶

B.46:1 An associated trait item is an associated item that appears within a trait.

B.47. associated trait type¶

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

B.48. associated type¶

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

B.49. associated type projection¶

B.49:1 An associated type projection is a qualified type path of the form <type as trait>::associated_type, where type is a type, trait is a qualifying trait, and associated type is an associated type.

B.50. associativity¶

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

B.51. async block¶

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

B.52. async block expression¶

B.52: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.52:2 See AsyncBlockExpression.

B.53. async control flow boundary¶

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

B.54. async function¶

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

B.55. atomic¶

B.55:1 See atomic type.

B.56. atomic type¶

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

B.57. attribute¶

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

B.58. attribute content¶

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

B.58:2 See AttributeContent.

B.59. attribute macro¶

B.59: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.60. auto trait¶

B.60: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.61. await expression¶

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

B.61:2 See AwaitExpression.

B.62. base initializer¶

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

B.63. basic assignment¶

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

B.64. binary crate¶

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

B.65. binary literal¶

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

B.65:2 See BinaryLiteral.

B.66. binary operator¶

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

B.67. binding¶

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

B.67:2 See Binding.

B.68. binding argument¶

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

B.69. binding mode¶

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

B.70. binding pattern¶

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

B.71. binding scope¶

B.71:1 A binding scope is a scope for bindings.

B.72. bit and assignment¶

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

B.73. bit and assignment expression¶

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

B.73:2 See BitAndAssignmentExpression.

B.74. bit and expression¶

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

B.74:2 See BitAndExpression.

B.75. bit expression¶

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

B.75:2 See BitExpression.

B.76. bit or assignment¶

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

B.77. bit or assignment expression¶

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

B.77:2 See BitOrAssignmentExpression.

B.78. bit or expression¶

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

B.78:2 See BitOrExpression.

B.79. bit xor assignment¶

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

B.80. bit xor assignment expression¶

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

B.80:2 See BitXorAssignmentExpression.

B.81. bit xor expression¶

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

B.81:2 See BitXorExpression.

B.82. block comment¶

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

B.82:2 See BlockComment.

B.83. block expression¶

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

B.83:2 See BlockExpression.

B.84. bool¶

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

B.85. boolean literal¶

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

B.85:2 See BooleanLiteral.

B.86. borrow¶

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

B.87. borrow expression¶

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

B.88. borrowed¶

B.88:1 A memory location is borrowed when a reference pointing to it is active.

B.89. borrowing¶

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

B.90. bound¶

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

B.90:2 See TypeBound.

B.91. bound pattern¶

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

B.91:2 See BoundPattern.

B.92. break expression¶

B.92:1 A break expression is an expression that terminates a loop expression or a named block expression.

B.92:2 See BreakExpression.

B.93. break type¶

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

B.94. break value¶

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

B.95. built-in attribute¶

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

B.95:2 See InnerBuiltinAttribute, OuterBuiltinAttribute.

B.96. built-in trait¶

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

B.97. byte literal¶

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

B.97:2 See ByteLiteral.

B.98. byte string literal¶

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

B.98:2 See ByteStringLiteral.

B.99. C¶

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

B.100. C representation¶

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

B.101. C signed int type¶

B.101:1 C signed int type is the signed int type of the C language.

B.102. Call conformance¶

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

B.103. call expression¶

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

B.103:2 See CallExpression.

B.104. call operand¶

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

B.105. call resolution¶

B.105:1 Call resolution is a kind of resolution that applies to a call expression.

B.106. call site hygiene¶

B.106: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.107. callee type¶

B.107: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.108. capture mode¶

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

B.109. capture target¶

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

B.110. capturing¶

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

B.111. capturing environment¶

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

B.112. capturing expression¶

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

B.113. cast¶

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

B.114. char¶

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

B.115. character literal¶

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

B.115:2 See CharacterLiteral.

B.116. closure body¶

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

B.116:2 See ClosureBody, ClosureBodyWithReturnType.

B.117. closure expression¶

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

B.117:2 See ClosureExpression.

B.118. closure parameter¶

B.118: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.118:2 See ClosureParameter.

B.119. closure type¶

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

B.120. code point¶

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

B.121. comment¶

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

B.121:2 See Comment.

B.122. comparison expression¶

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

B.122:2 See ComparisonExpression.

B.123. compilation root¶

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

B.124. compound assignment¶

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

B.125. compound assignment expression¶

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

B.126. concrete type¶

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

B.127. conditional compilation¶

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

B.128. conditionally-compiled source code¶

B.128: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.129. configuration predicate¶

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

B.129:2 See ConfigurationPredicate.

B.130. constant¶

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

B.130:2 See ConstantDeclaration.

B.131. constant argument¶

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

B.131:2 See ConstantArgument.

B.132. constant context¶

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

B.133. constant expression¶

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

B.134. constant function¶

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

B.135. constant initializer¶

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

B.135:2 See ConstantInitializer.

B.136. constant parameter¶

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

B.136:2 See ConstantParameter.

B.137. constant parameter initializer¶

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

B.137:2 See ConstantParameterInitializer.

B.138. constant promotion¶

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

B.139. constrain¶

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

B.140. construct¶

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

B.141. constructee¶

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

B.142. container operand¶

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

B.142:2 See ContainerOperand.

B.143. continue expression¶

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

B.143:2 See ContinueExpression.

B.144. control flow boundary¶

B.144: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.145. copy type¶

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

B.146. crate¶

B.146:1 A crate is a unit of compilation and linking that contains a tree of nested modules.

B.147. crate import¶

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

B.147:2 See ExternalCrateImport.

B.148. crate indication¶

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

B.148:2 See CrateIndication.

B.149. crate public modifier¶

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

B.149:2 See CratePublicModifier.

B.150. crate root¶

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

B.151. crate root module¶

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

B.152. dangling¶

B.152: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.153. data race¶

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

B.154. decimal literal¶

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

B.154:2 See DecimalLiteral.

B.155. declaration¶

B.155:1 A declaration is a construct that introduces a name for an entity.

B.156. declarative macro¶

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

B.156:2 See MacroRulesDeclaration.

B.157. deconstructee¶

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

B.157:2 See Deconstructee.

B.158. default representation¶

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

B.159. definition site hygiene¶

B.159: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.160. dereference¶

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

B.161. dereference expression¶

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

B.161:2 See DereferenceExpression.

B.162. dereference type¶

B.162:1 A dereference type is either a reference type or a type that implements the core::ops::Deref trait.

B.163. dereference type chain¶

B.163:1 A dereference type chain is a sequence of dereference types.

B.164. derive macro¶

B.164: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.165. destruction¶

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

B.166. destructor¶

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

B.167. destructuring assignment¶

B.167: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.168. direction modifier¶

B.168: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.168:2 See DirectionModifier.

B.169. discriminant¶

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

B.170. discriminant initializer¶

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

B.170:2 See DiscriminantInitializer.

B.171. discriminant type¶

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

B.172. diverging expression¶

B.172:1 A diverging expression is an expression whose evaluation causes program flow to diverge from the normal evaluation order.

B.173. diverging type variable¶

B.173:1 A diverging type variable is a type variable that can refer to any type and originates from a diverging expression.

B.174. division assignment¶

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

B.175. division assignment expression¶

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

B.175:2 See DivisionAssignmentExpression.

B.176. division expression¶

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

B.176:2 See DivisionExpression.

B.177. doc comment¶

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

B.178. drop construct¶

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

B.179. drop order¶

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

B.180. drop scope¶

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

B.181. drop scope extension¶

B.181: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.182. drop type¶

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

B.183. dropping¶

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

B.184. dynamically sized type¶

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

B.185. elaboration¶

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

B.186. element type¶

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

B.186:2 See ElementType.

B.187. elided¶

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

B.188. elided lifetime¶

B.188: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.189. else expression¶

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

B.189:2 See ElseExpression.

B.190. empty statement¶

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

B.191. entity¶

B.191:1 An entity is a construct that can be referred to within program text, usually via a field access expression or a path.

B.192. enum¶

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

B.193. enum field¶

B.193:1 An enum field is a field of an enum variant.

B.194. enum type¶

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

B.194:2 See EnumDeclaration.

B.195. enum value¶

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

B.196. enum variant¶

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

B.196:2 See EnumVariant.

B.197. enum variant value¶

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

B.198. equals expression¶

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

B.198:2 See EqualsExpression.

B.199. error propagation expression¶

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

B.200. escaped character¶

B.200: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.201. evaluated¶

B.201:1 See evaluation.

B.202. evaluation¶

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

B.203. executed¶

B.203:1 See execution.

B.204. execution¶

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

B.205. explicit register argument¶

B.205:1 An explicit register argument is a register argument that uses an explicit register name.

B.206. explicit register name¶

B.206:1 An explicit register name is a target-specific string that identifies a register.

B.206:2 See ExplicitRegisterName.

B.207. explicitly declared entity¶

B.207:1 An explicitly declared entity is an entity that has a declaration.

B.208. exported function¶

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

B.209. exported static¶

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

B.210. expression¶

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

B.210:2 See Expression.

B.211. expression statement¶

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

B.211:2 See ExpressionStatement.

B.212. expression-with-block¶

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

B.212:2 See ExpressionWithBlock.

B.213. expression-without-block¶

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

B.213:2 See ExpressionWithoutBlock.

B.214. external block¶

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

B.214:2 See ExternalBlock.

B.215. external function¶

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

B.216. external function item type¶

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

B.217. external static¶

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

B.218. f32¶

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

B.219. f64¶

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

B.220. fat pointer¶

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

B.221. fat pointer type¶

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

B.222. FFI¶

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

B.223. field¶

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

B.224. field access expression¶

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

B.224:2 See FieldAccessExpression.

B.225. field index¶

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

B.226. field list¶

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

B.227. field resolution¶

B.227:1 Field resolution is a form of resolution that applies to a field access expression.

B.228. field selector¶

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

B.228:2 See FieldSelector.

B.229. final match arm¶

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

B.229:2 See FinalMatchArm.

B.230. fixed sized type¶

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

B.231. float literal¶

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

B.231:2 See FloatLiteral.

B.232. float suffix¶

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

B.232:2 See FloatSuffix.

B.233. floating-point type¶

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

B.234. floating-point type variable¶

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

B.235. floating-point value¶

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

B.236. for loop¶

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

B.237. for loop expression¶

B.237: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.237:2 See ForLoopExpression.

B.238. Foreign Function Interface¶

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

B.239. fragment specifier¶

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

B.239:2 See MacroFragmentSpecifier.

B.240. full range expression¶

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

B.241. function¶

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

B.241:2 See FunctionDeclaration.

B.242. function body¶

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

B.242:2 See FunctionBody.

B.243. function item type¶

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

B.244. function lifetime elision¶

B.244: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.245. function parameter¶

B.245: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.245:2 See FunctionParameter.

B.246. function pointer type¶

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

B.246:2 See FunctionPointerTypeSpecification.

B.247. function pointer type parameter¶

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

B.247:2 See FunctionPointerTypeParameter.

B.248. function qualifier¶

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

B.248:2 See FunctionQualifierList.

B.249. function signature¶

B.249: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.250. function type¶

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

B.251. function-like macro¶

B.251: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.252. fundamental¶

B.252: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.

B.253. future¶

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

B.254. future operand¶

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

B.254:2 See FutureOperand.

B.255. generic argument¶

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

B.255:2 See GenericArgumentList.

B.256. generic associated type¶

B.256:1 A generic associated type is an associated type with generic parameters.

B.257. generic conformance¶

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

B.258. generic enum¶

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

B.259. generic function¶

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

B.260. generic implementation¶

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

B.261. generic parameter¶

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

B.262. generic parameter scope¶

B.262:1 A generic parameter scope is a scope for generic parameters.

B.263. generic struct¶

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

B.264. generic substitution¶

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

B.265. generic trait¶

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

B.266. generic type¶

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

B.267. generic type alias¶

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

B.268. generic union¶

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

B.269. glob import¶

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

B.269:2 See GlobImport.

B.270. global path¶

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

B.271. global type variable¶

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

B.272. greater-than expression¶

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

B.272:2 See GreaterThanExpression.

B.273. greater-than-or-equals expression¶

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

B.273:2 See GreaterThanOrEqualsExpression.

B.274. half-open range pattern¶

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

B.274:2 See HalfOpenRangePattern.

B.275. hexadecimal literal¶

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

B.275:2 See HexadecimalLiteral.

B.276. higher-ranked trait bound¶

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

B.276:2 See ForGenericParameterList.

B.277. hygiene¶

B.277: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.278. hygienic¶

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

B.279. i8¶

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

B.280. i16¶

B.280:1 i16 is a signed integer type whose values range from - (2¹⁵) to 2¹⁵ - 1, all inclusive.

B.281. i32¶

B.281:1 i32 is a signed integer type whose values range from - (2³¹) to 2³¹ - 1, all inclusive.

B.282. i64¶

B.282:1 i64 is a signed integer type whose values range from - (2⁶³) to 2⁶³ - 1, all inclusive.

B.283. i128¶

B.283:1 i128 is a signed integer type whose values range from - (2¹²⁷) to 2¹²⁷ - 1, all inclusive.

B.284. identifier¶

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

B.284:2 See Identifier.

B.285. identifier pattern¶

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

B.285:2 See IdentifierPattern.

B.286. if expression¶

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

B.287. if let expression¶

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

B.288. immutable¶

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

B.289. immutable borrow¶

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

B.290. immutable borrow expression¶

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

B.291. immutable place expression¶

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

B.292. immutable place expression context¶

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

B.293. immutable raw pointer type¶

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

B.294. immutable reference¶

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

B.295. immutable static¶

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

B.296. immutable variable¶

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

B.297. impl header lifetime elision¶

B.297: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.298. impl trait type¶

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

B.298:2 See ImplTraitTypeSpecification, ImplTraitTypeSpecificationOneBound.

B.299. implementation¶

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

B.299:2 See Implementation.

B.300. implementation body¶

B.300:1 An implementation body is a construct that encapsulates the associated items, inner attributes, and inner doc comments of an implementation.

B.300:2 See ImplementationBody.

B.301. implementation coherence¶

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

B.302. implementation conformance¶

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

B.303. implemented trait¶

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

B.303:2 See ImplementedTrait.

B.304. implementing type¶

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

B.304:2 See ImplementingType.

B.305. implicit borrow¶

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

B.306. implicitly declared entity¶

B.306:1 An implicitly declared entity is an entity that lacks an explicit declaration.

B.307. implied bound¶

B.307: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.308. in scope¶

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

B.309. inclusive range pattern¶

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

B.309:2 See InclusiveRangePattern.

B.310. incomplete associated constant¶

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

B.311. incomplete associated function¶

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

B.312. incomplete associated type¶

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

B.313. index expression¶

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

B.313:2 See IndexExpression.

B.314. indexable type¶

B.314:1 A indexable type is a type that implements the core::ops::Index trait.

B.315. indexed deconstructor¶

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

B.315:2 See IndexedDeconstructor.

B.316. indexed field selector¶

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

B.316:2 See IndexedFieldSelector.

B.317. indexed initializer¶

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

B.317:2 See IndexedInitializer.

B.318. indexed operand¶

B.318: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.318:2 See IndexedOperand.

B.319. indexing operand¶

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

B.319:2 See IndexingOperand.

B.320. indirection type¶

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

B.321. inert attribute¶

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

B.322. inferred type¶

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

B.322:2 See InferredType.

B.323. infinite loop¶

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

B.324. infinite loop expression¶

B.324:1 An infinite loop expression is a loop expression that continues to evaluate its loop body indefinitely.

B.324:2 See InfiniteLoopExpression.

B.325. inherent implementation¶

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

B.325:2 See InherentImplementation.

B.326. initialization¶

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

B.327. initialization expression¶

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

B.328. initialization type¶

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

B.328:2 See InitializationType.

B.329. inline assembly¶

B.329:1 Inline assembly is hand-written assembly code that is integrated into a Rust program.

B.330. inline module¶

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

B.330:2 See InlineModuleSpecification.

B.331. inner attribute¶

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

B.331:2 See InnerAttribute.

B.332. inner block doc¶

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

B.332:2 See InnerBlockDoc.

B.333. inner doc comment¶

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

B.334. inner line doc¶

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

B.334:2 See InnerLineDoc.

B.335. input register¶

B.335:1 An input register is a register whose register name is used in a register argument subject to direction modifier in, inout, or inlateout.

B.336. input register expression¶

B.336:1 An input register expression is an expression that provides the initial value of a register.

B.336:2 See InputRegisterExpression.

B.337. input-output register expression¶

B.337:1 An input-output register expression is a construct that specifies both an input register expression and an output register expression.

B.337:2 See InputOutputRegisterExpression.

B.338. integer literal¶

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

B.338:2 See IntegerLiteral.

B.339. integer suffix¶

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

B.339:2 See IntegerSuffix.

B.340. integer type¶

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

B.341. integer type variable¶

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

B.342. interior mutability¶

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

B.343. intermediate match arm¶

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

B.343:2 See IntermediateMatchArm.

B.344. irrefutable constant¶

B.344:1 An irrefutable constant is a constant of a type that has at most one value.

B.345. irrefutable pattern¶

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

B.346. isize¶

B.346: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.347. item¶

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

B.348. item scope¶

B.348:1 An item scope is a scope for items.

B.349. item statement¶

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

B.350. iteration expression¶

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

B.350:2 See IterationExpression.

B.351. keyword¶

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

B.351:2 See Keyword.

B.352. label¶

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

B.352:2 See Label.

B.353. label indication¶

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

B.353:2 See LabelIndication.

B.354. label scope¶

B.354:1 A label scope is a scope for labels.

B.355. layout¶

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

B.356. lazy and expression¶

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

B.356:2 See LazyAndExpression.

B.357. lazy boolean expression¶

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

B.357:2 See LazyBooleanExpression.

B.358. lazy or expression¶

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

B.358:2 See LazyOrExpression.

B.359. left operand¶

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

B.359:2 See LeftOperand.

B.360. less-than expression¶

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

B.360:2 See LessThanExpression.

B.361. less-than-or-equals expression¶

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

B.361:2 See LessThanOrEqualsExpression.

B.362. let initializer¶

B.362: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.362:2 See LetInitializer.

B.363. let statement¶

B.363: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.363:2 See LetStatement.

B.364. lexical element¶

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

B.365. library crate¶

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

B.366. lifetime¶

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

B.366:2 See Lifetime.

B.367. lifetime argument¶

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

B.367:2 See LifetimeArgument.

B.368. lifetime bound¶

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

B.368:2 See LifetimeIndication.

B.369. lifetime bound predicate¶

B.369:1 A lifetime bound predicate is a construct that specifies lifetime bounds on a lifetime parameter.

B.369:2 See LifetimeBoundPredicate.

B.370. lifetime elision¶

B.370: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.371. lifetime parameter¶

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

B.371:2 See LifetimeParameter.

B.372. lifetime variable¶

B.372:1 A lifetime variable is a placeholder used during type inference to stand in for an undetermined lifetime of a type.

B.373. line¶

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

B.374. line comment¶

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

B.374:2 See LineComment.

B.375. literal¶

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

B.375:2 See Literal.

B.376. literal expression¶

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

B.376:2 See LiteralExpression.

B.377. literal pattern¶

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

B.377:2 See LiteralPattern.

B.378. local trait¶

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

B.379. local type¶

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

B.380. local variable¶

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

B.381. loop¶

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

B.382. loop body¶

B.382:1 A loop body is the block expression of a loop expression.

B.382:2 See LoopBody.

B.383. loop expression¶

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

B.383:2 See LoopExpression.

B.384. macro¶

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

B.385. macro expansion¶

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

B.386. macro implementation function¶

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

B.387. macro invocation¶

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

B.388. macro match¶

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

B.388:2 See MacroMatch.

B.389. macro matcher¶

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

B.389:2 See MacroMatcher.

B.390. macro matching¶

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

B.391. macro repetition¶

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

B.392. macro repetition in matching¶

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

B.392:2 See MacroRepetitionMatch.

B.393. macro repetition in transcription¶

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

B.393:2 See MacroRepetitionTranscriber.

B.394. macro rule¶

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

B.394:2 See MacroRule.

B.395. macro statement¶

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

B.396. macro transcriber¶

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

B.396:2 See MacroTranscriber.

B.397. macro transcription¶

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

B.398. main function¶

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

B.399. match arm¶

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

B.400. match arm body¶

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

B.401. match arm guard¶

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

B.401:2 See MatchArmGuard.

B.402. match arm matcher¶

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

B.402:2 See MatchArmMatcher.

B.403. match expression¶

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

B.404. metavariable¶

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

B.404:2 See MacroMetavariable.

B.405. metavariable indication¶

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

B.405:2 See MacroMetavariableIndication.

B.406. method¶

B.406:1 A method is an associated function with a self parameter.

B.407. method call expression¶

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

B.407:2 See MethodCallExpression.

B.408. method operand¶

B.408:1 A method operand is an operand that denotes the method being invoked by a method call expression.

B.408:2 See MethodOperand.

B.409. method resolution¶

B.409:1 Method resolution is a kind of resolution that applies to a method call expression.

B.410. mixed site hygiene¶

B.410: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.411. modifying operand¶

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

B.411:2 See ModifyingOperand.

B.412. module¶

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

B.412:2 See ModuleDeclaration.

B.413. move type¶

B.413:1 A move type is a type that implements the core::marker::Sized trait and that is not a copy type.

B.414. multi segment path¶

B.414:1 A multi segment path is a path consisting of more than one path segment.

B.415. multiplication assignment¶

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

B.416. multiplication assignment expression¶

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

B.416:2 See MultiplicationAssignmentExpression.

B.417. multiplication expression¶

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

B.417:2 See MultiplicationExpression.

B.418. mutability¶

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

B.419. mutable¶

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

B.420. mutable assignee expression¶

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

B.421. mutable binding¶

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

B.422. mutable borrow¶

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

B.423. mutable borrow expression¶

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

B.424. mutable place expression¶

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

B.425. mutable place expression context¶

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

B.426. mutable raw pointer type¶

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

B.427. mutable reference¶

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

B.428. mutable reference type¶

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

B.429. mutable static¶

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

B.430. mutable variable¶

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

B.431. name¶

B.431:1 A name is an identifier that refers to an entity.

B.431:2 See Name.

B.432. named block expression¶

B.432:1 A named block expression is a block expression with a label.

B.433. named deconstructor¶

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

B.433:2 See NamedDeconstructor.

B.434. named field selector¶

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

B.434:2 See NamedFieldSelector.

B.435. named initializer¶

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

B.435:2 See NamedInitializer.

B.436. named loop expression¶

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

B.437. named register argument¶

B.437:1 A named register argument is a register argument whose configuration is bound to an identifier.

B.438. namespace¶

B.438: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.

B.439. NaN-boxing¶

B.439:1 NaN-boxing is a technique for encoding values using the low order bits of the mantissa of a 64-bit IEEE floating-point NaN.

B.440. negation expression¶

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

B.440:2 See NegationExpression.

B.441. nesting import¶

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

B.441:2 See NestingImport.

B.442. never type¶

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

B.442:2 See NeverType.

B.443. non-reference pattern¶

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

B.444. not configuration predicate¶

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

B.444:2 See ConfigurationPredicateNot.

B.445. not-equals expression¶

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

B.445:2 See NotEqualsExpression.

B.446. null¶

B.446:1 A null value denotes the address 0.

B.447. numeric literal¶

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

B.447:2 See NumericLiteral.

B.448. numeric type¶

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

B.449. object safe¶

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

B.450. object safety¶

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

B.451. obsolete range pattern¶

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

B.451:2 See ObsoleteRangePattern.

B.452. octal literal¶

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

B.452:2 See OctalLiteral.

B.453. operand¶

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

B.453:2 See Operand.

B.454. operator expression¶

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

B.454:2 See OperatorExpression.

B.455. opt-out trait bound¶

B.455:1 An opt-out trait bound is a trait bound with Punctuation ? that nullifies an implicitly added trait bound.

B.456. outer attribute¶

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

B.456:2 See OuterAttribute.

B.457. outer block doc¶

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

B.457:2 See OuterBlockDoc.

B.458. outer doc comment¶

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

B.459. outer line doc¶

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

B.459:2 See OuterLineDoc.

B.460. outline module¶

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

B.460:2 See OutlineModuleSpecification.

B.461. outlives bound¶

B.461:1 An outlives bound is a trait bound which requires that a generic parameter outlives a lifetime parameter.

B.462. output register¶

B.462:1 An output register is a register whose register name is used in a register argument subject to direction modifier out, lateout, inout, or inlateout.

B.463. output register expression¶

B.463:1 An output register expression is an expression that is assigned the value of a register.

B.463:2 See OutputRegisterExpression.

B.464. overlap¶

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

B.465. owner¶

B.465:1 An owner is a variable that holds a value.

B.466. ownership¶

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

B.467. panic¶

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

B.468. parenthesized expression¶

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

B.468:2 See ParenthesizedExpression.

B.469. parenthesized pattern¶

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

B.469:2 See ParenthesizedPattern.

B.470. parenthesized type¶

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

B.470:2 See ParenthesizedTypeSpecification.

B.471. partially hygienic¶

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

B.472. passing convention¶

B.472:1 A passing convention is the mechanism that defines how a value is transferred between places.

B.473. path¶

B.473:1 A path is a sequence of path segments logically separated by namespace qualifier :: that resolves to an entity.

B.474. path expression¶

B.474:1 A path expression is a path that acts as an expression.

B.474:2 See PathExpression.

B.475. path expression resolution¶

B.475:1 Path expression resolution is a form of path resolution that applies to a path expression.

B.476. path pattern¶

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

B.477. path resolution¶

B.477:1 Path resolution is a form of resolution that applies to a path.

B.478. path segment¶

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

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

B.479. pattern¶

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

B.479:2 See Pattern.

B.480. pattern matching¶

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

B.481. pattern-without-alternation¶

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

B.481:2 See PatternWithoutAlternation.

B.482. pattern-without-range¶

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

B.482:2 See PatternWithoutRange.

B.483. place¶

B.483:1 A place is a location where a value resides.

B.484. place expression¶

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

B.485. place expression context¶

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

B.486. plane¶

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

B.487. pointer¶

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

B.488. pointer type¶

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

B.489. positional register argument¶

B.489:1 A positional register argument is a register argument whose configuration is not bound to an identifier.

B.490. precedence¶

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

B.491. prelude¶

B.491:1 A prelude is a collection of entities that are automatically brought in scope of every module in a crate.

B.492. prelude entity¶

B.492:1 A prelude entity is an entity declared in a prelude.

B.493. prelude name¶

B.493:1 A prelude name is a name of a prelude entity.

B.494. primitive representation¶

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

B.495. private visibility¶

B.495: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.496. proc-macro crate¶

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

B.497. procedural macro¶

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

B.498. public visibility¶

B.498: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.499. punctuator¶

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

B.500. pure identifier¶

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

B.501. qualified path expression¶

B.501:1 A qualified path expression is a path expression that resolves through a qualified type.

B.501:2 See QualifiedPathExpression.

B.502. qualified type¶

B.502:1 A qualified type is a type that is restricted to a set of implementations that exhibit implementation conformance to a qualifying trait.

B.502:2 See QualifiedType.

B.503. qualified type path¶

B.503:1 A qualified type path is a type path that resolves through a qualified type.

B.503:2 See QualifiedTypePath.

B.504. qualifying trait¶

B.504:1 A qualifying trait is a trait that imposes a restriction on a qualified type.

B.504:2 See QualifyingTrait.

B.505. range expression¶

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

B.505:2 See RangeExpression.

B.506. range expression high bound¶

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

B.506:2 See RangeExpressionHighBound.

B.507. range expression low bound¶

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

B.507:2 See RangeExpressionLowBound.

B.508. range pattern¶

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

B.508:2 See RangePattern.

B.509. range pattern bound¶

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

B.509:2 See RangePatternBound.

B.510. range pattern high bound¶

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

B.510:2 See RangePatternHighBound.

B.511. range pattern low bound¶

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

B.511:2 See RangePatternLowBound.

B.512. range-from expression¶

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

B.512:2 See RangeFromExpression.

B.513. range-from-to expression¶

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

B.514. range-full expression¶

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

B.514:2 See RangeFullExpression.

B.515. range-inclusive expression¶

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

B.516. range-to expression¶

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

B.516:2 See RangeToExpression.

B.517. range-to-inclusive expression¶

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

B.517:2 See RangeToInclusiveExpression.

B.518. raw byte string literal¶

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

B.518:2 See RawByteStringLiteral.

B.519. raw pointer¶

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

B.520. raw pointer type¶

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

B.520:2 See RawPointerTypeSpecification.

B.521. raw string literal¶

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

B.521:2 See RawStringLiteral.

B.522. reachable control flow path¶

B.522:1 A reachable control flow path is a control flow path that can be taken by the execution of a program between two given points in the program.

B.523. receiver operand¶

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

B.523:2 See ReceiverOperand.

B.524. receiver type¶

B.524:1 A receiver type is the type of a receiver operand.

B.525. record enum variant¶

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

B.526. record struct¶

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

B.526:2 See RecordStructDeclaration.

B.527. record struct field¶

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

B.527:2 See RecordStructField.

B.528. record struct pattern¶

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

B.528:2 See RecordStructPattern.

B.529. record struct type¶

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

B.530. record struct value¶

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

B.531. recursive type¶

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

B.532. reference¶

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

B.533. reference identifier pattern¶

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

B.534. reference pattern¶

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

B.534:2 See ReferencePattern.

B.535. reference type¶

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

B.535:2 See ReferenceTypeSpecification.

B.536. referent¶

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

B.537. refutability¶

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

B.538. refutable constant¶

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

B.539. refutable pattern¶

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

B.540. refutable type¶

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

B.541. register¶

B.541:1 A register is a hardware component capable of holding data that can be read and written.

B.542. register argument¶

B.542: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.542:2 See RegisterArgument.

B.543. register class¶

B.543:1 A register class represents a set of registers.

B.544. register class argument¶

B.544:1 A register class argument is a register argument that uses a register class name.

B.545. register class name¶

B.545:1 A register class name is a target-specific string that identifies a register class.

B.545:2 See RegisterClassName.

B.546. register expression¶

B.546:1 A register expression is either an input-output register expression or a simple register expression.

B.546:2 See RegisterExpression.

B.547. register name¶

B.547: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.547:2 See RegisterName.

B.548. register parameter¶

B.548: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.549. register parameter modifier¶

B.549: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.550. remainder assignment¶

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

B.551. remainder assignment expression¶

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

B.551:2 See RemainderAssignmentExpression.

B.552. remainder expression¶

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

B.552:2 See RemainderExpression.

B.553. renaming¶

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

B.553:2 See Renaming.

B.554. repeat operand¶

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

B.554:2 See RepeatOperand.

B.555. repetition operator¶

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

B.556. representation¶

B.556:1 See type representation.

B.557. representation modifier¶

B.557:1 A representation modifier is a construct that modifies the alignment of a type.

B.557:2 See Alignment.

B.558. reserved keyword¶

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

B.558:2 See ReservedKeyword.

B.559. resolution¶

B.559:1 Resolution is the process of finding a unique interpretation for a field access expression, a method call expression, or a path.

B.560. rest pattern¶

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

B.560:2 See RestPattern.

B.561. return expression¶

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

B.561:2 See ReturnExpression.

B.562. return type¶

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

B.562:2 See ReturnType.

B.563. right operand¶

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

B.563:2 See RightOperand.

B.564. rule matching¶

B.564: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.565. rustc¶

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

B.566. safety invariant¶

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

B.567. scalar type¶

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

B.568. scope¶

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

B.569. scope hierarchy¶

B.569:1 The scope hierarchy reflects the nesting of scopes as introduced by scoping constructs.

B.570. selected field¶

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

B.571. Self¶

B.571: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.572. self parameter¶

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

B.573. self public modifier¶

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

B.573:2 See SelfPublicModifier.

B.574. Self scope¶

B.574:1 A Self scope is a scope for Self.

B.575. send type¶

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

B.576. separator¶

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

B.577. sequence type¶

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

B.578. shadowing¶

B.578: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.579. shared borrow¶

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

B.580. shared reference¶

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

B.581. shared reference type¶

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

B.582. shift left assignment¶

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

B.583. shift left assignment expression¶

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

B.583:2 See ShiftLeftAssignmentExpression.

B.584. shift left expression¶

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

B.584:2 See ShiftLeftExpression.

B.585. shift right assignment¶

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

B.586. shift right assignment expression¶

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

B.586:2 See ShiftRightAssignmentExpression.

B.587. shift right expression¶

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

B.587:2 See ShiftRightExpression.

B.588. shorthand deconstructor¶

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

B.589. shorthand initializer¶

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

B.589:2 See ShorthandInitializer.

B.590. signed integer type¶

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

B.591. simple byte string literal¶

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

B.591:2 See SimpleByteStringLiteral.

B.592. simple import¶

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

B.592:2 See SimpleImport.

B.593. simple path¶

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

B.593:2 See SimplePath.

B.594. simple path prefix¶

B.594:1 A simple path prefix is the leading simple path of a glob import or a nesting import.

B.594:2 See SimplePathPrefix.

B.595. simple path public modifier¶

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

B.595:2 See SimplePathPublicModifier.

B.596. simple path resolution¶

B.596:1 Simple path resolution is a kind of path resolution that applies to a simple path.

B.597. simple public modifier¶

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

B.597:2 See SelfPublicModifier.

B.598. simple register expression¶

B.598:1 A simple register expression is either an expression or an underscore expression.

B.598:2 See SimpleRegisterExpression.

B.599. simple string literal¶

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

B.599:2 See SimpleStringLiteral.

B.600. single segment path¶

B.600:1 A single segment path is a path consisting of exactly one path segment.

B.601. size¶

B.601: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.602. size operand¶

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

B.602:2 See SizeOperand.

B.603. sized type¶

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

B.604. slice¶

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

B.605. slice pattern¶

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

B.605:2 See SlicePattern.

B.606. slice type¶

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

B.606:2 See SliceTypeSpecification.

B.607. source file¶

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

B.607:2 See SourceFile.

B.608. statement¶

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

B.608:2 See Statement.

B.609. static¶

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

B.609:2 See StaticDeclaration.

B.610. static initializer¶

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

B.610:2 See StaticInitializer.

B.611. static lifetime elision¶

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

B.612. str¶

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

B.613. strict keyword¶

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

B.613:2 See StrictKeyword.

B.614. string literal¶

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

B.614:2 See StringLiteral.

B.615. struct¶

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

B.616. struct expression¶

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

B.616:2 See StructExpression.

B.617. struct field¶

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

B.618. struct pattern¶

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

B.618:2 See StructPattern.

B.619. struct type¶

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

B.619:2 See StructDeclaration.

B.620. struct value¶

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

B.621. structurally equal¶

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

B.622. subexpression¶

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

B.623. subject expression¶

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

B.623:2 See SubjectExpression.

B.624. subject let expression¶

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

B.624:2 See SubjectLetExpression.

B.625. subpattern¶

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

B.626. subtraction assignment¶

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

B.627. subtraction assignment expression¶