Remove unneeded references to C++14 and C++17

Author: Morwenn

docs/Comparator-adapters.md

@@ -56,7 +56,7 @@ constexpr auto base() const
 #include <cpp-sort/comparators/not_fn.h>
 ```
 
-The class template `not_fn_t` is roughly equivalent to the one returned by the C++17 [`std::not_fn`][std-not-fn], a function object which, when called, returns the negation of the *Callable* it holds.
+The class template `not_fn_t` is roughly equivalent to the one returned by [`std::not_fn`][std-not-fn], a function object which, when called, returns the negation of the *Callable* it holds.
 
 `not_fn_t<F>` has the following member functions:
 

docs/Miscellaneous-utilities.md

@@ -375,7 +375,7 @@ auto m = get<foo_tag>(mm);
 
 ***WARNING:** this header is removed in version 3.0.0, use `mstd::distance` instead.*
 
-`size` is a function that can be used to get the size of a container. It is equivalent to the C++17 function [`std::size`][std-size] but has an additional tweak so that, if the container is not a fixed-size C array and doesn't have a `size` method, it calls `std::distance(std::begin(cont), std::end(cont))` on the container. Therefore, this function can also be used for `std::forward_list` as well as some views.
+`size` is a function that can be used to get the size of a container. It is equivalent to [`std::size`][std-size] but has an additional tweak so that, if the container is not a fixed-size C array and doesn't have a `size` method, it calls `std::distance(std::begin(cont), std::end(cont))` on the container. Therefore, this function can also be used for `std::forward_list` as well as some views.
 
 ### `sorted_indices`
 

docs/Sorter-adapters.md

@@ -6,7 +6,7 @@ Sorter adapters are the main reason for using sorter function objects instead of
 
 In this documentation, we call *adapted sorters* the sorters passed to the adapters and *resulting sorter* the sorter class that results from the adaption of a sorter by an adapter. If not specified, the stability and the iterator category of the *resulting sorter* is that of the *adapted sorter* provided there is a single *adapted sorter*. The *resulting sorter* is expected to follow the *unified sorting interface*.
 
-In C++17, *sorter adapters* can be used in a function-like fashion thanks to `explicit` constructors (taking one or several sorters) by taking advantage of implicit [deduction guides][ctad]. The following example illustrates how it simplifies their use:
+*sorter adapters* can be used in a function-like fashion thanks to `explicit` constructors (taking one or several sorters) by taking advantage of implicit [deduction guides][ctad]. The following example illustrates how it simplifies their use:
 
 ```cpp
 // With explicit template parameter
@@ -204,7 +204,7 @@ using sorter = cppsort::hybrid_adapter<
 >;
 ```
 
-*Warning: this adapter does note take advantage of the C++17 deduction guides.*
+*Warning: this adapter does note take advantage of deduction guides.*
 
 *Warning: this adapter only supports default-constructible stateless sorters.*
 

docs/Sorter-facade.md

@@ -127,8 +127,6 @@ These overloads will generally forward the parameters to the corresponding `oper
 
 It will always call the most suitable range `operator()` overload in the wrapped *sorter implementation* if there is one, and dispatch the call to an overload taking a pair of iterators when it cannot do otherwise.
 
-*NOTE:* range overloads are marked as `constexpr` but rely on [`std::begin`][std-begin] and [`std::end`][std-end], which means that they can't actually be used in a `constexpr` context before C++17 (except for arrays).
-
 ### Projection support for comparison-only sorters
 
 Some *sorter implementations* are able to handle custom comparison functions but don't have any dedicated support for projections. If such an implementation is wrapped by `sorter_facade` and is given a projection function, `sorter_facade` will bake the projection into the comparison function and give the result to the *sorter implementation* as a comparison function. Basically it means that a *sorter implementation* with a single `operator()` taking a pair of iterators and a comparison function can take any range, pair of iterators, comparison and/or projection function once it is wrapped into `sorter_facade`.

include/cpp-sort/comparators/not_fn.h

@@ -170,7 +170,7 @@ namespace cppsort
     }
 
     ////////////////////////////////////////////////////////////
-    // C++17 std::not_fn equivalent
+    // std::not_fn equivalent
 
     template<typename F>
     constexpr auto not_fn(F&& func)