// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

export namespace std {
  namespace ranges {
    inline namespace __cpo {
      // [range.access], range access
      using std::ranges::__cpo::begin;
      using std::ranges::__cpo::cbegin;
      using std::ranges::__cpo::cend;
      using std::ranges::__cpo::crbegin;
      using std::ranges::__cpo::crend;
      using std::ranges::__cpo::end;
      using std::ranges::__cpo::rbegin;
      using std::ranges::__cpo::rend;

      using std::ranges::__cpo::cdata;
      using std::ranges::__cpo::data;
      using std::ranges::__cpo::empty;
      using std::ranges::__cpo::size;
      using std::ranges::__cpo::ssize;
    } // namespace __cpo

    // [range.range], ranges
    using std::ranges::range;

    using std::ranges::enable_borrowed_range;

    using std::ranges::borrowed_range;

    // using std::ranges::const_iterator_t;
    // using std::ranges::const_sentinel_t;
    using std::ranges::iterator_t;
    // using std::ranges::range_const_reference_t;
    using std::ranges::range_common_reference_t;
    using std::ranges::range_difference_t;
    using std::ranges::range_reference_t;
    using std::ranges::range_rvalue_reference_t;
    using std::ranges::range_size_t;
    using std::ranges::range_value_t;
    using std::ranges::sentinel_t;

    // [range.sized], sized ranges
    using std::ranges::disable_sized_range;
    using std::ranges::sized_range;

    // [range.view], views
    using std::ranges::enable_view;
    using std::ranges::view;
    using std::ranges::view_base;

    // [range.refinements], other range refinements
    using std::ranges::bidirectional_range;
    using std::ranges::common_range;
    // using std::ranges::constant_range;
    using std::ranges::contiguous_range;
    using std::ranges::forward_range;
    using std::ranges::input_range;
    using std::ranges::output_range;
    using std::ranges::random_access_range;
    using std::ranges::viewable_range;

    // [view.interface], class template view_­interface
    using std::ranges::view_interface;

    // [range.subrange], sub-ranges
    using std::ranges::subrange;
    using std::ranges::subrange_kind;

    using std::ranges::get;
  } // namespace ranges

  using std::ranges::get;

  namespace ranges {

    // [range.dangling], dangling iterator handling
    using std::ranges::dangling;

    // [range.elementsof], class template elements_­of
    // using std::ranges::elements_of;

    using std::ranges::borrowed_iterator_t;

    using std::ranges::borrowed_subrange_t;

#if _LIBCPP_STD_VER >= 23
    // [range.utility.conv], range conversions
    using std::ranges::to;
#endif

    // [range.empty], empty view
    using std::ranges::empty_view;

    namespace views {
      using std::ranges::views::empty;
    }

    // [range.single], single view
    using std::ranges::single_view;

    namespace views {
      using std::ranges::views::single;
    } // namespace views

    // [range.iota], iota view
    using std::ranges::iota_view;

    namespace views {
      using std::ranges::views::iota;
    } // namespace views

#if _LIBCPP_STD_VER >= 23
    // [range.repeat], repeat view
    using std::ranges::repeat_view;

    namespace views {
      using std::ranges::views::repeat;
    } // namespace views
#endif // _LIBCPP_STD_VER >= 23

#ifndef _LIBCPP_HAS_NO_LOCALIZATION
    // [range.istream], istream view
    using std::ranges::basic_istream_view;
    using std::ranges::istream_view;
#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
    using std::ranges::wistream_view;
#  endif

    namespace views {
      using std::ranges::views::istream;
    }
#endif // _LIBCPP_HAS_NO_LOCALIZATION

    // Note: This declaration not in the synopsis or explicitly in the wording.
    // However it is needed for the range adaptors.
    // [range.adaptor.object]/3
    //   The template parameter D for range_adaptor_closure may be an
    //   incomplete type. If an expression of type cv D is used as an operand
    //   to the | operator, D shall be complete and model
    //   derived_from<range_adaptor_closure<D>>. The behavior of an expression
    //   involving an object of type cv D as an operand to the | operator is
    //   undefined if overload resolution selects a program-defined operator|
    //   function.
    // This is used internally in C++20 mode.
    using std::ranges::operator|;
#if _LIBCPP_STD_VER >= 23
    // [range.adaptor.object], range adaptor objects
    using std::ranges::range_adaptor_closure;
#endif

    // [range.all], all view
    namespace views {
      using std::ranges::views::all;
      using std::ranges::views::all_t;
    } // namespace views

    // [range.ref.view], ref view
    using std::ranges::ref_view;

    // [range.owning.view], owning view
    using std::ranges::owning_view;

#if _LIBCPP_STD_VER >= 23
    // [range.as.rvalue], as rvalue view
    using std::ranges::as_rvalue_view;

    namespace views {
      using std::ranges::views::as_rvalue;
    } // namespace views
#endif // _LIBCPP_STD_VER >= 23

    // [range.filter], filter view
    using std::ranges::filter_view;

    namespace views {
      using std::ranges::views::filter;
    } // namespace views

    // [range.transform], transform view
    using std::ranges::transform_view;

    namespace views {
      using std::ranges::views::transform;
    } // namespace views

    // [range.take], take view
    using std::ranges::take_view;

    namespace views {
      using std::ranges::views::take;
    } // namespace views

    // [range.take.while], take while view
    using std::ranges::take_while_view;

    namespace views {
      using std::ranges::views::take_while;
    } // namespace views

    // [range.drop], drop view
    using std::ranges::drop_view;

    namespace views {
      using std::ranges::views::drop;
    } // namespace views

    // [range.drop.while], drop while view
    using std::ranges::drop_while_view;

    namespace views {
      using std::ranges::views::drop_while;
    } // namespace views

    using std::ranges::join_view;

    namespace views {
      using std::ranges::views::join;
    } // namespace views
#if 0
    using std::ranges::join_with_view;

    namespace views {
      using std::ranges::views::join_with;
    } // namespace views
#endif
    using std::ranges::lazy_split_view;

    // [range.split], split view
    using std::ranges::split_view;

    namespace views {
      using std::ranges::views::lazy_split;
      using std::ranges::views::split;
    } // namespace views

    // [range.counted], counted view
    namespace views {
      using std::ranges::views::counted;
    } // namespace views

    // [range.common], common view
    using std::ranges::common_view;

    namespace views {
      using std::ranges::views::common;
    } // namespace views

    // [range.reverse], reverse view
    using std::ranges::reverse_view;

    namespace views {
      using std::ranges::views::reverse;
    } // namespace views

    // [range.as.const], as const view
#if 0
    using std::ranges::as_const_view;

    namespace views {
      using std::ranges::views::as_const;
    } // namespace views
#endif
    // [range.elements], elements view
    using std::ranges::elements_view;

    using std::ranges::keys_view;
    using std::ranges::values_view;

    namespace views {
      using std::ranges::views::elements;
      using std::ranges::views::keys;
      using std::ranges::views::values;
    } // namespace views

#if _LIBCPP_STD_VER >= 23
    // [range.zip], zip view
    using std::ranges::zip_view;

    namespace views {
      using std::ranges::views::zip;
    } // namespace views
#endif // _LIBCPP_STD_VER >= 23

#if 0
    // [range.zip.transform], zip transform view
    using std::ranges::zip_transform_view;

    namespace views {
      using std::ranges::views::zip_transform;
    }

    using std::ranges::adjacent_view;

    namespace views {
      using std::ranges::views::adjacent;
      using std::ranges::views::pairwise;
    } // namespace views

    using std::ranges::adjacent_transform_view;

    namespace views {
      using std::ranges::views::adjacent_transform;
      using std::ranges::views::pairwise_transform;
    } // namespace views

    using std::ranges::chunk_view;

    using std::ranges::chunk_view<V>;

    namespace views {
      using std::ranges::views::chunk;
    }

    using std::ranges::slide_view;

    namespace views {
      using std::ranges::views::slide;
    }
#endif

#if _LIBCPP_STD_VER >= 23
    // [range.chunk.by], chunk by view
    using std::ranges::chunk_by_view;

    namespace views {
      using std::ranges::views::chunk_by;
    }
#endif // _LIBCPP_STD_VER >= 23

#if 0
    // [range.stride], stride view
    using std::ranges::stride_view;

    namespace views {
      using std::ranges::views::stride;
    }

    using std::ranges::cartesian_product_view;

    namespace views {
      using std::ranges::views::cartesian_product;
    }
#endif
  } // namespace ranges

  namespace views = ranges::views;

  using std::tuple_element;
  using std::tuple_size;

#if _LIBCPP_STD_VER >= 23
  using std::from_range;
  using std::from_range_t;
#endif // _LIBCPP_STD_VER >= 23
} // namespace std