#### Forward Sequence

##### Description

A Forward Sequence is a Sequence whose elements are arranged in a definite order. The ordering is guaranteed not to change from iteration to iteration. The requirement of a definite ordering allows the definition of element-by-element equality (if the container's element type is Equality Comparable) and of lexicographical ordering (if the container's element type is LessThan Comparable).

Notation

`s`
A Forward Sequence
`S`
A Forward Sequence type
`o`
An arbitrary object
`e`
A Sequence element
##### Valid Expressions

For any Forward Sequence the following expressions must be valid:

Expression

Return type

Type Requirements

Runtime Complexity

`begin(s)`

Constant

`end(s)`

Constant

`size(s)`

MPL Integral Constant. Convertible to int.

Constant

`empty(s)`

MPL Boolean Constant. Convertible to bool.

Constant

`front(s)`

Any type

Constant

```front(s) = o```

Any type

`s` is mutable and ```e = o```, where `e` is the first element in the sequence, is a valid expression.

Constant

##### Result Type Expressions

Expression

Compile Time Complexity

`result_of::begin<S>::type`

Amortized constant time

`result_of::end<S>::type`

Amortized constant time

`result_of::size<S>::type`

Unspecified

`result_of::empty<S>::type`

Constant time

`result_of::front<S>::type`

Amortized constant time

##### Expression Semantics

Expression

Semantics

`begin(s)`

An iterator to the first element of the sequence; see `begin`.

`end(s)`

A past-the-end iterator to the sequence; see `end`.

`size(s)`

The size of the sequence; see `size`.

`empty(s)`

A boolean Integral Constant `c` such that ```c::value == true``` if and only if the sequence is empty; see `empty`.

`front(s)`

The first element in the sequence; see `front`.

##### Invariants

For any Forward Sequence s the following invariants always hold:

• `[begin(s), end(s))` is always a valid range.
• An Algorithm that iterates through the range `[begin(s), end(s))` will pass through every element of `s` exactly once.
• `begin(s)` is identical to `end(s))` if and only if `s` is empty.
• Two different iterations through `s` will access its elements in the same order.