# std::experimental::ranges::WeaklyIncrementable

> C++ Atlas: `cppatlas.com/w/cpp/experimental/ranges/iterator/WeaklyIncrementable` | Source: https://en.cppreference.com/w/cpp/experimental/ranges/iterator/WeaklyIncrementable | Domain: Technical specifications

The concept WeaklyIncrementable<I> specifies the requirements on a type that can be incremented (with the pre- and post-increment operators).

## Official Specification Summary (cppreference)

```cpp
// Defined in header <experimental/ranges/iterator>

template< class I >
concept bool WeaklyIncrementable =
    Semiregular<I> &&
    requires(I i) {
        typename ranges::difference_type_t<I>;
        requires SignedIntegral<ranges::difference_type_t<I>>;
        { ++i } -> Same<I>&; /* not required to be equality preserving */
        i++; /* not required to be equality preserving */
    }; // (ranges TS)
```

The concept `WeaklyIncrementable<I>` specifies the requirements on a type that can be incremented (with the pre- and post-increment operators). The increment operations need not be equality-preserving, and the type need not be `EqualityComparable`.

Let `i` be an object of type `I`. `i` is said to be *incrementable* if it is in the domain of both pre- and post-increment. `WeaklyIncrementable<I>` is satisfied only if:

- `++i` and `i++` have the same domain;
- If `i` is incrementable, then:
  - `++i` and `i++` both advance `i` to the next element; and
  - `++i` refers to the same object as `i`.

### Equality preservation

An expression is *equality preserving* if it results in equal outputs given equal inputs.

- The inputs to an expression consist of its operands.
- The outputs of an expression consist of its result and all operands modified by the expression (if any).

Every expression required to be equality preserving is further required to be *stable*: two evaluations of such an expression with the same input objects must have equal outputs absent any explicit intervening modification of those input objects.

### Notes

For `WeaklyIncrementable` types, `a` equals `b` does not imply that `++a` equals `++b`. Algorithms on such types should be single pass and never attempt to pass through the same value twice.

---
Attribution: content from https://en.cppreference.com/w/cpp/experimental/ranges/iterator/WeaklyIncrementable (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.