0001    // MARK: - Eager
0002    
0003    // MARK: Cycle n
0004    
0005    public extension CollectionType {
0006      
0007      /// Returns an array of n cycles of self.
0008      /// ```swift
0009      /// [1, 2, 3].cycle(2)
0010      ///
0011      /// [1, 2, 3, 1, 2, 3]
0012      /// ```
0013      @warn_unused_result
0014      func cycle(n: Int) -> [Generator.Element] {
0015        var cycled: [Generator.Element] = []
0016        cycled.reserveCapacity(underestimateCount() * n)
0017        for _ in ..<n {
0018          cycled.appendContentsOf(self)
0019        }
0020        return cycled
0021      }
0022    }
0023    
0024    // MARK: - Lazy
0025    
0026    // MARK: Cycle n
0027    /// :nodoc:
0028    public struct CycleNGen
Cycle.swift:53
  func cycle(n: Int) -> CycleNGen<Self> {
Cycle.swift:54
    return CycleNGen(inner: self, innerGen: generate(), n: n)<C
Cycle.swift:30
  private let inner: C
Cycle.swift:31
  private var innerGen: C.Generator
Cycle.swift:34
  public mutating func next() -> C.Generator.Element? {: CollectionType> : GeneratorType, LazySequenceType {
0029      
0030      private let inner
Cycle.swift:38
      if n > 0 { innerGen = inner.generate() }: C
0031      private var innerGen
Cycle.swift:36
      if let next = innerGen.next() { return next }
Cycle.swift:38
      if n > 0 { innerGen = inner.generate() }: C.Generator
0032      private var n
Cycle.swift:37
      n -= 1
Cycle.swift:38
      if n > 0 { innerGen = inner.generate() }: Int
0033      /// :nodoc:
0034      public mutating func next() -> C.Generator.Element? {
0035        while true {
0036          if let next = innerGen.next() { return next }
0037          n -= 
0038          if n >  { innerGen = inner.generate() }
0039          else { return nil }
0040        }
0041      }
0042    }
0043    
0044    public extension LazySequenceType where Self : CollectionType {
0045      
0046      /// Returns a generator of n cycles of self.
0047      /// ```swift
0048      /// [1, 2, 3].lazy.cycle(2)
0049      ///
0050      /// 1, 2, 3, 1, 2, 3
0051      /// ```
0052      @warn_unused_result
0053      func cycle(n: Int) -> CycleNGen<Self> {
0054        return CycleNGen(inner: self, innerGen: generate(), n: n)
0055      }
0056    }
0057    
0058    // MARK: Cycle infinite
0059    /// :nodoc:
0060    public struct CycleGen
Cycle.swift:83
  func cycle() -> CycleGen<Self> {
Cycle.swift:84
    return CycleGen(inner: self, innerGen: generate())<C
Cycle.swift:62
  private let inner: C
Cycle.swift:63
  private var innerGen: C.Generator
Cycle.swift:65
  public mutating func next() -> C.Generator.Element? {: CollectionType> : GeneratorType, LazySequenceType {
0061      
0062      private let inner
Cycle.swift:66
    for ;;innerGen = inner.generate() {: C
0063      private var innerGen
Cycle.swift:66
    for ;;innerGen = inner.generate() {
Cycle.swift:67
      if let next = innerGen.next() {: C.Generator
0064      /// :nodoc:
0065      public mutating func next() -> C.Generator.Element? {
0066        for ;;innerGen = inner.generate() {
0067          if let next = innerGen.next() {
0068            return next
0069          }
0070        }
0071      }
0072    }
0073    
0074    public extension CollectionType {
0075      
0076      /// Returns an infinite generator of cycles of self.
0077      /// ```swift
0078      /// [1, 2, 3].cycle()
0079      ///
0080      /// 1, 2, 3, 1, 2, 3, 1...
0081      /// ```
0082      @warn_unused_result
0083      func cycle() -> CycleGen<Self> {
0084        return CycleGen(inner: self, innerGen: generate())
0085      }
0086    }
0087