 }
 
 internal
-func _advanceForward<T : _ForwardIndexType>(start: T, _ n: T.Distance) -> T {
+func _advanceForward<T : ForwardIndexType>(start: T, _ n: T.Distance) -> T {
   _precondition(n >= 0,
       "Only BidirectionalIndexType can be advanced by a negative amount")
   var p = start


/// Do not use this operator directly; call advance(start, n) instead.
@transparent
public func ~> <T : _ForwardIndexType>(
  start: T, rest: (_Advance, T.Distance)
) -> T {
  let n = rest.1

/// Represents a discrete value in a series, where a value's
/// successor, if any, is reachable by applying the value's
/// `successor()` method.
public protocol ForwardIndexType : _Incrementable {
  /// A type that can represent the number of steps between pairs of
  /// `Self` values where one value is reachable from the other.
  ///
  /// Reachability is defined by the ability to produce one value from
  /// the other via zero or more applications of `successor`.
  typealias Distance : _SignedIntegerType = Int

  // See the implementation of Range for an explanation of this
  // associated type
  typealias _DisabledRangeIndex = _DisabledRangeIndex_

  // This requirement allows generic distance() to find default
  // implementations.  Only the author of F and the author of a
  // refinement of F having a non-default distance implementation need
