A Forward Iterator `i` is a type that represents a positional reference
to an element of a Forward Sequence. It allows to access the element through
a dereference operation, and provides a way to obtain an iterator to
the next element in a sequence.

- An iterator can be dereferenceable, meaning that
`deref<i>::type`
is a well-defined expression.
- An iterator is past-the-end if it points beyond the last element of a
sequence; past-the-end iterators are non-dereferenceable.
- An iterator
`i` is incrementable if there is a "next" iterator, that
is, if `next<i>::type` expression is well-defined; past-the-end iterators are
not incrementable.
- Two iterators into the same sequence are equivalent if they have the same
type.
- An iterator
`j` is reachable from an iterator `i` if , after recursive
application of `next` metafunction to `i` a finite number of times, `i`
is equivalent to `j`.
- The notation [
`i`,`j`) refers to a range of iterators beginning with
`i` and up to but not including `j`.
- The range [
`i`,`j`) is a valid range if `j` is reachable from `i`.

Expression |
Type |
Complexity |

`deref<i>::type` |
Any type |
Amortized constant time |

`next<i>::type` |
Forward Iterator |
Amortized constant time |

`i::category` |
Integral Constant, convertible
to `forward_iterator_tag` |
Constant time |

typedef deref<i>::type j;

Precondition: | `i` is dereferenceable |

Semantics: | `j` is identical to the type of the pointed element |

typedef next<i>::type j;

Precondition: | `i` is incrementable |

Semantics: | `j` is the next iterator in a sequence |

Postcondition: | `j` is dereferenceable or past-the-end |

typedef i::category c;

Semantics: | `c` is identical to the iterator's category tag |

For any forward iterators `i` and `j` the following invariants always hold:

`i` and `j` are equivalent if and only if they are pointing to the same
element.
- If
`i` is dereferenceable, and `j` is equivalent to `i`, then `j` is
dereferenceable as well.
- If
`i` and `j` are equivalent and dereferenceable, then `deref<i>::type`
and `deref<j>::type` are identical.
- If
`i` is incrementable, and `j` is equivalent to `i`, then `j` is
incrementable as well.
- If
`i` and `j` are equivalent and incrementable, then `next<i>::type`
and `next<j>::type` are equivalent.