a little wordsmithing

Tyler Whitney · Tyler Whitney · commit a41191fde90a · 2020-05-29T10:08:22.000-07:00
diff --git a/docs/standard-library/span-class.md b/docs/standard-library/span-class.md
@@ -7,11 +7,11 @@ helpviewer_keywords: ["std::span [C++]", "std::span [C++], const_pointer", "std:
 ---
 # span Class (C++ Standard Library)
 
-Provides a lightweight view over a contiguous sequence of objects. A span provides a safe way to iterate over, and index into, objects that are arranged back-to-back in memory (for example, objects stored in a built-in array, `std::array`, or `std::vector`).
+Provides a lightweight view over a contiguous sequence of objects. A span provides a safe way to iterate over, and index into, objects that are arranged back-to-back in memory such as objects stored in a built-in array, `std::array`, or `std::vector`.
 
-If you typically access a sequence of back-to-back objects using a pointer and an index, span is a safer, lightweight alternative.
+If you typically access a sequence of back-to-back objects using a pointer and an index, a `span` is a safer, lightweight alternative.
 
-A span's size is determined at compile time by specifying it as a template argument, or at runtime by specifying `dynamic_extent`.
+The size of a `span` can be set at compile time by specifying it as a template argument, or at runtime by specifying `dynamic_extent`.
 
 ## Syntax
 
@@ -42,30 +42,30 @@ class span;
 | [reference](#reference) | The type of a reference to an element. |
 | [reverse_iterator](#reverse_iterator) | The type of a reverse iterator for a span. |
 | [size_type](#size_type) | The type for the result of the unsigned distance between two elements in the span. |
-| [value_type](#value_type) | The type of an element without `const` or `volatile` qualifications. |
+| [value_type](#value_type) | The type of an element, without `const` or `volatile` qualifications. |
 | **Constructors** | **Description** |
-|[span](#span)| Constructs a `span`.|
+|[span](#span)| Construct a `span`.|
 | **Iterator support** | **Description** |
-|[begin](#begin) | Returns an iterator pointing to the first element in the span.|
-|[end](#end) | Returns an iterator pointing to the end of the span. |
-|[rbegin](#rbegin) | Returns a reverse iterator pointing to the last element of the span; that is, the beginning of the reversed span.|
-|[rend](#rend) | Returns a reverse iterator pointing to the front  of the span; that is, the end of the reversed span.|
+|[begin](#begin) | Get an iterator pointing to the first element in the span.|
+|[end](#end) | Get an iterator pointing to the end of the span. |
+|[rbegin](#rbegin) | Get a reverse iterator pointing to the last element of the span; that is, the beginning of the reversed span.|
+|[rend](#rend) | Get a reverse iterator pointing to the front  of the span; that is, the end of the reversed span.|
 | **Access elements**| **Description** |
 |[back](#back) | Get the last element in the span.|
 |[data](#data) | Get the address of the first element in the span.|
 |[front](#front) | Get the first element in the span.|
 |[operator\[\]](#op_at) | Access an element at a specified position.|
 | **Observers** | **Description** |
-|[empty](#empty)| Tests whether the span is empty.|
-|[size](#size) | Returns the number of elements in the span.|
-|[size_bytes](#size_bytes) | Returns the size of the span in bytes.|
+|[empty](#empty)| Test whether the span is empty.|
+|[size](#size) | Get the number of elements in the span.|
+|[size_bytes](#size_bytes) | Get the size of the span in bytes.|
 | **Subviews** | **Description**|
 | [first](#first_view) | Get a subspan from the front of the span.|
 | [last](#last_view) | Get a subspan from the back of the span.|
-| [subspan](#sub_view) | Gets a subspan from anywhere in the span.|
+| [subspan](#sub_view) | Get a subspan from anywhere in the span.|
 | **Operators** | **Description** |
-|[span::operator=](#op_eq)| Replaces the span.|
-|[span::operator\[\]](#op_at)| Access an element at a specified position. |
+|[span::operator=](#op_eq)| Replace the span.|
+|[span::operator\[\]](#op_at)| Get the element at the specified position. |
 
 ## Remarks
 
@@ -83,7 +83,7 @@ Unlike `array` or `vector`, a span doesn't "own" the elements inside it. A span
 
 ## <a name="back"></a> `span::back`
 
-Returns the last element in the span.
+Get the last element in the span.
 
 ```cpp
 constexpr reference back() const noexcept;
@@ -116,15 +116,15 @@ int main()
 
 ## <a name="begin"></a> `span::begin`
 
-Returns an iterator pointing at the first element in the span.
+Get an iterator pointing at the first element in the span.
 
 ```cpp
 constexpr iterator begin() const noexcept;
 ```
 
 ### Return value
 
-An iterator that starts with the first element in the span.
+An iterator pointing at the first element in the span.
 
 ### Example
 
@@ -150,7 +150,7 @@ int main()
 
 ## <a name="data"></a> `span::data`
 
-Returns a pointer to the beginning of the span data.
+Get a pointer to the beginning of the span data.
 
 ```cpp
 constexpr pointer data() const noexcept;
@@ -183,7 +183,7 @@ int main()
 
 ## <a name="difference_type"></a> `span::difference_type`
 
-This type represents the number of elements between two elements in a span.
+The number of elements between two elements in a span.
 
 ```cpp
 using difference_type = std::ptrdiff_t;
@@ -273,21 +273,21 @@ int main()
 
 ## <a name="end"></a> `span::end`
 
-Returns an iterator to the end of the span.
+Get an iterator to the end of the span.
 
 ```cpp
 constexpr iterator end() const noexcept;
 ```
 
 ### Return Value
 
-An iterator to just beyond the end of the span.
+An iterator pointing just beyond the end of the span.
 
 ### Remarks
 
 `end` is used to test whether an iterator has passed the end of its range.
 
-Don't dereference the value returned by the iterator. Use it to identify whether the iterator has reached beyond the last element in the span.
+Don't dereference the value returned by this iterator. Use it to identify whether the iterator has reached beyond the last element in the span.
 
 ### Example
 
@@ -320,7 +320,7 @@ A span that contains `count` elements from the front of this span.
 
 ### Remarks
 
-A template version of this function can be used to validate the count at compile time, and to preserve info about the span by returning a span of fixed extent when possible.
+Use the template version of this function when possible to validate the `count` at compile time, and to preserve info about the span since it returns a span of fixed extent.
 
 ### Example
 
@@ -358,7 +358,7 @@ mySpan.first<2>: 01
 
 ## <a name="front"></a> `span::front`
 
-Returns the first element in the span.
+Get the first element in the span.
 
 ```cpp
 constexpr reference front() const noexcept;
@@ -445,7 +445,7 @@ A span containing the last `count` elements from this span.
 
 ### Remarks
 
-A template version of this function can be used instead to check the count at compile time. The template version also preserves info about the span by returning a span of fixed extent, when possible.
+Use the template version of this function when possible to validate the `count` at compile time, and to preserve info about the span since it returns a span of fixed extent.
 
 ### Example
 
@@ -483,7 +483,7 @@ mySpan.last<2>: 12
 
 ## <a name="op_at"></a> `span::operator[]`
 
-Access an element in the span at a specified position.
+Get the element in the span at a specified position.
 
 ```cpp
 constexpr reference operator[](size_type offset) const;
@@ -537,7 +537,7 @@ The span to assign to this one.
 
 ### Remarks
 
-Assignment does a shallow copy of the data pointer and the size. A shallow copy is safe because spans don't allocate memory for the elements they contain.
+Assignment does a shallow copy of the data pointer and the size. A shallow copy is safe because a `span` doesn't allocate memory for the elements it contains.
 
 ### Example
 
@@ -566,7 +566,7 @@ int main()
 
 ## <a name="pointer"></a> `span::pointer`
 
-The types for a pointer and `const` pointer to a span element.
+The types for a pointer, and `const` pointer, to a span element.
 
 ```cpp
 using pointer = T*;
@@ -677,7 +677,7 @@ int main()
 
 ## <a name="rend"></a> `span::rend`
 
-Get a random-access iterator to just beyond the end of the reversed span.
+Get a random-access iterator that points just beyond the end of the reversed span.
 
 ```cpp
 constexpr reverse_iterator rend() const noexcept;
@@ -783,7 +783,7 @@ constexpr size_type size_bytes() const noexcept;
 
 ### Return Value
 
-The number of bytes that all of the elements in the span take up; that is, `sizeof(element_type)` multiplied by the number of elements in the span.
+The number of bytes that all of the elements in the span occupy; that is, `sizeof(element_type)` multiplied by the number of elements in the span.
 
 ### Example
 
@@ -881,7 +881,7 @@ span(const span<T, OtherExtent>& other) noexcept
 ### Parameters
 
 *arr*\
-Construct a span from this array.
+Construct a span from an array.
 
 *count*\
 Number of elements that will be in the span.
@@ -896,7 +896,7 @@ Iterator to just past the last element in the span.
 The number of elements that will be in the span.
 
 *other*\
-Copy from this span.
+Make a copy of this span.
 
 *r*\
 Construct a span from this range.
@@ -907,13 +907,13 @@ A span doesn't free storage for items in the span because it doesn't own the sto
 
 |Constructor  | Description  |
 |---------|---------|
-|`span()` | Constructs an empty span. Only considered during overload resolution when the template parameter `Extent` is `0` or `dynamic_extent`.|
-|`span(It first, size_type count)` | Constructs a span from the first `count` elements from iterator `first`.  Only considered during overload resolution when template parameter `Extent` isn't `dynamic_extent`. |
-|`span(It first, End last)` | Constructs a span from the elements in iterator `first` until the end `last` is reached. Only considered during overload resolution when template parameter `Extent` isn't `dynamic_extent`. `It` must be a `contiguous_iterator`.  |
-|`span(array<T, N>& arr) noexcept;`<br /><br />`span(const array<T, N>& arr) noexcept;`<br /><br />`span(type_identity_t<element_type> (&arr)[N]) noexcept;` |  Constructs a span from `N` elements of the specified array. Only considered during overload resolution when template parameter `Extent` is `dynamic_extent` or equals `N`. |
-|`span(R&& r)` |  Constructs a span from a range. Only participates in overload resolution if template parameter `Extent` isn't `dynamic_extent`.|
+|`span()` | Construct an empty span. Only considered during overload resolution when the template parameter `Extent` is `0` or `dynamic_extent`.|
+|`span(It first, size_type count)` | Construct a span from the first `count` elements from iterator `first`.  Only considered during overload resolution when template parameter `Extent` isn't `dynamic_extent`. |
+|`span(It first, End last)` | Construct a span from the elements in iterator `first` until the end `last` is reached. Only considered during overload resolution when template parameter `Extent` isn't `dynamic_extent`. `It` must be a `contiguous_iterator`.  |
+|`span(array<T, N>& arr) noexcept;`<br /><br />`span(const array<T, N>& arr) noexcept;`<br /><br />`span(type_identity_t<element_type> (&arr)[N]) noexcept;` |  Construct a span from `N` elements of the specified array. Only considered during overload resolution when template parameter `Extent` is `dynamic_extent` or equals `N`. |
+|`span(R&& r)` |  Construct a span from a range. Only participates in overload resolution if template parameter `Extent` isn't `dynamic_extent`.|
 |`span(const span& other)` |  The compiler-generated copy constructor. A shallow copy of the data pointer is safe because the span doesn't allocate the memory to hold the elements. |
-|`span(const span<OtherElementType, OtherExtent>& s) noexcept;` | Converting constructor: constructs a span from another span. Only participates in overload resolution if template parameter `Extent` is `dynamic_extent`, or `N` is `dynamic_extent` or  equals `Extent`.|
+|`span(const span<OtherElementType, OtherExtent>& s) noexcept;` | Converting constructor: construct a span from another span. Only participates in overload resolution if template parameter `Extent` is `dynamic_extent`, or `N` is `dynamic_extent` or  equals `Extent`.|
 
 ### Example
 
@@ -953,18 +953,18 @@ constexpr auto subspan() const noexcept
 ### Parameters
 
 *count*\
-The number of elements to put in the subspan. If `count` is `dynamic_extent` (the default value), then gets the subspan from `offset` to the end of this span.
+The number of elements to put in the subspan. If `count` is `dynamic_extent` (the default value), then the subspan is taken from `offset` to the end of this span.
 
 *offset*\
 The location in this span to start the subspan.
 
 ### Return Value
 
-A span starting at `offset` in this span, containing `count` elements.
+A span starting at `offset` in this span. Contains `count` elements.
 
 ### Remarks
 
-A template version of this function is available that checks the count at compile time, and that preserves information about the span by returning a span of fixed extent, when possible.
+A template version of this function is available that checks the count at compile time, which preserves information about the span by returning a span of fixed extent.
 
 ### Example
 
@@ -1005,7 +1005,7 @@ mySpan.subspan<1>: 12
 
 ## <a name="value_type"></a> `span::value_type`
 
-The type of the element in the span but without any `const` or `volatile` qualifications.
+The type of the element in the span, without `const` or `volatile` qualifications.
 
 ```cpp
 using value_type = std::remove_cv_t<T>;
diff --git a/docs/standard-library/span-functions.md b/docs/standard-library/span-functions.md
@@ -11,7 +11,7 @@ The \<span> header includes the following non-member functions that operate on *
 | **Non-member functions** | **Description** |
 |-|-|
 |[as_bytes](#as_bytes) | Get a read-only view of the object representation of the elements in the span. |
-|[as_writable_bytes](#as_writable_bytes) | Get a read/write view to the object representation of the elements in the span. |
+|[as_writable_bytes](#as_writable_bytes) | Get a read/write view of the object representation of the elements in the span. |
 
 ## <a name="as_bytes"></a>`as_bytes`
 
@@ -55,7 +55,7 @@ void main()
 
 ## <a name="as_writable_bytes"></a>`as_writable_bytes`
 
-If `T` isn't `const`, gets a read/write view to the raw byte representation of the elements in the span.
+If `T` isn't `const`, gets a read/write view of the raw byte representation of the elements in the span.
 
 ```cpp
 template <class T, size_t Extent>
diff --git a/docs/standard-library/span.md b/docs/standard-library/span.md
@@ -15,6 +15,8 @@ See [span class](span-class.md) for detailed information. Here's an example of h
 #include <span>
 #include <iostream>
 
+u
+
 void Show(std::span<int> someValues)
 {
     // show values in reverse
@@ -50,28 +52,28 @@ int main()
 ### Classes
 
 |||
-|-|-|
+|-|:-|
 |[span](span-class.md)| Provides a view over a contiguous sequence of objects. |
 
 ### Operators
 
 |||
-|-|-|
+|-|:-|
 |[operator=](span-class.md#op_eq)| Span assignment |
 |[operator\[\]](span-class.md#op_at)| Element access |
 
 ### Functions
 
 |||
-|-|-|
+|-|:-|
 | [as_bytes](span-functions.md#as_bytes)| Get the underlying read-only bytes of the span. |
 | [as_writable_bytes](span-functions.md#as_writable_bytes) | Get the underlying bytes of the span. |
 
 ### Constants
 
 |||
-|-|-|
-| **dynamic_extent** | Indicates that the span size is determined at runtime rather than compile time. When the number of elements in the span is known at compile time, it's specified as the `Extent` template parameter. When the number isn't known until runtime, `dynamic_extent` is specified instead. |
+|-|:-|
+| **dynamic_extent** | Indicates that the span size is determined at runtime rather than compile time. When the number of elements in the span is known at compile time, it's specified as the `Extent` template parameter. When the number isn't known until runtime, specify `dynamic_extent` instead. |
 
 ## See also
 
