edits

TylerMSFT · TylerMSFT · commit f614a95bbf8e · 2022-12-19T14:05:32.000-08:00
diff --git a/docs/standard-library/iterator-concepts.md b/docs/standard-library/iterator-concepts.md
@@ -7,9 +7,9 @@ helpviewer_keywords: ["std::ranges [C++], ranges::range", "std::ranges [C++], ra
 ---
 # Iterator concepts
 
-Concepts are a C++20 language feature that constrains template parameters at compile time. They help prevent incorrect template instantiation, specify template argument requirements in a readable form, and provide more succinct template related compiler errors.
+Concepts are a C++20 language feature that constrain template parameters at compile time. They help prevent incorrect template instantiation, specify template argument requirements in a readable form, and provide more succinct template related compiler errors.
 
-Consider the following example, which defines a concept to prevent instantiating a template with a type that doesn't support division:
+Consider the following example, which defines a concept to prevent instantiating the template with a type that doesn't support division:
 
 ```cpp
 // requires /std:c++20 or later
@@ -48,9 +48,9 @@ int main()
 }
 ```
 
-When you pass the compiler switch `/diagnostics:caret` to Visual Studio 2022 version 17.4 or later, the error that concept `dividable<char*>` evaluated to false will point directly to the expression requirement `(a / b)` that failed.
+When you pass the compiler switch `/diagnostics:caret` to Visual Studio 2022 version 17.4 preview 4 or later, the error that concept `dividable<char*>` evaluated to false will point directly to the expression requirement `(a / b)` that failed.
 
-Iterator concepts are defined in the `std` namespace as declared in the `<iterator>` header file. They're used in the declarations of [range adaptors](range-adaptors.md), [views](view-classes.md), and so on.
+Iterator concepts are defined in the `std` namespace, and are declared in the `<iterator>` header file. They're used in the declarations of [range adaptors](range-adaptors.md), [views](view-classes.md), and so on.
 
 There are six categories of iterators. They're directly related to the categories of ranges listed under [Range concepts](ranges.md#range-concepts).
 
@@ -65,18 +65,18 @@ In the following table, "Types" refers to the types of collections/iterators tha
 | Iterator concept | Description | Direction | Read/write | Multi-pass | Types |
 |--|--|--|--|--|--|
 | [`input_or_output_iterator`](#input_or_output_iterator)<sup>C++20</sup> | The basis of the iterator concept taxonomy. | Forward | Read/write | no | `istream_iterator`, `ostream_iterator` |
-| [`output_iterator`](#output_iterator)<sup>C++20</sup> | Test for an iterator that you can write to. | Forward | Write | no | `ostream`, `inserter` |
-| [`input_iterator`](#input_iterator)<sup>C++20</sup> | Test for an iterator that you can read from at least once. | Forward | Read | no | `istream`, `istreambuf_iterator` |
-| [`forward_iterator`](#forward_iterator)<sup>C++20</sup> | Test for an iterator that can read (and possibly write) multiple times. | Forward | Read/write | yes | `vector`, `list` |
-| [`bidirectional_iterator`](#bidirectional_iterator)<sup>C++20</sup> | Test for an iterator that can read and write both forwards and backwards. | Forward/backward | Read/write | yes | `list`, `set`, `multiset`, `map`, and `multimap`. |
-| [`random_access_iterator`](#random_access_iterator)<sup>C++20</sup> | Test for an iterator that can read and write by index. | Forward/Backward | Read/write | yes | `vector`, `array`, `deque` |
-| [`contiguous_iterator`](#contiguous_iterator)<sup>C++20</sup> | Test for an iterator whose elements are sequential in memory and can be accessed using pointer arithmetic. | Forward/backward | Read/write | yes | `array`, `vector` `string`.|
+| [`output_iterator`](#output_iterator)<sup>C++20</sup> | Specifies an iterator that you can write to. | Forward | Write | no | `ostream`, `inserter` |
+| [`input_iterator`](#input_iterator)<sup>C++20</sup> | Specifies an iterator that you can read from once. | Forward | Read | no | `istream`, `istreambuf_iterator` |
+| [`forward_iterator`](#forward_iterator)<sup>C++20</sup> | Specifies an iterator that can read (and possibly write) multiple times. | Forward | Read/write | yes | `vector`, `list` |
+| [`bidirectional_iterator`](#bidirectional_iterator)<sup>C++20</sup> | Specifies an iterator that you can read and write both forwards and backwards. | Forward/backward | Read/write | yes | `list`, `set`, `multiset`, `map`, and `multimap`. |
+| [`random_access_iterator`](#random_access_iterator)<sup>C++20</sup> | Specifies an iterator that you can read and write by index. | Forward/Backward | Read/write | yes | `vector`, `array`, `deque` |
+| [`contiguous_iterator`](#contiguous_iterator)<sup>C++20</sup> | Specifies an iterator whose elements are sequential in memory, are the same size, and can be accessed using pointer arithmetic. | Forward/backward | Read/write | yes | `array`, `vector` `string`.|
 
 Other iterator concepts include:
 
 | Iterator concept | Description |
 |--|--|
-| [`sentinel_for`](#sentinel_for)<sup>C++20</sup> | Test that a type is a sentinel for an iterator type. |
+| [`sentinel_for`](#sentinel_for)<sup>C++20</sup> | Specifies that a type is a sentinel for an iterator type. |
 | [`sized_sentinel_for`](#sized_sentinel_for)<sup>C++20</sup> | Specifies that an iterator and its sentinel can be subtracted (using `-`) to find their difference in constant time. |
 
 ## `bidirectional_iterator`
@@ -103,7 +103,7 @@ The iterator to test to see if it's a `bidirectional_iterator`.
 
 A `bidirectional_iterator` has the capabilities of a `forward_iterator`, but can also iterate backwards.
 
-Some examples of containers that can be used with a `bidirectional_iterator` are `set`, `vector`, and `list`.
+Some examples of containers that can be used with a `bidirectional_iterator` are `set`, `multiset`, `map`, `multimap`, `vector`, and `list`.
 
 ### Example: `bidirectional_iterator`
 
@@ -126,7 +126,7 @@ int main()
 
 ## `contiguous_iterator`
 
-Specifies an iterator whose elements are sequential in memory and can be accessed using pointer arithmetic.
+Specifies an iterator whose elements are sequential in memory, are the same size, and can be accessed using pointer arithmetic.
 
 ```cpp
 template<class I>
@@ -171,7 +171,7 @@ int main()
 
 ## `forward_iterator`
 
-Has the capabilities of an `input_iterator` and an `output_iterator`. Also supports iterating over a collection multiple times.
+Has the capabilities of an `input_iterator` and an `output_iterator`. Supports iterating over a collection multiple times.
 
 ```cpp
 template<class I>
@@ -191,7 +191,7 @@ The iterator to test to see if it's a `forward_iterator`.
 
 A `forward_iterator` can only move forward.
 
-Some examples of containers that can be used with a `forward_iterator` are `unordered_set`, `unordered_multiset`, `unordered_map`, and `unordered_multimap`.
+Some examples of containers that can be used with a `forward_iterator` are `vector`, `list`, `unordered_set`, `unordered_multiset`, `unordered_map`, and `unordered_multimap`.
 
 ### Example: `forward_iterator`
 
@@ -233,7 +233,7 @@ The type to test to see if it's an `input_iterator`.
 
 ### Remarks
 
-Calling `begin()` on an `input_iterator` more than once results in undefined behavior. This implies that if a type only models `input_iterator`, it isn't multi-pass and can read an element only once. Consider reading from standard input (`cin`) for example. In this case, you can only read the current element once and you can't re-read characters you've already read. An `input_iterator` only reads forward, not backwards.
+Calling `begin()` on an `input_iterator` more than once results in undefined behavior. A type that only models `input_iterator` isn't multi-pass. Consider reading from standard input (`cin`) for example. In this case, you can only read the current element once and you can't re-read characters you've already read. An `input_iterator` only reads forward, not backwards.
 
 ### Example: `input_iterator`
 
@@ -294,7 +294,7 @@ int main()
 
 ## `output_iterator`
 
-An `output_iterator` is a type that you can write to.
+An `output_iterator` is an iterator that you can write to.
 
 ```cpp
 template<class I, class T>
@@ -333,7 +333,7 @@ int main()
     std::cout << std::boolalpha << std::output_iterator<std::vector<int>::iterator, int> << "\n"; // outputs "true"
 
     // another way to test
-    std::vector<int> v = { 0,1,2,3,4,5 };
+    std::vector<int> v = {0,1,2,3,4,5};
     std::cout << std::boolalpha << std::output_iterator<decltype(v)::iterator, int>; // outputs true
 }
 ```
@@ -392,7 +392,7 @@ int main()
 
 ## `sentinel_for`
 
-Test that a type is a sentinel for an iterator.
+Specifies that a type is a sentinel for an iterator.
 
 ```cpp
 template<class S, class I>
diff --git a/docs/standard-library/iterator.md b/docs/standard-library/iterator.md
@@ -89,18 +89,18 @@ Visual Studio has added extensions to C++ Standard Library iterators to support
 
 ## Concepts
 
-The following concepts are defined in the `std` namespace. They apply to iterators, and are directly related to the iterator categories for ranges described in [`<ranges>` concepts](range-concepts.md).
+The following concepts are defined in the `std` namespace. They apply to iterators, and are also related to the iterator categories for ranges described in [`<ranges>` concepts](range-concepts.md).
 
 | Iterator concept | Description |
 |--|--|
 | [`bidirectional_iterator`](iterator-concepts.md#bidirectional_iterator)<sup>C++20</sup> | Specifies an iterator that can read and write both forwards and backwards. |
-| [`contiguous_iterator`](iterator-concepts.md#contiguous_iterator)<sup>C++20</sup> | Specifies an iterator whose elements are sequential in memory, and can be accessed using pointer arithmetic. |
+| [`contiguous_iterator`](iterator-concepts.md#contiguous_iterator)<sup>C++20</sup> | Specifies an iterator whose elements are sequential in memory, the same size, and can be accessed using pointer arithmetic. |
 | [`forward_iterator`](iterator-concepts.md#forward_iterator)<sup>C++20</sup> | Specifies an iterator that can read (and possibly write) multiple times. |
 | [`input_iterator`](iterator-concepts.md#input_iterator)<sup>C++20</sup> | Specifies an iterator that you can read from at least once. |
 | [`input_or_output_iterator`](iterator-concepts.md#input_or_output_iterator)<sup>C++20</sup> | The basis of the iterator concept taxonomy. |
 | [`output_iterator`](iterator-concepts.md#output_iterator) | Specifies an iterator that you can write to. |
-| [`random_access_iterator`](iterator-concepts.md#random_access_iterator)<sup>C++20</sup> | Specifies an iterator that can read and write by index. |
-| [`sentinel_for`](iterator-concepts.md#sentinel_for)<sup>C++20</sup> | Test that a type is a sentinel for an iterator type. |
+| [`random_access_iterator`](iterator-concepts.md#random_access_iterator)<sup>C++20</sup> | Specifies an iterator that you can read and write by index. |
+| [`sentinel_for`](iterator-concepts.md#sentinel_for)<sup>C++20</sup> | Specifies a sentinel for an iterator type. |
 | [`sized_sentinel_for`](iterator-concepts.md#sized_sentinel_for)<sup>C++20</sup> | Specifies that an iterator and its sentinel can be subtracted (using `-`) to find their difference in constant time. |
 
 ## See also
diff --git a/docs/standard-library/range-adaptors.md b/docs/standard-library/range-adaptors.md
@@ -50,7 +50,7 @@ When a range adaptor produces a view, it doesn't incur the cost of transforming
 
 Creating a view is preparation to do work in the future. In the previous example, creating the view doesn't result in finding all the elements divisible by three or squaring those elements. Work happens only when you access an element in the view.
 
-Elements of a view are usually the actual elements of the range used to create the view. The view usually doesn't own the elements; it just refers to them. Although [`owning_view`](owning-view-class.md) is an exception. Changing an element changes that element in the range that the view was created from. The following example shows this behavior:
+Elements of a view are usually the actual elements of the range used to create the view. The view usually doesn't own the elements; it just refers to them, with the exception of [`owning_view`](owning-view-class.md). Changing an element changes that element in the range that the view was created from. The following example shows this behavior:
 
 ```cpp
 #include <algorithm>
diff --git a/docs/standard-library/range-concepts.md b/docs/standard-library/range-concepts.md
@@ -7,7 +7,7 @@ helpviewer_keywords: ["std::ranges [C++], ranges::range", "std::ranges [C++], ra
 ---
 # `<ranges>` concepts
 
-Concepts are a C++20 language feature that constrains template parameters at compile time. They help prevent incorrect template instantiation, specify template argument requirements in a readable form, and provide more succinct template related compiler errors.
+Concepts are a C++20 language feature that constrain template parameters at compile time. They help prevent incorrect template instantiation, specify template argument requirements in a readable form, and provide more succinct template related compiler errors.
 
 Consider the following example, which defines a concept to prevent instantiating a template with a type that doesn't support division:
 
@@ -48,24 +48,23 @@ int main()
 }
 ```
 
-When you pass the compiler switch `/diagnostics:caret` to Visual Studio 2022 version 17.4 or later, the error that concept `dividable<char*>` evaluated to false will point directly to the expression requirement `(a / b)` that failed.
+When you pass the compiler switch `/diagnostics:caret` to Visual Studio 2022 version 17.4 preview 4, or later, the error that concept `dividable<char*>` evaluated to false will point directly to the expression requirement `(a / b)` that failed.
 
-Range concepts are defined in the `std::ranges` namespace as declared in the `<ranges>` header file. They're used in the declarations of [range adaptors](range-adaptors.md), [views](view-classes.md), and so on.
+Range concepts are defined in the `std::ranges` namespace, and declared in the `<ranges>` header file. They're used in the declarations of [range adaptors](range-adaptors.md), [views](view-classes.md), and so on.
 
 There are six categories of ranges. They're related to the categories of iterators listed in [`<iterator>` concepts](iterator-concepts.md). In order of increasing capability, the categories are:
 
 | Range concept | Description |
 |--|--|
-| [`output_range`](#output_range) | Specifies a range that you can write to. |
-| [`input_range`](#input_range) | Specifies a range that you can read from at least once.|
-| [`forward_range`](#forward_range) | Specifies a range that can read (and possibly write) multiple times. |
-| [`bidirectional_range`](#bidirectional_range) | Specifies a range that can read and write both forwards and backwards. |
-| [`random_access_range`](#random_access_range) | Specifies a range that can read and write by index. |
-| [`contiguous_range`](#contiguous_range) | Specifies a range whose elements are sequential in memory and can be accessed using pointer arithmetic. |
+| [`output_range`](#output_range)<br>[`input_range`](#input_range) | Specifies a range that you can write to.<br>Specifies a range that you can read from once. |
+| [`forward_range`](#forward_range) | Specifies a range that you can read (and possibly write) multiple times. |
+| [`bidirectional_range`](#bidirectional_range) | Specifies a range that you can read and write both forwards and backwards. |
+| [`random_access_range`](#random_access_range) | Specifies a range that you can read and write by index. |
+| [`contiguous_range`](#contiguous_range) | Specifies a range whose elements are sequential in memory, are the same size, and can be accessed using pointer arithmetic. |
 
-In the preceding table, concepts are listed in order of increasing capability. A range that meets the requirements of a concept generally meets the requirements of the concepts in the rows that precede it. For example, a `random_access_range` has the capability of a `bidirectional_range`, `forward_range`, `input_range`, and `output_range`. Except `input_range`, which doesn't have the capability of an `output_range` because it can't be written to.
+In the preceding table, concepts are listed in order of increasing capability. A range that meets the requirements of a concept generally meets the requirements of the concepts in the rows that precede it. For example, a `random_access_range` has the capability of a `bidirectional_range`, `forward_range`, `input_range`, and `output_range`. The exception is `input_range`, which can't be written to, so it doesn't have the capabilities of `output_range`.
 
-:::image type="content" source="media/ranges-iterator-hiearchy.svg" alt-text="Diagram of the ranges iterator hierarchy. input_range and output_range are the base. forward_range is next and refines both input_range and output_range. bidirectional_range refines forward_range. random_access_range refines bidirectional_range. Finally, contiguous_range refines random_access_range":::
+:::image type="content" source="media/ranges-iterator-hiearchy.svg" alt-text="Diagram of the ranges iterator hierarchy. input_range and output_range are the most basic iterators. forward_range is next and refines both input_range and output_range. bidirectional_range refines forward_range. random_access_range refines bidirectional_range. Finally, contiguous_range refines random_access_range":::
 
 Other range concepts include:
 
@@ -75,7 +74,7 @@ Other range concepts include:
 | [`borrowed_range`](#borrowed_range)<sup>C++20</sup> | Specifies that the lifetime of the range's iterators aren't tied to the range's lifetime. |
 | [`common_range`](#common_range)<sup>C++20</sup> | Specifies that the type of the range's iterator and the type of the range's sentinel are the same. |
 | [`Simple_View`](#simple_view)<sup>C++20</sup> | Not an official concept defined as part of the standard library, but used as a helper concept on some interfaces. |
-| [`sized_range`](#sized_range)<sup>C++20</sup> | Specifies a range that can provide the number of elements in a range efficiently. |
+| [`sized_range`](#sized_range)<sup>C++20</sup> | Specifies a range that can provide its number of elements efficiently. |
 | [`view`](#view)<sup>C++20</sup> | Specifies a type that has efficient (constant time) move construction, assignment, and destruction. |
 | [`viewable_range`](#viewable_range)<sup>C++20</sup> | Specifies a type that either is a view or can be converted to one. |
 
@@ -208,7 +207,7 @@ This kind of range supports [`forward_iterator`](iterator-concepts.md#forward_it
 
 ## `input_range`
 
-An `input_range` is a range that can be read from at least once.
+An `input_range` is a range that can be read from once.
 
 ```cpp
 template<class T>
diff --git a/docs/standard-library/ranges.md b/docs/standard-library/ranges.md
diff --git a/docs/standard-library/view-classes.md b/docs/standard-library/view-classes.md
