STL Preview

Description

Use the latest STL implementation in C++14

// All implementations are written under C++14 standard semantics
#include "preview/ranges.h"

auto map = preview::views::iota('A', 'E') | 
           preview::views::enumerate | 
           preview::ranges::to<std::map>(); // See notes about CTAD below

std::cout << map[0] << ' '
          << map[1] << ' '
          << map[2] << '\n';
// A B C

preview is standard-conforming, and is compatible with existing STL

// Pre-C++20 iterators are fully compatible
auto floats = std::istringstream{"1.1  2.2\t3.3\v4.4\f55\n66\r7.7  8.8"};
ranges::copy(views::istream<float>(floats), std::ostream_iterator<float>{std::cout, ", "});

// Complex ranges/iterators are also compatible with both pre C++20 and 
// post C++20 std::iterator_traits
auto r = preview::views::iota(0) |
      preview::views::take(10) |
      preview::views::filter([](auto x) { return x % 2 == 0; });

static_assert(std::is_same<
    std::iterator_traits<decltype(r.begin())>::reference,
    int
>::value, "");

Up to C++26 STL are available

void foo(preview::span<int>) {}

int main() {
  // span with C++26 standard
  foo({1, 2, 3});
  
  preview::variant<int, float, double> v{1.0f};
  v.visit([](auto x) {
    // member visit(): C++26 standard
  });
  
  // views::concat
  std::vector<char> v = {'h', 'e', 'l'};
  std::string s = "lo, ";
  preview::string_view sv = "world";
  std::list<char> l = {'!'};

  // hello, world!
  for (auto c : preview::views::concat(v, s, sv, l)) {
    std::cout << c;
  }
  
  // expected
  auto process = [](preview::string_view str) -> preview::expected<int, std::string> {
    return parse_number(str)
      .transform([](double v) { return static_cast<int>(v); })
      .transform_error([](parse_error e) {
        return e == parse_error::invalid_input ? "invalid input" : "overflow";
      });
  };
  std::cout << process("42").value_or(-1) << '\n;'; // 42
  std::cout << process("inf").value_or(-1) << '\n'; // -1
}

Compiler Support

Compiler	Minimum version tested	Maximum version tested
MSVC	19.29.30154.0 (Visual Studio 16 2019)	19.40.33811.0 (Visual Studio 17 2022)
gcc	9.5.0	13.1.0
clang	11.1.0	15.0.7
Apple clang	14.0.0.14000029	15.0.0.15000040 (Silicon)
Android NDK	r18 (clang 7.0)	r26 (clang 17.0.2)
Emscripten	3.1.20 (clang 16.0.0)	latest(3.1.61) (clang 19.0.0)

Features

Description

: C++YY standard implemented in C++XX
: C++YY standard, not implemented yet
If the implementation is impossible(i.e., needs compiler support / hardware info) it is marked as N/A
Some features are working in progress
Introduced: First introduced version
Revision: Behavior changed/updated version

<algorithm> (61/114)

	Introduced	Revision
`search`
`clamp`
`for_each_n`
`sample`
`shift_left`
`shift_right`
`ranges::in_fun_result`
`ranges::in_in_result`
`ranges::in_out_result`
`ranges::in_in_out_result`
`ranges::in_out_out_result`
`ranges::min_max_result`
`ranges::in_found_result`
`ranges::in_value_result`
`ranges::out_value_result`
`ranges::all_of`
`ranges::any_of`
`ranges::none_of`
`ranges::for_each`
`ranges::for_each_n`
`ranges::count`
`ranges::count_if`
`ranges::mismatch`
`ranges::find`
`ranges::find_if`
`ranges::find_if_not`
`ranges::find_last`
`ranges::find_last_if` `
`ranges::find_last_if_not`
`ranges::find_end`
`ranges::find_first_of`
`ranges::adjacent_find`
`ranges::search`
`ranges::search_n`
`ranges::contains`
`ranges::contains_subrange`
`ranges::starts_with`
`ranges::ends_with`
`ranges::fold_left`
`ranges::fold_left_first`
`ranges::fold_right`
`ranges::fold_right_last`
`ranges::fold_left_with_iter`
`ranges::fold_left_first_with_iter`
`ranges::copy`
`ranges::copy_if`
`ranges::copy_n`
`ranges::copy_backward`
`ranges::move`
`ranges::move_backward`
`ranges::fill`
`ranges::fill_n`
`ranges::transform`
`ranges::generate`
`ranges::generate_n`
`ranges::remove`
`ranges::remove_if`
`ranges::remove_copy`
`ranges::remove_copy_if`
`ranges::replace`
`ranges::replace_if`
`ranges::replace_copy`
`ranges::replace_copy_if`
`ranges::swap_ranges`
`ranges::reverse`
`ranges::reverse_copy`
`ranges::rotate`
`ranges::rotate_copy`
`ranges::shift_left`
`ranges::shift_right`
`ranges::sample`
`ranges::shuffle`
`ranges::unique`
`ranges::unique_copy`
`ranges::is_partitioned`
`ranges::partition`
`ranges::partition_copy`
`ranges::stable_partition`
`ranges::partition_point`
`ranges::is_sorted`
`ranges::is_sorted_until`
`ranges::sort`
`ranges::partial_sort`
`ranges::partial_sort_copy`
`ranges::stable_sort`
`ranges::nth_element`
`ranges::lower_bound`
`ranges::upper_bound`
`ranges::binary_search`
`ranges::equal_range`
`ranges::merge`
`ranges::inplace_merge`
`ranges::includes`
`ranges::set_difference`
`ranges::set_intersection`
`ranges::set_symmetric_difference`
`ranges::set_union`
`ranges::is_heap`
`ranges::is_heap_until`
`ranges::make_heap`
`ranges::push_heap`
`ranges::pop_heap`
`ranges::sort_heap`
`ranges::max`
`ranges::max_element`
`ranges::min`
`ranges::min_element`
`ranges::minmax`
`ranges::minmax_element`
`ranges::clamp`
`ranges::equal`
`ranges::lexicographical_compare`
`ranges::is_permutation`
`ranges::next_permutation`
`ranges::prev_permutation`

<any> (0/5)

Introduced Revision

any

bad_any_cast

swap(any)

make_any

any_cast
<array> (1/1)

Introduced Revision

to_array

	Introduced	Revision
`to_array`

<atomic> (0/17)

	Introduced	Revision
`atomic_ref`
`atomic_signed_lock_free`
`atomic_unsigned_lock_free`
`atomic_wait`
`atomic_wait_explicit`
`atomic_notify_one`
`atomic_notify_all`
`atomic_flag_test`
`atomic_flag_test_explicit`
`atomic_flag_wait`
`atomic_flag_wait_explicit`
`atomic_flag_notify_one`
`atomic_flag_notifly_all`
`atomic_fetch_max`
`atomic_fetch_max_explicit`
`atomic_fetch_min`
`atomic_fetch_min_explicit`

<barrier> (0/1)

Introduced Revision

barrier

	Introduced	Revision
`barrier`

<bit> (0/14)

	Introduced	Revision
`endian`
`bit_cast`
`byteswap`
`has_single_bit`
`bit_ceil`
`bit_floor`
`bit_width`
`rotl`
`rotr`
`countl_zero`
`countl_one`
`countr_zero`
`countr_one`
`popcount`

<charconv> (0/5)

Introduced Revision

chars_format

from_chars_result

to_chars_result

from_chars

to_chars

<chrono>

	Introduced	Revision
`std::chrono::duration`
`std::chrono::time_point`
`clock_time_conversion`
`is_clock`
`utc_clock`
`tai_clock`
`gps_clock`
`file_clock`
`local_t`
`last_spec`
`day`
`month`
`year`
`weekday`
`weekday_indexed`
`weekday_last`
`month_day`
`month_day_last`
`month_weekday`
`month_weekday_last`
`year_month`
`year_month_day`
`year_month_day_last`
`year_month_weekday`
`year_month_weekday_last`
`hh_mm_ss`
`tzdb`
`tzdb_list`
`tzdb_zone`
`get_tzdb`
`get_tzdb_list`
`reload_tzdb`
`remote_version`
`locate_zone`
`sys_info`
`local_info`
`choose`
`zoned_traits`
`zoned_time`
`time_zone_link`
`nonexistent_local_time`
`ambiguous_local_time`
`leap_second`
`leap_second_info`
`get_leap_second_info`
`is_am` `is_pm`
`make_12` `make_24`

<cmath>

	Introduced	Revision
`assoc_laguerre`
`assoc_legendre`
`beta`
`comp_ellint_1`
`comp_ellint_2`
`comp_ellint_3`
`cyl_bessel_i`
`cyl_bessel_j`
`cyl_bessel_k`
`cyl_neumann`
`ellint_1`
`ellint_2`
`ellint_3`
`expint`
`hermite`
`legendre`
`laguerre`
`riemann_zeta`
`sph_bessel`
`sph_legendre`
`sph_neumann`
`hypot(x, y, z)`

<compare> N/A

<concepts>

	Introduced	Revision
`same_as`
`derived_from`
`convertible_to`
`common_reference_with`
`common_with`
`integral`
`signed_integral`
`unsigned_integral`
`floating_point`
`assignable_from`
`swappable`
`destructible`
`constructible_from`
`default_initializable`
`move_constructible`
`copy_constructible`
`equality_comparable`
`equality_comparable_with`
`totally_ordered`
`movable`
`copyable`
`semiregular`
`regular`
`invocable`
`regular_invocable`
`predicate`
`relation`
`equivalence_relation`
`strict_weak_order`
`ranges::swap`

<coroutine> N/A
<cstddef> (2/2)

Introduced Revision

byte

to_integer
<exception>

Introduced Revision

uncaught_exceptions (N/A)
<expected> (4/4)

Introduced Revision

expected

unexpected

bad_expected_access

unexpect
unexpect_t
<execution> N/A
<flat_map> (0/4)

Introduced Revision

flat_map

flat_multimap

sorted_unique
sorted_unique_t

sorted_equivalent
sorted_equivalent_t
<flat_set> (0/2)

Introduced Revision

flat_set

flat_multiset
<format>

Introduced Revision
<filesystem> N/A

	Introduced	Revision
`uncaught_exceptions`	(N/A)

<functional> (6/16)

	Introduced	Revision
`default_searcher`
`boyer_moore_searcher`
`boyer_moore_horspool_searcher`
`invoke`
`invoke_r`
`not_fn`
`bind_front`
`bind_back`
`identity`
`unwrap_reference`
`unwrap_ref_decay`
`ranges::equal_to`...
`ranges::three_way`
`move_only_function`
`copyable_function`
`function_ref`

<hazard_pointer>

Introduced Revision

hazard_pointer_obj_base

hazard_pointer

make_hazard_pointer

<iterator>

	Introduced	Revision
`indirectly_readable`
`indirectly_writable`
`weakly_incrementable`
`incrementable`
`input_or_output_iterator`
`sentinel_for`
`sized_sentinel_for`
`input_iterator`
`output_iterator`
`forward_iterator`
`bidirectional_iterator`
`random_access_iterator`
`contiguous_iterator`
`indirectly_unary_invocable`
`indirectly_regular_unary_invocable`
`indirect_unary_predicate`
`indirect_binary_predicate`
`indirect_equivalence_relation`
`indirect_strict_weak_order`
`indirectly_movable`
`indirectly_movable_storable`
`indirectly_copyable`
`indirectly_copyable_storable`
`indirectly_swappable`
`indirectly_comparable`
`permutable`
`mergeable`
`sortable`
`indirect_result_t`
`projected`		*
`projected_value_t`
`incrementable_traits`
`indirectly_readable_traits`
`iter_value_t` `iter_reference_t`
`iter_const_reference_t`
`iter_difference_t`
`iter_rvalue_reference_t`
`iter_common_reference_t`
`iterator_traits`
`move_sentinel`
`basic_const_iterator`
`const_iterator`
`const_sentinel`
`common_iterator`
`default_sentinel_t` `default_sentinel`
`counted_iterator`
`unreachable_sentinel_t` `unreachable_sentinel`
`iter_move`
`iter_swap`
`make_const_iterator` `make_const_sentinel`
`ranges::advance`
`ranges::distance`
`ranges::next`
`ranges::prev`
`size(C)`
`ssize(C)`
`empty(C)`
`data(C)`

<latch>

Introduced Revision

latch

	Introduced	Revision
`latch`

<linalg>

	Introduced	Revision
`layout_blas_packed`
`scaled_accessor`
`conjugated_accessor`
`layout_transpose`
`column_major` `column_major_t`
`row_major` `row_major_t`
`upper_triangle` `upper_triangle_t`
`lower_triangle` `lower_triangle_t`
`implicit_unit_diagonal` `implicit_unit_diagonal_t`
`explicit_unit_diagonal` `explicit_unit_diagonal_t`
`scaled`
`conjugated`
`transposed`
`conjugated_transposed`
`setup_givens_rotation`
`apply_givens_rotation`
`swap_elements`
`scale`
`copy`
`add`
`dot` `dotc`
`vector_sum_of_squares`
`vector_two_norm`
`vector_abs_sum`
`vector_idx_abs_max`
`matrix_frob_norm`
`matrix_one_norm`
`matrix_inf_norm`
`matrix_vector_product`
`symmetric_matrix_vector_product`
...

<mdspan>

	Introduced	Revision
`mdspan`
`extents`
`layout_left`
`layout_right`
`layout_stride`
`layout_stride`
`submdspan`
`submdspan_extents`
`strided_slice`
`submdspan_mapping_result`
`full_extent` `full_extent_t`

<memory>

	Introduced	Revision
`aligned_alloc`
`assume_aligned`
`construct_at`
`destroy_at`
`destroy`
`destroy_n`
`reinterpret_pointer_cast`
`uninitialized_default_construct`
`uninitialized_default_construct_n`
`uninitialized_move`
`uninitialized_move_n`
`uninitialized_value_construct`
`uninitialized_value_construct_n`
`make_obj_using_allocator`
`make_shared_for_overwrite`
`make_unique_for_overwrite`
`to_address`
`uninitialized_construct_using_allocator`
`uses_allocator_construction_args`
`operator<<(std::unique_ptr)`
`pointer_traits`
`ranges::construct_at`
`ranges::destroy`
`ranges::destroy_n`
`ranges::destroy_at`
`ranges::uninitialized_copy`
`ranges::uninitialized_copy_n`
`ranges::uninitialized_fill`
`ranges::uninitialized_fill_n`
`ranges::uninitialized_move`
`ranges::uninitialized_move_n`
`ranges::uninitialized_default_construct`
`ranges::uninitialized_default_construct_n`
`ranges::uninitialized_value_construct`
`ranges::uninitialized_value_construct_n`
`inout_ptr` `inout_ptr_t`
`out_ptr` `out_ptr_t`
`start_lifetime_as` `start_lifetime_as_array`
`owner_hash`
`owner_equal`

<memory_resource> N/A
<mutex>

Introduced Revision

scoped_lock
<new>

Introduced Revision

hardware_destructive_interference_size

hardware_constructive_interference_size

launder
<numbers>

Introduced Revision

e

log2e

log10e

pi

inv_pi

inv_sqrtpi

ln2

ln10

sqrt2

sqrt3

inv_sqrt3

egamma

phi

	Introduced	Revision
`scoped_lock`

<numeric>

	Introduced	Revision
`exclusive_scan`
`transform_exclusive_scan`
`inclusive_scan`
`transform_inclusive_scan`
`gcd`
`lcm`
`reduce`
`transform_reduce`
`midpoint`
`ranges::iota`
`add_sat`
`sub_sat`
`mul_sat`
`div_sat`
`saturate_cast`

<optional>

Introduced Revision

optional

bad_optional_access

std::hash<optional>

nullopt

nullopt_t

swap(optional)

make_optional
<random>

Introduced Revision

uniform_random_bit_generator

	Introduced	Revision
`uniform_random_bit_generator`

<ranges>

	Introduced	Revision
`ranges::range`
`ranges::borrowed_range`
`ranges::sized_range`
`ranges::view`
`ranges::input_range`
`ranges::output_range`
`ranges::forward_range`
`ranges::bidirectional_range`
`ranges::random_access_range`
`ranges::contiguous_range`
`ranges::common_range`
`ranges::viewable_range`
`ranges::constant_range`
`ranges::to`	*
`ranges::iterator_t`
`ranges::const_iterator_t`
`ranges::sentinel_t`
`ranges::const_sentinel_t`
`ranges::range_difference_t`
`ranges::range_size_t`
`ranges::range_value_t`
`ranges::range_refernce_t`
`ranges::range_const_reference_t`
`ranges::range_rvalue_reference_t`
`ranges::range_common_reference_t`
`ranges::view_interface`
`ranges::subrange`
`ranges::dangling`
`ranges::borrowed_iterator_t`
`ranges::borrowed_subrange_t`
`ranges::range_adaptor_closure`
`ranges::empty_view` `views::empty`
`ranges::single_view` `views::single`
`ranges::iota_view` `views::iota`
`ranges::iota_view` `views::iota`
`ranges::basic_istream_view` `views::istream`
`ranges::repeat_view` `views::repeat`
`ranges::cartesian_product_view` `views::cartesian_product`
`views::all_t` `views::all`
`ranges::ref_view`
`ranges::owning_view`
`ranges::filter_view` `views::filter`
`ranges::transform_view` `views::transform`
`ranges::take_view` `views::take`
`ranges::take_while_view` `views::take_while`
`ranges::drop_view` `views::drop`
`ranges::drop_while_view` `views::drop_while`
`ranges::join_view` `views::join`
`ranges::lazy_split_view` `views::lazy_split`
`ranges::split_view` `views::split`
`views::counted`
`ranges::common_view` `views::common`
`ranges::reverse_view` `views::reverse`
`ranges::as_const_view` `views::as_const`
`ranges::as_rvalue_view` `views::as_rvalue`
`ranges::elements_view` `views::elements`
`ranges::keys_view` `views::keys`
`ranges::values_view` `views::values`
`ranges::enumerate_view` `views::enumerate`
`ranges::zip_view` `views::zip`
`ranges::zip_transform_view` `views::zip_transform`
`ranges::adjacent_view` `views::adjacent`
`ranges::adjacent_transform_view` `views::adjacent_transform`
`ranges::join_with_view` `views::join_with`
`ranges::stride_view` `views::stride`
`ranges::slide_view` `views::slide`
`ranges::chunk_view` `views::chunk`
`ranges::chunk_by_view` `views::chunk_by`
`ranges::concat_view` `views::concat`
`ranges::begin`
`ranges::end`
`ranges::cbegin`
`ranges::cend`
`ranges::crbegin`
`ranges::crend`
`ranges::size`
`ranges::ssize`
`ranges::empty`
`ranges::data`
`ranges::cdata`
`ranges::subrange_kind`
`ranges::from_range_t` `ranges::from_range`

Notes
- ranges::to
  - CTAD for Args... may be incorrect before C++17
  - Equipped with C++23 conversions(e.g., pair-like -> std::pair)

<semaphore>

Introduced Revision

counting_semaphore

binary_semaphore
<stop_token>

Introduced Revision

stop_token

stop_source

stop_callback

nostopstate_t

nostopstate
<string>

Introduced Revision

erase(std::basic_string)

erase_if(std::basic_string)
<string_view>

Introduced Revision

basic_string_view

std::hash<basic_string_view>

swap(optional)

operator""_sv
<source_location> N/A
<syncstream>

Introduced Revision

basic_syncbuf

basic_osyncstream

std::swap(basic_syncbuf)
<span>

Introduced Revision

span

dynamic_extent

as_bytes

as_writable_bytes
<spanstream>

Introduced Revision

basic_spanbuf

basic_ispanstream

basic_ospanstream

basic_spanstream
<thread>

Introduced Revision

jthread
<tuple>

Introduced Revision

apply

make_from_tuple

	Introduced	Revision
`jthread`

<type_traits>

	Introduced	Revision
`common_type`
`conjunction`
`bool_constant`
`disjunction`
`has_unique_object_representations`	N/A
`is_aggregate`	N/A
`is_swappable`
`is_invocable`
`invoke_result`
`negation`
`void_t`
`common_reference` `basic_common_reference`
`is_bounded_array`
`is_constant_evaluated`	N/A
`is_corresponding_member`	N/A
`is_layout_compatible`	N/A
`is_nothrow_convertible`
`is_pointer_interconvertible_base_of`	N/A
`is_pointer_interconvertible_with_class`	N/A
`is_scoped_enum`	N/A
`is_unbounded_array`
`remove_cvref`
`type_identity`
`is_implicit_lifetime`	N/A
`is_within_lifetime`	N/A
`arity`	Extended
`conditional`	Extended
`copy_cvref`	Extended
`copy_template`	Extended
`has_typename_xxx`	Extended
`is_complete`	Extended
`is_explicitly_constructible`	Extended
`is_explicitly_convertible`	Extended
`is_implicitly_constructible`	Extended
`is_initializer_list`	Extended
`is_integer_like`	Extended
`is_list_initializable`	Extended
`is_referenceable`	Extended
`is_specialization`	Extended
`maybe_const`	Extended
`template_arity`	Extended

<utility>

Introduced Revision

as_const

in_place
in_place_t

cmp_equal

in_range

forward_like

to_underlying

nontype
nontype_t

unreachable N/A
<variant>

Introduced Revision

variant

monostate

bad_variant_access

variant_size

variant_alternative

std::hash<variant>

variant_npos

visit

get_if
<version>

Introduced Revision

lackhole / stl-preview Goto Github PK

stl-preview's Introduction

STL Preview

Description

Compiler Support

Features

stl-preview's People

Contributors

Stargazers

Watchers

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	Introduced	Revision
`chars_format`
`from_chars_result`
`to_chars_result`
`from_chars`
`to_chars`

	Introduced	Revision
`expected`
`unexpected`
`bad_expected_access`
`unexpect` `unexpect_t`

	Introduced	Revision
`flat_map`
`flat_multimap`
`sorted_unique` `sorted_unique_t`
`sorted_equivalent` `sorted_equivalent_t`

	Introduced	Revision
`hazard_pointer_obj_base`
`hazard_pointer`
`make_hazard_pointer`

	Introduced	Revision
`hardware_destructive_interference_size`
`hardware_constructive_interference_size`
`launder`

	Introduced	Revision
`e`
`log2e`
`log10e`
`pi`
`inv_pi`
`inv_sqrtpi`
`ln2`
`ln10`
`sqrt2`
`sqrt3`
`inv_sqrt3`
`egamma`
`phi`

	Introduced	Revision
`optional`
`bad_optional_access`
`std::hash<optional>`
`nullopt`
`nullopt_t`
`swap(optional)`
`make_optional`

	Introduced	Revision
`stop_token`
`stop_source`
`stop_callback`
`nostopstate_t`
`nostopstate`

	Introduced	Revision
`basic_string_view`
`std::hash<basic_string_view>`
`swap(optional)`
`operator""_sv`

	Introduced	Revision
`basic_syncbuf`
`basic_osyncstream`
`std::swap(basic_syncbuf)`

	Introduced	Revision
`any`
`bad_any_cast`
`swap(any)`
`make_any`
`any_cast`

	Introduced	Revision
`byte`
`to_integer`

	Introduced	Revision
`flat_set`
`flat_multiset`

	Introduced	Revision
`counting_semaphore`
`binary_semaphore`

	Introduced	Revision
`basic_spanbuf`
`basic_ispanstream`
`basic_ospanstream`
`basic_spanstream`

	Introduced	Revision
`as_const`
`in_place` `in_place_t`
`cmp_equal`
`in_range`
`forward_like`
`to_underlying`
`nontype` `nontype_t`
`unreachable`	N/A

	Introduced	Revision
`variant`
`monostate`
`bad_variant_access`
`variant_size`
`variant_alternative`
`std::hash<variant>`
`variant_npos`
`visit`
`get_if`