Fix typos in spec (#1266)
This commit is contained in:
stakx
Julien Couvreur
parent
c2327f101b
commit
7f39331672
|
|
@ -420,7 +420,7 @@ Signatures are the enabling mechanism for ***overloading*** of members in classe
|
|||
|
||||
Although `out` and `ref` parameter modifiers are considered part of a signature, members declared in a single type cannot differ in signature solely by `ref` and `out`. A compile-time error occurs if two members are declared in the same type with signatures that would be the same if all parameters in both methods with `out` modifiers were changed to `ref` modifiers. For other purposes of signature matching (e.g., hiding or overriding), `ref` and `out` are considered part of the signature and do not match each other. (This restriction is to allow C# programs to be easily translated to run on the Common Language Infrastructure (CLI), which does not provide a way to define methods that differ solely in `ref` and `out`.)
|
||||
|
||||
For the purposes of singatures, the types `object` and `dynamic` are considered the same. Members declared in a single type can therefore not differ in signature solely by `object` and `dynamic`.
|
||||
For the purposes of signatures, the types `object` and `dynamic` are considered the same. Members declared in a single type can therefore not differ in signature solely by `object` and `dynamic`.
|
||||
|
||||
The following example shows a set of overloaded method declarations along with their signatures.
|
||||
```csharp
|
||||
|
|
|
|||
|
|
@ -120,7 +120,7 @@ Having the declaration of a class distributed over separate segments of program
|
|||
|
||||
### Type parameters
|
||||
|
||||
A type parameter is a simple identifier that denotes a placeholder for a type argument supplied to create a constructed type. A type parameter is a formal placeholder for a type that will be supplied later. By constrast, a type argument ([Type arguments](types.md#type-arguments)) is the actual type that is substituted for the type parameter when a constructed type is created.
|
||||
A type parameter is a simple identifier that denotes a placeholder for a type argument supplied to create a constructed type. A type parameter is a formal placeholder for a type that will be supplied later. By contrast, a type argument ([Type arguments](types.md#type-arguments)) is the actual type that is substituted for the type parameter when a constructed type is created.
|
||||
|
||||
```antlr
|
||||
type_parameter_list
|
||||
|
|
@ -2651,8 +2651,8 @@ The accessor declarations consist of a *get_accessor_declaration*, a *set_access
|
|||
The use of *accessor_modifier*s is governed by the following restrictions:
|
||||
|
||||
* An *accessor_modifier* may not be used in an interface or in an explicit interface member implementation.
|
||||
* For a property or indexer that has no `override` modifer, an *accessor_modifier* is permitted only if the property or indexer has both a `get` and `set` accessor, and then is permitted only on one of those accessors.
|
||||
* For a property or indexer that includes an `override` modifer, an accessor must match the *accessor_modifier*, if any, of the accessor being overridden.
|
||||
* For a property or indexer that has no `override` modifier, an *accessor_modifier* is permitted only if the property or indexer has both a `get` and `set` accessor, and then is permitted only on one of those accessors.
|
||||
* For a property or indexer that includes an `override` modifier, an accessor must match the *accessor_modifier*, if any, of the accessor being overridden.
|
||||
* The *accessor_modifier* must declare an accessibility that is strictly more restrictive than the declared accessibility of the property or indexer itself. To be precise:
|
||||
* If the property or indexer has a declared accessibility of `public`, the *accessor_modifier* may be either `protected internal`, `internal`, `protected`, or `private`.
|
||||
* If the property or indexer has a declared accessibility of `protected internal`, the *accessor_modifier* may be either `internal`, `protected`, or `private`.
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ However, dynamic conversions ([Implicit dynamic conversions](conversions.md#impl
|
|||
|
||||
An identity conversion converts from any type to the same type. This conversion exists such that an entity that already has a required type can be said to be convertible to that type.
|
||||
|
||||
* Because object and dynamic are considered equivalent there is an identity conversion between `object` and `dynamic`, and between constructed types that are the same when replacing all occurences of `dynamic` with `object`.
|
||||
* Because object and dynamic are considered equivalent there is an identity conversion between `object` and `dynamic`, and between constructed types that are the same when replacing all occurrences of `dynamic` with `object`.
|
||||
|
||||
### Implicit numeric conversions
|
||||
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ The optional *variant_type_parameter_list* ([Variant type parameter lists](inter
|
|||
|
||||
The return type of a delegate type must be either `void`, or output-safe ([Variance safety](interfaces.md#variance-safety)).
|
||||
|
||||
All the formal parameter types of a delegate type must be input-safe. Additionally, any `out` or `ref` parameter types must also be output-safe. Note that even `out` parameters are required to be input-safe, due to a limitiation of the underlying execution platform.
|
||||
All the formal parameter types of a delegate type must be input-safe. Additionally, any `out` or `ref` parameter types must also be output-safe. Note that even `out` parameters are required to be input-safe, due to a limitation of the underlying execution platform.
|
||||
|
||||
Delegate types in C# are name equivalent, not structurally equivalent. Specifically, two different delegate types that have the same parameter lists and return type are considered different delegate types. However, instances of two distinct but structurally equivalent delegate types may compare as equal ([Delegate equality operators](expressions.md#delegate-equality-operators)).
|
||||
|
||||
|
|
|
|||
|
|
@ -292,7 +292,7 @@ __Example:__
|
|||
```csharp
|
||||
/// <summary>This is the entry point of the Point class testing program.
|
||||
/// <para>This program tests each method and operator, and
|
||||
/// is intended to be run after any non-trvial maintenance has
|
||||
/// is intended to be run after any non-trivial maintenance has
|
||||
/// been performed on the Point class.</para></summary>
|
||||
public static void Main() {
|
||||
// ...
|
||||
|
|
@ -994,7 +994,7 @@ public class Point
|
|||
/// <summary>This is the entry point of the Point class testing
|
||||
/// program.
|
||||
/// <para>This program tests each method and operator, and
|
||||
/// is intended to be run after any non-trvial maintenance has
|
||||
/// is intended to be run after any non-trivial maintenance has
|
||||
/// been performed on the Point class.</para></summary>
|
||||
public static void Main() {
|
||||
// class test code goes here
|
||||
|
|
@ -1121,7 +1121,7 @@ Here is the output produced by one documentation generator when given the source
|
|||
<summary>This is the entry point of the Point class testing
|
||||
program.
|
||||
<para>This program tests each method and operator, and
|
||||
is intended to be run after any non-trvial maintenance has
|
||||
is intended to be run after any non-trivial maintenance has
|
||||
been performed on the Point class.</para></summary>
|
||||
</member>
|
||||
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ The following operations in C# are subject to binding:
|
|||
|
||||
* Member access: `e.M`
|
||||
* Method invocation: `e.M(e1, ..., eN)`
|
||||
* Delegate invocaton:`e(e1, ..., eN)`
|
||||
* Delegate invocation:`e(e1, ..., eN)`
|
||||
* Element access: `e[e1, ..., eN]`
|
||||
* Object creation: `new C(e1, ..., eN)`
|
||||
* Overloaded unary operators: `+`, `-`, `!`, `~`, `++`, `--`, `true`, `false`
|
||||
|
|
@ -879,7 +879,7 @@ interface I2<T> {...}
|
|||
|
||||
class G1<U>
|
||||
{
|
||||
int F1(U u); // Overload resulotion for G<int>.F1
|
||||
int F1(U u); // Overload resolution for G<int>.F1
|
||||
int F1(int i); // will pick non-generic
|
||||
|
||||
void F2(I1<U> a); // Valid overload
|
||||
|
|
@ -1093,7 +1093,7 @@ A *simple_name* is either of the form `I` or of the form `I<A1,...,Ak>`, where `
|
|||
* Otherwise, the *namespace_or_type_name* refers to the type constructed with the given type arguments.
|
||||
* Otherwise, if the location where the *simple_name* occurs is enclosed by a namespace declaration for `N`:
|
||||
* If `K` is zero and the namespace declaration contains an *extern_alias_directive* or *using_alias_directive* that associates the name `I` with an imported namespace or type, then the *simple_name* refers to that namespace or type.
|
||||
* Otherwise, if the namespaces and type declarations imported by the *using_namespace_directive*s and *using_static_directive*s of the namespace declaration contain exactly one accessible type or non-extension static membre having name `I` and `K` type parameters, then the *simple_name* refers to that type or member constructed with the given type arguments.
|
||||
* Otherwise, if the namespaces and type declarations imported by the *using_namespace_directive*s and *using_static_directive*s of the namespace declaration contain exactly one accessible type or non-extension static member having name `I` and `K` type parameters, then the *simple_name* refers to that type or member constructed with the given type arguments.
|
||||
* Otherwise, if the namespaces and types imported by the *using_namespace_directive*s of the namespace declaration contain more than one accessible type or non-extension-method static member having name `I` and `K` type parameters, then the *simple_name* is ambiguous and an error occurs.
|
||||
|
||||
Note that this entire step is exactly parallel to the corresponding step in the processing of a *namespace_or_type_name* ([Namespace and type names](basic-concepts.md#namespace-and-type-names)).
|
||||
|
|
@ -1407,7 +1407,7 @@ E.F(1)
|
|||
D.G(2)
|
||||
C.H(3)
|
||||
```
|
||||
`D.G` takes precendece over `C.G`, and `E.F` takes precedence over both `D.F` and `C.F`.
|
||||
`D.G` takes precedence over `C.G`, and `E.F` takes precedence over both `D.F` and `C.F`.
|
||||
|
||||
#### Delegate invocations
|
||||
|
||||
|
|
@ -2769,7 +2769,7 @@ The predefined division operators are listed below. The operators all compute th
|
|||
decimal operator /(decimal x, decimal y);
|
||||
```
|
||||
|
||||
If the value of the right operand is zero, a `System.DivideByZeroException` is thrown. If the resulting value is too large to represent in the `decimal` format, a `System.OverflowException` is thrown. If the result value is too small to represent in the `decimal` format, the result is zero. The scale of the result is the smallest scale that will preserve a result equal to the nearest representantable decimal value to the true mathematical result.
|
||||
If the value of the right operand is zero, a `System.DivideByZeroException` is thrown. If the resulting value is too large to represent in the `decimal` format, a `System.OverflowException` is thrown. If the result value is too small to represent in the `decimal` format, the result is zero. The scale of the result is the smallest scale that will preserve a result equal to the nearest representable decimal value to the true mathematical result.
|
||||
|
||||
Decimal division is equivalent to using the division operator of type `System.Decimal`.
|
||||
|
||||
|
|
@ -3864,7 +3864,7 @@ static void F() {
|
|||
}
|
||||
```
|
||||
|
||||
When not captured, there is no way to observe exactly how often a local variable is instantiated—because the lifetimes of the instantiations are disjoint, it is possible for each instantation to simply use the same storage location. However, when an anonymous function captures a local variable, the effects of instantiation become apparent.
|
||||
When not captured, there is no way to observe exactly how often a local variable is instantiated—because the lifetimes of the instantiations are disjoint, it is possible for each instantiation to simply use the same storage location. However, when an anonymous function captures a local variable, the effects of instantiation become apparent.
|
||||
|
||||
The example
|
||||
```csharp
|
||||
|
|
@ -4070,7 +4070,7 @@ A query expression begins with a `from` clause and ends with either a `select` o
|
|||
|
||||
Query expressions contain a number of "contextual keywords", i.e., identifiers that have special meaning in a given context. Specifically these are `from`, `where`, `join`, `on`, `equals`, `into`, `let`, `orderby`, `ascending`, `descending`, `select`, `group` and `by`. In order to avoid ambiguities in query expressions caused by mixed use of these identifiers as keywords or simple names, these identifiers are considered keywords when occurring anywhere within a query expression.
|
||||
|
||||
For this purpose, a query expression is any expression that starts with "`from dentifier`" followed by any token except "`;`", "`=`" or "`,`".
|
||||
For this purpose, a query expression is any expression that starts with "`from identifier`" followed by any token except "`;`", "`=`" or "`,`".
|
||||
|
||||
In order to use these words as identifiers within a query expression, they can be prefixed with "`@`" ([Identifiers](lexical-structure.md#identifiers)).
|
||||
|
||||
|
|
|
|||
|
|
@ -218,7 +218,7 @@ The *attributes*, *return_type*, *identifier*, and *formal_parameter_list* of an
|
|||
|
||||
Each formal parameter type of an interface method must be input-safe ([Variance safety](interfaces.md#variance-safety)), and the return type must be either `void` or output-safe. Furthermore, each class type constraint, interface type constraint and type parameter constraint on any type parameter of the method must be input-safe.
|
||||
|
||||
These rules ensure that any covariant or contravariant usage of the interface remains typesafe. For example,
|
||||
These rules ensure that any covariant or contravariant usage of the interface remains type-safe. For example,
|
||||
```csharp
|
||||
interface I<out T> { void M<U>() where U : T; }
|
||||
```
|
||||
|
|
@ -287,7 +287,7 @@ The *attributes*, *type*, and *formal_parameter_list* of an interface indexer de
|
|||
|
||||
The accessors of an interface indexer declaration correspond to the accessors of a class indexer declaration ([Indexers](classes.md#indexers)), except that the accessor body must always be a semicolon. Thus, the accessors simply indicate whether the indexer is read-write, read-only, or write-only.
|
||||
|
||||
All the formal parameter types of an interface indexer must be input-safe . In addition, any `out` or `ref` formal parameter types must also be output-safe. Note that even `out` parameters are required to be input-safe, due to a limitiation of the underlying execution platform.
|
||||
All the formal parameter types of an interface indexer must be input-safe . In addition, any `out` or `ref` formal parameter types must also be output-safe. Note that even `out` parameters are required to be input-safe, due to a limitation of the underlying execution platform.
|
||||
|
||||
The type of an interface indexer must be output-safe if there is a get accessor, and must be input-safe if there is a set accessor.
|
||||
|
||||
|
|
|
|||
|
|
@ -1551,7 +1551,7 @@ An instance of the `Function` delegate type can reference any method that takes
|
|||
|
||||
A delegate can reference either a static method (such as `Square` or `Math.Sin` in the previous example) or an instance method (such as `m.Multiply` in the previous example). A delegate that references an instance method also references a particular object, and when the instance method is invoked through the delegate, that object becomes `this` in the invocation.
|
||||
|
||||
Delegates can also be created using anonymous functions, which are "inline methods" that are created on the fly. Anonymous functions can see the local variables of the sourrounding methods. Thus, the multiplier example above can be written more easily without using a `Multiplier` class:
|
||||
Delegates can also be created using anonymous functions, which are "inline methods" that are created on the fly. Anonymous functions can see the local variables of the surrounding methods. Thus, the multiplier example above can be written more easily without using a `Multiplier` class:
|
||||
|
||||
```csharp
|
||||
double[] doubles = Apply(a, (double x) => x * 2.0);
|
||||
|
|
|
|||
|
|
@ -774,8 +774,8 @@ single_verbatim_balanced_text_character
|
|||
|
||||
An *interpolated_string_literal* token is reinterpreted as multiple tokens and other input elements as follows, in order of occurrence in the *interpolated_string_literal*:
|
||||
|
||||
* Occurences of the following are reinterpreted as separate individual tokens: the leading `$` sign, *interpolated_regular_string_whole*, *interpolated_regular_string_start*, *interpolated_regular_string_mid*, *interpolated_regular_string_end*, *interpolated_verbatim_string_whole*, *interpolated_verbatim_string_start*, *interpolated_verbatim_string_mid* and *interpolated_verbatim_string_end*.
|
||||
* Occurences of *regular_balanced_text* and *verbatim_balanced_text* between these are reprocessed as an *input_section* ([Lexical analysis](lexical-structure.md#lexical-analysis)) and are reinterpreted as the resulting sequence of input elements. These may in turn include interpolated string literal tokens to be reinterpreted.
|
||||
* Occurrences of the following are reinterpreted as separate individual tokens: the leading `$` sign, *interpolated_regular_string_whole*, *interpolated_regular_string_start*, *interpolated_regular_string_mid*, *interpolated_regular_string_end*, *interpolated_verbatim_string_whole*, *interpolated_verbatim_string_start*, *interpolated_verbatim_string_mid* and *interpolated_verbatim_string_end*.
|
||||
* Occurrences of *regular_balanced_text* and *verbatim_balanced_text* between these are reprocessed as an *input_section* ([Lexical analysis](lexical-structure.md#lexical-analysis)) and are reinterpreted as the resulting sequence of input elements. These may in turn include interpolated string literal tokens to be reinterpreted.
|
||||
|
||||
Syntactic analysis will recombine the tokens into an *interpolated_string_expression* ([Interpolated strings](expressions.md#interpolated-strings)).
|
||||
|
||||
|
|
|
|||
|
|
@ -908,7 +908,7 @@ The buffer element type is followed by a list of fixed size buffer declarators,
|
|||
|
||||
The elements of a fixed size buffer are guaranteed to be laid out sequentially in memory.
|
||||
|
||||
A fixed size buffer declaration that declares multiple fixed size buffers is equivalent to multiple declarations of a single fixed size buffer declation with the same attributes, and element types. For example
|
||||
A fixed size buffer declaration that declares multiple fixed size buffers is equivalent to multiple declarations of a single fixed size buffer declaration with the same attributes, and element types. For example
|
||||
|
||||
```csharp
|
||||
unsafe struct A
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ If the parent *block*, *for_statement*, *switch_statement*, *using_statement*, *
|
|||
|
||||
A local variable introduced by a *local_variable_declaration* is not automatically initialized and thus has no default value. For the purpose of definite assignment checking, a local variable introduced by a *local_variable_declaration* is considered initially unassigned. A *local_variable_declaration* may include a *local_variable_initializer*, in which case the variable is considered definitely assigned only after the initializing expression ([Declaration statements](variables.md#declaration-statements)).
|
||||
|
||||
Within the scope of a local variableintroduced by a *local_variable_declaration*, it is a compile-time error to refer to that local variable in a textual position that precedes its *local_variable_declarator*. If the local variable declaration is implicit ([Local variable declarations](statements.md#local-variable-declarations)), it is also an error to refer to the variable within its *local_variable_declarator*.
|
||||
Within the scope of a local variable introduced by a *local_variable_declaration*, it is a compile-time error to refer to that local variable in a textual position that precedes its *local_variable_declarator*. If the local variable declaration is implicit ([Local variable declarations](statements.md#local-variable-declarations)), it is also an error to refer to the variable within its *local_variable_declarator*.
|
||||
|
||||
A local variable introduced by a *foreach_statement* or a *specific_catch_clause* is considered definitely assigned in its entire scope.
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue