Exercising Ranges (part 3)

(Start at the beginning of the series if you want more context.)

So, I was going to implement monoidal_zip, and to do that, I would clone zip_with.hpp. So I did that. Eric’s a great library author, and the ranges code is pretty easy to read. For the most part I found it concise, well-expressed and clear. The parts I didn’t immediately understand were owing to my own (temporary) ignorance and not a result of murky code.

Since zip_with takes N ranges and an n-ary function, it’s written with variadic templates and folding operations over parameter packs. A monoid by definition only uses a binary operation, so I immediately simplified that. Then I worked through each part of the file, adapting it to my use case.

Range cardinality

The first things in zip_with.hpp are a bunch of constexpr functions in a detail namespace, and then a cardinality calculation. Range cardinality turns out to be an enumeration with three members – infinite (-3), unknown (-2), and finite (-1) – and then a value of zero or above is a known cardinality such as might be obtained at compile-time from an array.

Aside: I didn’t think about/realise until much later that the cardinality of a vector isn’t known at compile time. Perhaps it could be in some cases – a shortcoming of the STL re constexpr?

In the case of known cardinalities, zip_with uses the minimum of the N ranges; I needed the maximum. Simple, if verbose to deal with the other possible enum values.

namespace detail
{
  template<typename C1, typename C2>
  using monoidal_zip_cardinality =
    std::integral_constant<cardinality,
      C1::value == infinite || C2::value == infinite ?
        infinite :
        C1::value == unknown || C2::value == unknown ?
          unknown :
          C1::value >= 0 && C2::value >= 0 ?
            max_(C1::value, C2::value) :
            finite>;
} // namespace detail

(The function max_ is one of Eric’s existing constexpr functions in zip_with.hpp.)

Cursors and sentinels

The main work in writing any view is of course, defining the cursor and the sentinel (internal representations of iterators: the view provides begin_cursor and end_cursor functions – in const and mutable forms – which return a cursor and a sentinel respectively).

There are a few simplifying implementation patterns I found in several views that I adopted. Commonly the cursor and the sentinel are templated on a bool representing constness. And it’s also common for the cursor to need a pointer back to the range it’s iterating over, and that pointer needs the right constness, so we end up with code like:

template<typename Fun, typename R1, typename R2>
struct iter_monoidal_zip_view
  : view_facade<iter_monoidal_zip_view<Fun, R1, R2>,
                detail::monoidal_zip_cardinality<range_cardinality<R1>,
                                                 range_cardinality<R2>>::value>
{
  ...
  template <bool IsConst>
  struct cursor
  {
    ...
  private:
    friend struct sentinel<IsConst>;
    // add a const if I am const
    template <typename T>
    using constify_if = meta::apply<meta::add_const_if_c<IsConst>, T>;
    // pointer to my view
    using monoidal_zip_view_t = constify_if<iter_monoidal_zip_view>;
    monoidal_zip_view_t *rng_;
    // iterators I use
    range_iterator_t<constify_if<R1>> it1_;
    range_iterator_t<constify_if<R2>> it2_;
    ...
  };
  ...
};

Satisfying the Concepts

I wanted a reversible range. That meant I needed my cursor to be bidirectional. Every cursor must implement current, next and equal, and of course a bidirectional cursor must implement prev:

auto current() const;
void next();
void prev();
bool equal(cursor const& that) const;

Every sentinel implements comparison with a cursor:

bool equal(cursor<IsConst> const &pos) const;

And the range itself implements begin_cursor and end_cursor, with end_cursor returning either a cursor or a sentinel depending on whether the underlying ranges are bounded:

  using are_bounded_t = meta::and_c<(bool) BoundedRange<R1>(),
                                    (bool) BoundedRange<R2>()>;
 
  cursor<false> begin_cursor()
  {
    return {*this, fun_, begin_tag{}};
  }
  meta::if_<are_bounded_t, cursor<false>, sentinel<false>>
  end_cursor()
  {
    return {*this, fun_, end_tag{}};
  }

(I omitted the const versions of these functions which use the CONCEPT_REQUIRES macro as a nice wrapper for enable_if style functionality.)

Nice conventions

In order that views work on containers-as-ranges, various views simply use view::all to turn whatever container is passed in into a range. If actual ranges are passed in, view::all just forwards them, unaffected. This is very handy.

There is a convention in the ranges code that deals with reporting concept violations to the user: separate out the concept as a template alias, eg:

template<typename Fun, typename R1, typename R2>
using Concept = meta::and_<
  InputRange<R1>, InputRange<R2>,
  Callable<Fun, range_reference_t<R1> &&, range_reference_t<R2> &&>>;

And write the required function with an overloaded version which uses the CONCEPT_REQUIRES_ macro in an inverted sense from the “normal” version:

// "normal" version
template<typename R1, typename R2, typename Fun,
         CONCEPT_REQUIRES_(Concept<Fun, R1, R2>())>
monoidal_zip_view<Fun, all_t<R1>, all_t<R2>> operator()(
    Fun fun, R1 && r1, R2 && r2) const
{ ... }
 
// "concept failed" version
template<typename Fun, typename R1, typename R2,
         CONCEPT_REQUIRES_(!Concept<Fun, R1, R2>())>
void operator()(Fun, R1 &&, R2 &&) const
{ CONCEPT_ASSERT_MESSAGE(...); }

The actual work

So, how does the cursor actually work? The idea is fairly simple. Keep an iterator to each range that the view is considering. Usually they advance together. When we run out of one range, keep track of the difference between the iterators, to enable reverse iteration. The rest is bookkeepping. (Error-prone, exacting bookkeeping: I didn’t get reverse iteration working properly until I gave the whole thing a proper workout with unit tests. Off-by-one errors, one of the three hardest things in computer science.)

The monoidal_zip view’s begin is when both iterators are at their respective begins, and the corresponding thing is true for end. You can find the implementation on github – it’s too much for an already long post.

Writing current is easy, we just need to check the iterators to do the monoid identity thing if needed:

auto current() const
RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
(
  diff_ == 0 ?
    fun_(it1_, it2_) :
    diff_ > 0 ? *it1_ : *it2_
)

And that’s it. Now we have monoidal_zip, which fulfils the needs of adding power series (and also subtracting them). It works on anything that’s a monoid, not just addition. And it’s reversible. In implementing this, I discovered that the result of reversing zip_with may be surprising: because the ranges are lazily traversed, effectively it’s as if the ranges were reversed inside the zip. If the ranges are different lengths, that may not be what you want, but if you think about it, it sort of has to be that way?

After that lengthy workout, in the next instalment something easier: pretty-printing power series.

One Response to “Exercising Ranges (part 3)”

  1. Eric Niebler Says:

    > In implementing this, I discovered that the result of reversing
    > zip_with may be surprising: because the ranges are lazily
    > traversed, effectively it’s as if the ranges were reversed inside
    > the zip. If the ranges are different lengths, that may not be
    > what you want

    Huh. I had never considered that. It might be a precondition on the decrement operator of the end iterator that the ranges are of equal lengths. It’s weird.

Leave a Reply