LazyCollection.swift.gyb

//===--- LazyCollection.swift ---------------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

%for traversal in [ 'Forward', 'Bidirectional', 'RandomAccess' ]:
%  whereClause = 'where S.Index : %sIndexType' % traversal
%  Self = 'Lazy%sCollection' % traversal

/// A collection that forwards its implementation to an underlying
/// collection instance while exposing lazy computations as methods.
public struct ${Self}<S: CollectionType ${whereClause}> : CollectionType {
  
  /// Construct an instance with `base` as its underlying collection
  /// instance.
  public init(_ base: S) {
    self._base = base
  }

  /// Return a *generator* over the elements of this *sequence*.
  ///
  /// Complexity: O(1)
  public func generate() -> S.Generator {
    return self._base.generate()
  }

  /// The position of the first element in a non-empty collection.
  ///
  /// Identical to `endIndex` in an empty collection.
  public var startIndex: S.Index {
    return _base.startIndex
  }
  
  /// The collection's "past the end" position.
  ///
  /// `endIndex` is not a valid argument to `subscript`, and is always
  /// reachable from `startIndex` by zero or more applications of
  /// `successor()`.
  public var endIndex: S.Index {
    return _base.endIndex
  }

  /// True if and only if the collection is empty
  public
  var isEmpty: Bool {
    return startIndex == endIndex
  }

  /// The first element, or `nil` if `self` is empty
  public var first: S.Generator.Element? {
    return Swift.first(self)
  }

%  if traversal != 'Forward':
  /// The last element, or `nil` if `self` is empty
  public var last: S.Generator.Element? {
    return Swift.last(self)
  }
%  end

  /// Access the element at `position`.
  ///
  /// Requires: `position` is a valid position in `self` and
  /// `position != endIndex`.
  public
  subscript(position: S.Index) -> S.Generator.Element {
    return _base[position]
  }
  
  /// an Array, created on-demand, containing the elements of this
  /// lazy CollectionType.
  public var array: [S.Generator.Element] {
    return Array(_base)
  }

  var _base: S
}

public func ~> <S : CollectionType ${whereClause}> (
  s: ${Self}<S>, _: (_UnderestimateCount, ())
) -> Int {
  return underestimateCount(s._base)
}

/// Augment `s` with lazy methods such as `map`, `filter`, etc.
public
func lazy<S: CollectionType ${whereClause}>(s: S) -> ${Self}<S> {
  return ${Self}(s)
}

%end

// ${'Local Variables'}:
// eval: (read-only-mode 1)
// End: