[nop] cleanup after switching to core-0.6.0

Author: h-2

include/bio/io/detail/concept.hpp

@@ -16,6 +16,7 @@
 #include <concepts>
 
 #include <bio/alphabet/concept.hpp>
+#include <bio/meta/overloaded.hpp>
 
 #include <bio/io/detail/utility.hpp>
 
@@ -26,16 +27,6 @@ namespace bio::io::detail
  * \{
  */
 
-/*!\interface   bio::io::detail::one_of <>
- * \tparam t    The query type to compare.
- * \tparam ts   The reference types.
- * \brief       Checks whether the list of reference types contains the query type.
- */
-//!\cond
-template <typename t, typename... ts>
-concept one_of = (std::same_as<t, ts> || ...);
-//!\endcond
-
 /*!\interface   bio::io::detail::deliberate_alphabet <>
  * \tparam t    The query type to compare.
  * \brief       A bio::alphabet::alphabet that is **not** a character or a number (any std::integral).
@@ -45,15 +36,6 @@ template <typename t>
 concept deliberate_alphabet = alphabet::alphabet<t> && !std::integral<std::remove_cvref_t<t>>;
 //!\endcond
 
-/*!\interface   bio::io::detail::decays_to <>
- * \tparam t    The type to check.
- * \brief       Shortcut for `std::same_as<std::decay_t<from_t>, to_t>`.
- */
-//!\cond
-template <typename from_t, typename to_t>
-concept decays_to = std::same_as<std::decay_t<from_t>, to_t>;
-//!\endcond
-
 /*!\brief Pass this function a constrained functor that accepts one argument and returns std::true_type.
  * \details
  *
@@ -65,7 +47,7 @@ constexpr bool lazy_concept_checker(auto fun)
     {
         return std::false_type{};
     };
-    using ret_t = decltype(detail::overloaded{fallback, fun}(1));
+    using ret_t = decltype(meta::overloaded{fallback, fun}(1));
     return ret_t::value;
 }
 

include/bio/io/detail/range.hpp

@@ -16,6 +16,9 @@
 #include <ranges>
 #include <span>
 
+#include <bio/meta/concept/core_language.hpp>
+#include <bio/ranges/concept.hpp>
+
 #include <bio/io/platform.hpp>
 
 namespace bio::io::detail
@@ -29,32 +32,6 @@ namespace bio::io::detail
 // concepts
 // ----------------------------------------------------------------------------
 
-/*!\interface bio::io::detail::back_insertable_with <>
- * \extends std::ranges::output_range
- * \tparam rng_t The container type.
- * \tparam val_t The type to append to the container.
- * \brief Describes range types that can grow in amortised constant time by appending an element of type val_t.
- */
-//!\cond
-template <typename rng_t, typename val_t>
-concept back_insertable_with = std::ranges::output_range<rng_t, val_t> && requires(rng_t & v)
-{
-    v.push_back(std::declval<val_t>());
-};
-//!\endcond
-
-/*!\interface bio::io::detail::back_insertable <>
- * \extends std::ranges::output_range
- * \extends std::ranges::input_range
- * \tparam rng_t The container type.
- * \brief Describes range types that can grow in amortised constant time by appending an element.
- */
-//!\cond
-template <typename rng_t>
-concept back_insertable =
-  std::ranges::input_range<rng_t> && back_insertable_with<rng_t, std::ranges::range_reference_t<rng_t>>;
-//!\endcond
-
 //!\brief A range whose value type is `char`.
 template <typename t>
 concept char_range =
@@ -69,21 +46,21 @@ char const * > ;
 template <typename t>
 concept int_range =
   std::ranges::forward_range<t> && std::integral<std::remove_cvref_t<std::ranges::range_value_t<t>>> &&
-  !std::same_as<char, std::remove_cvref_t<std::ranges::range_value_t<t>>>;
+  meta::different_from<char, std::ranges::range_value_t<t>>;
 
 /*!\interface bio::io::detail::out_string <>
  * \tparam rng_t The container type.
  * \brief A range that `char` can be back-inserted to, or a string_view.
  */
 //!\cond
 template <typename rng_t>
-concept out_string = back_insertable_with<rng_t, char> || std::same_as<rng_t &, std::string_view &>;
+concept out_string = ranges::back_insertable_with<rng_t, char> || std::same_as<rng_t &, std::string_view &>;
 //!\endcond
 
 //!\brief Range that is random-access, output, sized and has .resize() and .clear()
 template <typename rng_t>
 concept vector_like = std::ranges::random_access_range<rng_t> && std::ranges::sized_range<rng_t> &&
-  std::ranges::output_range<rng_t, std::ranges::range_reference_t<rng_t>> && requires(rng_t & v)
+  ranges::back_insertable<rng_t> && requires(rng_t & v)
 {
     v.resize(3);
     v.clear();
@@ -132,8 +109,8 @@ concept transform_view_on_string_view = requires
  * If the input range is sized and the target range offers a `.resize()` member, this function uses
  * resize and assignment instead of back-insertion.
  */
-void sized_range_copy(std::ranges::input_range auto &&                                           in,
-                      back_insertable_with<std::ranges::range_reference_t<decltype(in)>> auto && out)
+void sized_range_copy(std::ranges::input_range auto &&                                                   in,
+                      ranges::back_insertable_with<std::ranges::range_reference_t<decltype(in)>> auto && out)
 {
     using in_t  = decltype(in);
     using out_t = decltype(out);

include/bio/io/detail/tuple_record.hpp

@@ -431,7 +431,7 @@ consteval bool has_non_ignore_field()
     using field_ids      = typename tuple_record_t::field_ids;
     if constexpr (field_ids::contains(f))
     {
-        if constexpr (!decays_to<tuple_record_element_t<f, tuple_record_t>, ignore_t>)
+        if constexpr (!meta::decays_to<tuple_record_element_t<f, tuple_record_t>, ignore_t>)
         {
             return true;
         }

include/bio/io/detail/utility.hpp

@@ -32,18 +32,6 @@ namespace bio::io::detail
  * \{
  */
 
-//!\brief Wrapper to create an overload set of multiple functors.
-template <typename... functors>
-struct overloaded : functors...
-{
-    using functors::operator()...;
-};
-
-//!\brief Deduction guide for bio::io::detail::overloaded.
-template <typename... functors>
-overloaded(functors...) -> overloaded<functors...>;
-//!\}
-
 //!\brief Can be included as a member to infer whether parent is in moved-from state.
 //!\ingroup io
 struct move_tracker

include/bio/io/detail/writer_base.hpp

@@ -320,7 +320,7 @@ class writer_base
     void write_record(auto & r)
     {
         init_state = false;
-        std::visit(detail::overloaded([](std::monostate) {}, [&r](auto & handler) { handler.write_record(r); }),
+        std::visit(meta::overloaded([](std::monostate) {}, [&r](auto & handler) { handler.write_record(r); }),
                    format_handler);
     }
 

include/bio/io/format/bcf_input_handler.hpp

@@ -465,7 +465,7 @@ class format_input_handler<bcf> :
 
     // IMPLEMENTATION NOTE: the following is the only decoder that is used in parsed record reading.
     //!\brief Decodes any range of integral and stores in any range of integral (no check of sizes).
-    template <detail::back_insertable out_t>
+    template <ranges::back_insertable out_t>
         requires detail::int_range<out_t>
     void decode_numbers_into(std::span<std::byte const> in, out_t & out)
     {
@@ -764,7 +764,7 @@ class format_input_handler<bcf> :
     }
 
     //!\overload
-    template <detail::back_insertable parsed_field_t>
+    template <ranges::back_insertable parsed_field_t>
         requires(std::ranges::range<std::ranges::range_reference_t<parsed_field_t>>)
     void parse_field(meta::vtag_t<detail::field::alt> const & /**/, parsed_field_t & parsed_field)
     {
@@ -785,15 +785,15 @@ class format_input_handler<bcf> :
     }
 
     //!\brief Reading of FILTER field.
-    template <detail::back_insertable parsed_field_t>
+    template <ranges::back_insertable parsed_field_t>
         requires detail::int_range<parsed_field_t>
     void parse_field(meta::vtag_t<detail::field::filter> const & /**/, parsed_field_t & parsed_field)
     {
         decode_numbers_into(get<detail::field::filter>(raw_record), parsed_field);
     }
 
     //!\overload
-    template <detail::back_insertable parsed_field_t>
+    template <ranges::back_insertable parsed_field_t>
         requires detail::out_string<std::ranges::range_reference_t<parsed_field_t>>
     void parse_field(meta::vtag_t<detail::field::filter> const & /**/, parsed_field_t & parsed_field)
     {
@@ -810,7 +810,7 @@ class format_input_handler<bcf> :
     }
 
     //!\brief Reading of the INFO field.
-    template <detail::back_insertable parsed_field_t>
+    template <ranges::back_insertable parsed_field_t>
         requires detail::info_element_reader_concept<std::ranges::range_reference_t<parsed_field_t>>
     void parse_field(meta::vtag_t<detail::field::info> const & /**/, parsed_field_t & parsed_field)
     {
@@ -929,20 +929,19 @@ class format_input_handler<bcf> :
 
                 /* we transform number to string and store in caches */
                 std::visit(
-                  [&]<typename rng_t>(rng_t && int_range)
+                  [&]<typename rng_t>(rng_t && rng)
                   {
-                      using innermost_val_t = bio::ranges::range_innermost_value_t<rng_t>;
                       if constexpr (std::ranges::range<std::ranges::range_value_t<rng_t>> &&
-                                    std::integral<innermost_val_t> && !std::same_as<innermost_val_t, char>)
+                                    detail::int_range<std::ranges::range_value_t<rng_t>>)
                       {
-                          if (std::ranges::size(int_range) != record_core->n_sample)
+                          if (std::ranges::size(rng) != record_core->n_sample)
                               error("Expected exactly one GT string per sample.");
 
                           for (size_t sample = 0; sample < record_core->n_sample; ++sample)
                           {
                               gt_cache[sample].clear();
                               number_cache.clear();
-                              parse_gt_field(int_range[sample], number_cache, gt_cache[sample]);
+                              parse_gt_field(rng[sample], number_cache, gt_cache[sample]);
                           }
                       }
                       else
@@ -981,7 +980,7 @@ class format_input_handler<bcf> :
     }
 
     //!\brief Reading of the GENOTYPES field.
-    template <detail::back_insertable field_t>
+    template <ranges::back_insertable field_t>
         requires detail::genotype_reader_concept<std::ranges::range_reference_t<field_t>>
     void parse_field(meta::vtag_t<detail::field::genotypes> const & /**/, field_t & parsed_field)
     {

include/bio/io/format/bcf_output_handler.hpp

@@ -175,9 +175,9 @@ class format_output_handler<bcf>
     {
         size_t run_length = 1;
 
-        auto eq = detail::overloaded{[](std::ranges::range auto && lhs, std::ranges::range auto && rhs)
-                                     { return std::ranges::equal(lhs, rhs); },
-                                     [](auto && lhs, auto && rhs) { return lhs == rhs; }};
+        auto eq = meta::overloaded{[](std::ranges::range auto && lhs, std::ranges::range auto && rhs)
+                                   { return std::ranges::equal(lhs, rhs); },
+                                   [](auto && lhs, auto && rhs) { return lhs == rhs; }};
 
         for (auto rit = std::ranges::begin(range), next = std::ranges::next(rit); rit != std::ranges::end(range);
              ++rit, ++next)
@@ -446,8 +446,8 @@ class format_output_handler<bcf>
             return;
         }
 
-        auto to_size = detail::overloaded{[](char const * const cstr) { return std::string_view{cstr}.size(); },
-                                          [](std::ranges::range auto & rng) { return std::ranges::distance(rng); }};
+        auto to_size = meta::overloaded{[](char const * const cstr) { return std::string_view{cstr}.size(); },
+                                        [](std::ranges::range auto & rng) { return std::ranges::distance(rng); }};
 
         size_t size_sum = std::transform_reduce(std::ranges::begin(vector_of_string),
                                                 std::ranges::end(vector_of_string),
@@ -999,10 +999,12 @@ class format_output_handler<bcf>
             write_header();
         }
 
-        static_assert(!detail::decays_to<typename record_t::chrom_t, ignore_t>,
+        static_assert(meta::different_from<typename record_t::chrom_t, ignore_t>,
                       "The record must contain the CHROM field.");
-        static_assert(!detail::decays_to<typename record_t::pos_t, ignore_t>, "The record must contain the POS field.");
-        static_assert(!detail::decays_to<typename record_t::ref_t, ignore_t>, "The record must contain the REF field.");
+        static_assert(meta::different_from<typename record_t::pos_t, ignore_t>,
+                      "The record must contain the POS field.");
+        static_assert(meta::different_from<typename record_t::ref_t, ignore_t>,
+                      "The record must contain the REF field.");
 
         /* IMPLEMENTATION NOTE:
          * A problem when writing BCF is that the first fields of the record hold the size of the record
@@ -1038,45 +1040,45 @@ class format_output_handler<bcf>
 
         set_core_rlen(record.ref);
 
-        if constexpr (!detail::decays_to<typename record_t::qual_t, ignore_t>)
+        if constexpr (meta::different_from<typename record_t::qual_t, ignore_t>)
             set_core_qual(record.qual);
 
-        if constexpr (!detail::decays_to<typename record_t::info_t, ignore_t>)
+        if constexpr (meta::different_from<typename record_t::info_t, ignore_t>)
             set_core_n_info(record.info);
 
-        if constexpr (!detail::decays_to<typename record_t::alt_t, ignore_t>)
+        if constexpr (meta::different_from<typename record_t::alt_t, ignore_t>)
             set_core_n_allele(record.alt);
         else
             record_core.n_allele = 1; // the REF allele
 
         record_core.n_sample = header->column_labels.size() > 9 ? header->column_labels.size() - 9 : 0;
 
-        if constexpr (!detail::decays_to<typename record_t::genotypes_t, ignore_t>)
+        if constexpr (meta::different_from<typename record_t::genotypes_t, ignore_t>)
             set_core_n_fmt(record.genotypes);
 
         // write record core
         it->write_as_binary(record_core);
 
         /* After this point, the order of writers is important! */
 
-        if constexpr (!detail::decays_to<typename record_t::id_t, ignore_t>)
+        if constexpr (meta::different_from<typename record_t::id_t, ignore_t>)
             write_field(meta::vtag<detail::field::id>, record.id);
         else
             write_field(meta::vtag<detail::field::id>, std::string_view{});
 
         write_field(meta::vtag<detail::field::ref>, record.ref);
 
-        if constexpr (!detail::decays_to<typename record_t::alt_t, ignore_t>)
+        if constexpr (meta::different_from<typename record_t::alt_t, ignore_t>)
             write_field(meta::vtag<detail::field::alt>, record.alt);
         else
             write_field(meta::vtag<detail::field::alt>, std::span<std::string_view>{});
 
-        if constexpr (!detail::decays_to<typename record_t::filter_t, ignore_t>)
+        if constexpr (meta::different_from<typename record_t::filter_t, ignore_t>)
             write_field(meta::vtag<detail::field::filter>, record.filter);
         else
             write_field(meta::vtag<detail::field::filter>, std::span<std::string_view>{});
 
-        if constexpr (!detail::decays_to<typename record_t::info_t, ignore_t>)
+        if constexpr (meta::different_from<typename record_t::info_t, ignore_t>)
             write_field(meta::vtag<detail::field::info>, record.info);
         else
             write_field(meta::vtag<detail::field::info>, std::span<var_io::info_element<>>{});
@@ -1087,7 +1089,7 @@ class format_output_handler<bcf>
 
         if (header->column_labels.size() > 8)
         {
-            if constexpr (!detail::decays_to<typename record_t::genotypes_t, ignore_t>)
+            if constexpr (meta::different_from<typename record_t::genotypes_t, ignore_t>)
                 write_field(meta::vtag<detail::field::genotypes>, record.genotypes);
             else
                 write_field(meta::vtag<detail::field::genotypes>, std::span<var_io::genotype_element<>>{});

include/bio/io/format/format_input_handler.hpp

@@ -18,6 +18,7 @@
 #include <vector>
 
 #include <bio/meta/tag/vtag.hpp>
+#include <bio/ranges/concept.hpp>
 #include <bio/ranges/views/char_strictly_to.hpp>
 
 #include <bio/io/detail/charconv.hpp>
@@ -139,15 +140,15 @@ class format_input_handler_base
     }
 
     //!\brief Parse into string-like types.
-    template <detail::back_insertable parsed_field_t>
+    template <ranges::back_insertable parsed_field_t>
         requires detail::char_range<parsed_field_t>
     static void parse_field_aux(std::string_view const in, parsed_field_t & parsed_field)
     {
         detail::sized_range_copy(in, parsed_field);
     }
 
     //!\brief Parse into containers of alphabets.
-    template <detail::back_insertable parsed_field_t>
+    template <ranges::back_insertable parsed_field_t>
         requires detail::deliberate_alphabet<std::ranges::range_reference_t<parsed_field_t>>
     static void parse_field_aux(std::string_view const in, parsed_field_t & parsed_field)
     {