Showing preview only (1,828K chars total). Download the full file or copy to clipboard to get everything.
Repository: CaseyCarter/cmcstl2
Branch: master
Commit: 684a96d527e4
Files: 395
Total size: 1.7 MB
Directory structure:
gitextract_9l0su0ff/
├── .cirrus.yml
├── .gitattributes
├── .gitignore
├── .travis.yml
├── CMakeLists.txt
├── LICENSE.txt
├── README.md
├── config/
│ ├── ci/
│ │ └── Dockerfile
│ └── cmake/
│ └── FindSanitizer.cmake
├── examples/
│ ├── CMakeLists.txt
│ └── simple.cpp
├── include/
│ ├── experimental/
│ │ └── ranges/
│ │ ├── algorithm
│ │ ├── concepts
│ │ ├── functional
│ │ ├── iterator
│ │ ├── memory
│ │ ├── random
│ │ ├── range
│ │ ├── ranges
│ │ ├── type_traits
│ │ └── utility
│ ├── meta/
│ │ ├── meta.hpp
│ │ └── meta_fwd.hpp
│ └── stl2/
│ ├── algorithm.hpp
│ ├── concepts.hpp
│ ├── detail/
│ │ ├── algorithm/
│ │ │ ├── adjacent_find.hpp
│ │ │ ├── all_of.hpp
│ │ │ ├── any_of.hpp
│ │ │ ├── binary_search.hpp
│ │ │ ├── copy.hpp
│ │ │ ├── copy_backward.hpp
│ │ │ ├── copy_if.hpp
│ │ │ ├── copy_n.hpp
│ │ │ ├── count.hpp
│ │ │ ├── count_if.hpp
│ │ │ ├── equal.hpp
│ │ │ ├── equal_range.hpp
│ │ │ ├── fill.hpp
│ │ │ ├── fill_n.hpp
│ │ │ ├── find.hpp
│ │ │ ├── find_end.hpp
│ │ │ ├── find_first_of.hpp
│ │ │ ├── find_if.hpp
│ │ │ ├── find_if_not.hpp
│ │ │ ├── for_each.hpp
│ │ │ ├── generate.hpp
│ │ │ ├── generate_n.hpp
│ │ │ ├── heap_sift.hpp
│ │ │ ├── includes.hpp
│ │ │ ├── inplace_merge.hpp
│ │ │ ├── is_heap.hpp
│ │ │ ├── is_heap_until.hpp
│ │ │ ├── is_partitioned.hpp
│ │ │ ├── is_permutation.hpp
│ │ │ ├── is_sorted.hpp
│ │ │ ├── is_sorted_until.hpp
│ │ │ ├── lexicographical_compare.hpp
│ │ │ ├── lower_bound.hpp
│ │ │ ├── make_heap.hpp
│ │ │ ├── max.hpp
│ │ │ ├── max_element.hpp
│ │ │ ├── merge.hpp
│ │ │ ├── min.hpp
│ │ │ ├── min_element.hpp
│ │ │ ├── minmax.hpp
│ │ │ ├── minmax_element.hpp
│ │ │ ├── mismatch.hpp
│ │ │ ├── move.hpp
│ │ │ ├── move_backward.hpp
│ │ │ ├── next_permutation.hpp
│ │ │ ├── none_of.hpp
│ │ │ ├── nth_element.hpp
│ │ │ ├── partial_sort.hpp
│ │ │ ├── partial_sort_copy.hpp
│ │ │ ├── partition.hpp
│ │ │ ├── partition_copy.hpp
│ │ │ ├── partition_point.hpp
│ │ │ ├── pop_heap.hpp
│ │ │ ├── prev_permutation.hpp
│ │ │ ├── push_heap.hpp
│ │ │ ├── remove.hpp
│ │ │ ├── remove_copy.hpp
│ │ │ ├── remove_copy_if.hpp
│ │ │ ├── remove_if.hpp
│ │ │ ├── replace.hpp
│ │ │ ├── replace_copy.hpp
│ │ │ ├── replace_copy_if.hpp
│ │ │ ├── replace_if.hpp
│ │ │ ├── results.hpp
│ │ │ ├── reverse.hpp
│ │ │ ├── reverse_copy.hpp
│ │ │ ├── rotate.hpp
│ │ │ ├── rotate_copy.hpp
│ │ │ ├── sample.hpp
│ │ │ ├── search.hpp
│ │ │ ├── search_n.hpp
│ │ │ ├── set_difference.hpp
│ │ │ ├── set_intersection.hpp
│ │ │ ├── set_symmetric_difference.hpp
│ │ │ ├── set_union.hpp
│ │ │ ├── shuffle.hpp
│ │ │ ├── sort.hpp
│ │ │ ├── sort_heap.hpp
│ │ │ ├── stable_partition.hpp
│ │ │ ├── stable_sort.hpp
│ │ │ ├── swap_ranges.hpp
│ │ │ ├── transform.hpp
│ │ │ ├── unique.hpp
│ │ │ ├── unique_copy.hpp
│ │ │ └── upper_bound.hpp
│ │ ├── cached_position.hpp
│ │ ├── cheap_storage.hpp
│ │ ├── concepts/
│ │ │ ├── callable.hpp
│ │ │ ├── compare.hpp
│ │ │ ├── core.hpp
│ │ │ ├── function.hpp
│ │ │ ├── fundamental.hpp
│ │ │ ├── object/
│ │ │ │ ├── assignable.hpp
│ │ │ │ ├── movable.hpp
│ │ │ │ ├── move_constructible.hpp
│ │ │ │ ├── regular.hpp
│ │ │ │ └── semiregular.hpp
│ │ │ ├── object.hpp
│ │ │ └── urng.hpp
│ │ ├── construct_destruct.hpp
│ │ ├── ebo_box.hpp
│ │ ├── functional/
│ │ │ ├── comparisons.hpp
│ │ │ ├── invoke.hpp
│ │ │ └── not_fn.hpp
│ │ ├── fwd.hpp
│ │ ├── hash.hpp
│ │ ├── iostream/
│ │ │ └── concepts.hpp
│ │ ├── iterator/
│ │ │ ├── any_iterator.hpp
│ │ │ ├── basic_iterator.hpp
│ │ │ ├── common_iterator.hpp
│ │ │ ├── concepts.hpp
│ │ │ ├── counted_iterator.hpp
│ │ │ ├── default_sentinel.hpp
│ │ │ ├── increment.hpp
│ │ │ ├── insert_iterators.hpp
│ │ │ ├── istream_iterator.hpp
│ │ │ ├── istreambuf_iterator.hpp
│ │ │ ├── move_iterator.hpp
│ │ │ ├── operations.hpp
│ │ │ ├── ostream_iterator.hpp
│ │ │ ├── ostreambuf_iterator.hpp
│ │ │ ├── reverse_iterator.hpp
│ │ │ └── unreachable.hpp
│ │ ├── memory/
│ │ │ ├── concepts.hpp
│ │ │ ├── construct_at.hpp
│ │ │ ├── destroy.hpp
│ │ │ ├── uninitialized_copy.hpp
│ │ │ ├── uninitialized_default_construct.hpp
│ │ │ ├── uninitialized_fill.hpp
│ │ │ ├── uninitialized_move.hpp
│ │ │ └── uninitialized_value_construct.hpp
│ │ ├── meta.hpp
│ │ ├── non_propagating_cache.hpp
│ │ ├── randutils.hpp
│ │ ├── range/
│ │ │ ├── access.hpp
│ │ │ ├── concepts.hpp
│ │ │ ├── dangling.hpp
│ │ │ ├── nth_iterator.hpp
│ │ │ └── primitives.hpp
│ │ ├── raw_ptr.hpp
│ │ ├── semiregular_box.hpp
│ │ ├── span.hpp
│ │ ├── swap.hpp
│ │ ├── temporary_vector.hpp
│ │ ├── tuple_like.hpp
│ │ ├── variant.hpp
│ │ └── view/
│ │ └── view_closure.hpp
│ ├── functional.hpp
│ ├── iterator.hpp
│ ├── memory.hpp
│ ├── random.hpp
│ ├── ranges.hpp
│ ├── type_traits.hpp
│ ├── utility.hpp
│ └── view/
│ ├── all.hpp
│ ├── common.hpp
│ ├── counted.hpp
│ ├── drop.hpp
│ ├── drop_while.hpp
│ ├── empty.hpp
│ ├── filter.hpp
│ ├── generate.hpp
│ ├── indirect.hpp
│ ├── iota.hpp
│ ├── istream.hpp
│ ├── join.hpp
│ ├── move.hpp
│ ├── ref.hpp
│ ├── repeat.hpp
│ ├── repeat_n.hpp
│ ├── reverse.hpp
│ ├── single.hpp
│ ├── split.hpp
│ ├── subrange.hpp
│ ├── take.hpp
│ ├── take_exactly.hpp
│ ├── take_while.hpp
│ ├── transform.hpp
│ └── view_interface.hpp
└── test/
├── CMakeLists.txt
├── algorithm/
│ ├── CMakeLists.txt
│ ├── adjacent_find.cpp
│ ├── all_of.cpp
│ ├── any_of.cpp
│ ├── binary_search.cpp
│ ├── copy.cpp
│ ├── copy_backward.cpp
│ ├── copy_if.cpp
│ ├── copy_n.cpp
│ ├── count.cpp
│ ├── count_if.cpp
│ ├── equal.cpp
│ ├── equal_range.cpp
│ ├── fill.cpp
│ ├── fill_n.cpp
│ ├── find.cpp
│ ├── find_end.cpp
│ ├── find_first_of.cpp
│ ├── find_if.cpp
│ ├── find_if_not.cpp
│ ├── for_each.cpp
│ ├── generate.cpp
│ ├── generate_n.cpp
│ ├── includes.cpp
│ ├── inplace_merge.cpp
│ ├── is_heap.hpp
│ ├── is_heap1.cpp
│ ├── is_heap2.cpp
│ ├── is_heap3.cpp
│ ├── is_heap4.cpp
│ ├── is_heap_until.hpp
│ ├── is_heap_until1.cpp
│ ├── is_heap_until2.cpp
│ ├── is_heap_until3.cpp
│ ├── is_heap_until4.cpp
│ ├── is_partitioned.cpp
│ ├── is_permutation.cpp
│ ├── is_sorted.cpp
│ ├── is_sorted_until.cpp
│ ├── lexicographical_compare.cpp
│ ├── lower_bound.cpp
│ ├── make_heap.cpp
│ ├── max.cpp
│ ├── max_element.cpp
│ ├── merge.cpp
│ ├── min.cpp
│ ├── min_element.cpp
│ ├── minmax.cpp
│ ├── minmax_element.cpp
│ ├── mismatch.cpp
│ ├── move.cpp
│ ├── move_backward.cpp
│ ├── next_permutation.cpp
│ ├── none_of.cpp
│ ├── nth_element.cpp
│ ├── partial_sort.cpp
│ ├── partial_sort_copy.cpp
│ ├── partition.cpp
│ ├── partition_copy.cpp
│ ├── partition_point.cpp
│ ├── pop_heap.cpp
│ ├── prev_permutation.cpp
│ ├── push_heap.cpp
│ ├── remove.cpp
│ ├── remove_copy.cpp
│ ├── remove_copy_if.cpp
│ ├── remove_if.cpp
│ ├── replace.cpp
│ ├── replace_copy.cpp
│ ├── replace_copy_if.cpp
│ ├── replace_if.cpp
│ ├── reverse.cpp
│ ├── reverse_copy.cpp
│ ├── rotate.cpp
│ ├── rotate_copy.cpp
│ ├── sample.cpp
│ ├── search.cpp
│ ├── search_n.cpp
│ ├── set_difference.hpp
│ ├── set_difference1.cpp
│ ├── set_difference2.cpp
│ ├── set_difference3.cpp
│ ├── set_difference4.cpp
│ ├── set_difference5.cpp
│ ├── set_difference6.cpp
│ ├── set_intersection.hpp
│ ├── set_intersection1.cpp
│ ├── set_intersection2.cpp
│ ├── set_intersection3.cpp
│ ├── set_intersection4.cpp
│ ├── set_intersection5.cpp
│ ├── set_intersection6.cpp
│ ├── set_symmetric_difference.hpp
│ ├── set_symmetric_difference1.cpp
│ ├── set_symmetric_difference2.cpp
│ ├── set_symmetric_difference3.cpp
│ ├── set_symmetric_difference4.cpp
│ ├── set_symmetric_difference5.cpp
│ ├── set_symmetric_difference6.cpp
│ ├── set_union.hpp
│ ├── set_union1.cpp
│ ├── set_union2.cpp
│ ├── set_union3.cpp
│ ├── set_union4.cpp
│ ├── set_union5.cpp
│ ├── set_union6.cpp
│ ├── shuffle.cpp
│ ├── sort.cpp
│ ├── sort_heap.cpp
│ ├── stable_partition.cpp
│ ├── stable_sort.cpp
│ ├── swap_ranges.cpp
│ ├── transform.cpp
│ ├── unique.cpp
│ ├── unique_copy.cpp
│ └── upper_bound.cpp
├── all_public_headers.hpp
├── common-libcxx.hpp
├── common-libstdcxx.hpp
├── common.cpp
├── concepts/
│ ├── CMakeLists.txt
│ ├── compare.cpp
│ ├── core.cpp
│ ├── fundamental.cpp
│ ├── iterator.cpp
│ ├── object.cpp
│ ├── range.cpp
│ └── swap.cpp
├── detail/
│ ├── CMakeLists.txt
│ ├── raw_ptr.cpp
│ └── temporary_vector.cpp
├── functional/
│ ├── CMakeLists.txt
│ ├── invoke.cpp
│ └── not_fn.cpp
├── headers1.cpp
├── headers2.cpp
├── iterator/
│ ├── CMakeLists.txt
│ ├── any_iterator.cpp
│ ├── basic_iterator.cpp
│ ├── common_iterator.cpp
│ ├── counted_iterator.cpp
│ ├── incomplete.cpp
│ ├── istream_iterator.cpp
│ ├── istreambuf_iterator.cpp
│ ├── iterator.cpp
│ ├── make_range.cpp
│ ├── move_iterator.cpp
│ ├── operations.cpp
│ ├── ostream_iterator.cpp
│ ├── ostreambuf_iterator.cpp
│ ├── reverse_iterator.cpp
│ └── unreachable.cpp
├── memory/
│ ├── CMakeLists.txt
│ ├── common.hpp
│ ├── destroy.cpp
│ ├── uninitialized_copy.cpp
│ ├── uninitialized_default_construct.cpp
│ ├── uninitialized_fill.cpp
│ ├── uninitialized_move.cpp
│ └── uninitialized_value_construct.cpp
├── meta.cpp
├── move_only_string.hpp
├── range_access.cpp
├── simple_test.hpp
├── test_iterators.hpp
├── test_utils.hpp
└── view/
├── CMakeLists.txt
├── common_view.cpp
├── counted_view.cpp
├── drop_view.cpp
├── drop_while_view.cpp
├── empty_view.cpp
├── filter_view.cpp
├── generate_view.cpp
├── indirect_view.cpp
├── istream_view.cpp
├── join_view.cpp
├── move_view.cpp
├── ref_view.cpp
├── repeat_n_view.cpp
├── repeat_view.cpp
├── reverse_view.cpp
├── single_view.cpp
├── span.cpp
├── split_view.cpp
├── subrange.cpp
├── take_exactly_view.cpp
├── take_view.cpp
├── take_while_view.cpp
└── transform_view.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .cirrus.yml
================================================
#
# Copyright Christopher Di Bella
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
task:
env:
matrix:
COMPILER_VERSION: 8
matrix:
BUILD_TYPE: Debug
BUILD_TYPE: Release
container:
dockerfile: config/ci/Dockerfile
cpu: 8
memory: 16G
configure_script:
- mkdir -p build
- cd build
- export CC=`which gcc-${COMPILER_VERSION}`
- export CXX=`which g++-${COMPILER_VERSION}`
- cmake .. -GNinja -DCMAKE_BUILD_TYPE="${BUILD_TYPE}"
build_script:
- cd build
- ninja -v
test_script:
- cd build
- ctest -j8 --output-on-failure
================================================
FILE: .gitattributes
================================================
# Disable CRLF-mapping for all files.
* -text
================================================
FILE: .gitignore
================================================
*.user
*~
*.o
*.obj
a.out
\#*#
.#*
build*/
.vscode/
.vs/
*.*.swp
================================================
FILE: .travis.yml
================================================
# Copyright Casey Carter 2015-2017
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt)
dist: xenial
language: cpp
cache:
directories:
- ${TRAVIS_BUILD_DIR}/deps/cmake-3.12.4
matrix:
include:
- env: GCC_VERSION=8 BUILD_TYPE=Debug
os: linux
addons: &gcc8
apt:
packages:
- g++-8
- ninja-build
sources:
- ubuntu-toolchain-r-test
- env: GCC_VERSION=8 BUILD_TYPE=Release
os: linux
addons: *gcc8
before_install:
- if [ -n "$GCC_VERSION" ]; then export CXX="g++-${GCC_VERSION}" CC="gcc-${GCC_VERSION}"; fi
- which $CC
- which $CXX
- $CXX --version
- ninja --version
- JOBS=2
install:
- DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
- mkdir -p "${DEPS_DIR}" && cd "${DEPS_DIR}"
############################################################################
# Install a recent CMake (unless already installed on OS X)
############################################################################
- |
if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
CMAKE_VERSION=3.12.4
if [[ -z "$(ls -A ${DEPS_DIR}/cmake-${CMAKE_VERSION}/bin)" ]]; then
CMAKE_URL="https://cmake.org/files/v3.12/cmake-3.12.4-Linux-x86_64.tar.gz"
mkdir -p "cmake-${CMAKE_VERSION}" && travis_retry wget --no-check-certificate --quiet -O - "${CMAKE_URL}" | tar --strip-components=1 -xz -C "cmake-${CMAKE_VERSION}"
fi
export PATH="${DEPS_DIR}/cmake-${CMAKE_VERSION}/bin:${PATH}"
fi
before_script:
- cd "${TRAVIS_BUILD_DIR}"
- mkdir -p build
- cd build
- cmake .. -G Ninja -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_CXX_FLAGS="${CXX_FLAGS}"
- ninja -v
script:
- ctest -j${JOBS} --output-on-failure
================================================
FILE: CMakeLists.txt
================================================
# cmcstl2 - A concept-enabled C++ standard library
#
# Copyright Eric Niebler 2015
# Copyright Casey Carter 2015, 2017
#
# Use, modification and distribution is subject to the
# Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#
# Project home: https://github.com/caseycarter/cmcstl2
#
cmake_minimum_required(VERSION 3.12)
project(cmcstl2 CXX)
set(CMAKE_CXX_EXTENSIONS OFF)
# check if cmcstl2 is not a subproject
if(CMAKE_CURRENT_LIST_DIR STREQUAL CMAKE_SOURCE_DIR)
option(STL2_BUILD_EXAMPLES "Build stl2 examples" ON)
option(STL2_BUILD_TESTING "Build stl2 tests" ON)
else()
option(STL2_BUILD_EXAMPLES "Build stl2 examples" OFF)
option(STL2_BUILD_TESTING "Build stl2 tests" OFF)
endif()
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/config/cmake")
find_package(Sanitizer COMPONENTS address undefined)
add_library(stl2 INTERFACE)
target_include_directories(stl2 INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>)
target_compile_features(stl2 INTERFACE cxx_std_20)
target_compile_options(stl2 INTERFACE
$<$<CXX_COMPILER_ID:GNU>:-fconcepts>
$<$<CXX_COMPILER_ID:Clang>:-Xclang -fconcepts-ts>
$<$<CXX_COMPILER_ID:MSVC>:/permissive->)
install(DIRECTORY include/ DESTINATION include)
install(TARGETS stl2 EXPORT cmcstl2-targets)
install(EXPORT cmcstl2-targets DESTINATION lib/cmake/cmcstl2)
file(
WRITE ${PROJECT_BINARY_DIR}/cmcstl2-config.cmake
"include(\${CMAKE_CURRENT_LIST_DIR}/cmcstl2-targets.cmake)")
install(
FILES ${PROJECT_BINARY_DIR}/cmcstl2-config.cmake
DESTINATION lib/cmake/cmcstl2)
if(STL2_BUILD_EXAMPLES)
add_subdirectory(examples)
endif()
if(STL2_BUILD_TESTING)
include(CTest)
add_custom_target(stl2-check ${CMAKE_CTEST_COMMAND} -V)
add_subdirectory(test)
endif()
================================================
FILE: LICENSE.txt
================================================
========================================================
Boost Software License - Version 1.0 - August 17th, 2003
========================================================
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
==============================================================================
libc++ License
==============================================================================
The libc++ library is dual licensed under both the University of Illinois
"BSD-Like" license and the MIT license. As a user of this code you may choose
to use it under either license. As a contributor, you agree to allow your code
to be used under both.
Full text of the relevant licenses is included below.
==============================================================================
University of Illinois/NCSA
Open Source License
Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT
http://llvm.org/svn/llvm-project/libcxx/trunk/CREDITS.TXT
All rights reserved.
Developed by:
LLVM Team
University of Illinois at Urbana-Champaign
http://llvm.org
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal with
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimers.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimers in the
documentation and/or other materials provided with the distribution.
* Neither the names of the LLVM Team, University of Illinois at
Urbana-Champaign, nor the names of its contributors may be used to
endorse or promote products derived from this Software without specific
prior written permission.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
SOFTWARE.
==============================================================================
Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT
http://llvm.org/svn/llvm-project/libcxx/trunk/CREDITS.TXT
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
==============================================================================
SGI C++ Standard Template Library license
==============================================================================
// Copyright (c) 1994
// Hewlett-Packard Company
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation. Hewlett-Packard Company makes no
// representations about the suitability of this software for any
// purpose. It is provided "as is" without express or implied warranty.
//
// Copyright (c) 1996
// Silicon Graphics Computer Systems, Inc.
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation. Silicon Graphics makes no
// representations about the suitability of this software for any
// purpose. It is provided "as is" without express or implied warranty.
//
================================================
FILE: README.md
================================================
# cmcstl2
An implementation of [P0896R4 "The One Ranges Proposal"](https://wg21.link/p0896r4).
Compilation requires a compiler with support for C++17 and the Concepts TS, which as of this writing means [GCC 7+](https://gcc.gnu.org/) with the `-std=c++1z` and `-fconcepts` command line options.
================================================
FILE: config/ci/Dockerfile
================================================
# cmcstl2 - A concept-enabled C++ standard library
#
# Copyright Casey Carter
#
# Use, modification and distribution is subject to the
# Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#
# Project home: https://github.com/caseycarter/cmcstl2
#
FROM ubuntu:disco
# Install packages
RUN apt update
RUN apt upgrade -y
RUN apt update
RUN apt install -y git cmake ninja-build g++-8 g++-9
================================================
FILE: config/cmake/FindSanitizer.cmake
================================================
#
# Copyright Christopher Di Bella
# Copyright Morris Hafner
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
include(FindPackageHandleStandardArgs)
include(CheckCXXCompilerFlag)
include(CMakePushCheckState)
add_library(Sanitizer::all INTERFACE IMPORTED)
set(Sanitizer_FOUND ON)
foreach(san ${Sanitizer_FIND_COMPONENTS})
if(TARGET Sanitizer::${san})
continue()
endif()
cmake_push_check_state(RESET)
list(APPEND CMAKE_REQUIRED_LIBRARIES -fsanitize=${san})
check_cxx_compiler_flag(-fsanitize=${san} ${san}_sanitizer_supported)
cmake_pop_check_state()
if(${${san}_sanitizer_supported})
add_library(Sanitizer::${san} INTERFACE IMPORTED)
set_target_properties(Sanitizer::${san} PROPERTIES
INTERFACE_COMPILE_OPTIONS -fsanitize=${san}
INTERFACE_LINK_LIBRARIES -fsanitize=${san})
set(Sanitizer_${san}_FOUND TRUE)
set_property(TARGET Sanitizer::all APPEND PROPERTY
INTERFACE_LINK_LIBRARIES Sanitizer::${san})
endif()
endforeach()
find_package_handle_standard_args(Sanitizer
REQUIRED_VARS Sanitizer_FOUND
HANDLE_COMPONENTS)
================================================
FILE: examples/CMakeLists.txt
================================================
# cmcstl2 - A concept-enabled C++ standard library
#
# Copyright Casey Carter 2015, 2017
#
# Use, modification and distribution is subject to the
# Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#
# Project home: https://github.com/caseycarter/cmcstl2
#
add_executable(simple simple.cpp)
target_link_libraries(simple stl2)
================================================
FILE: examples/simple.cpp
================================================
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <experimental/ranges/algorithm>
#include <experimental/ranges/iterator>
// Qualify everything with "std::experimental::ranges" if you like,
// I prefer to use a namespace alias:
namespace ranges = std::experimental::ranges;
template<class...> class show_type;
template<ranges::readable T>
void foo(T&) {}
int main() {
auto v = std::vector<std::string>{"this", "is", "a", "test"};
ranges::sort(v);
auto out = ranges::ostream_iterator<std::string>{std::cout, " "};
ranges::copy(v, out);
std::cout << '\n';
auto result = ranges::reverse_copy(v, out);
std::cout << '\n';
return !(result.in == ranges::end(v));
}
================================================
FILE: include/experimental/ranges/algorithm
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/algorithm.hpp>
================================================
FILE: include/experimental/ranges/concepts
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/concepts.hpp>
================================================
FILE: include/experimental/ranges/functional
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/functional.hpp>
================================================
FILE: include/experimental/ranges/iterator
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/iterator.hpp>
================================================
FILE: include/experimental/ranges/memory
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/memory.hpp>
================================================
FILE: include/experimental/ranges/random
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/random.hpp>
================================================
FILE: include/experimental/ranges/range
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2018
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/ranges.hpp>
================================================
FILE: include/experimental/ranges/ranges
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2018
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/ranges.hpp>
================================================
FILE: include/experimental/ranges/type_traits
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/type_traits.hpp>
================================================
FILE: include/experimental/ranges/utility
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#include <stl2/utility.hpp>
================================================
FILE: include/meta/meta.hpp
================================================
/// \file meta.hpp Tiny meta-programming library.
//
// Meta library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/meta
//
#ifndef META_HPP
#define META_HPP
#include <cstddef>
#include <initializer_list>
#include <meta/meta_fwd.hpp>
#include <type_traits>
#include <utility>
#ifdef __clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunknown-pragmas"
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wdocumentation-deprecated-sync"
#pragma GCC diagnostic ignored "-Wmissing-variable-declarations"
#endif
/// \defgroup meta Meta
///
/// A tiny metaprogramming library
/// \defgroup trait Trait
/// Trait invocation/composition.
/// \ingroup meta
/// \defgroup invocation Invocation
/// Trait invocation
/// \ingroup trait
/// \defgroup composition Composition
/// Trait composition
/// \ingroup trait
/// \defgroup logical Logical
/// Logical operations
/// \ingroup meta
/// \defgroup algorithm Algorithms
/// Algorithms.
/// \ingroup meta
/// \defgroup query Query/Search
/// Query and search algorithms
/// \ingroup algorithm
/// \defgroup transformation Transformation
/// Transformation algorithms
/// \ingroup algorithm
/// \defgroup runtime Runtime
/// Runtime algorithms
/// \ingroup algorithm
/// \defgroup datatype Datatype
/// Datatypes.
/// \ingroup meta
/// \defgroup list List
/// \ingroup datatype
/// \defgroup integral Integer sequence
/// Equivalent to C++14's `std::integer_sequence`
/// \ingroup datatype
/// \defgroup extension Extension
/// Extend meta with your own datatypes.
/// \ingroup datatype
/// \defgroup math Math
/// Integral constant arithmetic.
/// \ingroup meta
/// \defgroup lazy_trait lazy
/// \ingroup trait
/// \defgroup lazy_invocation lazy
/// \ingroup invocation
/// \defgroup lazy_composition lazy
/// \ingroup composition
/// \defgroup lazy_logical lazy
/// \ingroup logical
/// \defgroup lazy_query lazy
/// \ingroup query
/// \defgroup lazy_transformation lazy
/// \ingroup transformation
/// \defgroup lazy_list lazy
/// \ingroup list
/// \defgroup lazy_datatype lazy
/// \ingroup datatype
/// \defgroup lazy_math lazy
/// \ingroup math
/// Tiny metaprogramming library
namespace meta
{
namespace detail
{
/// Returns a \p T nullptr
template <typename T>
constexpr T *_nullptr_v()
{
return nullptr;
}
#if META_CXX_VARIABLE_TEMPLATES
template <typename T>
META_INLINE_VAR constexpr T *nullptr_v = nullptr;
#endif
} // namespace detail
/// An empty type.
/// \ingroup datatype
struct nil_
{
};
/// Type alias for \p T::type.
/// \ingroup invocation
template <META_TYPE_CONSTRAINT(Trait) T>
using _t = typename T::type;
#if META_CXX_VARIABLE_TEMPLATES || defined(META_DOXYGEN_INVOKED)
/// Variable alias for \c T::type::value
/// \note Requires C++14 or greater.
/// \ingroup invocation
template <META_TYPE_CONSTRAINT(Integral) T>
constexpr typename T::type::value_type _v = T::type::value;
#endif
/// Lazy versions of meta actions
namespace lazy
{
/// \sa `meta::_t`
/// \ingroup lazy_invocation
template <typename T>
using _t = defer<_t, T>;
} // namespace lazy
/// An integral constant wrapper for \c std::size_t.
/// \ingroup integral
template <std::size_t N>
using size_t = std::integral_constant<std::size_t, N>;
/// An integral constant wrapper for \c bool.
/// \ingroup integral
template <bool B>
using bool_ = std::integral_constant<bool, B>;
/// An integral constant wrapper for \c int.
/// \ingroup integral
template <int I>
using int_ = std::integral_constant<int, I>;
/// An integral constant wrapper for \c char.
/// \ingroup integral
template <char Ch>
using char_ = std::integral_constant<char, Ch>;
///////////////////////////////////////////////////////////////////////////////////////////
// Math operations
/// An integral constant wrapper around the result of incrementing the wrapped integer \c
/// T::type::value.
template <META_TYPE_CONSTRAINT(Integral) T>
using inc = std::integral_constant<decltype(T::type::value + 1), T::type::value + 1>;
/// An integral constant wrapper around the result of decrementing the wrapped integer \c
/// T::type::value.
template <META_TYPE_CONSTRAINT(Integral) T>
using dec = std::integral_constant<decltype(T::type::value - 1), T::type::value - 1>;
/// An integral constant wrapper around the result of adding the two wrapped integers
/// \c T::type::value and \c U::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using plus = std::integral_constant<decltype(T::type::value + U::type::value),
T::type::value + U::type::value>;
/// An integral constant wrapper around the result of subtracting the two wrapped integers
/// \c T::type::value and \c U::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using minus = std::integral_constant<decltype(T::type::value - U::type::value),
T::type::value - U::type::value>;
/// An integral constant wrapper around the result of multiplying the two wrapped integers
/// \c T::type::value and \c U::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using multiplies = std::integral_constant<decltype(T::type::value * U::type::value),
T::type::value * U::type::value>;
/// An integral constant wrapper around the result of dividing the two wrapped integers \c
/// T::type::value and \c U::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using divides = std::integral_constant<decltype(T::type::value / U::type::value),
T::type::value / U::type::value>;
/// An integral constant wrapper around the result of negating the wrapped integer
/// \c T::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T>
using negate = std::integral_constant<decltype(-T::type::value), -T::type::value>;
/// An integral constant wrapper around the remainder of dividing the two wrapped integers
/// \c T::type::value and \c U::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using modulus = std::integral_constant<decltype(T::type::value % U::type::value),
T::type::value % U::type::value>;
/// A Boolean integral constant wrapper around the result of comparing \c T::type::value and
/// \c U::type::value for equality.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using equal_to = bool_<T::type::value == U::type::value>;
/// A Boolean integral constant wrapper around the result of comparing \c T::type::value and
/// \c U::type::value for inequality.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using not_equal_to = bool_<T::type::value != U::type::value>;
/// A Boolean integral constant wrapper around \c true if \c T::type::value is greater than
/// \c U::type::value; \c false, otherwise.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using greater = bool_<(T::type::value > U::type::value)>;
/// A Boolean integral constant wrapper around \c true if \c T::type::value is less than \c
/// U::type::value; \c false, otherwise.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using less = bool_<(T::type::value < U::type::value)>;
/// A Boolean integral constant wrapper around \c true if \c T::type::value is greater than
/// or equal to \c U::type::value; \c false, otherwise.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using greater_equal = bool_<(T::type::value >= U::type::value)>;
/// A Boolean integral constant wrapper around \c true if \c T::type::value is less than or
/// equal to \c U::type::value; \c false, otherwise.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using less_equal = bool_<(T::type::value <= U::type::value)>;
/// An integral constant wrapper around the result of bitwise-and'ing the two wrapped
/// integers \c T::type::value and \c U::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using bit_and = std::integral_constant<decltype(T::type::value & U::type::value),
T::type::value & U::type::value>;
/// An integral constant wrapper around the result of bitwise-or'ing the two wrapped
/// integers \c T::type::value and \c U::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using bit_or = std::integral_constant<decltype(T::type::value | U::type::value),
T::type::value | U::type::value>;
/// An integral constant wrapper around the result of bitwise-exclusive-or'ing the two
/// wrapped integers \c T::type::value and \c U::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T, META_TYPE_CONSTRAINT(Integral) U>
using bit_xor = std::integral_constant<decltype(T::type::value ^ U::type::value),
T::type::value ^ U::type::value>;
/// An integral constant wrapper around the result of bitwise-complementing the wrapped
/// integer \c T::type::value.
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral) T>
using bit_not = std::integral_constant<decltype(~T::type::value), ~T::type::value>;
namespace lazy
{
/// \sa 'meta::int'
/// \ingroup lazy_math
template <typename T>
using inc = defer<inc, T>;
/// \sa 'meta::dec'
/// \ingroup lazy_math
template <typename T>
using dec = defer<dec, T>;
/// \sa 'meta::plus'
/// \ingroup lazy_math
template <typename T, typename U>
using plus = defer<plus, T, U>;
/// \sa 'meta::minus'
/// \ingroup lazy_math
template <typename T, typename U>
using minus = defer<minus, T, U>;
/// \sa 'meta::multiplies'
/// \ingroup lazy_math
template <typename T, typename U>
using multiplies = defer<multiplies, T, U>;
/// \sa 'meta::divides'
/// \ingroup lazy_math
template <typename T, typename U>
using divides = defer<divides, T, U>;
/// \sa 'meta::negate'
/// \ingroup lazy_math
template <typename T>
using negate = defer<negate, T>;
/// \sa 'meta::modulus'
/// \ingroup lazy_math
template <typename T, typename U>
using modulus = defer<modulus, T, U>;
/// \sa 'meta::equal_to'
/// \ingroup lazy_math
template <typename T, typename U>
using equal_to = defer<equal_to, T, U>;
/// \sa 'meta::not_equal_t'
/// \ingroup lazy_math
template <typename T, typename U>
using not_equal_to = defer<not_equal_to, T, U>;
/// \sa 'meta::greater'
/// \ingroup lazy_math
template <typename T, typename U>
using greater = defer<greater, T, U>;
/// \sa 'meta::less'
/// \ingroup lazy_math
template <typename T, typename U>
using less = defer<less, T, U>;
/// \sa 'meta::greater_equal'
/// \ingroup lazy_math
template <typename T, typename U>
using greater_equal = defer<greater_equal, T, U>;
/// \sa 'meta::less_equal'
/// \ingroup lazy_math
template <typename T, typename U>
using less_equal = defer<less_equal, T, U>;
/// \sa 'meta::bit_and'
/// \ingroup lazy_math
template <typename T, typename U>
using bit_and = defer<bit_and, T, U>;
/// \sa 'meta::bit_or'
/// \ingroup lazy_math
template <typename T, typename U>
using bit_or = defer<bit_or, T, U>;
/// \sa 'meta::bit_xor'
/// \ingroup lazy_math
template <typename T, typename U>
using bit_xor = defer<bit_xor, T, U>;
/// \sa 'meta::bit_not'
/// \ingroup lazy_math
template <typename T>
using bit_not = defer<bit_not, T>;
} // namespace lazy
/// \cond
namespace detail
{
enum class indices_strategy_
{
done,
repeat,
recurse
};
constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
{
return cur >= end ? indices_strategy_::done
: cur * 2 <= end ? indices_strategy_::repeat
: indices_strategy_::recurse;
}
template <typename T>
constexpr std::size_t range_distance_(T begin, T end)
{
return begin <= end ? static_cast<std::size_t>(end - begin)
: throw "The start of the integer_sequence must not be "
"greater than the end";
}
template <std::size_t End, typename State, indices_strategy_ Status_>
struct make_indices_
{
using type = State;
};
template <typename T, T, typename>
struct coerce_indices_
{
};
} // namespace detail
/// \endcond
///////////////////////////////////////////////////////////////////////////////////////////
// integer_sequence
#if !META_CXX_INTEGER_SEQUENCE
/// A container for a sequence of compile-time integer constants.
/// \ingroup integral
template <typename T, T... Is>
struct integer_sequence
{
using value_type = T;
/// \return `sizeof...(Is)`
static constexpr std::size_t size() noexcept { return sizeof...(Is); }
};
#endif
///////////////////////////////////////////////////////////////////////////////////////////
// index_sequence
/// A container for a sequence of compile-time integer constants of type
/// \c std::size_t
/// \ingroup integral
template <std::size_t... Is>
using index_sequence = integer_sequence<std::size_t, Is...>;
#if META_HAS_MAKE_INTEGER_SEQ && !defined(META_DOXYGEN_INVOKED)
// Implement make_integer_sequence and make_index_sequence with the
// __make_integer_seq builtin on compilers that provide it. (Redirect
// through decltype to workaround suspected clang bug.)
/// \cond
namespace detail
{
template <typename T, T N>
__make_integer_seq<integer_sequence, T, N> make_integer_sequence_();
}
/// \endcond
template <typename T, T N>
using make_integer_sequence = decltype(detail::make_integer_sequence_<T, N>());
template <std::size_t N>
using make_index_sequence = make_integer_sequence<std::size_t, N>;
#elif META_HAS_INTEGER_PACK && !defined(META_DOXYGEN_INVOKED)
// Implement make_integer_sequence and make_index_sequence with the
// __integer_pack builtin on compilers that provide it.
template <typename T, T N>
using make_integer_sequence = integer_sequence<T, __integer_pack(N)...>;
template <std::size_t N>
using make_index_sequence = make_integer_sequence<std::size_t, N>;
#else
/// Generate \c index_sequence containing integer constants [0,1,2,...,N-1].
/// \par Complexity
/// \f$ O(log(N)) \f$.
/// \ingroup integral
template <std::size_t N>
using make_index_sequence =
_t<detail::make_indices_<N, index_sequence<0>, detail::strategy_(1, N)>>;
/// Generate \c integer_sequence containing integer constants [0,1,2,...,N-1].
/// \par Complexity
/// \f$ O(log(N)) \f$.
/// \ingroup integral
template <typename T, T N>
using make_integer_sequence =
_t<detail::coerce_indices_<T, 0, make_index_sequence<static_cast<std::size_t>(N)>>>;
#endif
///////////////////////////////////////////////////////////////////////////////////////////
// integer_range
/// Makes the integer sequence <tt>[From, To)</tt>.
/// \par Complexity
/// \f$ O(log(To - From)) \f$.
/// \ingroup integral
template <typename T, T From, T To>
using integer_range =
_t<detail::coerce_indices_<T, From,
make_index_sequence<detail::range_distance_(From, To)>>>;
/// \cond
namespace detail
{
template <typename, typename>
struct concat_indices_
{
};
template <std::size_t... Is, std::size_t... Js>
struct concat_indices_<index_sequence<Is...>, index_sequence<Js...>>
{
using type = index_sequence<Is..., (Js + sizeof...(Is))...>;
};
template <>
struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
{
using type = index_sequence<>;
};
template <std::size_t End, std::size_t... Values>
struct make_indices_<End, index_sequence<Values...>, indices_strategy_::repeat>
: make_indices_<End, index_sequence<Values..., (Values + sizeof...(Values))...>,
detail::strategy_(sizeof...(Values) * 2, End)>
{
};
template <std::size_t End, std::size_t... Values>
struct make_indices_<End, index_sequence<Values...>, indices_strategy_::recurse>
: concat_indices_<index_sequence<Values...>,
make_index_sequence<End - sizeof...(Values)>>
{
};
template <typename T, T Offset, std::size_t... Values>
struct coerce_indices_<T, Offset, index_sequence<Values...>>
{
using type =
integer_sequence<T, static_cast<T>(static_cast<T>(Values) + Offset)...>;
};
} // namespace detail
/// \endcond
/// Evaluate the Invocable \p Fn with the arguments \p Args.
/// \ingroup invocation
template <META_TYPE_CONSTRAINT(Invocable) Fn, typename... Args>
using invoke = typename Fn::template invoke<Args...>;
/// Lazy versions of meta actions
namespace lazy
{
/// \sa `meta::invoke`
/// \ingroup lazy_invocation
template <typename Fn, typename... Args>
using invoke = defer<invoke, Fn, Args...>;
} // namespace lazy
/// A Trait that always returns its argument \p T. It is also an Invocable
/// that always returns \p T.
/// \ingroup trait
/// \ingroup invocation
template <typename T>
struct id
{
#if defined(META_WORKAROUND_CWG_1558) && !defined(META_DOXYGEN_INVOKED)
// Redirect through decltype for compilers that have not
// yet implemented CWG 1558:
static id impl(void *);
template <typename... Ts>
using invoke = _t<decltype(id::impl(static_cast<list<Ts...> *>(nullptr)))>;
#else
template <typename...>
using invoke = T;
#endif
using type = T;
};
/// An alias for type \p T. Useful in non-deduced contexts.
/// \ingroup trait
template <typename T>
using id_t = _t<id<T>>;
namespace lazy
{
/// \sa `meta::id`
/// \ingroup lazy_trait
/// \ingroup lazy_invocation
template <typename T>
using id = defer<id, T>;
} // namespace lazy
/// An alias for `void`.
/// \ingroup trait
#if defined(META_WORKAROUND_CWG_1558) && !defined(META_DOXYGEN_INVOKED)
// Redirect through decltype for compilers that have not
// yet implemented CWG 1558:
template <typename... Ts>
using void_ = invoke<id<void>, Ts...>;
#else
template <typename...>
using void_ = void;
#endif
#if META_CXX_VARIABLE_TEMPLATES
#ifdef META_CONCEPT
/// `true` if `T::type` exists and names a type; `false` otherwise.
/// \ingroup trait
template <typename T>
META_INLINE_VAR constexpr bool is_trait_v = Trait<T>;
/// `true` if `T::invoke` exists and names a class template; `false` otherwise.
/// \ingroup trait
template <typename T>
META_INLINE_VAR constexpr bool is_callable_v = Invocable<T>;
#else // ^^^ Concepts / No concepts vvv
/// \cond
namespace detail
{
template <typename, typename = void>
META_INLINE_VAR constexpr bool is_trait_ = false;
template <typename T>
META_INLINE_VAR constexpr bool is_trait_<T, void_<typename T::type>> = true;
template <typename, typename = void>
META_INLINE_VAR constexpr bool is_callable_ = false;
template <typename T>
META_INLINE_VAR constexpr bool is_callable_<T, void_<quote<T::template invoke>>> = true;
} // namespace detail
/// \endcond
/// `true` if `T::type` exists and names a type; `false` otherwise.
/// \ingroup trait
template <typename T>
META_INLINE_VAR constexpr bool is_trait_v = detail::is_trait_<T>;
/// `true` if `T::invoke` exists and names a class template; `false` otherwise.
/// \ingroup trait
template <typename T>
META_INLINE_VAR constexpr bool is_callable_v = detail::is_callable_<T>;
#endif // Concepts vs. variable templates
/// An alias for `std::true_type` if `T::type` exists and names a type; otherwise, it's an
/// alias for `std::false_type`.
/// \ingroup trait
template <typename T>
using is_trait = bool_<is_trait_v<T>>;
/// An alias for `std::true_type` if `T::invoke` exists and names a class template;
/// otherwise, it's an alias for `std::false_type`.
/// \ingroup trait
template <typename T>
using is_callable = bool_<is_callable_v<T>>;
#else // ^^^ META_CXX_VARIABLE_TEMPLATES / !META_CXX_VARIABLE_TEMPLATES vvv
/// \cond
namespace detail
{
template <typename, typename = void>
struct is_trait_
{
using type = std::false_type;
};
template <typename T>
struct is_trait_<T, void_<typename T::type>>
{
using type = std::true_type;
};
template <typename, typename = void>
struct is_callable_
{
using type = std::false_type;
};
template <typename T>
struct is_callable_<T, void_<quote<T::template invoke>>>
{
using type = std::true_type;
};
} // namespace detail
/// \endcond
template <typename T>
using is_trait = _t<detail::is_trait_<T>>;
/// An alias for `std::true_type` if `T::invoke` exists and names a class
/// template or alias template; otherwise, it's an alias for
/// `std::false_type`.
/// \ingroup trait
template <typename T>
using is_callable = _t<detail::is_callable_<T>>;
#endif
/// \cond
namespace detail
{
#ifdef META_CONCEPT
template <template <typename...> class, typename...>
struct defer_
{
};
template <template <typename...> class C, typename... Ts>
requires Valid<C, Ts...> struct defer_<C, Ts...>
{
using type = C<Ts...>;
};
template <typename T, template <T...> class, T...>
struct defer_i_
{
};
template <typename T, template <T...> class C, T... Is>
requires Valid_I<T, C, Is...> struct defer_i_<T, C, Is...>
{
using type = C<Is...>;
};
#elif defined(META_WORKAROUND_MSVC_703656) // ^^^ Concepts / MSVC workaround vvv
template <typename, template <typename...> class, typename...>
struct _defer_
{
};
template <template <typename...> class C, typename... Ts>
struct _defer_<void_<C<Ts...>>, C, Ts...>
{
using type = C<Ts...>;
};
template <template <typename...> class C, typename... Ts>
using defer_ = _defer_<void, C, Ts...>;
template <typename, typename T, template <T...> class, T...>
struct _defer_i_
{
};
template <typename T, template <T...> class C, T... Is>
struct _defer_i_<void_<C<Is...>>, T, C, Is...>
{
using type = C<Is...>;
};
template <typename T, template <T...> class C, T... Is>
using defer_i_ = _defer_i_<void, T, C, Is...>;
#else // ^^^ workaround ^^^ / vvv no workaround vvv
template <template <typename...> class C, typename... Ts,
template <typename...> class D = C>
id<D<Ts...>> try_defer_(int);
template <template <typename...> class C, typename... Ts>
nil_ try_defer_(long);
template <template <typename...> class C, typename... Ts>
using defer_ = decltype(detail::try_defer_<C, Ts...>(0));
template <typename T, template <T...> class C, T... Is, template <T...> class D = C>
id<D<Is...>> try_defer_i_(int);
template <typename T, template <T...> class C, T... Is>
nil_ try_defer_i_(long);
template <typename T, template <T...> class C, T... Is>
using defer_i_ = decltype(detail::try_defer_i_<T, C, Is...>(0));
#endif // Concepts vs. MSVC vs. Other
template <typename T>
using _t_t = _t<_t<T>>;
} // namespace detail
/// \endcond
///////////////////////////////////////////////////////////////////////////////////////////
// defer
/// A wrapper that defers the instantiation of a template \p C with type parameters \p Ts in
/// a \c lambda or \c let expression.
///
/// In the code below, the lambda would ideally be written as
/// `lambda<_a,_b,push_back<_a,_b>>`, however this fails since `push_back` expects its first
/// argument to be a list, not a placeholder. Instead, we express it using \c defer as
/// follows:
///
/// \code
/// template <typename L>
/// using reverse = reverse_fold<L, list<>, lambda<_a, _b, defer<push_back, _a, _b>>>;
/// \endcode
///
/// \ingroup invocation
template <template <typename...> class C, typename... Ts>
struct defer : detail::defer_<C, Ts...>
{
};
///////////////////////////////////////////////////////////////////////////////////////////
// defer_i
/// A wrapper that defers the instantiation of a template \p C with integral constant
/// parameters \p Is in a \c lambda or \c let expression.
/// \sa `defer`
/// \ingroup invocation
template <typename T, template <T...> class C, T... Is>
struct defer_i : detail::defer_i_<T, C, Is...>
{
};
///////////////////////////////////////////////////////////////////////////////////////////
// defer_trait
/// A wrapper that defers the instantiation of a trait \p C with type parameters \p Ts in a
/// \c lambda or \c let expression.
/// \sa `defer`
/// \ingroup invocation
template <template <typename...> class C, typename... Ts>
using defer_trait = defer<detail::_t_t, detail::defer_<C, Ts...>>;
///////////////////////////////////////////////////////////////////////////////////////////
// defer_trait_i
/// A wrapper that defers the instantiation of a trait \p C with integral constant
/// parameters \p Is in a \c lambda or \c let expression.
/// \sa `defer_i`
/// \ingroup invocation
template <typename T, template <T...> class C, T... Is>
using defer_trait_i = defer<detail::_t_t, detail::defer_i_<T, C, Is...>>;
/// An alias that computes the size of the type \p T.
/// \par Complexity
/// \f$ O(1) \f$.
/// \ingroup trait
template <typename T>
using sizeof_ = meta::size_t<sizeof(T)>;
/// An alias that computes the alignment required for any instance of the type \p T.
/// \par Complexity
/// \f$ O(1) \f$.
/// \ingroup trait
template <typename T>
using alignof_ = meta::size_t<alignof(T)>;
namespace lazy
{
/// \sa `meta::sizeof_`
/// \ingroup lazy_trait
template <typename T>
using sizeof_ = defer<sizeof_, T>;
/// \sa `meta::alignof_`
/// \ingroup lazy_trait
template <typename T>
using alignof_ = defer<alignof_, T>;
} // namespace lazy
#if META_CXX_VARIABLE_TEMPLATES
/// is
/// Test whether a type \p T is an instantiation of class
/// template \p C.
/// \ingroup trait
template <typename T, template <typename...> class C>
using is = bool_<is_v<T, C>>;
#else
/// is
/// \cond
namespace detail
{
template <typename, template <typename...> class>
struct is_ : std::false_type
{
};
template <typename... Ts, template <typename...> class C>
struct is_<C<Ts...>, C> : std::true_type
{
};
} // namespace detail
/// \endcond
/// Test whether a type \c T is an instantiation of class
/// template \c C.
/// \ingroup trait
template <typename T, template <typename...> class C>
using is = _t<detail::is_<T, C>>;
#endif
/// Compose the Invocables \p Fns in the parameter pack \p Ts.
/// \ingroup composition
template <META_TYPE_CONSTRAINT(Invocable)... Fns>
struct compose_
{
};
template <META_TYPE_CONSTRAINT(Invocable) Fn0>
struct compose_<Fn0>
{
template <typename... Ts>
using invoke = invoke<Fn0, Ts...>;
};
template <META_TYPE_CONSTRAINT(Invocable) Fn0, META_TYPE_CONSTRAINT(Invocable)... Fns>
struct compose_<Fn0, Fns...>
{
template <typename... Ts>
using invoke = invoke<Fn0, invoke<compose_<Fns...>, Ts...>>;
};
template <typename... Fns>
using compose = compose_<Fns...>;
namespace lazy
{
/// \sa 'meta::compose'
/// \ingroup lazy_composition
template <typename... Fns>
using compose = defer<compose, Fns...>;
} // namespace lazy
/// Turn a template \p C into an Invocable.
/// \ingroup composition
template <template <typename...> class C>
struct quote
{
// Indirection through defer here needed to avoid Core issue 1430
// https://wg21.link/cwg1430
template <typename... Ts>
using invoke = _t<defer<C, Ts...>>;
};
/// Turn a template \p C taking literals of type \p T into a
/// Invocable.
/// \ingroup composition
template <typename T, template <T...> class C>
struct quote_i
{
// Indirection through defer_i here needed to avoid Core issue 1430
// https://wg21.link/cwg1430
template <META_TYPE_CONSTRAINT(Integral)... Ts>
using invoke = _t<defer_i<T, C, Ts::type::value...>>;
};
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 8 && \
!defined(META_DOXYGEN_INVOKED)
template <template <typename...> class C>
struct quote_trait
{
template <typename... Ts>
using invoke = _t<invoke<quote<C>, Ts...>>;
};
template <typename T, template <T...> class C>
struct quote_trait_i
{
template <typename... Ts>
using invoke = _t<invoke<quote_i<T, C>, Ts...>>;
};
#else
// clang-format off
/// Turn a trait template \p C into an Invocable.
/// \code
/// static_assert(std::is_same<invoke<quote_trait<std::add_const>, int>, int const>::value, "");
/// \endcode
/// \ingroup composition
template <template <typename...> class C>
using quote_trait = compose<quote<_t>, quote<C>>;
/// Turn a trait template \p C taking literals of type \p T into an Invocable.
/// \ingroup composition
template <typename T, template <T...> class C>
using quote_trait_i = compose<quote<_t>, quote_i<T, C>>;
// clang-format on
#endif
/// An Invocable that partially applies the Invocable
/// \p Fn by binding the arguments \p Ts to the \e front of \p Fn.
/// \ingroup composition
template <META_TYPE_CONSTRAINT(Invocable) Fn, typename... Ts>
struct bind_front
{
template <typename... Us>
using invoke = invoke<Fn, Ts..., Us...>;
};
/// An Invocable that partially applies the Invocable \p Fn by binding the
/// arguments \p Us to the \e back of \p Fn.
/// \ingroup composition
template <META_TYPE_CONSTRAINT(Invocable) Fn, typename... Us>
struct bind_back
{
template <typename... Ts>
using invoke = invoke<Fn, Ts..., Us...>;
};
namespace lazy
{
/// \sa 'meta::bind_front'
/// \ingroup lazy_composition
template <typename Fn, typename... Ts>
using bind_front = defer<bind_front, Fn, Ts...>;
/// \sa 'meta::bind_back'
/// \ingroup lazy_composition
template <typename Fn, typename... Ts>
using bind_back = defer<bind_back, Fn, Ts...>;
} // namespace lazy
/// Extend meta with your own datatypes.
namespace extension
{
/// A trait that unpacks the types in the type list \p L into the Invocable
/// \p Fn.
/// \ingroup extension
template <META_TYPE_CONSTRAINT(Invocable) Fn, typename L>
struct apply
{
};
template <META_TYPE_CONSTRAINT(Invocable) Fn, typename Ret, typename... Args>
struct apply<Fn, Ret(Args...)> : lazy::invoke<Fn, Ret, Args...>
{
};
template <META_TYPE_CONSTRAINT(Invocable) Fn, template <typename...> class T,
typename... Ts>
struct apply<Fn, T<Ts...>> : lazy::invoke<Fn, Ts...>
{
};
template <META_TYPE_CONSTRAINT(Invocable) Fn, typename T, T... Is>
struct apply<Fn, integer_sequence<T, Is...>>
: lazy::invoke<Fn, std::integral_constant<T, Is>...>
{
};
} // namespace extension
/// Applies the Invocable \p Fn using the types in the type list \p L as
/// arguments.
/// \ingroup invocation
template <META_TYPE_CONSTRAINT(Invocable) Fn, typename L>
using apply = _t<extension::apply<Fn, L>>;
namespace lazy
{
template <typename Fn, typename L>
using apply = defer<apply, Fn, L>;
}
/// An Invocable that takes a bunch of arguments, bundles them into a type
/// list, and then calls the Invocable \p Fn with the type list \p Q.
/// \ingroup composition
template <META_TYPE_CONSTRAINT(Invocable) Fn,
META_TYPE_CONSTRAINT(Invocable) Q = quote<list>>
using curry = compose<Fn, Q>;
/// An Invocable that takes a type list, unpacks the types, and then
/// calls the Invocable \p Fn with the types.
/// \ingroup composition
template <META_TYPE_CONSTRAINT(Invocable) Fn>
using uncurry = bind_front<quote<apply>, Fn>;
namespace lazy
{
/// \sa 'meta::curry'
/// \ingroup lazy_composition
template <typename Fn, typename Q = quote<list>>
using curry = defer<curry, Fn, Q>;
/// \sa 'meta::uncurry'
/// \ingroup lazy_composition
template <typename Fn>
using uncurry = defer<uncurry, Fn>;
} // namespace lazy
/// An Invocable that reverses the order of the first two arguments.
/// \ingroup composition
template <META_TYPE_CONSTRAINT(Invocable) Fn>
struct flip
{
private:
template <typename... Ts>
struct impl
{
};
template <typename A, typename B, typename... Ts>
struct impl<A, B, Ts...> : lazy::invoke<Fn, B, A, Ts...>
{
};
public:
template <typename... Ts>
using invoke = _t<impl<Ts...>>;
};
namespace lazy
{
/// \sa 'meta::flip'
/// \ingroup lazy_composition
template <typename Fn>
using flip = defer<flip, Fn>;
} // namespace lazy
/// \cond
namespace detail
{
template <typename...>
struct on_
{
};
template <typename Fn, typename... Gs>
struct on_<Fn, Gs...>
{
template <typename... Ts>
using invoke = invoke<Fn, invoke<compose<Gs...>, Ts>...>;
};
} // namespace detail
/// \endcond
/// Use as `on<Fn, Gs...>`. Creates an Invocable that applies Invocable \c Fn to the
/// result of applying Invocable `compose<Gs...>` to all the arguments.
/// \ingroup composition
template <META_TYPE_CONSTRAINT(Invocable)... Fns>
using on_ = detail::on_<Fns...>;
template <typename... Fns>
using on = on_<Fns...>;
namespace lazy
{
/// \sa 'meta::on'
/// \ingroup lazy_composition
template <typename Fn, typename G>
using on = defer<on, Fn, G>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// if_
/// \cond
namespace detail
{
#ifdef META_CONCEPT
template <typename...>
struct _if_
{
};
template <Integral If>
struct _if_<If> : std::enable_if<_v<If>>
{
};
template <Integral If, typename Then>
struct _if_<If, Then> : std::enable_if<_v<If>, Then>
{
};
template <Integral If, typename Then, typename Else>
struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
{
};
#elif defined(__clang__)
// Clang is faster with this implementation
template <typename, typename = bool>
struct _if_
{
};
template <typename If>
struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_if<If::type::value>
{
};
template <typename If, typename Then>
struct _if_<list<If, Then>, decltype(bool(If::type::value))>
: std::enable_if<If::type::value, Then>
{
};
template <typename If, typename Then, typename Else>
struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
: std::conditional<If::type::value, Then, Else>
{
};
#else
// GCC seems to prefer this implementation
template <typename, typename = std::true_type>
struct _if_
{
};
template <typename If>
struct _if_<list<If>, bool_<If::type::value>>
{
using type = void;
};
template <typename If, typename Then>
struct _if_<list<If, Then>, bool_<If::type::value>>
{
using type = Then;
};
template <typename If, typename Then, typename Else>
struct _if_<list<If, Then, Else>, bool_<If::type::value>>
{
using type = Then;
};
template <typename If, typename Then, typename Else>
struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
{
using type = Else;
};
#endif
} // namespace detail
/// \endcond
/// Select one type or another depending on a compile-time Boolean.
/// \ingroup logical
#ifdef META_CONCEPT
template <typename... Args>
using if_ = _t<detail::_if_<Args...>>;
/// Select one type or another depending on a compile-time Boolean.
/// \ingroup logical
template <bool If, typename... Args>
using if_c = _t<detail::_if_<bool_<If>, Args...>>;
#else
template <typename... Args>
using if_ = _t<detail::_if_<list<Args...>>>;
template <bool If, typename... Args>
using if_c = _t<detail::_if_<list<bool_<If>, Args...>>>;
#endif
namespace lazy
{
/// \sa 'meta::if_'
/// \ingroup lazy_logical
template <typename... Args>
using if_ = defer<if_, Args...>;
/// \sa 'meta::if_c'
/// \ingroup lazy_logical
template <bool If, typename... Args>
using if_c = if_<bool_<If>, Args...>;
} // namespace lazy
/// \cond
namespace detail
{
#ifdef META_CONCEPT
template <typename...>
struct _and_
{
};
template <>
struct _and_<> : std::true_type
{
};
template <Integral B, typename... Bs>
requires (bool(B::type::value)) struct _and_<B, Bs...> : _and_<Bs...>
{
};
template <Integral B, typename... Bs>
requires (!bool(B::type::value)) struct _and_<B, Bs...> : std::false_type
{
};
template <typename...>
struct _or_
{
};
template <>
struct _or_<> : std::false_type
{
};
template <Integral B, typename... Bs>
requires (bool(B::type::value)) struct _or_<B, Bs...> : std::true_type
{
};
template <Integral B, typename... Bs>
requires (!bool(B::type::value)) struct _or_<B, Bs...> : _or_<Bs...>
{
};
#else
template <bool>
struct _and_
{
template <typename...>
using invoke = std::true_type;
};
template <>
struct _and_<false>
{
template <typename B, typename... Bs>
using invoke = invoke<
if_c<!B::type::value, id<std::false_type>, _and_<0 == sizeof...(Bs)>>,
Bs...>;
};
template <bool>
struct _or_
{
template <typename = void>
using invoke = std::false_type;
};
template <>
struct _or_<false>
{
template <typename B, typename... Bs>
using invoke = invoke<
if_c<B::type::value, id<std::true_type>, _or_<0 == sizeof...(Bs)>>,
Bs...>;
};
#endif
} // namespace detail
/// \endcond
/// Logically negate the Boolean parameter
/// \ingroup logical
template <bool B>
using not_c = bool_<!B>;
/// Logically negate the integral constant-wrapped Boolean parameter.
/// \ingroup logical
template <META_TYPE_CONSTRAINT(Integral) B>
using not_ = not_c<B::type::value>;
#if META_CXX_FOLD_EXPRESSIONS && !defined(META_WORKAROUND_GCC_UNKNOWN1)
template <bool... Bs>
META_INLINE_VAR constexpr bool and_v = (true && ... && Bs);
/// Logically AND together all the Boolean parameters
/// \ingroup logical
template <bool... Bs>
#if defined(META_WORKAROUND_MSVC_756112) || defined(META_WORKAROUND_GCC_86356)
using and_c = bool_<and_v<Bs...>>;
#else
using and_c = bool_<(true && ... && Bs)>;
#endif
#else
#if defined(META_WORKAROUND_GCC_66405)
template <bool... Bs>
using and_c = std::is_same<integer_sequence<bool, true, Bs...>,
integer_sequence<bool, Bs..., true>>;
#else
template <bool... Bs>
using and_c = std::is_same<integer_sequence<bool, Bs...>,
integer_sequence<bool, (Bs || true)...>>;
#endif
#if META_CXX_VARIABLE_TEMPLATES
template <bool... Bs>
META_INLINE_VAR constexpr bool and_v = and_c<Bs...>::value;
#endif
#endif
/// Logically AND together all the integral constant-wrapped Boolean
/// parameters, \e without short-circuiting.
/// \ingroup logical
template <META_TYPE_CONSTRAINT(Integral)... Bs>
using strict_and_ = and_c<Bs::type::value...>;
template <typename... Bs>
using strict_and = strict_and_<Bs...>;
/// Logically AND together all the integral constant-wrapped Boolean
/// parameters, \e with short-circuiting.
/// \ingroup logical
template <typename... Bs>
#ifdef META_CONCEPT
using and_ = _t<detail::_and_<Bs...>>;
#else
// Make a trip through defer<> to avoid CWG1430
// https://wg21.link/cwg1430
using and_ = _t<defer<detail::_and_<0 == sizeof...(Bs)>::template invoke, Bs...>>;
#endif
/// Logically OR together all the Boolean parameters
/// \ingroup logical
#if META_CXX_FOLD_EXPRESSIONS && !defined(META_WORKAROUND_GCC_UNKNOWN1)
template <bool... Bs>
META_INLINE_VAR constexpr bool or_v = (false || ... || Bs);
template <bool... Bs>
#if defined(META_WORKAROUND_MSVC_756112) || defined(META_WORKAROUND_GCC_86356)
using or_c = bool_<or_v<Bs...>>;
#else
using or_c = bool_<(false || ... || Bs)>;
#endif
#else
template <bool... Bs>
using or_c = not_<std::is_same<integer_sequence<bool, Bs...>,
integer_sequence<bool, (Bs && false)...>>>;
#if META_CXX_VARIABLE_TEMPLATES
template <bool... Bs>
META_INLINE_VAR constexpr bool or_v = or_c<Bs...>::value;
#endif
#endif
/// Logically OR together all the integral constant-wrapped Boolean
/// parameters, \e without short-circuiting.
/// \ingroup logical
template <META_TYPE_CONSTRAINT(Integral)... Bs>
using strict_or_ = or_c<Bs::type::value...>;
template <typename... Bs>
using strict_or = strict_or_<Bs...>;
/// Logically OR together all the integral constant-wrapped Boolean
/// parameters, \e with short-circuiting.
/// \ingroup logical
template <typename... Bs>
#ifdef META_CONCEPT
using or_ = _t<detail::_or_<Bs...>>;
#else
// Make a trip through defer<> to avoid CWG1430
// https://wg21.link/cwg1430
using or_ = _t<defer<detail::_or_<0 == sizeof...(Bs)>::template invoke, Bs...>>;
#endif
namespace lazy
{
/// \sa 'meta::and_'
/// \ingroup lazy_logical
template <typename... Bs>
using and_ = defer<and_, Bs...>;
/// \sa 'meta::or_'
/// \ingroup lazy_logical
template <typename... Bs>
using or_ = defer<or_, Bs...>;
/// \sa 'meta::not_'
/// \ingroup lazy_logical
template <typename B>
using not_ = defer<not_, B>;
/// \sa 'meta::strict_and'
/// \ingroup lazy_logical
template <typename... Bs>
using strict_and = defer<strict_and, Bs...>;
/// \sa 'meta::strict_or'
/// \ingroup lazy_logical
template <typename... Bs>
using strict_or = defer<strict_or, Bs...>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// fold
/// \cond
namespace detail
{
template <typename, typename, typename>
struct fold_
{
};
template <typename Fn, typename T0, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9>
struct compose10_
{
template <typename X, typename Y>
using F = invoke<Fn, X, Y>;
template <typename S>
using invoke =
F<F<F<F<F<F<F<F<F<F<_t<S>, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
};
#ifdef META_CONCEPT
template <typename Fn>
struct compose_
{
template <typename X, typename Y>
using F = invoke<Fn, X, Y>;
template <typename T0, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9,
typename State>
using invoke =
F<F<F<F<F<F<F<F<F<F<State, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
};
template <typename State, typename Fn>
struct fold_<list<>, State, Fn>
{
using type = State;
};
template <typename Head, typename... Tail, typename State, typename Fn>
requires Valid<invoke, Fn, State, Head>
struct fold_<list<Head, Tail...>, State, Fn>
: fold_<list<Tail...>, invoke<Fn, State, Head>, Fn>
{
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename... Tail,
typename State, typename Fn>
requires Valid<invoke, compose_<Fn>, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State>
struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
: fold_<list<Tail...>,
invoke<compose_<Fn>, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State>, Fn>
{
};
#else // ^^^ Concepts / no Concepts vvv
template <typename Fn, typename T0>
struct compose1_
{
template <typename X>
using invoke = invoke<Fn, _t<X>, T0>;
};
template <typename State, typename Fn>
struct fold_<list<>, State, Fn> : State
{
};
template <typename Head, typename... Tail, typename State, typename Fn>
struct fold_<list<Head, Tail...>, State, Fn>
: fold_<list<Tail...>, lazy::invoke<compose1_<Fn, Head>, State>, Fn>
{
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename... Tail,
typename State, typename Fn>
struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
: fold_<list<Tail...>,
lazy::invoke<compose10_<Fn, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, State>, Fn>
{
};
#endif // META_CONCEPT
} // namespace detail
/// \endcond
/// Return a new \c meta::list constructed by doing a left fold of the list \p L using
/// binary Invocable \p Fn and initial state \p State. That is, the \c State_N for
/// the list element \c A_N is computed by `Fn(State_N-1, A_N) -> State_N`.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, typename State, META_TYPE_CONSTRAINT(Invocable) Fn>
#ifdef META_CONCEPT
using fold = _t<detail::fold_<L, State, Fn>>;
#else
using fold = _t<detail::fold_<L, id<State>, Fn>>;
#endif
/// An alias for `meta::fold`.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, typename State, META_TYPE_CONSTRAINT(Invocable) Fn>
using accumulate = fold<L, State, Fn>;
namespace lazy
{
/// \sa 'meta::foldl'
/// \ingroup lazy_transformation
template <typename L, typename State, typename Fn>
using fold = defer<fold, L, State, Fn>;
/// \sa 'meta::accumulate'
/// \ingroup lazy_transformation
template <typename L, typename State, typename Fn>
using accumulate = defer<accumulate, L, State, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// reverse_fold
/// \cond
namespace detail
{
template <typename, typename, typename>
struct reverse_fold_
{
};
template <typename State, typename Fn>
struct reverse_fold_<list<>, State, Fn>
{
using type = State;
};
#ifdef META_CONCEPT
template <typename Head, typename... L, typename State, typename Fn>
requires Trait<reverse_fold_<list<L...>, State, Fn>> struct reverse_fold_<
list<Head, L...>, State, Fn>
: lazy::invoke<Fn, _t<reverse_fold_<list<L...>, State, Fn>>, Head>
{
};
#else
template <typename Head, typename... Tail, typename State, typename Fn>
struct reverse_fold_<list<Head, Tail...>, State, Fn>
: lazy::invoke<compose1_<Fn, Head>, reverse_fold_<list<Tail...>, State, Fn>>
{
};
#endif
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename... Tail,
typename State, typename Fn>
struct reverse_fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
: lazy::invoke<compose10_<Fn, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>,
reverse_fold_<list<Tail...>, State, Fn>>
{
};
} // namespace detail
/// \endcond
/// Return a new \c meta::list constructed by doing a right fold of the list \p L using
/// binary Invocable \p Fn and initial state \p State. That is, the \c State_N for the list
/// element \c A_N is computed by `Fn(A_N, State_N+1) -> State_N`.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, typename State, META_TYPE_CONSTRAINT(Invocable) Fn>
using reverse_fold = _t<detail::reverse_fold_<L, State, Fn>>;
namespace lazy
{
/// \sa 'meta::foldr'
/// \ingroup lazy_transformation
template <typename L, typename State, typename Fn>
using reverse_fold = defer<reverse_fold, L, State, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// npos
/// A special value used to indicate no matches. It equals the maximum
/// value representable by std::size_t.
/// \ingroup list
using npos = meta::size_t<std::size_t(-1)>;
///////////////////////////////////////////////////////////////////////////////////////////
// list
/// A list of types.
/// \ingroup list
template <typename... Ts>
struct list
{
using type = list;
/// \return `sizeof...(Ts)`
static constexpr std::size_t size() noexcept { return sizeof...(Ts); }
};
///////////////////////////////////////////////////////////////////////////////////////////
// size
/// An integral constant wrapper that is the size of the \c meta::list
/// \p L.
/// \ingroup list
template <META_TYPE_CONSTRAINT(List) L>
using size = meta::size_t<L::size()>;
namespace lazy
{
/// \sa 'meta::size'
/// \ingroup lazy_list
template <typename L>
using size = defer<size, L>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// concat
/// \cond
namespace detail
{
template <typename... Lists>
struct concat_
{
};
template <>
struct concat_<>
{
using type = list<>;
};
template <typename... L1>
struct concat_<list<L1...>>
{
using type = list<L1...>;
};
template <typename... L1, typename... L2>
struct concat_<list<L1...>, list<L2...>>
{
using type = list<L1..., L2...>;
};
template <typename... L1, typename... L2, typename... L3>
struct concat_<list<L1...>, list<L2...>, list<L3...>>
{
using type = list<L1..., L2..., L3...>;
};
template <typename... L1, typename... L2, typename... L3, typename... Rest>
struct concat_<list<L1...>, list<L2...>, list<L3...>, Rest...>
: concat_<list<L1..., L2..., L3...>, Rest...>
{
};
template <typename... L1, typename... L2, typename... L3, typename... L4,
typename... L5, typename... L6, typename... L7, typename... L8,
typename... L9, typename... L10, typename... Rest>
struct concat_<list<L1...>, list<L2...>, list<L3...>, list<L4...>, list<L5...>,
list<L6...>, list<L7...>, list<L8...>, list<L9...>, list<L10...>,
Rest...>
: concat_<list<L1..., L2..., L3..., L4..., L5..., L6..., L7..., L8..., L9..., L10...>,
Rest...>
{
};
} // namespace detail
/// \endcond
/// Concatenates several lists into a single list.
/// \pre The parameters must all be instantiations of \c meta::list.
/// \par Complexity
/// \f$ O(L) \f$ where \f$ L \f$ is the number of lists in the list of lists.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List)... Ls>
using concat_ = _t<detail::concat_<Ls...>>;
template <typename... Lists>
using concat = concat_<Lists...>;
namespace lazy
{
/// \sa 'meta::concat'
/// \ingroup lazy_transformation
template <typename... Lists>
using concat = defer<concat, Lists...>;
} // namespace lazy
/// Joins a list of lists into a single list.
/// \pre The parameter must be an instantiation of \c meta::list\<T...\>
/// where each \c T is itself an instantiation of \c meta::list.
/// \par Complexity
/// \f$ O(L) \f$ where \f$ L \f$ is the number of lists in the list of
/// lists.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) ListOfLists>
using join = apply<quote<concat>, ListOfLists>;
namespace lazy
{
/// \sa 'meta::join'
/// \ingroup lazy_transformation
template <typename ListOfLists>
using join = defer<join, ListOfLists>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// transform
/// \cond
namespace detail
{
#ifdef META_CONCEPT
template <typename... Args>
struct transform_
{
};
template <typename... Ts, Invocable Fn>
requires (Valid<invoke, Fn, Ts> && ...)
struct transform_<list<Ts...>, Fn>
{
using type = list<invoke<Fn, Ts>...>;
};
template <typename... Ts, typename... Us, Invocable Fn>
requires (Valid<invoke, Fn, Ts, Us> && ...)
struct transform_<list<Ts...>, list<Us...>, Fn>
{
using type = list<invoke<Fn, Ts, Us>...>;
};
#else
template <typename, typename = void>
struct transform_
{
};
template <typename... Ts, typename Fn>
struct transform_<list<list<Ts...>, Fn>, void_<invoke<Fn, Ts>...>>
{
using type = list<invoke<Fn, Ts>...>;
};
template <typename... Ts0, typename... Ts1, typename Fn>
struct transform_<list<list<Ts0...>, list<Ts1...>, Fn>,
void_<invoke<Fn, Ts0, Ts1>...>>
{
using type = list<invoke<Fn, Ts0, Ts1>...>;
};
#endif
} // namespace detail
/// \endcond
/// Return a new \c meta::list constructed by transforming all the
/// elements in \p L with the unary Invocable \p Fn. \c transform can
/// also be called with two lists of the same length and a binary
/// Invocable, in which case it returns a new list constructed with the
/// results of calling \c Fn with each element in the lists, pairwise.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
#ifdef META_CONCEPT
template <typename... Args>
using transform = _t<detail::transform_<Args...>>;
#else
template <typename... Args>
using transform = _t<detail::transform_<list<Args...>>>;
#endif
namespace lazy
{
/// \sa 'meta::transform'
/// \ingroup lazy_transformation
template <typename... Args>
using transform = defer<transform, Args...>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// repeat_n
/// \cond
namespace detail
{
template <typename T, std::size_t>
using first_ = T;
template <typename T, typename Ints>
struct repeat_n_c_
{
};
template <typename T, std::size_t... Is>
struct repeat_n_c_<T, index_sequence<Is...>>
{
using type = list<first_<T, Is>...>;
};
} // namespace detail
/// \endcond
/// Generate `list<T,T,T...T>` of size \p N arguments.
/// \par Complexity
/// \f$ O(log N) \f$.
/// \ingroup list
template <std::size_t N, typename T = void>
using repeat_n_c = _t<detail::repeat_n_c_<T, make_index_sequence<N>>>;
/// Generate `list<T,T,T...T>` of size \p N arguments.
/// \par Complexity
/// \f$ O(log N) \f$.
/// \ingroup list
template <META_TYPE_CONSTRAINT(Integral) N, typename T = void>
using repeat_n = repeat_n_c<N::type::value, T>;
namespace lazy
{
/// \sa 'meta::repeat_n'
/// \ingroup lazy_list
template <typename N, typename T = void>
using repeat_n = defer<repeat_n, N, T>;
/// \sa 'meta::repeat_n_c'
/// \ingroup lazy_list
template <std::size_t N, typename T = void>
using repeat_n_c = defer<repeat_n, meta::size_t<N>, T>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// at
/// \cond
namespace detail
{
#if META_HAS_TYPE_PACK_ELEMENT && !defined(META_DOXYGEN_INVOKED)
template <typename L, std::size_t N, typename = void>
struct at_
{
};
template <typename... Ts, std::size_t N>
struct at_<list<Ts...>, N, void_<__type_pack_element<N, Ts...>>>
{
using type = __type_pack_element<N, Ts...>;
};
#else
template <typename VoidPtrs>
struct at_impl_;
template <typename... VoidPtrs>
struct at_impl_<list<VoidPtrs...>>
{
static nil_ eval(...);
template <typename T, typename... Us>
static T eval(VoidPtrs..., T *, Us *...);
};
template <typename L, std::size_t N>
struct at_
{
};
template <typename... Ts, std::size_t N>
struct at_<list<Ts...>, N>
: decltype(at_impl_<repeat_n_c<N, void *>>::eval(static_cast<id<Ts> *>(nullptr)...))
{
};
#endif // META_HAS_TYPE_PACK_ELEMENT
} // namespace detail
/// \endcond
/// Return the \p N th element in the \c meta::list \p L.
/// \par Complexity
/// Amortized \f$ O(1) \f$.
/// \ingroup list
template <META_TYPE_CONSTRAINT(List) L, std::size_t N>
using at_c = _t<detail::at_<L, N>>;
/// Return the \p N th element in the \c meta::list \p L.
/// \par Complexity
/// Amortized \f$ O(1) \f$.
/// \ingroup list
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Integral) N>
using at = at_c<L, N::type::value>;
namespace lazy
{
/// \sa 'meta::at'
/// \ingroup lazy_list
template <typename L, typename N>
using at = defer<at, L, N>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// drop
/// \cond
namespace detail
{
///////////////////////////////////////////////////////////////////////////////////////
/// drop_impl_
template <typename VoidPtrs>
struct drop_impl_
{
static nil_ eval(...);
};
template <typename... VoidPtrs>
struct drop_impl_<list<VoidPtrs...>>
{
static nil_ eval(...);
template <typename... Ts>
static id<list<Ts...>> eval(VoidPtrs..., id<Ts> *...);
};
template <>
struct drop_impl_<list<>>
{
template <typename... Ts>
static id<list<Ts...>> eval(id<Ts> *...);
};
template <typename L, std::size_t N>
struct drop_
{
};
template <typename... Ts, std::size_t N>
struct drop_<list<Ts...>, N>
#if META_CXX_VARIABLE_TEMPLATES
: decltype(drop_impl_<repeat_n_c<N, void *>>::eval(detail::nullptr_v<id<Ts>>...))
#else
: decltype(drop_impl_<repeat_n_c<N, void *>>::eval(detail::_nullptr_v<id<Ts>>()...))
#endif
{
};
} // namespace detail
/// \endcond
/// Return a new \c meta::list by removing the first \p N elements from \p L.
/// \par Complexity
/// \f$ O(1) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, std::size_t N>
using drop_c = _t<detail::drop_<L, N>>;
/// Return a new \c meta::list by removing the first \p N elements from \p L.
/// \par Complexity
/// \f$ O(1) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Integral) N>
using drop = drop_c<L, N::type::value>;
namespace lazy
{
/// \sa 'meta::drop'
/// \ingroup lazy_transformation
template <typename L, typename N>
using drop = defer<drop, L, N>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// front
/// \cond
namespace detail
{
template <typename L>
struct front_
{
};
template <typename Head, typename... Tail>
struct front_<list<Head, Tail...>>
{
using type = Head;
};
} // namespace detail
/// \endcond
/// Return the first element in \c meta::list \p L.
/// \par Complexity
/// \f$ O(1) \f$.
/// \ingroup list
template <META_TYPE_CONSTRAINT(List) L>
using front = _t<detail::front_<L>>;
namespace lazy
{
/// \sa 'meta::front'
/// \ingroup lazy_list
template <typename L>
using front = defer<front, L>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// back
/// \cond
namespace detail
{
template <typename L>
struct back_
{
};
template <typename Head, typename... Tail>
struct back_<list<Head, Tail...>>
{
using type = at_c<list<Head, Tail...>, sizeof...(Tail)>;
};
} // namespace detail
/// \endcond
/// Return the last element in \c meta::list \p L.
/// \par Complexity
/// Amortized \f$ O(1) \f$.
/// \ingroup list
template <META_TYPE_CONSTRAINT(List) L>
using back = _t<detail::back_<L>>;
namespace lazy
{
/// \sa 'meta::back'
/// \ingroup lazy_list
template <typename L>
using back = defer<back, L>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// push_front
/// Return a new \c meta::list by adding the element \c T to the front of \p L.
/// \par Complexity
/// \f$ O(1) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, typename... Ts>
using push_front = apply<bind_front<quote<list>, Ts...>, L>;
namespace lazy
{
/// \sa 'meta::push_front'
/// \ingroup lazy_transformation
template <typename... Ts>
using push_front = defer<push_front, Ts...>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// pop_front
/// \cond
namespace detail
{
template <typename L>
struct pop_front_
{
};
template <typename Head, typename... L>
struct pop_front_<list<Head, L...>>
{
using type = list<L...>;
};
} // namespace detail
/// \endcond
/// Return a new \c meta::list by removing the first element from the
/// front of \p L.
/// \par Complexity
/// \f$ O(1) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L>
using pop_front = _t<detail::pop_front_<L>>;
namespace lazy
{
/// \sa 'meta::pop_front'
/// \ingroup lazy_transformation
template <typename L>
using pop_front = defer<pop_front, L>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// push_back
/// Return a new \c meta::list by adding the element \c T to the back of \p L.
/// \par Complexity
/// \f$ O(1) \f$.
/// \note \c pop_back not provided because it cannot be made to meet the
/// complexity guarantees one would expect.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, typename... Ts>
using push_back = apply<bind_back<quote<list>, Ts...>, L>;
namespace lazy
{
/// \sa 'meta::push_back'
/// \ingroup lazy_transformation
template <typename... Ts>
using push_back = defer<push_back, Ts...>;
} // namespace lazy
/// \cond
namespace detail
{
template <typename T, typename U>
using min_ = if_<less<U, T>, U, T>;
template <typename T, typename U>
using max_ = if_<less<U, T>, T, U>;
} // namespace detail
/// \endcond
/// An integral constant wrapper around the minimum of `Ts::type::value...`
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral)... Ts>
using min_ = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::min_>>;
template <typename... Ts>
using min = min_<Ts...>;
/// An integral constant wrapper around the maximum of `Ts::type::value...`
/// \ingroup math
template <META_TYPE_CONSTRAINT(Integral)... Ts>
using max_ = fold<pop_front<list<Ts...>>, front<list<Ts...>>, quote<detail::max_>>;
template <typename... Ts>
using max = max_<Ts...>;
namespace lazy
{
/// \sa 'meta::min'
/// \ingroup lazy_math
template <typename... Ts>
using min = defer<min, Ts...>;
/// \sa 'meta::max'
/// \ingroup lazy_math
template <typename... Ts>
using max = defer<max, Ts...>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// empty
/// An Boolean integral constant wrapper around \c true if \p L is an
/// empty type list; \c false, otherwise.
/// \par Complexity
/// \f$ O(1) \f$.
/// \ingroup list
template <META_TYPE_CONSTRAINT(List) L>
using empty = bool_<0 == size<L>::type::value>;
namespace lazy
{
/// \sa 'meta::empty'
/// \ingroup lazy_list
template <typename L>
using empty = defer<empty, L>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// pair
/// A list with exactly two elements
/// \ingroup list
template <typename F, typename S>
using pair = list<F, S>;
/// Retrieve the first element of the \c pair \p Pair
/// \ingroup list
template <typename Pair>
using first = front<Pair>;
/// Retrieve the first element of the \c pair \p Pair
/// \ingroup list
template <typename Pair>
using second = front<pop_front<Pair>>;
namespace lazy
{
/// \sa 'meta::first'
/// \ingroup lazy_list
template <typename Pair>
using first = defer<first, Pair>;
/// \sa 'meta::second'
/// \ingroup lazy_list
template <typename Pair>
using second = defer<second, Pair>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// find_index
/// \cond
namespace detail
{
// With thanks to Peter Dimov:
constexpr std::size_t find_index_i_(bool const *const first, bool const *const last,
std::size_t N = 0)
{
return first == last ? npos::value
: *first ? N : find_index_i_(first + 1, last, N + 1);
}
template <typename L, typename T>
struct find_index_
{
};
template <typename V>
struct find_index_<list<>, V>
{
using type = npos;
};
template <typename... T, typename V>
struct find_index_<list<T...>, V>
{
#ifdef META_WORKAROUND_LLVM_28385
static constexpr bool s_v[sizeof...(T)] = {std::is_same<T, V>::value...};
#else
static constexpr bool s_v[] = {std::is_same<T, V>::value...};
#endif
using type = size_t<find_index_i_(s_v, s_v + sizeof...(T))>;
};
} // namespace detail
/// \endcond
/// Finds the index of the first occurrence of the type \p T within the list \p L.
/// Returns `#meta::npos` if the type \p T was not found.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
/// \sa `meta::npos`
template <META_TYPE_CONSTRAINT(List) L, typename T>
using find_index = _t<detail::find_index_<L, T>>;
namespace lazy
{
/// \sa 'meta::find_index'
/// \ingroup lazy_query
template <typename L, typename T>
using find_index = defer<find_index, L, T>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// reverse_find_index
/// \cond
namespace detail
{
// With thanks to Peter Dimov:
constexpr std::size_t reverse_find_index_i_(bool const *const first,
bool const *const last, std::size_t N)
{
return first == last
? npos::value
: *(last - 1) ? N - 1 : reverse_find_index_i_(first, last - 1, N - 1);
}
template <typename L, typename T>
struct reverse_find_index_
{
};
template <typename V>
struct reverse_find_index_<list<>, V>
{
using type = npos;
};
template <typename... T, typename V>
struct reverse_find_index_<list<T...>, V>
{
#ifdef META_WORKAROUND_LLVM_28385
static constexpr bool s_v[sizeof...(T)] = {std::is_same<T, V>::value...};
#else
static constexpr bool s_v[] = {std::is_same<T, V>::value...};
#endif
using type = size_t<reverse_find_index_i_(s_v, s_v + sizeof...(T), sizeof...(T))>;
};
} // namespace detail
/// \endcond
/// Finds the index of the last occurrence of the type \p T within the
/// list \p L. Returns `#meta::npos` if the type \p T was not found.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
/// \sa `#meta::npos`
template <META_TYPE_CONSTRAINT(List) L, typename T>
using reverse_find_index = _t<detail::reverse_find_index_<L, T>>;
namespace lazy
{
/// \sa 'meta::reverse_find_index'
/// \ingroup lazy_query
template <typename L, typename T>
using reverse_find_index = defer<reverse_find_index, L, T>;
} // namespace lazy
////////////////////////////////////////////////////////////////////////////////////
// find
/// Return the tail of the list \p L starting at the first occurrence of
/// \p T, if any such element exists; the empty list, otherwise.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, typename T>
using find = drop<L, min<find_index<L, T>, size<L>>>;
namespace lazy
{
/// \sa 'meta::find'
/// \ingroup lazy_query
template <typename L, typename T>
using find = defer<find, L, T>;
} // namespace lazy
////////////////////////////////////////////////////////////////////////////////////
// reverse_find
/// \cond
namespace detail
{
template <typename L, typename T, typename State = list<>>
struct reverse_find_
{
};
template <typename T, typename State>
struct reverse_find_<list<>, T, State>
{
using type = State;
};
template <typename Head, typename... L, typename T, typename State>
struct reverse_find_<list<Head, L...>, T, State> : reverse_find_<list<L...>, T, State>
{
};
template <typename... L, typename T, typename State>
struct reverse_find_<list<T, L...>, T, State>
: reverse_find_<list<L...>, T, list<T, L...>>
{
};
} // namespace detail
/// \endcond
/// Return the tail of the list \p L starting at the last occurrence of \p T, if any such
/// element exists; the empty list, otherwise.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, typename T>
using reverse_find = drop<L, min<reverse_find_index<L, T>, size<L>>>;
namespace lazy
{
/// \sa 'meta::rfind'
/// \ingroup lazy_query
template <typename L, typename T>
using reverse_find = defer<reverse_find, L, T>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// find_if
/// \cond
namespace detail
{
#ifdef META_CONCEPT
template <typename L, typename Fn>
struct find_if_
{
};
template <typename Fn>
struct find_if_<list<>, Fn>
{
using type = list<>;
};
template <typename Head, typename... L, typename Fn>
requires Integral<invoke<Fn, Head>>
struct find_if_<list<Head, L...>, Fn>
: if_<invoke<Fn, Head>, id<list<Head, L...>>, find_if_<list<L...>, Fn>>
{
};
#else
constexpr bool const *find_if_i_(bool const *const begin, bool const *const end)
{
return begin == end || *begin ? begin : find_if_i_(begin + 1, end);
}
template <typename L, typename Fn, typename = void>
struct find_if_
{
};
template <typename Fn>
struct find_if_<list<>, Fn>
{
using type = list<>;
};
template <typename... L, typename Fn>
struct find_if_<list<L...>, Fn,
void_<integer_sequence<bool, bool(invoke<Fn, L>::type::value)...>>>
{
#ifdef META_WORKAROUND_LLVM_28385
static constexpr bool s_v[sizeof...(L)] = {invoke<Fn, L>::type::value...};
#else
static constexpr bool s_v[] = {invoke<Fn, L>::type::value...};
#endif
using type =
drop_c<list<L...>, detail::find_if_i_(s_v, s_v + sizeof...(L)) - s_v>;
};
#endif
} // namespace detail
/// \endcond
/// Return the tail of the list \p L starting at the first element `A`
/// such that `invoke<Fn, A>::%value` is \c true, if any such element
/// exists; the empty list, otherwise.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Invocable) Fn>
using find_if = _t<detail::find_if_<L, Fn>>;
namespace lazy
{
/// \sa 'meta::find_if'
/// \ingroup lazy_query
template <typename L, typename Fn>
using find_if = defer<find_if, L, Fn>;
} // namespace lazy
////////////////////////////////////////////////////////////////////////////////////
// reverse_find_if
/// \cond
namespace detail
{
#ifdef META_CONCEPT
template <typename L, typename Fn, typename State = list<>>
struct reverse_find_if_
{
};
template <typename Fn, typename State>
struct reverse_find_if_<list<>, Fn, State>
{
using type = State;
};
template <typename Head, typename... L, typename Fn, typename State>
requires Integral<invoke<Fn, Head>>
struct reverse_find_if_<list<Head, L...>, Fn, State>
: reverse_find_if_<list<L...>, Fn, if_<invoke<Fn, Head>, list<Head, L...>, State>>
{
};
#else
constexpr bool const *reverse_find_if_i_(bool const *const begin, bool const *const pos,
bool const *const end)
{
return begin == pos
? end
: *(pos - 1) ? pos - 1 : reverse_find_if_i_(begin, pos - 1, end);
}
template <typename L, typename Fn, typename = void>
struct reverse_find_if_
{
};
template <typename Fn>
struct reverse_find_if_<list<>, Fn>
{
using type = list<>;
};
template <typename... L, typename Fn>
struct reverse_find_if_<
list<L...>, Fn,
void_<integer_sequence<bool, bool(invoke<Fn, L>::type::value)...>>>
{
#ifdef META_WORKAROUND_LLVM_28385
static constexpr bool s_v[sizeof...(L)] = {invoke<Fn, L>::type::value...};
#else
static constexpr bool s_v[] = {invoke<Fn, L>::type::value...};
#endif
using type =
drop_c<list<L...>, detail::reverse_find_if_i_(s_v, s_v + sizeof...(L),
s_v + sizeof...(L)) -
s_v>;
};
#endif
} // namespace detail
/// \endcond
/// Return the tail of the list \p L starting at the last element `A`
/// such that `invoke<Fn, A>::%value` is \c true, if any such element
/// exists; the empty list, otherwise.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Invocable) Fn>
using reverse_find_if = _t<detail::reverse_find_if_<L, Fn>>;
namespace lazy
{
/// \sa 'meta::rfind_if'
/// \ingroup lazy_query
template <typename L, typename Fn>
using reverse_find_if = defer<reverse_find_if, L, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// replace
/// \cond
namespace detail
{
template <typename L, typename T, typename U>
struct replace_
{
};
template <typename... L, typename T, typename U>
struct replace_<list<L...>, T, U>
{
using type = list<if_<std::is_same<T, L>, U, L>...>;
};
} // namespace detail
/// \endcond
/// Return a new \c meta::list where all instances of type \p T have
/// been replaced with \p U.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, typename T, typename U>
using replace = _t<detail::replace_<L, T, U>>;
namespace lazy
{
/// \sa 'meta::replace'
/// \ingroup lazy_transformation
template <typename L, typename T, typename U>
using replace = defer<replace, T, U>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// replace_if
/// \cond
namespace detail
{
#ifdef META_CONCEPT
template <typename L, typename C, typename U>
struct replace_if_
{
};
template <typename... L, typename C, typename U>
requires (Integral<invoke<C, L>> &&...)
struct replace_if_<list<L...>, C, U>
{
using type = list<if_<invoke<C, L>, U, L>...>;
};
#else
template <typename L, typename C, typename U, typename = void>
struct replace_if_
{
};
template <typename... L, typename C, typename U>
struct replace_if_<list<L...>, C, U,
void_<integer_sequence<bool, bool(invoke<C, L>::type::value)...>>>
{
using type = list<if_<invoke<C, L>, U, L>...>;
};
#endif
} // namespace detail
/// \endcond
/// Return a new \c meta::list where all elements \c A of the list \p L
/// for which `invoke<C,A>::%value` is \c true have been replaced with
/// \p U.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, typename C, typename U>
using replace_if = _t<detail::replace_if_<L, C, U>>;
namespace lazy
{
/// \sa 'meta::replace_if'
/// \ingroup lazy_transformation
template <typename L, typename C, typename U>
using replace_if = defer<replace_if, C, U>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////
// count
namespace detail
{
template <typename, typename>
struct count_
{
};
#if defined(META_CONCEPT) || META_CXX_VARIABLE_TEMPLATES && META_CXX_FOLD_EXPRESSIONS
template <typename... Ts, typename T>
struct count_<list<Ts...>, T>
{
using type = meta::size_t<((std::size_t)_v<std::is_same<T, Ts>> + ...)>;
};
#else
constexpr std::size_t count_i_(bool const *const begin, bool const *const end,
std::size_t n)
{
return begin == end ? n : detail::count_i_(begin + 1, end, n + *begin);
}
template <typename T>
struct count_<list<>, T>
{
using type = meta::size_t<0>;
};
template <typename... L, typename T>
struct count_<list<L...>, T>
{
#ifdef META_WORKAROUND_LLVM_28385
static constexpr bool s_v[sizeof...(L)] = {std::is_same<T, L>::value...};
#else
static constexpr bool s_v[] = {std::is_same<T, L>::value...};
#endif
using type = meta::size_t<detail::count_i_(s_v, s_v + sizeof...(L), 0u)>;
};
#endif
} // namespace detail
/// Count the number of times a type \p T appears in the list \p L.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, typename T>
using count = _t<detail::count_<L, T>>;
namespace lazy
{
/// \sa `meta::count`
/// \ingroup lazy_query
template <typename L, typename T>
using count = defer<count, L, T>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////
// count_if
namespace detail
{
#ifdef META_CONCEPT
template <typename, typename>
struct count_if_
{
};
template <typename... Ts, typename Fn>
requires (Integral<invoke<Fn, Ts>> &&...)
struct count_if_<list<Ts...>, Fn>
{
using type = meta::size_t<((std::size_t)(bool)_v<invoke<Fn, Ts>> + ...)>;
};
#else
template <typename L, typename Fn, typename = void>
struct count_if_
{
};
template <typename Fn>
struct count_if_<list<>, Fn>
{
using type = meta::size_t<0>;
};
template <typename... L, typename Fn>
struct count_if_<list<L...>, Fn,
void_<integer_sequence<bool, bool(invoke<Fn, L>::type::value)...>>>
{
#if META_CXX_FOLD_EXPRESSIONS
using type = meta::size_t<((std::size_t)(bool)invoke<Fn, L>::type::value + ...)>;
#else
#ifdef META_WORKAROUND_LLVM_28385
static constexpr bool s_v[sizeof...(L)] = {invoke<Fn, L>::type::value...};
#else
static constexpr bool s_v[] = {invoke<Fn, L>::type::value...};
#endif
using type = meta::size_t<detail::count_i_(s_v, s_v + sizeof...(L), 0u)>;
#endif // META_CXX_FOLD_EXPRESSIONS
};
#endif // META_CONCEPT
} // namespace detail
/// Count the number of times the predicate \p Fn evaluates to true for all the elements in
/// the list \p L.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Invocable) Fn>
using count_if = _t<detail::count_if_<L, Fn>>;
namespace lazy
{
/// \sa `meta::count_if`
/// \ingroup lazy_query
template <typename L, typename Fn>
using count_if = defer<count_if, L, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// filter
/// \cond
namespace detail
{
template <typename Pred>
struct filter_
{
template <typename A>
using invoke = if_c<invoke<Pred, A>::type::value, list<A>, list<>>;
};
} // namespace detail
/// \endcond
/// Returns a new meta::list where only those elements of \p L that satisfy the
/// Callable \p Pred such that `invoke<Pred,A>::%value` is \c true are present.
/// That is, those elements that don't satisfy the \p Pred are "removed".
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
template <typename L, typename Pred>
using filter = join<transform<L, detail::filter_<Pred>>>;
namespace lazy
{
/// \sa 'meta::filter'
/// \ingroup lazy_transformation
template <typename L, typename Fn>
using filter = defer<filter, L, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// static_const
///\cond
namespace detail
{
template <typename T>
struct static_const
{
static constexpr T value{};
};
// Avoid potential ODR violations with global objects:
template <typename T>
constexpr T static_const<T>::value;
} // namespace detail
///\endcond
///////////////////////////////////////////////////////////////////////////////////////////
// for_each
/// \cond
namespace detail
{
struct for_each_fn
{
template <class Fn, class... Args>
constexpr auto operator()(list<Args...>, Fn f) const -> Fn
{
return (void)std::initializer_list<int>{((void)f(Args{}), 0)...}, f;
}
};
} // namespace detail
/// \endcond
#if META_CXX_INLINE_VARIABLES
/// `for_each(L, Fn)` calls the \p Fn for each
/// argument in the \p L.
/// \ingroup runtime
inline constexpr detail::for_each_fn for_each{};
#else
///\cond
namespace
{
/// \endcond
/// `for_each(List, UnaryFunction)` calls the \p UnaryFunction for each
/// argument in the \p List.
/// \ingroup runtime
constexpr auto &&for_each = detail::static_const<detail::for_each_fn>::value;
/// \cond
}
/// \endcond
#endif
///////////////////////////////////////////////////////////////////////////////////////////
// transpose
/// Given a list of lists of the same number of types \p ListOfLists, transpose the
/// elements from the lists.
/// \par Complexity
/// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and \f$ M \f$ is
/// the size of all of the inner lists.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) ListOfLists>
using transpose = fold<ListOfLists, repeat_n<size<front<ListOfLists>>, list<>>,
bind_back<quote<transform>, quote<push_back>>>;
namespace lazy
{
/// \sa 'meta::transpose'
/// \ingroup lazy_transformation
template <typename ListOfLists>
using transpose = defer<transpose, ListOfLists>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// zip_with
/// Given a list of lists of types \p ListOfLists and an Invocable \p Fn, construct a new
/// list by calling \p Fn with the elements from the lists pairwise.
/// \par Complexity
/// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
/// \f$ M \f$ is the size of the inner lists.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(Invocable) Fn, META_TYPE_CONSTRAINT(List) ListOfLists>
using zip_with = transform<transpose<ListOfLists>, uncurry<Fn>>;
namespace lazy
{
/// \sa 'meta::zip_with'
/// \ingroup lazy_transformation
template <typename Fn, typename ListOfLists>
using zip_with = defer<zip_with, Fn, ListOfLists>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// zip
/// Given a list of lists of types \p ListOfLists, construct a new list by grouping the
/// elements from the lists pairwise into `meta::list`s.
/// \par Complexity
/// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and \f$ M \f$
/// is the size of the inner lists.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) ListOfLists>
using zip = transpose<ListOfLists>;
namespace lazy
{
/// \sa 'meta::zip'
/// \ingroup lazy_transformation
template <typename ListOfLists>
using zip = defer<zip, ListOfLists>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// as_list
/// \cond
namespace detail
{
template <typename T>
using uncvref_t = _t<std::remove_cv<_t<std::remove_reference<T>>>>;
// Indirection here needed to avoid Core issue 1430
// https://wg21.link/cwg1430
template <typename Sequence>
struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
{
};
} // namespace detail
/// \endcond
/// Turn a type into an instance of \c meta::list in a way determined by
/// \c meta::apply.
/// \ingroup list
template <typename Sequence>
using as_list = _t<detail::as_list_<detail::uncvref_t<Sequence>>>;
namespace lazy
{
/// \sa 'meta::as_list'
/// \ingroup lazy_list
template <typename Sequence>
using as_list = defer<as_list, Sequence>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// reverse
/// \cond
namespace detail
{
template <typename L, typename State = list<>>
struct reverse_ : lazy::fold<L, State, quote<push_front>>
{
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename... Ts,
typename... Us>
struct reverse_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ts...>, list<Us...>>
: reverse_<list<Ts...>, list<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0, Us...>>
{
};
}
/// \endcond
/// Return a new \c meta::list by reversing the elements in the list \p L.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L>
using reverse = _t<detail::reverse_<L>>;
namespace lazy
{
/// \sa 'meta::reverse'
/// \ingroup lazy_transformation
template <typename L>
using reverse = defer<reverse, L>;
} // namespace lazy
/// Logically negate the result of Invocable \p Fn.
/// \ingroup trait
template <META_TYPE_CONSTRAINT(Invocable) Fn>
using not_fn = compose<quote<not_>, Fn>;
namespace lazy
{
/// \sa 'meta::not_fn'
/// \ingroup lazy_trait
template <typename Fn>
using not_fn = defer<not_fn, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// all_of
/// A Boolean integral constant wrapper around \c true if `invoke<Fn, A>::%value` is \c true
/// for all elements \c A in \c meta::list \p L; \c false, otherwise.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Invocable) Fn>
using all_of = empty<find_if<L, not_fn<Fn>>>;
namespace lazy
{
/// \sa 'meta::all_of'
/// \ingroup lazy_query
template <typename L, typename Fn>
using all_of = defer<all_of, L, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// any_of
/// A Boolean integral constant wrapper around \c true if `invoke<Fn, A>::%value` is
/// \c true for any element \c A in \c meta::list \p L; \c false, otherwise.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Invocable) Fn>
using any_of = not_<empty<find_if<L, Fn>>>;
namespace lazy
{
/// \sa 'meta::any_of'
/// \ingroup lazy_query
template <typename L, typename Fn>
using any_of = defer<any_of, L, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// none_of
/// A Boolean integral constant wrapper around \c true if `invoke<Fn, A>::%value` is
/// \c false for all elements \c A in \c meta::list \p L; \c false, otherwise.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Invocable) Fn>
using none_of = empty<find_if<L, Fn>>;
namespace lazy
{
/// \sa 'meta::none_of'
/// \ingroup lazy_query
template <typename L, META_TYPE_CONSTRAINT(Invocable) Fn>
using none_of = defer<none_of, L, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// in
/// A Boolean integral constant wrapper around \c true if there is at least one occurrence
/// of \p T in \p L.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup query
template <META_TYPE_CONSTRAINT(List) L, typename T>
using in = not_<empty<find<L, T>>>;
namespace lazy
{
/// \sa 'meta::in'
/// \ingroup lazy_query
template <typename L, typename T>
using in = defer<in, L, T>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// inherit
/// \cond
namespace detail
{
template <typename L>
struct inherit_
{
};
template <typename... L>
struct inherit_<list<L...>> : L...
{
using type = inherit_;
};
} // namespace detail
/// \endcond
/// A type that inherits from all the types in the list
/// \pre The types in the list must be unique
/// \pre All the types in the list must be non-final class types
/// \ingroup datatype
template <META_TYPE_CONSTRAINT(List) L>
using inherit = meta::_t<detail::inherit_<L>>;
namespace lazy
{
/// \sa 'meta::inherit'
/// \ingroup lazy_datatype
template <typename L>
using inherit = defer<inherit, L>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// unique
/// \cond
namespace detail
{
template <typename Set, typename T>
struct in_
{
};
template <typename... Set, typename T>
struct in_<list<Set...>, T> : std::is_base_of<id<T>, inherit<list<id<Set>...>>>
{
};
template <typename Set, typename T>
struct insert_back_
{
};
template <typename... Set, typename T>
struct insert_back_<list<Set...>, T>
{
using type = if_<in_<list<Set...>, T>, list<Set...>, list<Set..., T>>;
};
} // namespace detail
/// \endcond
/// Return a new \c meta::list where all duplicate elements have been removed.
/// \par Complexity
/// \f$ O(N^2) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L>
using unique = fold<L, list<>, quote_trait<detail::insert_back_>>;
namespace lazy
{
/// \sa 'meta::unique'
/// \ingroup lazy_transformation
template <typename L>
using unique = defer<unique, L>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// partition
/// \cond
namespace detail
{
template <typename Fn>
struct partition_
{
#ifdef META_CONCEPT
template <typename, typename>
#else
template <typename, typename, typename = void>
#endif
struct impl
{
};
template <typename... Yes, typename... No, typename A>
#ifdef META_CONCEPT
requires Integral<invoke<Fn, A>>
struct impl<pair<list<Yes...>, list<No...>>, A>
#else
struct impl<pair<list<Yes...>, list<No...>>, A,
void_<bool_<invoke<Fn, A>::type::value>>>
#endif
{
using type = if_<invoke<Fn, A>, pair<list<Yes..., A>, list<No...>>,
pair<list<Yes...>, list<No..., A>>>;
};
template <typename State, typename A>
using invoke = _t<impl<State, A>>;
};
} // namespace detail
/// \endcond
/// Returns a pair of lists, where the elements of \p L that satisfy the
/// Invocable \p Fn such that `invoke<Fn,A>::%value` is \c true are present in the
/// first list and the rest are in the second.
/// \par Complexity
/// \f$ O(N) \f$.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Invocable) Fn>
using partition = fold<L, pair<list<>, list<>>, detail::partition_<Fn>>;
namespace lazy
{
/// \sa 'meta::partition'
/// \ingroup lazy_transformation
template <typename L, typename Fn>
using partition = defer<partition, L, Fn>;
} // namespace lazy
///////////////////////////////////////////////////////////////////////////////////////////
// sort
/// \cond
namespace detail
{
template <META_TYPE_CONSTRAINT(Invocable) Fn, typename A, typename B, typename... Ts>
using part_ = partition<list<B, Ts...>, bind_back<Fn, A>>;
#ifdef META_CONCEPT
template <List L, Invocable Fn>
#else
template <typename, typename, typename = void>
#endif
struct sort_
{
};
template <typename Fn>
struct sort_<list<>, Fn>
{
using type = list<>;
};
template <typename A, typename Fn>
struct sort_<list<A>, Fn>
{
using type = list<A>;
};
template <typename A, typename B, typename... Ts, typename Fn>
#ifdef META_CONCEPT
requires Trait<sort_<first<part_<Fn, A, B, Ts...>>, Fn>> &&
Trait<sort_<second<part_<Fn, A, B, Ts...>>, Fn>>
struct sort_<list<A, B, Ts...>, Fn>
#else
struct sort_<
list<A, B, Ts...>, Fn,
void_<_t<sort_<first<part_<Fn, A, B, Ts...>>, Fn>>>>
#endif
{
using P = part_<Fn, A, B, Ts...>;
using type = concat<_t<sort_<first<P>, Fn>>, list<A>, _t<sort_<second<P>, Fn>>>;
};
} // namespace detail
/// \endcond
// clang-format off
/// Return a new \c meta::list that is sorted according to Invocable predicate \p Fn.
/// \par Complexity
/// Expected: \f$ O(N log N) \f$
/// Worst case: \f$ O(N^2) \f$.
/// \code
/// using L0 = list<char[5], char[3], char[2], char[6], char[1], char[5], char[10]>;
/// using L1 = meta::sort<L0, lambda<_a, _b, lazy::less<lazy::sizeof_<_a>, lazy::sizeof_<_b>>>>;
/// static_assert(std::is_same<L1, list<char[1], char[2], char[3], char[5], char[5], char[6], char[10]>>::value, "");
/// \endcode
/// \ingroup transformation
// clang-format on
template <META_TYPE_CONSTRAINT(List) L, META_TYPE_CONSTRAINT(Invocable) Fn>
using sort = _t<detail::sort_<L, Fn>>;
namespace lazy
{
/// \sa 'meta::sort'
/// \ingroup lazy_transformation
template <typename L, typename Fn>
using sort = defer<sort, L, Fn>;
} // namespace lazy
////////////////////////////////////////////////////////////////////////////
// lambda_
/// \cond
namespace detail
{
template <typename T, int = 0>
struct protect_;
template <typename, int = 0>
struct vararg_;
template <typename T, int = 0>
struct is_valid_;
// Returns which branch to evaluate
template <typename If, typename... Ts>
#ifdef META_CONCEPT
using lazy_if_ = lazy::_t<defer<_if_, If, protect_<Ts>...>>;
#else
using lazy_if_ = lazy::_t<defer<_if_, list<If, protect_<Ts>...>>>;
#endif
template <typename A, typename T, typename Fn, typename Ts>
struct subst1_
{
using type = list<list<T>>;
};
template <typename T, typename Fn, typename Ts>
struct subst1_<Fn, T, Fn, Ts>
{
using type = list<>;
};
template <typename A, typename T, typename Fn, typename Ts>
struct subst1_<vararg_<A>, T, Fn, Ts>
{
using type = list<Ts>;
};
template <typename As, typename Ts>
using substitutions_ = push_back<
join<transform<
concat<As, repeat_n_c<size<Ts>{} + 2 - size<As>{}, back<As>>>,
concat<Ts, repeat_n_c<2, back<As>>>,
bind_back<quote_trait<subst1_>, back<As>, drop_c<Ts, size<As>{} - 2>>>>,
list<back<As>>>;
#ifdef META_CONCEPT
template <List As, List Ts>
requires (_v<size<Ts>> + 2 >= _v<size<As>>)
using substitutions = substitutions_<As, Ts>;
#else // ^^^ concepts / no concepts vvv
template <typename As, typename Ts>
using substitutions =
#ifdef META_WORKAROUND_MSVC_702792
invoke<if_c<(size<Ts>::value + 2 >= size<As>::value), quote<substitutions_>>, As,
Ts>;
#else // ^^^ workaround ^^^ / vvv no workaround vvv
invoke<if_c<(size<Ts>{} + 2 >= size<As>{}), quote<substitutions_>>, As, Ts>;
#endif // META_WORKAROUND_MSVC_702792
#endif // META_CONCEPT
template <typename T>
struct is_vararg_ : std::false_type
{
};
template <typename T>
struct is_vararg_<vararg_<T>> : std::true_type
{
};
template <META_TYPE_CONSTRAINT(List) Tags>
using is_variadic_ = is_vararg_<at<push_front<Tags, void>, dec<size<Tags>>>>;
template <META_TYPE_CONSTRAINT(List) Tags, bool IsVariadic = is_variadic_<Tags>::value>
struct lambda_;
// Non-variadic lambda implementation
template <typename... As>
struct lambda_<list<As...>, false>
{
private:
static constexpr std::size_t arity = sizeof...(As) - 1;
using Tags = list<As...>; // Includes the lambda body as the last arg!
using Fn = back<Tags>;
template <typename T, META_TYPE_CONSTRAINT(List) Args>
struct impl;
template <typename T, META_TYPE_CONSTRAINT(List) Args>
using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
#ifdef META_CONCEPT
template <typename, List>
#else
template <typename, typename, typename = void>
#endif
struct subst_
{
};
template <template <typename...> class C, typename... Ts, typename Args>
#ifdef META_CONCEPT
requires Valid<C, _t<impl<Ts, Args>>...> struct subst_<defer<C, Ts...>, Args>
#else
struct subst_<defer<C, Ts...>, Args, void_<C<_t<impl<Ts, Args>>...>>>
#endif
{
using type = C<_t<impl<Ts, Args>>...>;
};
template <typename T, template <T...> class C, T... Is, typename Args>
#ifdef META_CONCEPT
requires Valid_I<T, C, Is...> struct subst_<defer_i<T, C, Is...>, Args>
#else
struct subst_<defer_i<T, C, Is...>, Args, void_<C<Is...>>>
#endif
{
using type = C<Is...>;
};
template <typename T, META_TYPE_CONSTRAINT(List) Args>
struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
lazy::at<Args, reverse_find_index<Tags, T>>, id<T>>
{
};
template <typename T, typename Args>
struct impl<protect_<T>, Args>
{
using type = T;
};
template <typename T, typename Args>
struct impl<is_valid_<T>, Args>
{
using type = is_trait<impl<T, Args>>;
};
template <typename If, typename... Ts, typename Args>
struct impl<defer<if_, If, Ts...>, Args> // Short-circuit if_
: impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
{
};
template <typename B, typename... Bs, typename Args>
struct impl<defer<and_, B, Bs...>, Args> // Short-circuit and_
: impl<lazy_impl_<lazy_if_<B, lazy::and_<Bs...>, protect_<std::false_type>>, Args>,
Args>
{
};
template <typename B, typename... Bs, typename Args>
struct impl<defer<or_, B, Bs...>, Args> // Short-circuit or_
: impl<lazy_impl_<lazy_if_<B, protect_<std::true_type>, lazy::or_<Bs...>>, Args>,
Args>
{
};
template <template <typename...> class C, typename... Ts, typename Args>
struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
{
};
template <typename T, template <T...> class C, T... Is, typename Args>
struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
{
};
template <template <typename...> class C, typename... Ts, typename Args>
struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
{
};
template <typename... Ts, typename Args>
struct impl<lambda_<list<Ts...>, false>, Args>
{
using type = compose<uncurry<lambda_<list<As..., Ts...>, false>>,
curry<bind_front<quote<concat>, Args>>>;
};
template <typename... Bs, typename Args>
struct impl<lambda_<list<Bs...>, true>, Args>
{
using type = compose<typename lambda_<list<As..., Bs...>, true>::thunk,
bind_front<quote<concat>, transform<Args, quote<list>>>,
curry<bind_front<quote<substitutions>, list<Bs...>>>>;
};
public:
template <typename... Ts>
#ifdef META_CONCEPT
requires (sizeof...(Ts) == arity) using invoke = _t<impl<Fn, list<Ts..., Fn>>>;
#else
using invoke = _t<if_c<sizeof...(Ts) == arity, impl<Fn, list<Ts..., Fn>>>>;
#endif
};
// Lambda with variadic placeholder (broken out due to less efficient compile-time
// resource usage)
template <typename... As>
struct lambda_<list<As...>, true>
{
private:
template <META_TYPE_CONSTRAINT(List), bool>
friend struct lambda_;
using Tags = list<As...>; // Includes the lambda body as the last arg!
template <typename T, META_TYPE_CONSTRAINT(List) Args>
struct impl;
template <META_TYPE_CONSTRAINT(List) Args>
using eval_impl_ = bind_back<quote_trait<impl>, Args>;
template <typename T, META_TYPE_CONSTRAINT(List) Args>
using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
template <template <typename...> class C, META_TYPE_CONSTRAINT(List) Args,
META_TYPE_CONSTRAINT(List) Ts>
using try_subst_ = apply<quote<C>, join<transform<Ts, eval_impl_<Args>>>>;
#ifdef META_CONCEPT
template <typename, List>
#else
template <typename, typename, typename = void>
#endif
struct subst_
{
};
template <template <typename...> class C, typename... Ts, typename Args>
#ifdef META_CONCEPT
requires True<try_subst_<C, Args, list<Ts...>>> struct subst_<defer<C, Ts...>, Args>
#else
struct subst_<defer<C, Ts...>, Args, void_<try_subst_<C, Args, list<Ts...>>>>
#endif
{
using type = list<try_subst_<C, Args, list<Ts...>>>;
};
template <typename T, template <T...> class C, T... Is, typename Args>
#ifdef META_CONCEPT
requires Valid_I<T, C, Is...> struct subst_<defer_i<T, C, Is...>, Args>
#else
struct subst_<defer_i<T, C, Is...>, Args, void_<C<Is...>>>
#endif
{
using type = list<C<Is...>>;
};
template <typename T, META_TYPE_CONSTRAINT(List) Args>
struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
lazy::at<Args, reverse_find_index<Tags, T>>, id<list<T>>>
{
};
template <typename T, typename Args>
struct impl<protect_<T>, Args>
{
using type = list<T>;
};
template <typename T, typename Args>
struct impl<is_valid_<T>, Args>
{
using type = list<is_trait<impl<T, Args>>>;
};
template <typename If, typename... Ts, typename Args>
struct impl<defer<if_, If, Ts...>, Args> // Short-circuit if_
: impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
{
};
template <typename B, typename... Bs, typename Args>
struct impl<defer<and_, B, Bs...>, Args> // Short-circuit and_
: impl<lazy_impl_<lazy_if_<B, lazy::and_<Bs...>, protect_<std::false_type>>, Args>,
Args>
{
};
template <typename B, typename... Bs, typename Args>
struct impl<defer<or_, B, Bs...>, Args> // Short-circuit or_
: impl<lazy_impl_<lazy_if_<B, protect_<std::true_type>, lazy::or_<Bs...>>, Args>,
Args>
{
};
template <template <typename...> class C, typename... Ts, typename Args>
struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
{
};
template <typename T, template <T...> class C, T... Is, typename Args>
struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
{
};
template <template <typename...> class C, typename... Ts, typename Args>
struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
{
};
template <typename... Bs, bool IsVar, typename Args>
struct impl<lambda_<list<Bs...>, IsVar>, Args>
{
using type =
list<compose<typename lambda_<list<As..., Bs...>, true>::thunk,
bind_front<quote<concat>, Args>,
curry<bind_front<quote<substitutions>, list<Bs...>>>>>;
};
struct thunk
{
template <typename S, typename R = _t<impl<back<Tags>, S>>>
#ifdef META_CONCEPT
requires (_v<size<R>> == 1) using invoke = front<R>;
#else
using invoke = if_c<size<R>{} == 1, front<R>>;
#endif
};
public:
template <typename... Ts>
using invoke = invoke<thunk, substitutions<Tags, list<Ts...>>>;
};
} // namespace detail
/// \endcond
///////////////////////////////////////////////////////////////////////////////////////////
// lambda
/// For creating anonymous Invocables.
/// \code
/// using L = lambda<_a, _b, std::pair<_b, std::pair<_a, _a>>>;
/// using P = invoke<L, int, short>;
/// static_assert(std::is_same<P, std::pair<short, std::pair<int, int>>>::value, "");
/// \endcode
/// \ingroup trait
template <typename... Ts>
#ifdef META_CONCEPT
requires (sizeof...(Ts) > 0) using lambda = detail::lambda_<list<Ts...>>;
#else
using lambda = if_c<(sizeof...(Ts) > 0), detail::lambda_<list<Ts...>>>;
#endif
///////////////////////////////////////////////////////////////////////////////////////////
// is_valid
/// For testing whether a deferred computation will succeed in a \c let or a \c lambda.
/// \ingroup trait
template <typename T>
using is_valid = detail::is_valid_<T>;
///////////////////////////////////////////////////////////////////////////////////////////
// vararg
/// For defining variadic placeholders.
template <typename T>
using vararg = detail::vararg_<T>;
///////////////////////////////////////////////////////////////////////////////////////////
// protect
/// For preventing the evaluation of a nested `defer`ed computation in a \c let or
/// \c lambda expression.
template <typename T>
using protect = detail::protect_<T>;
///////////////////////////////////////////////////////////////////////////////////////////
// var
/// For use when defining local variables in \c meta::let expressions
/// \sa `meta::let`
template <typename Tag, typename Value>
struct var;
/// \cond
namespace detail
{
template <typename...>
struct let_
{
};
template <typename Fn>
struct let_<Fn>
{
using type = lazy::invoke<lambda<Fn>>;
};
template <typename Tag, typename Value, typename... Rest>
struct let_<var<Tag, Value>, Rest...>
{
using type = lazy::invoke<lambda<Tag, _t<let_<Rest...>>>, Value>;
};
} // namespace detail
/// \endcond
/// A lexically scoped expression with local variables.
///
/// \code
/// template <typename T, typename L>
/// using find_index_ = let<
/// var<_a, L>,
/// var<_b, lazy::find<_a, T>>,
/// lazy::if_<
/// std::is_same<_b, list<>>,
/// meta::npos,
/// lazy::minus<lazy::size<_a>, lazy::size<_b>>>>;
/// static_assert(find_index_<int, list<short, int, float>>{} == 1, "");
/// static_assert(find_index_<double, list<short, int, float>>{} == meta::npos{}, "");
/// \endcode
/// \ingroup trait
template <typename... As>
using let = _t<_t<detail::let_<As...>>>;
namespace lazy
{
/// \sa `meta::let`
/// \ingroup lazy_trait
template <typename... As>
using let = defer<let, As...>;
} // namespace lazy
// Some argument placeholders for use in \c lambda expressions.
/// \ingroup trait
inline namespace placeholders
{
// regular placeholders:
struct _a;
struct _b;
struct _c;
struct _d;
struct _e;
struct _f;
struct _g;
struct _h;
struct _i;
// variadic placeholders:
using _args = vararg<void>;
using _args_a = vararg<_a>;
using _args_b = vararg<_b>;
using _args_c = vararg<_c>;
} // namespace placeholders
///////////////////////////////////////////////////////////////////////////////////////////
// cartesian_product
/// \cond
namespace detail
{
template <typename M2, typename M>
struct cartesian_product_fn
{
template <typename X>
struct lambda0
{
template <typename Xs>
using lambda1 = list<push_front<Xs, X>>;
using type = join<transform<M2, quote<lambda1>>>;
};
using type = join<transform<M, quote_trait<lambda0>>>;
};
} // namespace detail
/// \endcond
/// Given a list of lists \p ListOfLists, return a new list of lists that is the Cartesian
/// Product. Like the `sequence` function from the Haskell Prelude.
/// \par Complexity
/// \f$ O(N \times M) \f$, where \f$ N \f$ is the size of the outer list, and
/// \f$ M \f$ is the size of the inner lists.
/// \ingroup transformation
template <META_TYPE_CONSTRAINT(List) ListOfLists>
using cartesian_product =
reverse_fold<ListOfLists, list<list<>>, quote_trait<detail::cartesian_product_fn>>;
namespace lazy
{
/// \sa 'meta::cartesian_product'
/// \ingroup lazy_transformation
template <typename ListOfLists>
using cartesian_product = defer<cartesian_product, ListOfLists>;
} // namespace lazy
/// \cond
///////////////////////////////////////////////////////////////////////////////////////////
// add_const_if
namespace detail
{
template <bool>
struct add_const_if
{
template <typename T>
using invoke = T const;
};
template <>
struct add_const_if<false>
{
template <typename T>
using invoke = T;
};
} // namespace detail
template <bool If>
using add_const_if_c = detail::add_const_if<If>;
template <META_TYPE_CONSTRAINT(Integral) If>
using add_const_if = add_const_if_c<If::type::value>;
/// \endcond
/// \cond
///////////////////////////////////////////////////////////////////////////////////////////
// const_if
template <bool If, typename T>
using const_if_c = invoke<add_const_if_c<If>, T>;
template <typename If, typename T>
using const_if = invoke<add_const_if<If>, T>;
/// \endcond
/// \cond
namespace detail
{
template <typename State, typename Ch>
using atoi_ = if_c<(Ch::value >= '0' && Ch::value <= '9'),
std::integral_constant<typename State::value_type,
State::value * 10 + (Ch::value - '0')>>;
}
/// \endcond
inline namespace literals
{
/// A user-defined literal that generates objects of type \c meta::size_t.
/// \ingroup integral
template <char... Chs>
constexpr fold<list<char_<Chs>...>, meta::size_t<0>, quote<detail::atoi_>>
operator"" _z()
{
return {};
}
} // namespace literals
} // namespace meta
/// \cond
#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 1101
_LIBCPP_BEGIN_NAMESPACE_STD
template <class>
class _LIBCPP_TYPE_VIS_ONLY allocator;
template <class, class>
struct _LIBCPP_TYPE_VIS_ONLY pair;
template <class>
struct _LIBCPP_TYPE_VIS_ONLY hash;
template <class>
struct _LIBCPP_TYPE_VIS_ONLY less;
template <class>
struct _LIBCPP_TYPE_VIS_ONLY equal_to;
template <class>
struct _LIBCPP_TYPE_VIS_ONLY char_traits;
template <class, class>
class _LIBCPP_TYPE_VIS_ONLY list;
template <class, class>
class _LIBCPP_TYPE_VIS_ONLY forward_list;
template <class, class>
class _LIBCPP_TYPE_VIS_ONLY vector;
template <class, class>
class _LIBCPP_TYPE_VIS_ONLY deque;
template <class, class, class>
class _LIBCPP_TYPE_VIS_ONLY basic_string;
template <class, class, class, class>
class _LIBCPP_TYPE_VIS_ONLY map;
template <class, class, class, class>
class _LIBCPP_TYPE_VIS_ONLY multimap;
template <class, class, class>
class _LIBCPP_TYPE_VIS_ONLY set;
template <class, class, class>
class _LIBCPP_TYPE_VIS_ONLY multiset;
template <class, class, class, class, class>
class _LIBCPP_TYPE_VIS_ONLY unordered_map;
template <class, class, class, class, class>
class _LIBCPP_TYPE_VIS_ONLY unordered_multimap;
template <class, class, class, class>
class _LIBCPP_TYPE_VIS_ONLY unordered_set;
template <class, class, class, class>
class _LIBCPP_TYPE_VIS_ONLY unordered_multiset;
template <class, class>
class _LIBCPP_TYPE_VIS_ONLY queue;
template <class, class, class>
class _LIBCPP_TYPE_VIS_ONLY priority_queue;
template <class, class>
class _LIBCPP_TYPE_VIS_ONLY stack;
_LIBCPP_END_NAMESPACE_STD
namespace meta
{
namespace detail
{
template <typename T, typename A = std::allocator<T>>
using std_list = std::list<T, A>;
template <typename T, typename A = std::allocator<T>>
using std_forward_list = std::forward_list<T, A>;
template <typename T, typename A = std::allocator<T>>
using std_vector = std::vector<T, A>;
template <typename T, typename A = std::allocator<T>>
using std_deque = std::deque<T, A>;
template <typename T, typename C = std::char_traits<T>, typename A = std::allocator<T>>
using std_basic_string = std::basic_string<T, C, A>;
template <typename K, typename V, typename C = std::less<K>,
typename A = std::allocator<std::pair<K const, V>>>
using std_map = std::map<K, V, C, A>;
template <typename K, typename V, typename C = std::less<K>,
typename A = std::allocator<std::pair<K const, V>>>
using std_multimap = std::multimap<K, V, C, A>;
template <typename K, typename C = std::less<K>, typename A = std::allocator<K>>
using std_set = std::set<K, C, A>;
template <typename K, typename C = std::less<K>, typename A = std::allocator<K>>
using std_multiset = std::multiset<K, C, A>;
template <typename K, typename V, typename H = std::hash<K>,
typename C = std::equal_to<K>,
typename A = std::allocator<std::pair<K const, V>>>
using std_unordered_map = std::unordered_map<K, V, H, C, A>;
template <typename K, typename V, typename H = std::hash<K>,
typename C = std::equal_to<K>,
typename A = std::allocator<std::pair<K const, V>>>
using std_unordered_multimap = std::unordered_multimap<K, V, H, C, A>;
template <typename K, typename H = std::hash<K>, typename C = std::equal_to<K>,
typename A = std::allocator<K>>
using std_unordered_set = std::unordered_set<K, H, C, A>;
template <typename K, typename H = std::hash<K>, typename C = std::equal_to<K>,
typename A = std::allocator<K>>
using std_unordered_multiset = std::unordered_multiset<K, H, C, A>;
template <typename T, typename C = std_deque<T>>
using std_queue = std::queue<T, C>;
template <typename T, typename C = std_vector<T>,
class D = std::less<typename C::value_type>>
using std_priority_queue = std::priority_queue<T, C, D>;
template <typename T, typename C = std_deque<T>>
using std_stack = std::stack<T, C>;
} // namespace detail
template <>
struct quote<::std::list> : quote<detail::std_list>
{
};
template <>
struct quote<::std::deque> : quote<detail::std_deque>
{
};
template <>
struct quote<::std::forward_list> : quote<detail::std_forward_list>
{
};
template <>
struct quote<::std::vector> : quote<detail::std_vector>
{
};
template <>
struct quote<::std::basic_string> : quote<detail::std_basic_string>
{
};
template <>
struct quote<::std::map> : quote<detail::std_map>
{
};
template <>
struct quote<::std::multimap> : quote<detail::std_multimap>
{
};
template <>
struct quote<::std::set> : quote<detail::std_set>
{
};
template <>
struct quote<::std::multiset> : quote<detail::std_multiset>
{
};
template <>
struct quote<::std::unordered_map> : quote<detail::std_unordered_map>
{
};
template <>
struct quote<::std::unordered_multimap> : quote<detail::std_unordered_multimap>
{
};
template <>
struct quote<::std::unordered_set> : quote<detail::std_unordered_set>
{
};
template <>
struct quote<::std::unordered_multiset> : quote<detail::std_unordered_multiset>
{
};
template <>
struct quote<::std::queue> : quote<detail::std_queue>
{
};
template <>
struct quote<::std::priority_queue> : quote<detail::std_priority_queue>
{
};
template <>
struct quote<::std::stack> : quote<detail::std_stack>
{
};
} // namespace meta
#endif
/// \endcond
#ifdef __clang__
#pragma GCC diagnostic pop
#endif
#endif
================================================
FILE: include/meta/meta_fwd.hpp
================================================
/// \file meta_fwd.hpp Forward declarations
//
// Meta library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/meta
//
#ifndef META_FWD_HPP
#define META_FWD_HPP
#include <type_traits>
#include <utility>
#ifdef __clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-variable-declarations"
#endif
#define META_CXX_STD_14 201402L
#define META_CXX_STD_17 201703L
#if defined(_MSVC_LANG) && _MSVC_LANG > __cplusplus // Older clangs define _MSVC_LANG < __cplusplus
#define META_CXX_VER _MSVC_LANG
#else
#define META_CXX_VER __cplusplus
#endif
#if defined(__apple_build_version__) || defined(__clang__)
#if defined(__apple_build_version__) || (defined(__clang__) && __clang_major__ < 6)
#define META_WORKAROUND_LLVM_28385 // https://llvm.org/bugs/show_bug.cgi?id=28385
#endif
#elif defined(_MSC_VER)
#define META_HAS_MAKE_INTEGER_SEQ 1
#if _MSC_VER < 1921
#define META_WORKAROUND_MSVC_756112 // fold expression + alias templates in template argument (Fixed in next VS2019 toolset update)
#if _MSC_VER < 1920
#define META_WORKAROUND_MSVC_702792 // Fixed in VS2019 Preview 2
#define META_WORKAROUND_MSVC_703656 // Fixed in VS2019 Preview 2
#endif // _MSC_VER < 1920
#endif // _MSC_VER < 1921
#elif defined(__GNUC__)
#define META_WORKAROUND_GCC_86356 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86356
#if __GNUC__ >= 8
#define META_HAS_INTEGER_PACK 1
#else
#define META_WORKAROUND_GCC_UNKNOWN1 // Older GCCs don't like fold + debug + -march=native
#endif
#if __GNUC__ == 5 && __GNUC_MINOR__ == 1
#define META_WORKAROUND_GCC_66405 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66405
#endif
#if __GNUC__ < 5
#define META_WORKAROUND_CWG_1558 // https://wg21.link/cwg1558
#endif
#endif
#ifndef META_CXX_VARIABLE_TEMPLATES
#ifdef __cpp_variable_templates
#define META_CXX_VARIABLE_TEMPLATES __cpp_variable_templates
#else
#define META_CXX_VARIABLE_TEMPLATES (META_CXX_VER >= META_CXX_STD_14)
#endif
#endif
#ifndef META_CXX_INLINE_VARIABLES
#ifdef __cpp_inline_variables
#define META_CXX_INLINE_VARIABLES __cpp_inline_variables
#else
#define META_CXX_INLINE_VARIABLES (META_CXX_VER >= META_CXX_STD_17)
#endif
#endif
#ifndef META_INLINE_VAR
#if META_CXX_INLINE_VARIABLES
#define META_INLINE_VAR inline
#else
#define META_INLINE_VAR
#endif
#endif
#ifndef META_CXX_INTEGER_SEQUENCE
#ifdef __cpp_lib_integer_sequence
#define META_CXX_INTEGER_SEQUENCE __cpp_lib_integer_sequence
#else
#define META_CXX_INTEGER_SEQUENCE (META_CXX_VER >= META_CXX_STD_14)
#endif
#endif
#ifndef META_HAS_MAKE_INTEGER_SEQ
#ifdef __has_builtin
#if __has_builtin(__make_integer_seq)
#define META_HAS_MAKE_INTEGER_SEQ 1
#endif
#endif
#endif
#ifndef META_HAS_MAKE_INTEGER_SEQ
#define META_HAS_MAKE_INTEGER_SEQ 0
#endif
#ifndef META_HAS_INTEGER_PACK
#define META_HAS_INTEGER_PACK 0
#endif
#ifndef META_HAS_TYPE_PACK_ELEMENT
#ifdef __has_builtin
#if __has_builtin(__type_pack_element)
#define META_HAS_TYPE_PACK_ELEMENT 1
#endif
#endif
#endif
#ifndef META_HAS_TYPE_PACK_ELEMENT
#define META_HAS_TYPE_PACK_ELEMENT 0
#endif
#if !defined(META_DEPRECATED) && !defined(META_DISABLE_DEPRECATED_WARNINGS)
#if defined(__cpp_attribute_deprecated) || META_CXX_VER >= META_CXX_STD_14
#define META_DEPRECATED(...) [[deprecated(__VA_ARGS__)]]
#elif defined(__clang__) || defined(__GNUC__)
#define META_DEPRECATED(...) __attribute__((deprecated(__VA_ARGS__)))
#endif
#endif
#ifndef META_DEPRECATED
#define META_DEPRECATED(...)
#endif
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64970
#if(defined(__GNUC__) && __GNUC__ >= 5) || defined(__clang__)
#define META_WORKAROUND_GCC_64970
#endif
#ifndef META_CXX_FOLD_EXPRESSIONS
#ifdef __cpp_fold_expressions
#define META_CXX_FOLD_EXPRESSIONS __cpp_fold_expressions
#else
#define META_CXX_FOLD_EXPRESSIONS (META_CXX_VER >= META_CXX_STD_17)
#endif
#endif
#if META_CXX_FOLD_EXPRESSIONS
#if !META_CXX_VARIABLE_TEMPLATES
#error Fold expressions, but no variable templates?
#endif
#endif
#if defined(__cpp_concepts) && __cpp_concepts > 0
#if !META_CXX_VARIABLE_TEMPLATES
#error Concepts, but no variable templates?
#endif
#if __cpp_concepts <= 201507L
#define META_CONCEPT concept bool
// TS concepts subsumption barrier for atomic expressions
#define META_CONCEPT_BARRIER(...) ::meta::detail::barrier<__VA_ARGS__>
#else
#define META_CONCEPT concept
#define META_CONCEPT_BARRIER(...) __VA_ARGS__
#if __cpp_concepts >= 201811L
#define META_HAS_P1084
#endif
#endif
#define META_TYPE_CONSTRAINT(...) __VA_ARGS__
#else
#define META_TYPE_CONSTRAINT(...) typename
#endif
namespace meta
{
#if META_CXX_INTEGER_SEQUENCE
using std::integer_sequence;
#else
template <typename T, T...>
struct integer_sequence;
#endif
template <typename... Ts>
struct list;
template <typename T>
struct id;
template <template <typename...> class>
struct quote;
template <typename T, template <T...> class F>
struct quote_i;
template <template <typename...> class C, typename... Ts>
struct defer;
template <typename T, template <T...> class C, T... Is>
struct defer_i;
#if META_CXX_VARIABLE_TEMPLATES || defined(META_DOXYGEN_INVOKED)
/// is_v
/// Test whether a type \p T is an instantiation of class
/// template \p C.
/// \ingroup trait
template <typename, template <typename...> class>
META_INLINE_VAR constexpr bool is_v = false;
template <typename... Ts, template <typename...> class C>
META_INLINE_VAR constexpr bool is_v<C<Ts...>, C> = true;
#endif
#ifdef META_CONCEPT
namespace detail
{
template <bool B>
META_INLINE_VAR constexpr bool barrier = B;
template <auto> struct require_constant; // not defined
}
template <typename...>
META_CONCEPT True = META_CONCEPT_BARRIER(true);
template <typename T, typename U>
META_CONCEPT Same =
#if defined(__clang__)
META_CONCEPT_BARRIER(__is_same(T, U));
#elif defined(__GNUC__) && __GNUC__ >= 6
META_CONCEPT_BARRIER(__is_same_as(T, U));
#else
META_CONCEPT_BARRIER(std::is_same_v<T, U>);
#endif
template <template <typename...> class C, typename... Ts>
META_CONCEPT Valid = requires
{
typename C<Ts...>;
};
template <typename T, template <T...> class C, T... Is>
META_CONCEPT Valid_I = requires
{
typename C<Is...>;
};
template <typename T>
META_CONCEPT Trait = requires
{
typename T::type;
};
template <typename T>
META_CONCEPT Invocable = requires
{
typename quote<T::template invoke>;
};
template <typename T>
META_CONCEPT List = is_v<T, list>;
// clang-format off
template <typename T>
META_CONCEPT Integral = requires
{
typename T::type;
typename T::value_type;
typename T::type::value_type;
}
&& Same<typename T::value_type, typename T::type::value_type>
&& std::is_integral_v<typename T::value_type>
&& requires
{
#ifdef META_HAS_P1084
{ T::value } -> Same<const typename T::value_type&>;
#else
T::value;
requires Same<decltype(T::value), const typename T::value_type>;
#endif
typename detail::require_constant<T::value>;
#ifdef META_HAS_P1084
{ T::type::value } -> Same<const typename T::value_type&>;
#else
T::type::value;
requires Same<decltype(T::type::value), const typename T::value_type>;
#endif
typename detail::require_constant<T::type::value>;
requires T::value == T::type::value;
#ifdef META_HAS_P1084
{ T{}() } -> Same<typename T::value_type>;
#else
T{}();
requires Same<decltype(T{}()), typename T::value_type>;
#endif
typename detail::require_constant<T{}()>;
requires T{}() == T::value;
requires std::is_convertible_v<T, typename T::value_type>;
};
// clang-format on
#endif // META_CONCEPT
namespace extension
{
template <META_TYPE_CONSTRAINT(Invocable) F, typename L>
struct apply;
}
} // namespace meta
#ifdef __clang__
#pragma GCC diagnostic pop
#endif
#endif
================================================
FILE: include/stl2/algorithm.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
// Copyright Eric Niebler 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_ALGORITHM_HPP
#define STL2_ALGORITHM_HPP
#include <stl2/detail/algorithm/results.hpp>
#include <stl2/detail/algorithm/adjacent_find.hpp>
#include <stl2/detail/algorithm/all_of.hpp>
#include <stl2/detail/algorithm/any_of.hpp>
#include <stl2/detail/algorithm/binary_search.hpp>
#include <stl2/detail/algorithm/copy.hpp>
#include <stl2/detail/algorithm/copy_backward.hpp>
#include <stl2/detail/algorithm/copy_if.hpp>
#include <stl2/detail/algorithm/copy_n.hpp>
#include <stl2/detail/algorithm/count.hpp>
#include <stl2/detail/algorithm/count_if.hpp>
#include <stl2/detail/algorithm/equal.hpp>
#include <stl2/detail/algorithm/equal_range.hpp>
#include <stl2/detail/algorithm/fill.hpp>
#include <stl2/detail/algorithm/fill_n.hpp>
#include <stl2/detail/algorithm/find.hpp>
#include <stl2/detail/algorithm/find_end.hpp>
#include <stl2/detail/algorithm/find_first_of.hpp>
#include <stl2/detail/algorithm/find_if.hpp>
#include <stl2/detail/algorithm/find_if_not.hpp>
#include <stl2/detail/algorithm/for_each.hpp>
#include <stl2/detail/algorithm/generate.hpp>
#include <stl2/detail/algorithm/generate_n.hpp>
#include <stl2/detail/algorithm/includes.hpp>
#include <stl2/detail/algorithm/inplace_merge.hpp>
#include <stl2/detail/algorithm/is_heap.hpp>
#include <stl2/detail/algorithm/is_heap_until.hpp>
#include <stl2/detail/algorithm/is_partitioned.hpp>
#include <stl2/detail/algorithm/is_permutation.hpp>
#include <stl2/detail/algorithm/is_sorted.hpp>
#include <stl2/detail/algorithm/is_sorted_until.hpp>
#include <stl2/detail/algorithm/lexicographical_compare.hpp>
#include <stl2/detail/algorithm/lower_bound.hpp>
#include <stl2/detail/algorithm/make_heap.hpp>
#include <stl2/detail/algorithm/max.hpp>
#include <stl2/detail/algorithm/max_element.hpp>
#include <stl2/detail/algorithm/merge.hpp>
#include <stl2/detail/algorithm/min.hpp>
#include <stl2/detail/algorithm/min_element.hpp>
#include <stl2/detail/algorithm/minmax.hpp>
#include <stl2/detail/algorithm/minmax_element.hpp>
#include <stl2/detail/algorithm/mismatch.hpp>
#include <stl2/detail/algorithm/move.hpp>
#include <stl2/detail/algorithm/move_backward.hpp>
#include <stl2/detail/algorithm/next_permutation.hpp>
#include <stl2/detail/algorithm/none_of.hpp>
#include <stl2/detail/algorithm/nth_element.hpp>
#include <stl2/detail/algorithm/partial_sort.hpp>
#include <stl2/detail/algorithm/partial_sort_copy.hpp>
#include <stl2/detail/algorithm/partition.hpp>
#include <stl2/detail/algorithm/partition_copy.hpp>
#include <stl2/detail/algorithm/partition_point.hpp>
#include <stl2/detail/algorithm/pop_heap.hpp>
#include <stl2/detail/algorithm/prev_permutation.hpp>
#include <stl2/detail/algorithm/push_heap.hpp>
#include <stl2/detail/algorithm/remove.hpp>
#include <stl2/detail/algorithm/remove_copy.hpp>
#include <stl2/detail/algorithm/remove_copy_if.hpp>
#include <stl2/detail/algorithm/remove_if.hpp>
#include <stl2/detail/algorithm/replace.hpp>
#include <stl2/detail/algorithm/replace_copy.hpp>
#include <stl2/detail/algorithm/replace_copy_if.hpp>
#include <stl2/detail/algorithm/replace_if.hpp>
#include <stl2/detail/algorithm/reverse.hpp>
#include <stl2/detail/algorithm/reverse_copy.hpp>
#include <stl2/detail/algorithm/rotate.hpp>
#include <stl2/detail/algorithm/rotate_copy.hpp>
#include <stl2/detail/algorithm/search.hpp>
#include <stl2/detail/algorithm/search_n.hpp>
#include <stl2/detail/algorithm/set_difference.hpp>
#include <stl2/detail/algorithm/set_intersection.hpp>
#include <stl2/detail/algorithm/set_symmetric_difference.hpp>
#include <stl2/detail/algorithm/set_union.hpp>
#include <stl2/detail/algorithm/shuffle.hpp>
#include <stl2/detail/algorithm/sort.hpp>
#include <stl2/detail/algorithm/sort_heap.hpp>
#include <stl2/detail/algorithm/stable_partition.hpp>
#include <stl2/detail/algorithm/stable_sort.hpp>
#include <stl2/detail/algorithm/swap_ranges.hpp>
#include <stl2/detail/algorithm/transform.hpp>
#include <stl2/detail/algorithm/unique.hpp>
#include <stl2/detail/algorithm/unique_copy.hpp>
#include <stl2/detail/algorithm/upper_bound.hpp>
#endif
================================================
FILE: include/stl2/concepts.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_CONCEPTS_HPP
#define STL2_CONCEPTS_HPP
#include <stl2/detail/swap.hpp>
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/concepts/compare.hpp>
#include <stl2/detail/concepts/core.hpp>
#include <stl2/detail/concepts/function.hpp>
#include <stl2/detail/concepts/fundamental.hpp>
#include <stl2/detail/concepts/object.hpp>
#include <stl2/detail/concepts/urng.hpp>
#include <stl2/detail/iostream/concepts.hpp>
#include <stl2/detail/iterator/concepts.hpp>
#include <stl2/detail/range/concepts.hpp>
#endif
================================================
FILE: include/stl2/detail/algorithm/adjacent_find.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Eric Niebler 2014
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_ADJACENT_FIND_HPP
#define STL2_DETAIL_ALGORITHM_ADJACENT_FIND_HPP
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/concepts.hpp>
#include <stl2/detail/range/dangling.hpp>
///////////////////////////////////////////////////////////////////////////
// adjacent_find [alg.adjacent.find]
//
STL2_OPEN_NAMESPACE {
struct __adjacent_find_fn : private __niebloid {
template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
indirect_relation<projected<I, Proj>> Pred = equal_to>
constexpr I
operator()(I first, S last, Pred pred = {}, Proj proj = {}) const {
if (first == last) {
return first;
}
auto next = first;
for (; ++next != last; first = next) {
if (__stl2::invoke(pred,
__stl2::invoke(proj, *first),
__stl2::invoke(proj, *next))) {
return first;
}
}
return next;
}
template<forward_range R, class Proj = identity,
indirect_relation<projected<iterator_t<R>, Proj>> Pred = equal_to>
constexpr safe_iterator_t<R>
operator()(R&& r, Pred pred = {}, Proj proj = {}) const {
return (*this)(begin(r), end(r), __stl2::ref(pred),
__stl2::ref(proj));
}
};
inline constexpr __adjacent_find_fn adjacent_find{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/all_of.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Algorithm adapted (stolen) from Range v3 library
//
// Copyright Andrew Sutton 2014
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_ALL_OF_HPP
#define STL2_DETAIL_ALGORITHM_ALL_OF_HPP
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/concepts.hpp>
////////////////////////////////////////////////////////////////////////////////
// all_of [alg.all_of]
//
STL2_OPEN_NAMESPACE {
struct __all_of_fn : private __niebloid {
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr bool operator()(I first, S last, Pred pred, Proj proj = {}) const {
for (; first != last; ++first) {
if (!bool(__stl2::invoke(pred, __stl2::invoke(proj, *first)))) {
return false;
}
}
return true;
}
template<input_range R, class Proj = identity,
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr bool operator()(R&& rng, Pred pred, Proj proj = {}) const {
return (*this)(begin(rng), end(rng), __stl2::ref(pred), __stl2::ref(proj));
}
};
inline constexpr __all_of_fn all_of{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/any_of.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Andrew Sutton 2014
// Copyright Gonzalo Brito Gadeschi 2014
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_ANY_OF_HPP
#define STL2_DETAIL_ALGORITHM_ANY_OF_HPP
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/concepts.hpp>
////////////////////////////////////////////////////////////////////////////////
// any_of [alg.any_of]
//
STL2_OPEN_NAMESPACE {
struct __any_of_fn : private __niebloid {
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr bool operator()(I first, S last, Pred pred, Proj proj = {}) const {
for (; first != last; ++first) {
if (__stl2::invoke(pred, __stl2::invoke(proj, *first))) {
return true;
}
}
return false;
}
template<input_range R, class Proj = identity,
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr bool operator()(R&& rng, Pred pred, Proj proj = {}) const {
return (*this)(begin(rng), end(rng), __stl2::ref(pred), __stl2::ref(proj));
}
};
inline constexpr __any_of_fn any_of{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/binary_search.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_BINARY_SEARCH_HPP
#define STL2_DETAIL_ALGORITHM_BINARY_SEARCH_HPP
#include <stl2/detail/algorithm/lower_bound.hpp>
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/concepts.hpp>
///////////////////////////////////////////////////////////////////////////
// binary_search [binary.search]
//
STL2_OPEN_NAMESPACE {
struct __binary_search_fn : private __niebloid {
template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = less>
constexpr bool operator()(I first, S last, const T& value,
Comp comp = {}, Proj proj = {}) const
{
auto result = lower_bound(std::move(first), last, value,
__stl2::ref(comp), __stl2::ref(proj));
return bool(result != last) &&
!bool(__stl2::invoke(comp, value, __stl2::invoke(proj, *result)));
}
template<forward_range R, class T, class Proj = identity,
indirect_strict_weak_order<const T*,
projected<iterator_t<R>, Proj>> Comp = less>
constexpr bool operator()(R&& r, const T& value, Comp comp = {},
Proj proj = {}) const
{
return (*this)(begin(r), end(r), value, static_cast<Comp&&>(comp),
static_cast<Proj&&>(proj));
}
};
inline constexpr __binary_search_fn binary_search{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/copy.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_COPY_HPP
#define STL2_DETAIL_ALGORITHM_COPY_HPP
#include <stl2/detail/algorithm/results.hpp>
#include <stl2/detail/range/concepts.hpp>
#include <stl2/detail/range/dangling.hpp>
///////////////////////////////////////////////////////////////////////////
// copy [alg.copy]
//
STL2_OPEN_NAMESPACE {
template<class I, class O>
using copy_result = __in_out_result<I, O>;
struct __copy_fn : private __niebloid {
template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
requires indirectly_copyable<I, O>
constexpr copy_result<I, O>
operator()(I first, S last, O result) const {
for (; first != last; (void) ++first, (void) ++result) {
*result = *first;
}
return {std::move(first), std::move(result)};
}
template<input_range R, weakly_incrementable O>
requires indirectly_copyable<iterator_t<R>, O>
constexpr copy_result<safe_iterator_t<R>, O>
operator()(R&& r, O result) const {
return (*this)(begin(r), end(r), std::move(result));
}
};
inline constexpr __copy_fn copy{};
namespace ext {
struct __copy_fn : private __niebloid {
template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
requires indirectly_copyable<I, O>
constexpr copy_result<I, O>
operator()(I first, S last, O result) const {
for (; first != last; (void) ++first, (void) ++result) {
*result = *first;
}
return {std::move(first), std::move(result)};
}
template<input_range R, class O>
requires (!range<O> && weakly_incrementable<__f<O>>
&& indirectly_copyable<iterator_t<R>, __f<O>>)
constexpr copy_result<safe_iterator_t<R>, __f<O>>
operator()(R&& r, O&& result_) const {
auto result = std::forward<O>(result_);
return (*this)(begin(r), end(r), std::move(result));
}
// Extension
template<input_iterator I1, sentinel_for<I1> S1, input_or_output_iterator I2, sentinel_for<I2> S2>
requires indirectly_copyable<I1, I2>
constexpr copy_result<I1, I2>
operator()(I1 first, S1 last, I2 rfirst, S2 rlast) const {
for (; first != last && rfirst != rlast; (void) ++first, (void)++rfirst) {
*rfirst = *first;
}
return {std::move(first), std::move(rfirst)};
}
// Extension
template<input_range R1, range R2>
requires indirectly_copyable<iterator_t<R1>, iterator_t<R2>>
constexpr copy_result<safe_iterator_t<R1>, safe_iterator_t<R2>>
operator()(R1&& r1, R2&& r2) const {
return (*this)(begin(r1), end(r1), begin(r2), end(r2));
}
};
inline constexpr __copy_fn copy{};
} // namespace ext
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/copy_backward.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Eric Niebler 2013-2014
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_COPY_BACKWARD_HPP
#define STL2_DETAIL_ALGORITHM_COPY_BACKWARD_HPP
#include <stl2/detail/algorithm/results.hpp>
#include <stl2/detail/range/concepts.hpp>
#include <stl2/detail/range/dangling.hpp>
///////////////////////////////////////////////////////////////////////////
// copy_backward [alg.copy]
//
STL2_OPEN_NAMESPACE {
template<class I, class O>
using copy_backward_result = __in_out_result<I, O>;
struct __copy_backward_fn : private __niebloid {
template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
requires indirectly_copyable<I1, I2>
constexpr copy_backward_result<I1, I2>
operator()(I1 first, S1 sent, I2 out) const {
auto last = next(first, static_cast<S1&&>(sent));
auto i = last;
while (i != first) {
*--out = *--i;
}
return {static_cast<I1&&>(last), static_cast<I2&&>(out)};
}
template<bidirectional_range R, bidirectional_iterator I>
constexpr copy_backward_result<safe_iterator_t<R>, I>
operator()(R&& r, I result) const {
return (*this)(begin(r), end(r), static_cast<I&&>(result));
}
};
inline constexpr __copy_backward_fn copy_backward{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/copy_if.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Eric Niebler 2014
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_COPY_IF_HPP
#define STL2_DETAIL_ALGORITHM_COPY_IF_HPP
#include <stl2/detail/algorithm/results.hpp>
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/concepts.hpp>
#include <stl2/detail/range/dangling.hpp>
///////////////////////////////////////////////////////////////////////////
// copy_if [alg.copy]
//
STL2_OPEN_NAMESPACE {
template<class I, class O>
using copy_if_result = __in_out_result<I, O>;
struct __copy_if_fn : private __niebloid {
template<input_iterator I, sentinel_for<I> S, weakly_incrementable O,
class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
requires indirectly_copyable<I, O>
constexpr copy_if_result<I, O>
operator()(I first, S last, O result, Pred pred, Proj proj = {}) const {
for (; first != last; ++first) {
iter_reference_t<I>&& v = *first;
if (__stl2::invoke(pred, __stl2::invoke(proj, v))) {
*result = static_cast<iter_reference_t<I>&&>(v);
++result;
}
}
return {static_cast<I&&>(first), static_cast<O&&>(result)};
}
template<input_range R, weakly_incrementable O, class Proj = identity,
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
requires indirectly_copyable<iterator_t<R>, O>
constexpr copy_if_result<safe_iterator_t<R>, O>
operator()(R&& r, O result, Pred pred, Proj proj = {}) const {
return (*this)(begin(r), end(r), static_cast<O&&>(result),
static_cast<Pred&&>(pred), static_cast<Proj&&>(proj));
}
};
inline constexpr __copy_if_fn copy_if{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/copy_n.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Eric Niebler 2014
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_COPY_N_HPP
#define STL2_DETAIL_ALGORITHM_COPY_N_HPP
#include <stl2/detail/algorithm/results.hpp>
#include <stl2/detail/iterator/concepts.hpp>
#include <stl2/detail/iterator/counted_iterator.hpp>
///////////////////////////////////////////////////////////////////////////
// copy_n [alg.copy]
//
STL2_OPEN_NAMESPACE {
template<class I, class O>
using copy_n_result = __in_out_result<I, O>;
struct __copy_n_fn : private __niebloid {
template<input_iterator I, weakly_incrementable O>
requires indirectly_copyable<I, O>
constexpr copy_n_result<I, O>
operator()(I first_, iter_difference_t<I> n, O result) const {
if (n < 0) n = 0;
auto norig = n;
auto first = ext::uncounted(first_);
for(; n > 0; (void) ++first, (void) ++result, --n) {
*result = *first;
}
return {
ext::recounted(first_, first, norig),
static_cast<O&&>(result)
};
}
};
inline constexpr __copy_n_fn copy_n{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/count.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_COUNT_HPP
#define STL2_DETAIL_ALGORITHM_COUNT_HPP
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/concepts.hpp>
///////////////////////////////////////////////////////////////////////////
// count [alg.count]
//
STL2_OPEN_NAMESPACE {
struct __count_fn : private __niebloid {
template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
requires indirect_relation<equal_to, projected<I, Proj>, const T*>
constexpr iter_difference_t<I>
operator()(I first, S last, const T& value, Proj proj = {}) const {
iter_difference_t<I> n = 0;
for (; first != last; ++first) {
if (__stl2::invoke(proj, *first) == value) {
++n;
}
}
return n;
}
template<input_range R, class T, class Proj = identity>
requires indirect_relation<equal_to, projected<iterator_t<R>, Proj>, const T*>
constexpr iter_difference_t<iterator_t<R>>
operator()(R&& r, const T& value, Proj proj = {}) const {
return (*this)(begin(r), end(r), value, __stl2::ref(proj));
}
};
inline constexpr __count_fn count{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/count_if.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_COUNT_IF_HPP
#define STL2_DETAIL_ALGORITHM_COUNT_IF_HPP
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/concepts.hpp>
///////////////////////////////////////////////////////////////////////////
// count_if [alg.count]
//
STL2_OPEN_NAMESPACE {
struct __count_if_fn : private __niebloid {
template<input_iterator I, sentinel_for<I> S, class Proj = identity,
indirect_unary_predicate<projected<I, Proj>> Pred>
constexpr iter_difference_t<I>
operator()(I first, S last, Pred pred, Proj proj = {}) const {
auto n = iter_difference_t<I>{0};
for (; first != last; ++first) {
if (__stl2::invoke(pred, __stl2::invoke(proj, *first))) {
++n;
}
}
return n;
}
template<input_range R, class Proj = identity,
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr iter_difference_t<iterator_t<R>>
operator()(R&& r, Pred pred, Proj proj = {}) const {
return (*this)(begin(r), end(r), __stl2::ref(pred), __stl2::ref(proj));
}
};
inline constexpr __count_if_fn count_if{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/equal.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_EQUAL_HPP
#define STL2_DETAIL_ALGORITHM_EQUAL_HPP
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/primitives.hpp>
///////////////////////////////////////////////////////////////////////////
// equal [alg.equal]
//
STL2_OPEN_NAMESPACE {
struct __equal_fn : private __niebloid {
private:
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2,
class Pred, class Proj1, class Proj2>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
static constexpr bool __equal_3(I1 first1, S1 last1, I2 first2,
Pred& pred, Proj1& proj1, Proj2& proj2)
{
for (; first1 != last1; (void) ++first1, (void) ++first2) {
if (!__stl2::invoke(pred,
__stl2::invoke(proj1, *first1),
__stl2::invoke(proj2, *first2))) {
return false;
}
}
return true;
}
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2,
sentinel_for<I2> S2, class Pred, class Proj1, class Proj2>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
static constexpr bool __equal_4(I1 first1, S1 last1, I2 first2, S2 last2,
Pred& pred, Proj1& proj1, Proj2& proj2)
{
while (true) {
const bool b = first2 == last2;
if (first1 == last1) return b;
if (b) return false;
if (!__stl2::invoke(pred,
__stl2::invoke(proj1, *first1),
__stl2::invoke(proj2, *first2))) return false;
++first1;
++first2;
}
}
public:
template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
class Pred = equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr bool operator()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {}) const
{
if constexpr (sized_sentinel_for<S1, I1> && sized_sentinel_for<S2, I2>) {
auto len1 = distance(first1, last1);
auto len2 = distance(first2, std::move(last2));
return len1 == len2 &&
__equal_3(std::move(first1), std::move(last1),
std::move(first2), pred, proj1, proj2);
} else {
return __equal_4(
std::move(first1), std::move(last1),
std::move(first2), std::move(last2),
pred, proj1, proj2);
}
}
template<input_range R1, input_range R2, class Pred = equal_to,
class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr bool operator()(R1&& r1, R2&& r2, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {}) const
{
if constexpr (sized_range<R1> && sized_range<R2>) {
return distance(r1) == distance(r2) &&
__equal_3(
begin(r1), end(r1),
begin(r2), pred, proj1, proj2);
} else {
return __equal_4(
begin(r1), end(r1),
begin(r2), end(r2),
pred, proj1, proj2);
}
}
};
inline constexpr __equal_fn equal{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/equal_range.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_EQUAL_RANGE_HPP
#define STL2_DETAIL_ALGORITHM_EQUAL_RANGE_HPP
#include <stl2/detail/algorithm/lower_bound.hpp>
#include <stl2/detail/algorithm/upper_bound.hpp>
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/view/subrange.hpp>
///////////////////////////////////////////////////////////////////////////
// equal_range [equal.range]
//
STL2_OPEN_NAMESPACE {
namespace ext {
struct __equal_range_n_fn {
template<forward_iterator I, class T, class Comp = less, class Proj = identity>
requires indirect_strict_weak_order<Comp, const T*, projected<I, Proj>>
constexpr subrange<I>
operator()(I first, iter_difference_t<I> dist, const T& value,
Comp comp = {}, Proj proj = {}) const {
if (0 < dist) {
do {
auto half = dist / 2;
auto middle = next(first, half);
auto&& v = *middle;
auto&& pv = __stl2::invoke(proj, std::forward<decltype(v)>(v));
if (__stl2::invoke(comp, pv, value)) {
first = std::move(middle);
++first;
dist -= half + 1;
} else if (__stl2::invoke(comp, value, pv)) {
dist = half;
} else {
return {
ext::lower_bound_n(
std::move(first), half, value,
__stl2::ref(comp), __stl2::ref(proj)),
ext::upper_bound_n(next(middle),
dist - (half + 1), value,
__stl2::ref(comp), __stl2::ref(proj))
};
}
} while (0 != dist);
}
return {first, first};
}
};
inline constexpr __equal_range_n_fn equal_range_n{};
} // namespace ext
struct __equal_range_fn : private __niebloid {
template<forward_iterator I, sentinel_for<I> S, class T, class Comp = less,
class Proj = identity>
requires indirect_strict_weak_order<Comp, const T*, projected<I, Proj>>
constexpr subrange<I> operator()(I first, S last, const T& value,
Comp comp = {}, Proj proj = {}) const
{
if constexpr (sized_sentinel_for<S, I>) {
auto len = distance(first, std::move(last));
return ext::equal_range_n(std::move(first), len, value,
__stl2::ref(comp), __stl2::ref(proj));
} else {
// Probe exponentially for either end-of-range, an iterator that
// is past the equal range (i.e., denotes an element greater
// than value), or is in the equal range (denotes an element equal
// to value).
auto dist = iter_difference_t<I>{1};
while (true) {
auto mid = first;
auto d = advance(mid, dist, last);
STL2_EXPECT(d >= 0);
if (d || mid == last) {
// at the end of the input range
return ext::equal_range_n(
std::move(first), dist - d, value,
__stl2::ref(comp), __stl2::ref(proj));
}
auto&& v = *mid;
auto&& pv = __stl2::invoke(proj, std::forward<decltype(v)>(v));
// if value < *mid, mid is after the target range.
if (__stl2::invoke(comp, value, pv)) {
return ext::equal_range_n(
std::move(first), dist, value,
__stl2::ref(comp), __stl2::ref(proj));
} else if (!__stl2::invoke(comp, pv, value)) {
// *mid == value: the lower bound is <= mid, and the upper bound is > mid.
return {
ext::lower_bound_n(std::move(first), dist, value,
__stl2::ref(comp), __stl2::ref(proj)),
upper_bound(std::move(mid), std::move(last),
value, __stl2::ref(comp), __stl2::ref(proj))
};
}
// *mid < value, mid is before the target range.
first = std::move(mid);
++first;
dist *= 2;
}
}
}
template<forward_range Rng, class T, class Comp = less, class Proj = identity>
requires indirect_strict_weak_order<Comp, const T*, projected<iterator_t<Rng>, Proj>>
constexpr safe_subrange_t<Rng>
operator()(Rng&& rng, const T& value, Comp comp = {}, Proj proj = {}) const {
if constexpr (sized_range<Rng>) {
return ext::equal_range_n(begin(rng), size(rng), value, __stl2::ref(comp),
__stl2::ref(proj));
} else {
return (*this)(begin(rng), end(rng), value, __stl2::ref(comp),
__stl2::ref(proj));
}
}
};
inline constexpr __equal_range_fn equal_range{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/fill.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_FILL_HPP
#define STL2_DETAIL_ALGORITHM_FILL_HPP
#include <stl2/detail/range/concepts.hpp>
#include <stl2/detail/range/dangling.hpp>
///////////////////////////////////////////////////////////////////////////
// fill [alg.fill]
STL2_OPEN_NAMESPACE {
struct __fill_fn : private __niebloid {
template<class T, output_iterator<const T&> O, sentinel_for<O> S>
constexpr O operator()(O first, S last, const T& value) const {
for (; first != last; ++first) {
*first = value;
}
return first;
}
template<class T, output_range<const T&> R>
constexpr safe_iterator_t<R> operator()(R&& r, const T& value) const {
return (*this)(begin(r), end(r), value);
}
};
inline constexpr __fill_fn fill{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/fill_n.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_FILL_N_HPP
#define STL2_DETAIL_ALGORITHM_FILL_N_HPP
#include <stl2/detail/iterator/concepts.hpp>
///////////////////////////////////////////////////////////////////////////
// fill_n [alg.fill]
//
STL2_OPEN_NAMESPACE {
struct __fill_n_fn : private __niebloid {
template<class T, output_iterator<const T&> O>
constexpr O
operator()(O first, iter_difference_t<O> n, const T& value) const {
for (; n > 0; --n, (void)++first) {
*first = value;
}
return first;
}
};
inline constexpr __fill_n_fn fill_n{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/find.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_FIND_HPP
#define STL2_DETAIL_ALGORITHM_FIND_HPP
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/dangling.hpp>
///////////////////////////////////////////////////////////////////////////
// find [alg.find]
//
STL2_OPEN_NAMESPACE {
struct __find_fn : private __niebloid {
template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
requires indirect_relation<equal_to, projected<I, Proj>, const T*>
constexpr I
operator()(I first, S last, const T& value, Proj proj = {}) const {
for (; first != last; ++first) {
if (__stl2::invoke(proj, *first) == value) {
break;
}
}
return first;
}
template<input_range R, class T, class Proj = identity>
requires indirect_relation<equal_to, projected<iterator_t<R>, Proj>, const T*>
constexpr safe_iterator_t<R>
operator()(R&& r, const T& value, Proj proj = {}) const {
return (*this)(begin(r), end(r), value, __stl2::ref(proj));
}
};
inline constexpr __find_fn find{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/find_end.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Eric Niebler 2014
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_FIND_END_HPP
#define STL2_DETAIL_ALGORITHM_FIND_END_HPP
#include <optional>
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/primitives.hpp>
///////////////////////////////////////////////////////////////////////////
// find_end [alg.find.end]
//
STL2_OPEN_NAMESPACE {
struct __find_end_fn : private __niebloid {
template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2,
sentinel_for<I2> S2, class Pred = equal_to, class Proj1 = identity,
class Proj2 = identity>
requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr I1 operator()(I1 first1, S1 last1, I2 first2, S2 last2,
Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
{
if (first2 == last2) {
return next(first1, last1);
}
if constexpr (bidirectional_iterator<I1> && bidirectional_iterator<I2>) {
auto end1 = next(first1, last1);
auto end2 = next(first2, last2);
if constexpr (random_access_iterator<I1> && random_access_iterator<I2>) {
// Take advantage of knowing source and pattern lengths.
// Stop short when source is smaller than pattern
const auto len2 = end2 - first2;
if (end1 - first1 < len2) {
return end1;
}
// End of pattern match can't go before here
const auto s = first1 + (len2 - 1);
for (auto l1 = end1; l1 != s; --l1) {
auto m1 = l1;
auto m2 = end2;
while (__stl2::invoke(pred,
__stl2::invoke(proj1, *--m1),
__stl2::invoke(proj2, *--m2))) {
if (m2 == first2) {
return m1;
}
}
}
return end1;
} else {
--end2;
auto l1 = end1;
while (l1 != first1) {
if (__stl2::invoke(pred,
__stl2::invoke(proj1, *--l1),
__stl2::invoke(proj2, *end2))) {
auto m1 = l1;
auto m2 = end2;
do {
if (m2 == first2) {
return m1;
}
if (m1 == first1) {
return end1;
}
} while (__stl2::invoke(pred,
__stl2::invoke(proj1, *--m1),
__stl2::invoke(proj2, *--m2)));
}
}
return end1;
}
} else {
std::optional<I1> res;
for (; first1 != last1; ++first1) {
if (__stl2::invoke(pred,
__stl2::invoke(proj1, *first1),
__stl2::invoke(proj2, *first2))) {
auto m1 = first1;
auto m2 = first2;
do {
if (++m2 == last2) {
res = first1;
break;
}
if (++m1 == last1) {
return std::move(res).value_or(std::move(m1));
}
} while (__stl2::invoke(pred,
__stl2::invoke(proj1, *m1),
__stl2::invoke(proj2, *m2)));
}
}
return std::move(res).value_or(std::move(first1));
}
}
template<forward_range R1, forward_range R2,
class Pred = equal_to, class Proj1 = identity, class Proj2 = identity>
requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
constexpr safe_iterator_t<R1> operator()(R1&& r1, R2&& r2,
Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
{
return (*this)(begin(r1), end(r1), begin(r2), end(r2),
__stl2::ref(pred), __stl2::ref(proj1), __stl2::ref(proj2));
}
};
inline constexpr __find_end_fn find_end{};
} STL2_CLOSE_NAMESPACE
#endif
================================================
FILE: include/stl2/detail/algorithm/find_first_of.hpp
================================================
// cmcstl2 - A concept-enabled C++ standard library
//
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/caseycarter/cmcstl2
//
#ifndef STL2_DETAIL_ALGORITHM_FIND_FIRST_OF_HPP
#define STL2_DETAIL_ALGORITHM_FIND_FIRST_OF_HPP
#include <stl2/detail/concepts/callable.hpp>
#include <stl2/detail/range/concepts.hpp>
#include <stl2/detail/range/dangling.hpp>
///////////////////////////////////////////////////////////////////////////
// find_first_of [alg.find.first.of]
//
STL2_OPEN_NAMESPACE {
struct __find_first_of_fn : private __niebloid {
template<input_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
class Proj1 = identity,
gitextract_9l0su0ff/
├── .cirrus.yml
├── .gitattributes
├── .gitignore
├── .travis.yml
├── CMakeLists.txt
├── LICENSE.txt
├── README.md
├── config/
│ ├── ci/
│ │ └── Dockerfile
│ └── cmake/
│ └── FindSanitizer.cmake
├── examples/
│ ├── CMakeLists.txt
│ └── simple.cpp
├── include/
│ ├── experimental/
│ │ └── ranges/
│ │ ├── algorithm
│ │ ├── concepts
│ │ ├── functional
│ │ ├── iterator
│ │ ├── memory
│ │ ├── random
│ │ ├── range
│ │ ├── ranges
│ │ ├── type_traits
│ │ └── utility
│ ├── meta/
│ │ ├── meta.hpp
│ │ └── meta_fwd.hpp
│ └── stl2/
│ ├── algorithm.hpp
│ ├── concepts.hpp
│ ├── detail/
│ │ ├── algorithm/
│ │ │ ├── adjacent_find.hpp
│ │ │ ├── all_of.hpp
│ │ │ ├── any_of.hpp
│ │ │ ├── binary_search.hpp
│ │ │ ├── copy.hpp
│ │ │ ├── copy_backward.hpp
│ │ │ ├── copy_if.hpp
│ │ │ ├── copy_n.hpp
│ │ │ ├── count.hpp
│ │ │ ├── count_if.hpp
│ │ │ ├── equal.hpp
│ │ │ ├── equal_range.hpp
│ │ │ ├── fill.hpp
│ │ │ ├── fill_n.hpp
│ │ │ ├── find.hpp
│ │ │ ├── find_end.hpp
│ │ │ ├── find_first_of.hpp
│ │ │ ├── find_if.hpp
│ │ │ ├── find_if_not.hpp
│ │ │ ├── for_each.hpp
│ │ │ ├── generate.hpp
│ │ │ ├── generate_n.hpp
│ │ │ ├── heap_sift.hpp
│ │ │ ├── includes.hpp
│ │ │ ├── inplace_merge.hpp
│ │ │ ├── is_heap.hpp
│ │ │ ├── is_heap_until.hpp
│ │ │ ├── is_partitioned.hpp
│ │ │ ├── is_permutation.hpp
│ │ │ ├── is_sorted.hpp
│ │ │ ├── is_sorted_until.hpp
│ │ │ ├── lexicographical_compare.hpp
│ │ │ ├── lower_bound.hpp
│ │ │ ├── make_heap.hpp
│ │ │ ├── max.hpp
│ │ │ ├── max_element.hpp
│ │ │ ├── merge.hpp
│ │ │ ├── min.hpp
│ │ │ ├── min_element.hpp
│ │ │ ├── minmax.hpp
│ │ │ ├── minmax_element.hpp
│ │ │ ├── mismatch.hpp
│ │ │ ├── move.hpp
│ │ │ ├── move_backward.hpp
│ │ │ ├── next_permutation.hpp
│ │ │ ├── none_of.hpp
│ │ │ ├── nth_element.hpp
│ │ │ ├── partial_sort.hpp
│ │ │ ├── partial_sort_copy.hpp
│ │ │ ├── partition.hpp
│ │ │ ├── partition_copy.hpp
│ │ │ ├── partition_point.hpp
│ │ │ ├── pop_heap.hpp
│ │ │ ├── prev_permutation.hpp
│ │ │ ├── push_heap.hpp
│ │ │ ├── remove.hpp
│ │ │ ├── remove_copy.hpp
│ │ │ ├── remove_copy_if.hpp
│ │ │ ├── remove_if.hpp
│ │ │ ├── replace.hpp
│ │ │ ├── replace_copy.hpp
│ │ │ ├── replace_copy_if.hpp
│ │ │ ├── replace_if.hpp
│ │ │ ├── results.hpp
│ │ │ ├── reverse.hpp
│ │ │ ├── reverse_copy.hpp
│ │ │ ├── rotate.hpp
│ │ │ ├── rotate_copy.hpp
│ │ │ ├── sample.hpp
│ │ │ ├── search.hpp
│ │ │ ├── search_n.hpp
│ │ │ ├── set_difference.hpp
│ │ │ ├── set_intersection.hpp
│ │ │ ├── set_symmetric_difference.hpp
│ │ │ ├── set_union.hpp
│ │ │ ├── shuffle.hpp
│ │ │ ├── sort.hpp
│ │ │ ├── sort_heap.hpp
│ │ │ ├── stable_partition.hpp
│ │ │ ├── stable_sort.hpp
│ │ │ ├── swap_ranges.hpp
│ │ │ ├── transform.hpp
│ │ │ ├── unique.hpp
│ │ │ ├── unique_copy.hpp
│ │ │ └── upper_bound.hpp
│ │ ├── cached_position.hpp
│ │ ├── cheap_storage.hpp
│ │ ├── concepts/
│ │ │ ├── callable.hpp
│ │ │ ├── compare.hpp
│ │ │ ├── core.hpp
│ │ │ ├── function.hpp
│ │ │ ├── fundamental.hpp
│ │ │ ├── object/
│ │ │ │ ├── assignable.hpp
│ │ │ │ ├── movable.hpp
│ │ │ │ ├── move_constructible.hpp
│ │ │ │ ├── regular.hpp
│ │ │ │ └── semiregular.hpp
│ │ │ ├── object.hpp
│ │ │ └── urng.hpp
│ │ ├── construct_destruct.hpp
│ │ ├── ebo_box.hpp
│ │ ├── functional/
│ │ │ ├── comparisons.hpp
│ │ │ ├── invoke.hpp
│ │ │ └── not_fn.hpp
│ │ ├── fwd.hpp
│ │ ├── hash.hpp
│ │ ├── iostream/
│ │ │ └── concepts.hpp
│ │ ├── iterator/
│ │ │ ├── any_iterator.hpp
│ │ │ ├── basic_iterator.hpp
│ │ │ ├── common_iterator.hpp
│ │ │ ├── concepts.hpp
│ │ │ ├── counted_iterator.hpp
│ │ │ ├── default_sentinel.hpp
│ │ │ ├── increment.hpp
│ │ │ ├── insert_iterators.hpp
│ │ │ ├── istream_iterator.hpp
│ │ │ ├── istreambuf_iterator.hpp
│ │ │ ├── move_iterator.hpp
│ │ │ ├── operations.hpp
│ │ │ ├── ostream_iterator.hpp
│ │ │ ├── ostreambuf_iterator.hpp
│ │ │ ├── reverse_iterator.hpp
│ │ │ └── unreachable.hpp
│ │ ├── memory/
│ │ │ ├── concepts.hpp
│ │ │ ├── construct_at.hpp
│ │ │ ├── destroy.hpp
│ │ │ ├── uninitialized_copy.hpp
│ │ │ ├── uninitialized_default_construct.hpp
│ │ │ ├── uninitialized_fill.hpp
│ │ │ ├── uninitialized_move.hpp
│ │ │ └── uninitialized_value_construct.hpp
│ │ ├── meta.hpp
│ │ ├── non_propagating_cache.hpp
│ │ ├── randutils.hpp
│ │ ├── range/
│ │ │ ├── access.hpp
│ │ │ ├── concepts.hpp
│ │ │ ├── dangling.hpp
│ │ │ ├── nth_iterator.hpp
│ │ │ └── primitives.hpp
│ │ ├── raw_ptr.hpp
│ │ ├── semiregular_box.hpp
│ │ ├── span.hpp
│ │ ├── swap.hpp
│ │ ├── temporary_vector.hpp
│ │ ├── tuple_like.hpp
│ │ ├── variant.hpp
│ │ └── view/
│ │ └── view_closure.hpp
│ ├── functional.hpp
│ ├── iterator.hpp
│ ├── memory.hpp
│ ├── random.hpp
│ ├── ranges.hpp
│ ├── type_traits.hpp
│ ├── utility.hpp
│ └── view/
│ ├── all.hpp
│ ├── common.hpp
│ ├── counted.hpp
│ ├── drop.hpp
│ ├── drop_while.hpp
│ ├── empty.hpp
│ ├── filter.hpp
│ ├── generate.hpp
│ ├── indirect.hpp
│ ├── iota.hpp
│ ├── istream.hpp
│ ├── join.hpp
│ ├── move.hpp
│ ├── ref.hpp
│ ├── repeat.hpp
│ ├── repeat_n.hpp
│ ├── reverse.hpp
│ ├── single.hpp
│ ├── split.hpp
│ ├── subrange.hpp
│ ├── take.hpp
│ ├── take_exactly.hpp
│ ├── take_while.hpp
│ ├── transform.hpp
│ └── view_interface.hpp
└── test/
├── CMakeLists.txt
├── algorithm/
│ ├── CMakeLists.txt
│ ├── adjacent_find.cpp
│ ├── all_of.cpp
│ ├── any_of.cpp
│ ├── binary_search.cpp
│ ├── copy.cpp
│ ├── copy_backward.cpp
│ ├── copy_if.cpp
│ ├── copy_n.cpp
│ ├── count.cpp
│ ├── count_if.cpp
│ ├── equal.cpp
│ ├── equal_range.cpp
│ ├── fill.cpp
│ ├── fill_n.cpp
│ ├── find.cpp
│ ├── find_end.cpp
│ ├── find_first_of.cpp
│ ├── find_if.cpp
│ ├── find_if_not.cpp
│ ├── for_each.cpp
│ ├── generate.cpp
│ ├── generate_n.cpp
│ ├── includes.cpp
│ ├── inplace_merge.cpp
│ ├── is_heap.hpp
│ ├── is_heap1.cpp
│ ├── is_heap2.cpp
│ ├── is_heap3.cpp
│ ├── is_heap4.cpp
│ ├── is_heap_until.hpp
│ ├── is_heap_until1.cpp
│ ├── is_heap_until2.cpp
│ ├── is_heap_until3.cpp
│ ├── is_heap_until4.cpp
│ ├── is_partitioned.cpp
│ ├── is_permutation.cpp
│ ├── is_sorted.cpp
│ ├── is_sorted_until.cpp
│ ├── lexicographical_compare.cpp
│ ├── lower_bound.cpp
│ ├── make_heap.cpp
│ ├── max.cpp
│ ├── max_element.cpp
│ ├── merge.cpp
│ ├── min.cpp
│ ├── min_element.cpp
│ ├── minmax.cpp
│ ├── minmax_element.cpp
│ ├── mismatch.cpp
│ ├── move.cpp
│ ├── move_backward.cpp
│ ├── next_permutation.cpp
│ ├── none_of.cpp
│ ├── nth_element.cpp
│ ├── partial_sort.cpp
│ ├── partial_sort_copy.cpp
│ ├── partition.cpp
│ ├── partition_copy.cpp
│ ├── partition_point.cpp
│ ├── pop_heap.cpp
│ ├── prev_permutation.cpp
│ ├── push_heap.cpp
│ ├── remove.cpp
│ ├── remove_copy.cpp
│ ├── remove_copy_if.cpp
│ ├── remove_if.cpp
│ ├── replace.cpp
│ ├── replace_copy.cpp
│ ├── replace_copy_if.cpp
│ ├── replace_if.cpp
│ ├── reverse.cpp
│ ├── reverse_copy.cpp
│ ├── rotate.cpp
│ ├── rotate_copy.cpp
│ ├── sample.cpp
│ ├── search.cpp
│ ├── search_n.cpp
│ ├── set_difference.hpp
│ ├── set_difference1.cpp
│ ├── set_difference2.cpp
│ ├── set_difference3.cpp
│ ├── set_difference4.cpp
│ ├── set_difference5.cpp
│ ├── set_difference6.cpp
│ ├── set_intersection.hpp
│ ├── set_intersection1.cpp
│ ├── set_intersection2.cpp
│ ├── set_intersection3.cpp
│ ├── set_intersection4.cpp
│ ├── set_intersection5.cpp
│ ├── set_intersection6.cpp
│ ├── set_symmetric_difference.hpp
│ ├── set_symmetric_difference1.cpp
│ ├── set_symmetric_difference2.cpp
│ ├── set_symmetric_difference3.cpp
│ ├── set_symmetric_difference4.cpp
│ ├── set_symmetric_difference5.cpp
│ ├── set_symmetric_difference6.cpp
│ ├── set_union.hpp
│ ├── set_union1.cpp
│ ├── set_union2.cpp
│ ├── set_union3.cpp
│ ├── set_union4.cpp
│ ├── set_union5.cpp
│ ├── set_union6.cpp
│ ├── shuffle.cpp
│ ├── sort.cpp
│ ├── sort_heap.cpp
│ ├── stable_partition.cpp
│ ├── stable_sort.cpp
│ ├── swap_ranges.cpp
│ ├── transform.cpp
│ ├── unique.cpp
│ ├── unique_copy.cpp
│ └── upper_bound.cpp
├── all_public_headers.hpp
├── common-libcxx.hpp
├── common-libstdcxx.hpp
├── common.cpp
├── concepts/
│ ├── CMakeLists.txt
│ ├── compare.cpp
│ ├── core.cpp
│ ├── fundamental.cpp
│ ├── iterator.cpp
│ ├── object.cpp
│ ├── range.cpp
│ └── swap.cpp
├── detail/
│ ├── CMakeLists.txt
│ ├── raw_ptr.cpp
│ └── temporary_vector.cpp
├── functional/
│ ├── CMakeLists.txt
│ ├── invoke.cpp
│ └── not_fn.cpp
├── headers1.cpp
├── headers2.cpp
├── iterator/
│ ├── CMakeLists.txt
│ ├── any_iterator.cpp
│ ├── basic_iterator.cpp
│ ├── common_iterator.cpp
│ ├── counted_iterator.cpp
│ ├── incomplete.cpp
│ ├── istream_iterator.cpp
│ ├── istreambuf_iterator.cpp
│ ├── iterator.cpp
│ ├── make_range.cpp
│ ├── move_iterator.cpp
│ ├── operations.cpp
│ ├── ostream_iterator.cpp
│ ├── ostreambuf_iterator.cpp
│ ├── reverse_iterator.cpp
│ └── unreachable.cpp
├── memory/
│ ├── CMakeLists.txt
│ ├── common.hpp
│ ├── destroy.cpp
│ ├── uninitialized_copy.cpp
│ ├── uninitialized_default_construct.cpp
│ ├── uninitialized_fill.cpp
│ ├── uninitialized_move.cpp
│ └── uninitialized_value_construct.cpp
├── meta.cpp
├── move_only_string.hpp
├── range_access.cpp
├── simple_test.hpp
├── test_iterators.hpp
├── test_utils.hpp
└── view/
├── CMakeLists.txt
├── common_view.cpp
├── counted_view.cpp
├── drop_view.cpp
├── drop_while_view.cpp
├── empty_view.cpp
├── filter_view.cpp
├── generate_view.cpp
├── indirect_view.cpp
├── istream_view.cpp
├── join_view.cpp
├── move_view.cpp
├── ref_view.cpp
├── repeat_n_view.cpp
├── repeat_view.cpp
├── reverse_view.cpp
├── single_view.cpp
├── span.cpp
├── split_view.cpp
├── subrange.cpp
├── take_exactly_view.cpp
├── take_view.cpp
├── take_while_view.cpp
└── transform_view.cpp
Showing preview only (436K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2592 symbols across 285 files)
FILE: examples/simple.cpp
class show_type (line 12) | class show_type
function foo (line 15) | void foo(T&) {}
function main (line 17) | int main() {
FILE: include/meta/meta.hpp
type detail (line 117) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type nil_ (line 134) | struct nil_
type lazy (line 152) | namespace lazy
type lazy (line 296) | namespace lazy
type detail (line 390) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type integer_sequence (line 433) | struct integer_sequence
method size (line 437) | static constexpr std::size_t size() noexcept { return sizeof...(Is); }
type detail (line 454) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type detail (line 504) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type concat_indices_<index_sequence<Is...>, index_sequence<Js...>> (line 512) | struct concat_indices_<index_sequence<Is...>, index_sequence<Js...>>
type make_indices_<End, index_sequence<Values...>, indices_strategy_::repeat> (line 524) | struct make_indices_<End, index_sequence<Values...>, indices_strategy_::...
type make_indices_<End, index_sequence<Values...>, indices_strategy_::recurse> (line 531) | struct make_indices_<End, index_sequence<Values...>, indices_strategy_::...
type coerce_indices_<T, Offset, index_sequence<Values...>> (line 538) | struct coerce_indices_<T, Offset, index_sequence<Values...>>
type lazy (line 552) | namespace lazy
type id (line 565) | struct id
type lazy (line 587) | namespace lazy
type detail (line 621) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type detail (line 661) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type detail (line 701) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type defer_<C, Ts...> (line 710) | struct defer_<C, Ts...>
type defer_i_<T, C, Is...> (line 721) | struct defer_i_<T, C, Is...>
type _defer_<void_<C<Ts...>>, C, Ts...> (line 732) | struct _defer_<void_<C<Ts...>>, C, Ts...>
type _defer_i_<void_<C<Is...>>, T, C, Is...> (line 746) | struct _defer_i_<void_<C<Is...>>, T, C, Is...>
type defer (line 794) | struct defer : detail::defer_<C, Ts...>
type defer_i (line 805) | struct defer_i : detail::defer_i_<T, C, Is...>
type lazy (line 841) | namespace lazy
type detail (line 864) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type is_<C<Ts...>, C> (line 872) | struct is_<C<Ts...>, C> : std::true_type
type compose_ (line 888) | struct compose_
type compose_<Fn0> (line 893) | struct compose_<Fn0>
type compose_<Fn0, Fns...> (line 900) | struct compose_<Fn0, Fns...>
type lazy (line 909) | namespace lazy
type quote (line 920) | struct quote
type quote_i (line 932) | struct quote_i
type quote_trait (line 943) | struct quote_trait
type quote_trait_i (line 950) | struct quote_trait_i
type bind_front (line 976) | struct bind_front
type bind_back (line 986) | struct bind_back
type lazy (line 992) | namespace lazy
type extension (line 1006) | namespace extension
type apply (line 1012) | struct apply
type apply<Fn, Ret(Args...)> (line 1017) | struct apply<Fn, Ret(Args...)> : lazy::invoke<Fn, Ret, Args...>
type apply<Fn, T<Ts...>> (line 1023) | struct apply<Fn, T<Ts...>> : lazy::invoke<Fn, Ts...>
type apply<Fn, integer_sequence<T, Is...>> (line 1028) | struct apply<Fn, integer_sequence<T, Is...>>
type lazy (line 1040) | namespace lazy
type lazy (line 1059) | namespace lazy
type flip (line 1075) | struct flip
type impl (line 1079) | struct impl
type impl<A, B, Ts...> (line 1083) | struct impl<A, B, Ts...> : lazy::invoke<Fn, B, A, Ts...>
type lazy (line 1092) | namespace lazy
type detail (line 1101) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type on_<Fn, Gs...> (line 1108) | struct on_<Fn, Gs...>
type lazy (line 1125) | namespace lazy
type detail (line 1136) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type lazy (line 1233) | namespace lazy
type detail (line 1247) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type _and_<B, Bs...> (line 1261) | struct _and_<B, Bs...> : _and_<Bs...>
type _and_<B, Bs...> (line 1266) | struct _and_<B, Bs...> : std::false_type
type _or_<B, Bs...> (line 1281) | struct _or_<B, Bs...> : std::true_type
type _or_<B, Bs...> (line 1286) | struct _or_<B, Bs...> : _or_<Bs...>
type lazy (line 1427) | namespace lazy
type detail (line 1458) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type fold_<list<Head, Tail...>, State, Fn> (line 1499) | struct fold_<list<Head, Tail...>, State, Fn>
type fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn> (line 1508) | struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, Stat...
type fold_<list<Head, Tail...>, State, Fn> (line 1527) | struct fold_<list<Head, Tail...>, State, Fn>
type fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn> (line 1535) | struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, Stat...
type lazy (line 1564) | namespace lazy
type detail (line 1580) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type reverse_fold_<
list<Head, L...>, State, Fn> (line 1595) | struct reverse_fold_<
type reverse_fold_<list<Head, Tail...>, State, Fn> (line 1602) | struct reverse_fold_<list<Head, Tail...>, State, Fn>
type reverse_fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn> (line 1611) | struct reverse_fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail.....
type lazy (line 1628) | namespace lazy
type list (line 1648) | struct list
method size (line 1652) | static constexpr std::size_t size() noexcept { return sizeof...(Ts); }
type lazy (line 1663) | namespace lazy
type detail (line 1674) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type concat_<list<L1...>> (line 1688) | struct concat_<list<L1...>>
type concat_<list<L1...>, list<L2...>> (line 1694) | struct concat_<list<L1...>, list<L2...>>
type concat_<list<L1...>, list<L2...>, list<L3...>> (line 1700) | struct concat_<list<L1...>, list<L2...>, list<L3...>>
type concat_<list<L1...>, list<L2...>, list<L3...>, Rest...> (line 1706) | struct concat_<list<L1...>, list<L2...>, list<L3...>, Rest...>
type concat_<list<L1...>, list<L2...>, list<L3...>, list<L4...>, list<L5...>,
list<L6...>, list<L7...>, list<L8...>, list<L9...>, list<L10...>,
Rest...> (line 1714) | struct concat_<list<L1...>, list<L2...>, list<L3...>, list<L4...>, list<...
type lazy (line 1735) | namespace lazy
type lazy (line 1753) | namespace lazy
type detail (line 1764) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type transform_<list<Ts...>, Fn> (line 1774) | struct transform_<list<Ts...>, Fn>
type transform_<list<Ts...>, list<Us...>, Fn> (line 1781) | struct transform_<list<Ts...>, list<Us...>, Fn>
type transform_<list<list<Ts...>, Fn>, void_<invoke<Fn, Ts>...>> (line 1792) | struct transform_<list<list<Ts...>, Fn>, void_<invoke<Fn, Ts>...>>
type transform_<list<list<Ts0...>, list<Ts1...>, Fn>,
void_<invoke<Fn, Ts0, Ts1>...>> (line 1798) | struct transform_<list<list<Ts0...>, list<Ts1...>, Fn>,
type lazy (line 1823) | namespace lazy
type detail (line 1834) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type repeat_n_c_<T, index_sequence<Is...>> (line 1845) | struct repeat_n_c_<T, index_sequence<Is...>>
type lazy (line 1866) | namespace lazy
type detail (line 1882) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type at_<list<Ts...>, N, void_<__type_pack_element<N, Ts...>>> (line 1891) | struct at_<list<Ts...>, N, void_<__type_pack_element<N, Ts...>>>
type at_impl_<list<VoidPtrs...>> (line 1900) | struct at_impl_<list<VoidPtrs...>>
type at_<list<Ts...>, N> (line 1914) | struct at_<list<Ts...>, N>
type lazy (line 1936) | namespace lazy
type detail (line 1947) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type drop_impl_<list<VoidPtrs...>> (line 1958) | struct drop_impl_<list<VoidPtrs...>>
type drop_<list<Ts...>, N> (line 1979) | struct drop_<list<Ts...>, N>
type lazy (line 2004) | namespace lazy
type detail (line 2015) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type front_<list<Head, Tail...>> (line 2023) | struct front_<list<Head, Tail...>>
type lazy (line 2037) | namespace lazy
type detail (line 2048) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type back_<list<Head, Tail...>> (line 2056) | struct back_<list<Head, Tail...>>
type lazy (line 2070) | namespace lazy
type lazy (line 2087) | namespace lazy
type detail (line 2098) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type pop_front_<list<Head, L...>> (line 2106) | struct pop_front_<list<Head, L...>>
type lazy (line 2121) | namespace lazy
type lazy (line 2140) | namespace lazy
type detail (line 2149) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type lazy (line 2175) | namespace lazy
type lazy (line 2198) | namespace lazy
type lazy (line 2223) | namespace lazy
type detail (line 2239) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type find_index_<list<T...>, V> (line 2261) | struct find_index_<list<T...>, V>
type lazy (line 2282) | namespace lazy
type detail (line 2293) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type reverse_find_index_<list<T...>, V> (line 2316) | struct reverse_find_index_<list<T...>, V>
type lazy (line 2337) | namespace lazy
type lazy (line 2355) | namespace lazy
type detail (line 2366) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type reverse_find_<list<Head, L...>, T, State> (line 2380) | struct reverse_find_<list<Head, L...>, T, State> : reverse_find_<list<L....
type reverse_find_<list<T, L...>, T, State> (line 2385) | struct reverse_find_<list<T, L...>, T, State>
type lazy (line 2400) | namespace lazy
type detail (line 2411) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type find_if_<list<Head, L...>, Fn> (line 2427) | struct find_if_<list<Head, L...>, Fn>
type find_if_<list<L...>, Fn,
void_<integer_sequence<bool, bool(invoke<Fn, L>::type::value)...>>> (line 2449) | struct find_if_<list<L...>, Fn,
type lazy (line 2473) | namespace lazy
type detail (line 2484) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type reverse_find_if_<list<Head, L...>, Fn, State> (line 2500) | struct reverse_find_if_<list<Head, L...>, Fn, State>
type reverse_find_if_<
list<L...>, Fn,
void_<integer_sequence<bool, bool(invoke<Fn, L>::type::value)...>>> (line 2525) | struct reverse_find_if_<
type lazy (line 2552) | namespace lazy
type detail (line 2563) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type replace_<list<L...>, T, U> (line 2571) | struct replace_<list<L...>, T, U>
type lazy (line 2586) | namespace lazy
type detail (line 2597) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct _if_<list<If>, bool_<If::type::value>>
type _if_<list<If, Then>, bool_<If::type::value>> (line 1195) | struct _if_<list<If, Then>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<If::type::value>> (line 1201) | struct _if_<list<If, Then, Else>, bool_<If::type::value>>
type _if_<list<If, Then, Else>, bool_<!If::type::value>> (line 1207) | struct _if_<list<If, Then, Else>, bool_<!If::type::value>>
type _and_ (line 1251) | struct _and_
type _and_<> (line 1256) | struct _and_<> : std::true_type
type _or_ (line 1271) | struct _or_
type _or_<> (line 1276) | struct _or_<> : std::false_type
type _and_ (line 1291) | struct _and_
type _and_<false> (line 1298) | struct _and_<false>
type _or_ (line 1307) | struct _or_
type _or_<false> (line 1314) | struct _or_<false>
type fold_ (line 1461) | struct fold_
type compose10_ (line 1467) | struct compose10_
type compose_ (line 1479) | struct compose_
type fold_<list<>, State, Fn> (line 1492) | struct fold_<list<>, State, Fn>
type compose1_ (line 1515) | struct compose1_
type fold_<list<>, State, Fn> (line 1522) | struct fold_<list<>, State, Fn> : State
type reverse_fold_ (line 1583) | struct reverse_fold_
type reverse_fold_<list<>, State, Fn> (line 1588) | struct reverse_fold_<list<>, State, Fn>
type concat_ (line 1677) | struct concat_
type concat_<> (line 1682) | struct concat_<>
type transform_ (line 1768) | struct transform_
type transform_ (line 1787) | struct transform_
type repeat_n_c_ (line 1840) | struct repeat_n_c_
type at_ (line 1886) | struct at_
type at_impl_ (line 1897) | struct at_impl_
type at_ (line 1909) | struct at_
type drop_impl_ (line 1952) | struct drop_impl_
type drop_impl_<list<>> (line 1967) | struct drop_impl_<list<>>
type drop_ (line 1974) | struct drop_
type front_ (line 2018) | struct front_
type back_ (line 2051) | struct back_
type pop_front_ (line 2101) | struct pop_front_
function find_index_i_ (line 2242) | constexpr std::size_t find_index_i_(bool const *const first, bool cons...
type find_index_ (line 2250) | struct find_index_
type find_index_<list<>, V> (line 2255) | struct find_index_<list<>, V>
function reverse_find_index_i_ (line 2296) | constexpr std::size_t reverse_find_index_i_(bool const *const first,
type reverse_find_index_ (line 2305) | struct reverse_find_index_
type reverse_find_index_<list<>, V> (line 2310) | struct reverse_find_index_<list<>, V>
type reverse_find_ (line 2369) | struct reverse_find_
type reverse_find_<list<>, T, State> (line 2374) | struct reverse_find_<list<>, T, State>
type find_if_ (line 2415) | struct find_if_
type find_if_<list<>, Fn> (line 2420) | struct find_if_<list<>, Fn>
type find_if_ (line 2438) | struct find_if_
type find_if_<list<>, Fn> (line 2443) | struct find_if_<list<>, Fn>
type reverse_find_if_ (line 2488) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn, State> (line 2493) | struct reverse_find_if_<list<>, Fn, State>
type reverse_find_if_ (line 2514) | struct reverse_find_if_
type reverse_find_if_<list<>, Fn> (line 2519) | struct reverse_find_if_<list<>, Fn>
type replace_ (line 2566) | struct replace_
type replace_if_ (line 2601) | struct replace_if_
type replace_if_ (line 2613) | struct replace_if_
type count_ (line 2649) | struct count_
function count_i_ (line 2660) | constexpr std::size_t count_i_(bool const *const begin, bool const *co...
type count_<list<>, T> (line 2667) | struct count_<list<>, T>
type count_if_ (line 2706) | struct count_if_
type count_if_ (line 2718) | struct count_if_
type count_if_<list<>, Fn> (line 2723) | struct count_if_<list<>, Fn>
type filter_ (line 2768) | struct filter_
type static_const (line 2799) | struct static_const
type for_each_fn (line 2816) | struct for_each_fn
type as_list_ (line 2917) | struct as_list_ : lazy::invoke<uncurry<quote<list>>, Sequence>
type reverse_ (line 2943) | struct reverse_ : lazy::fold<L, State, quote<push_front>>
type inherit_ (line 3063) | struct inherit_
type in_ (line 3096) | struct in_
type insert_back_ (line 3106) | struct insert_back_
type replace_if_<list<L...>, C, U> (line 2607) | struct replace_if_<list<L...>, C, U>
type replace_if_<list<L...>, C, U,
void_<integer_sequence<bool, bool(invoke<C, L>::type::value)...>>> (line 2618) | struct replace_if_<list<L...>, C, U,
type lazy (line 2636) | namespace lazy
type detail (line 2646) | namespace detail
function T (line 121) | constexpr T *_nullptr_v()
type indices_strategy_ (line 392) | enum class indices_strategy_
function indices_strategy_ (line 399) | constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
function range_distance_ (line 407) | constexpr std::size_t range_distance_(T begin, T end)
type make_indices_ (line 415) | struct make_indices_
type coerce_indices_ (line 421) | struct coerce_indices_
type concat_indices_ (line 507) | struct concat_indices_
type make_indices_<0u, index_sequence<0>, indices_strategy_::done> (line 518) | struct make_indices_<0u, index_sequence<0>, indices_strategy_::done>
type is_trait_ (line 664) | struct is_trait_
type is_trait_<T, void_<typename T::type>> (line 670) | struct is_trait_<T, void_<typename T::type>>
type is_callable_ (line 676) | struct is_callable_
type is_callable_<T, void_<quote<T::template invoke>>> (line 682) | struct is_callable_<T, void_<quote<T::template invoke>>>
type defer_ (line 705) | struct defer_
type defer_i_ (line 716) | struct defer_i_
type _defer_ (line 727) | struct _defer_
type _defer_i_ (line 741) | struct _defer_i_
type is_ (line 867) | struct is_ : std::false_type
type on_ (line 1104) | struct on_
type _if_ (line 1140) | struct _if_
type _if_<If> (line 1145) | struct _if_<If> : std::enable_if<_v<If>>
type _if_<If, Then> (line 1150) | struct _if_<If, Then> : std::enable_if<_v<If>, Then>
type _if_<If, Then, Else> (line 1155) | struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
type _if_ (line 1161) | struct _if_
type _if_<list<If>, decltype(bool(If::type::value))> (line 1166) | struct _if_<list<If>, decltype(bool(If::type::value))> : std::enable_i...
type _if_<list<If, Then>, decltype(bool(If::type::value))> (line 1171) | struct _if_<list<If, Then>, decltype(bool(If::type::value))>
type _if_<list<If, Then, Else>, decltype(bool(If::type::value))> (line 1177) | struct _if_<list<If, Then, Else>, decltype(bool(If::type::value))>
type _if_ (line 1184) | struct _if_
type _if_<list<If>, bool_<If::type::value>> (line 1189) | struct
Condensed preview — 395 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,899K chars).
[
{
"path": ".cirrus.yml",
"chars": 1095,
"preview": "#\n# Copyright Christopher Di Bella\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not us"
},
{
"path": ".gitattributes",
"chars": 46,
"preview": "# Disable CRLF-mapping for all files.\n* -text\n"
},
{
"path": ".gitignore",
"chars": 65,
"preview": "*.user\n*~\n*.o\n*.obj\na.out\n\\#*#\n.#*\nbuild*/\n.vscode/\n.vs/\n*.*.swp\n"
},
{
"path": ".travis.yml",
"chars": 1818,
"preview": "# Copyright Casey Carter 2015-2017\n\n# Distributed under the Boost Software License, Version 1.0.\n# (See accompanying fil"
},
{
"path": "CMakeLists.txt",
"chars": 1910,
"preview": "# cmcstl2 - A concept-enabled C++ standard library\n#\n# Copyright Eric Niebler 2015\n# Copyright Casey Carter 2015, 2017"
},
{
"path": "LICENSE.txt",
"chars": 6355,
"preview": "========================================================\nBoost Software License - Version 1.0 - August 17th, 2003\n======"
},
{
"path": "README.md",
"chars": 294,
"preview": "# cmcstl2\nAn implementation of [P0896R4 \"The One Ranges Proposal\"](https://wg21.link/p0896r4).\nCompilation requires a co"
},
{
"path": "config/ci/Dockerfile",
"chars": 470,
"preview": "# cmcstl2 - A concept-enabled C++ standard library\n#\n# Copyright Casey Carter\n#\n# Use, modification and distribution i"
},
{
"path": "config/cmake/FindSanitizer.cmake",
"chars": 1634,
"preview": "#\n# Copyright Christopher Di Bella\n# Copyright Morris Hafner\n#\n# Licensed under the Apache License, Version 2.0 (the \""
},
{
"path": "examples/CMakeLists.txt",
"chars": 410,
"preview": "# cmcstl2 - A concept-enabled C++ standard library\n#\n# Copyright Casey Carter 2015, 2017\n#\n# Use, modification and dis"
},
{
"path": "examples/simple.cpp",
"chars": 704,
"preview": "#include <cassert>\n#include <iostream>\n#include <string>\n#include <vector>\n#include <experimental/ranges/algorithm>\n#inc"
},
{
"path": "include/experimental/ranges/algorithm",
"chars": 376,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/concepts",
"chars": 375,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/functional",
"chars": 377,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/iterator",
"chars": 375,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/memory",
"chars": 373,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/random",
"chars": 373,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/range",
"chars": 373,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2018\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/ranges",
"chars": 373,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2018\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/type_traits",
"chars": 378,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/experimental/ranges/utility",
"chars": 374,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/meta/meta.hpp",
"chars": 129214,
"preview": "/// \\file meta.hpp Tiny meta-programming library.\n//\n// Meta library\n//\n// Copyright Eric Niebler 2014-present\n//\n// U"
},
{
"path": "include/meta/meta_fwd.hpp",
"chars": 8289,
"preview": "/// \\file meta_fwd.hpp Forward declarations\n//\n// Meta library\n//\n// Copyright Eric Niebler 2014-present\n//\n// Use, mo"
},
{
"path": "include/stl2/algorithm.hpp",
"chars": 4419,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/concepts.hpp",
"chars": 878,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/adjacent_find.hpp",
"chars": 1659,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/all_of.hpp",
"chars": 1484,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Algorithm adapted (stolen) from Range v3 library\n//\n// Copyri"
},
{
"path": "include/stl2/detail/algorithm/any_of.hpp",
"chars": 1464,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Andrew Sutton 2014\n// Copyright Gonzalo Brito Gade"
},
{
"path": "include/stl2/detail/algorithm/binary_search.hpp",
"chars": 1679,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/copy.hpp",
"chars": 2944,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/copy_backward.hpp",
"chars": 1581,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2013-2014\n// Copyright Casey Carter 2"
},
{
"path": "include/stl2/detail/algorithm/copy_if.hpp",
"chars": 1961,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/copy_n.hpp",
"chars": 1364,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/count.hpp",
"chars": 1471,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/count_if.hpp",
"chars": 1462,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/equal.hpp",
"chars": 3290,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/equal_range.hpp",
"chars": 4455,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/fill.hpp",
"chars": 1124,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/fill_n.hpp",
"chars": 934,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/find.hpp",
"chars": 1406,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/find_end.hpp",
"chars": 3664,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/find_first_of.hpp",
"chars": 1935,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/find_if.hpp",
"chars": 1395,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/find_if_not.hpp",
"chars": 1454,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/for_each.hpp",
"chars": 1547,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/generate.hpp",
"chars": 1293,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-present\n//\n// Use, modification "
},
{
"path": "include/stl2/detail/algorithm/generate_n.hpp",
"chars": 1078,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-present\n//\n// Use, modification "
},
{
"path": "include/stl2/detail/algorithm/heap_sift.hpp",
"chars": 3599,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/includes.hpp",
"chars": 1967,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/inplace_merge.hpp",
"chars": 7853,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/is_heap.hpp",
"chars": 1801,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/is_heap_until.hpp",
"chars": 2746,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/is_partitioned.hpp",
"chars": 1544,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/is_permutation.hpp",
"chars": 8596,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015, "
},
{
"path": "include/stl2/detail/algorithm/is_sorted.hpp",
"chars": 1419,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/is_sorted_until.hpp",
"chars": 1578,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/lexicographical_compare.hpp",
"chars": 2147,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/lower_bound.hpp",
"chars": 2679,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/make_heap.hpp",
"chars": 2367,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/max.hpp",
"chars": 2413,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/max_element.hpp",
"chars": 1545,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/merge.hpp",
"chars": 2717,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/min.hpp",
"chars": 2434,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/min_element.hpp",
"chars": 1544,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/minmax.hpp",
"chars": 3442,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/minmax_element.hpp",
"chars": 2432,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/mismatch.hpp",
"chars": 2074,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/move.hpp",
"chars": 2997,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/move_backward.hpp",
"chars": 1554,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/next_permutation.hpp",
"chars": 2352,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/none_of.hpp",
"chars": 1396,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/nth_element.hpp",
"chars": 7911,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/partial_sort.hpp",
"chars": 2017,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/partial_sort_copy.hpp",
"chars": 2885,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/partition.hpp",
"chars": 2490,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/partition_copy.hpp",
"chars": 2272,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/partition_point.hpp",
"chars": 3295,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/pop_heap.hpp",
"chars": 2361,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/prev_permutation.hpp",
"chars": 2352,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/push_heap.hpp",
"chars": 1919,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/remove.hpp",
"chars": 1650,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/remove_copy.hpp",
"chars": 1910,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/remove_copy_if.hpp",
"chars": 1916,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/remove_if.hpp",
"chars": 1667,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/replace.hpp",
"chars": 1620,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/replace_copy.hpp",
"chars": 2092,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/replace_copy_if.hpp",
"chars": 2068,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/replace_if.hpp",
"chars": 1581,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/results.hpp",
"chars": 3999,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/reverse.hpp",
"chars": 1463,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/reverse_copy.hpp",
"chars": 1548,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/rotate.hpp",
"chars": 4781,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/rotate_copy.hpp",
"chars": 1631,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/sample.hpp",
"chars": 5328,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2015\n// Copyright Casey Carter 2016\n/"
},
{
"path": "include/stl2/detail/algorithm/search.hpp",
"chars": 4820,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/search_n.hpp",
"chars": 4147,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/set_difference.hpp",
"chars": 2455,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/set_intersection.hpp",
"chars": 2490,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/set_symmetric_difference.hpp",
"chars": 3068,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/set_union.hpp",
"chars": 2773,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/shuffle.hpp",
"chars": 1849,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/sort.hpp",
"chars": 7019,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/sort_heap.hpp",
"chars": 2351,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/stable_partition.hpp",
"chars": 11166,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/stable_sort.hpp",
"chars": 6622,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2014\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/swap_ranges.hpp",
"chars": 2172,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/transform.hpp",
"chars": 3263,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2015\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/algorithm/unique.hpp",
"chars": 1708,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/algorithm/unique_copy.hpp",
"chars": 3348,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-present\n//\n// Use, modification "
},
{
"path": "include/stl2/detail/algorithm/upper_bound.hpp",
"chars": 2639,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/cached_position.hpp",
"chars": 2919,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\r\n//\r\n// Copyright Casey Carter 2018\r\n//\r\n// Use, modification and "
},
{
"path": "include/stl2/detail/cheap_storage.hpp",
"chars": 1555,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/concepts/callable.hpp",
"chars": 6723,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/compare.hpp",
"chars": 6271,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/core.hpp",
"chars": 2274,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/function.hpp",
"chars": 2471,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/concepts/fundamental.hpp",
"chars": 2044,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/object/assignable.hpp",
"chars": 1355,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/object/movable.hpp",
"chars": 966,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/object/move_constructible.hpp",
"chars": 1953,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/object/regular.hpp",
"chars": 853,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/object/semiregular.hpp",
"chars": 1653,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/object.hpp",
"chars": 3923,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/concepts/urng.hpp",
"chars": 1211,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/construct_destruct.hpp",
"chars": 1298,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/ebo_box.hpp",
"chars": 2684,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/functional/comparisons.hpp",
"chars": 2666,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/functional/invoke.hpp",
"chars": 4278,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter\n//\n// Use, modification and distribut"
},
{
"path": "include/stl2/detail/functional/not_fn.hpp",
"chars": 2999,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/fwd.hpp",
"chars": 8419,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-2016\n// Copyright Eric Niebler 2"
},
{
"path": "include/stl2/detail/hash.hpp",
"chars": 1282,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iostream/concepts.hpp",
"chars": 1553,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/any_iterator.hpp",
"chars": 6924,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2016\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/basic_iterator.hpp",
"chars": 31611,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2014-2"
},
{
"path": "include/stl2/detail/iterator/common_iterator.hpp",
"chars": 8929,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2015\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/iterator/concepts.hpp",
"chars": 25011,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/iterator/counted_iterator.hpp",
"chars": 9861,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/default_sentinel.hpp",
"chars": 621,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/increment.hpp",
"chars": 4517,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-2016\n// Copyright Eric Niebler 2"
},
{
"path": "include/stl2/detail/iterator/insert_iterators.hpp",
"chars": 5044,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/istream_iterator.hpp",
"chars": 3395,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/istreambuf_iterator.hpp",
"chars": 5154,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/move_iterator.hpp",
"chars": 7426,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/operations.hpp",
"chars": 3991,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-present\n//\n// Use, modification "
},
{
"path": "include/stl2/detail/iterator/ostream_iterator.hpp",
"chars": 2248,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/iterator/ostreambuf_iterator.hpp",
"chars": 2739,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/reverse_iterator.hpp",
"chars": 4633,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/iterator/unreachable.hpp",
"chars": 1382,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/memory/concepts.hpp",
"chars": 2276,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Christopher Di Bella 2016\n// Copyright Casey Carte"
},
{
"path": "include/stl2/detail/memory/construct_at.hpp",
"chars": 1078,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n// Copyright Christopher Di Bell"
},
{
"path": "include/stl2/detail/memory/destroy.hpp",
"chars": 3721,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Christopher Di Bell"
},
{
"path": "include/stl2/detail/memory/uninitialized_copy.hpp",
"chars": 2797,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n// Copyright Christopher Di Bell"
},
{
"path": "include/stl2/detail/memory/uninitialized_default_construct.hpp",
"chars": 2219,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n// Copyright Christopher Di Bell"
},
{
"path": "include/stl2/detail/memory/uninitialized_fill.hpp",
"chars": 2136,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Christopher Di Bell"
},
{
"path": "include/stl2/detail/memory/uninitialized_move.hpp",
"chars": 2843,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Christopher Di Bell"
},
{
"path": "include/stl2/detail/memory/uninitialized_value_construct.hpp",
"chars": 2194,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n// Copyright Christopher Di Bell"
},
{
"path": "include/stl2/detail/meta.hpp",
"chars": 2072,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/non_propagating_cache.hpp",
"chars": 1549,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/randutils.hpp",
"chars": 1630,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/range/access.hpp",
"chars": 15256,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/range/concepts.hpp",
"chars": 5642,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/range/dangling.hpp",
"chars": 1100,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2015\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/detail/range/nth_iterator.hpp",
"chars": 1734,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter\n//\n// Use, modification and distribut"
},
{
"path": "include/stl2/detail/range/primitives.hpp",
"chars": 3280,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/raw_ptr.hpp",
"chars": 1104,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/semiregular_box.hpp",
"chars": 5710,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/span.hpp",
"chars": 12768,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/swap.hpp",
"chars": 5158,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/detail/temporary_vector.hpp",
"chars": 4352,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/tuple_like.hpp",
"chars": 826,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/detail/variant.hpp",
"chars": 2119,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015, 2018\n//\n// Use, modification an"
},
{
"path": "include/stl2/detail/view/view_closure.hpp",
"chars": 5453,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/functional.hpp",
"chars": 1080,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/iterator.hpp",
"chars": 1538,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n// Copyright Eric Niebler 2015\n/"
},
{
"path": "include/stl2/memory.hpp",
"chars": 835,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-2016\n//\n// Use, modification and"
},
{
"path": "include/stl2/random.hpp",
"chars": 493,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/ranges.hpp",
"chars": 1451,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2018\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/type_traits.hpp",
"chars": 8386,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2015\n// Copyright Casey Carter 2015\n/"
},
{
"path": "include/stl2/utility.hpp",
"chars": 589,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/all.hpp",
"chars": 1942,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/common.hpp",
"chars": 2702,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/counted.hpp",
"chars": 1000,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/drop.hpp",
"chars": 3319,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter\n// Copyright Eric Niebler\n// Copyrig"
},
{
"path": "include/stl2/view/drop_while.hpp",
"chars": 3099,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter\n// Copyright Eric Niebler\n// Copyrig"
},
{
"path": "include/stl2/view/empty.hpp",
"chars": 1121,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/filter.hpp",
"chars": 5812,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/generate.hpp",
"chars": 3396,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter\n// Copyright Christopher Di Bella\n//\n"
},
{
"path": "include/stl2/view/indirect.hpp",
"chars": 4056,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/iota.hpp",
"chars": 7271,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-2016\n// Copyright Eric Niebler 2"
},
{
"path": "include/stl2/view/istream.hpp",
"chars": 2952,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2013-present\n// Copyright Casey Carte"
},
{
"path": "include/stl2/view/join.hpp",
"chars": 9655,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/move.hpp",
"chars": 3059,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/ref.hpp",
"chars": 2678,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2016\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/repeat.hpp",
"chars": 2924,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-2016\n//\n// Use, modification and"
},
{
"path": "include/stl2/view/repeat_n.hpp",
"chars": 1260,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Casey Carter 2015-2016\n//\n// Use, modification and"
},
{
"path": "include/stl2/view/reverse.hpp",
"chars": 3394,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/single.hpp",
"chars": 1885,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/split.hpp",
"chars": 10267,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/subrange.hpp",
"chars": 8699,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
},
{
"path": "include/stl2/view/take.hpp",
"chars": 4184,
"preview": "// cmcstl2 - A concept-enabled C++ standard library\n//\n// Copyright Eric Niebler 2017\n//\n// Use, modification and dist"
}
]
// ... and 195 more files (download for full content)
About this extraction
This page contains the full source code of the CaseyCarter/cmcstl2 GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 395 files (1.7 MB), approximately 535.5k tokens, and a symbol index with 2592 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.