0001    // MARK: - Eager
0002    
0003    // MARK: Categorise
0004    
0005    public extension SequenceType {
0006      
0007      /**
0008      Categorises elements of `self` into a dictionary, with the keys
0009      given by `keyFunc`
0010      ```swift
0011      struct Person : CustomStringConvertible {
0012        let name: String
0013        let age : Int
0014        init(_ name: String, _ age: Int) {
0015          self.name = name
0016          self.age  = age
0017        }
0018        var description: String { return name }
0019      }
0020      
0021      let people = [ 
0022        Person("Jo", 20),
0023        Person("An", 20),
0024        Person("Cthulu", 4000)
0025      ]
0026      
0027      people.categorise { p in p.age }
0028      
0029      //[20: [Jo, An], 4000: [Cthulu]]
0030      ```
0031      */
0032      @warn_unused_result
0033      func categorise<U : Hashable>(@noescape keyFunc: Generator.Element throws -> U)
0034        rethrows -> [U:[Generator.Element]] {
0035        var dict: [U:[Generator.Element]] = [:]
0036        for el in self {
0037          let key = try keyFunc(el)
0038          if case nil = dict[key]?.append(el) { dict[key] = [el] }
0039        }
0040        return dict
0041      }
0042    }
0043    
0044    public extension SequenceType where Generator.Element : Hashable {
0045      
0046      // MARK: Frequencies
0047      
0048      /** 
0049      Returns a dictionary where the keys are the elements of self, and
0050      the values are their respective frequencies 
0051      ```swift
0052      [0, 3, 0, 1, 1, 3, 2, 3, 1, 0].freqs()
0053      // [2: 1, 0: 3, 3: 3, 1: 3]
0054      ```
0055      */
0056      @warn_unused_result
0057      func freqs() -> [Generator.Element:Int] {
0058        var freqs: [Generator.Element:Int] = [:]
0059        for el in self { freqs[el] = freqs[el]?.successor() ??  }
0060        return freqs
0061      }
0062      
0063      // MARK: Uniques
0064      
0065      /** 
0066      Returns an array of the elements of `self`, in order, with
0067      duplicates removed
0068      ```swift
0069      [3, 1, 2, 3, 2, 1, 1, 2, 3, 3].uniques()
0070      // [3, 1, 2]
0071      ```
0072      */
0073      @warn_unused_result
0074      public func uniques() -> [Generator.Element] {
0075        var prevs: Set<Generator.Element> = []
0076        var uniqs: [Generator.Element] = []
0077        for el in self where !prevs.contains(el) {
0078          prevs.insert(el)
0079          uniqs.append(el)
0080        }
0081        return uniqs
0082      }
0083      
0084      /// Returns the element which occurs most frequently in `self`
0085      @warn_unused_result
0086      public func mostFrequent() -> Generator.Element? {
0087        var g = generate()
0088        guard let b = g.next() else { return nil }
0089        var be = b
0090        var bn = 
0091        var freqs: [Generator.Element:Int] = [:]
0092        for e in self {
0093          let n = (freqs[e] ?? ) + 
0094          if n > bn { (be,bn) = (e,n) }
0095          freqs[e] = n
0096        }
0097        return be
0098      }
0099    }
0100    
0101    // MARK: - Lazy
0102    
0103    // MARK: Uniques
0104    /// :nodoc:
0105    public struct UniquesGen
Categorise.swift:127
  public func generate() -> UniquesGen<S.Generator> {
Categorise.swift:128
    return UniquesGen(prevs: [], g: seq.generate())<G
Categorise.swift:107
  private var prevs: Set<G.Element>
Categorise.swift:108
  private var g: G
Categorise.swift:110
  public mutating func next() -> G.Element? { : GeneratorType where G.Element : Hashable> : GeneratorType {
0106      
0107      private var prevs
Categorise.swift:112
      if !prevs.contains(next) {
Categorise.swift:113
        prevs.insert(next): Set<G.Element>
0108      private var g
Categorise.swift:111
    while let next = g.next() {: G
0109      /// :nodoc:
0110      public mutating func next() -> G.Element? {
0111        while let next = g.next() {
0112          if !prevs.contains(next) {
0113            prevs.insert(next)
0114            return next
0115          }
0116        }
0117        return nil
0118      }
0119    }
0120    /// :nodoc:
0121    public struct UniquesSeq
Categorise.swift:137
  func uniques() -> UniquesSeq<Self> {
Categorise.swift:138
    return UniquesSeq(seq: self)<
0122      S
Categorise.swift:125
  private let seq: S
Categorise.swift:127
  public func generate() -> UniquesGen<S.Generator> { : SequenceType where
0123      S.Generator.Element : Hashable
0124      > : LazySequenceType {
0125      private let seq
Categorise.swift:128
    return UniquesGen(prevs: [], g: seq.generate()): S
0126      /// :nodoc:
0127      public func generate() -> UniquesGen<S.Generator> {
0128        return UniquesGen(prevs: [], g: seq.generate())
0129      }
0130    }
0131    
0132    public extension LazySequenceType where Generator.Element : Hashable {
0133      
0134      /// returns a `LazySequence` of the elements of `self`, in order, with
0135      /// duplicates removed
0136      @warn_unused_result
0137      func uniques() -> UniquesSeq<Self> {
0138        return UniquesSeq(seq: self)
0139      }
0140    }
0141    
0142    // MARK: Grouping
0143    
0144    /// :nodoc:
0145    
0146    public struct GroupByGen
Categorise.swift:178
  public func generate() -> GroupByGen<S.Generator> {
Categorise.swift:179
    return GroupByGen(g: seq.generate(), isEquivalent: isEquivalent)<G
Categorise.swift:148
  private var genr: G
Categorise.swift:149
  private var last: G.Element?
Categorise.swift:150
  private let isEq: (G.Element, G.Element) -> Bool
Categorise.swift:150
  private let isEq: (G.Element, G.Element) -> Bool
Categorise.swift:152
  mutating public func next() -> [G.Element]? {
Categorise.swift:165
  private init(g : G, isEquivalent: (G.Element, G.Element) -> Bool) {
Categorise.swift:165
  private init(g : G, isEquivalent: (G.Element, G.Element) -> Bool) {
Categorise.swift:165
  private init(g : G, isEquivalent: (G.Element, G.Element) -> Bool) { : GeneratorType> : GeneratorType {
0147      
0148      private var genr
Categorise.swift:156
    while let next = genr.next() {
Categorise.swift:166
    genr = g
Categorise.swift:167
    last = genr.next(): G
0149      private var last
Categorise.swift:153
    guard let head = last else { return nil }
Categorise.swift:155
    last = nil
Categorise.swift:158
        last = next
Categorise.swift:167
    last = genr.next(): G.Element?
0150      private let isEq
Categorise.swift:157
      guard isEq(group.last!, next) else {
Categorise.swift:168
    isEq = isEquivalent: (G.Element, G.Element) -> Bool
0151      /// :nodoc:
0152      mutating public func next() -> [G.Element]? {
0153        guard let head = last else { return nil }
0154        var group = [head]
0155        last = nil
0156        while let next = genr.next() {
0157          guard isEq(group.last!, next) else {
0158            last = next
0159            return group
0160          }
0161          group.append(next)
0162        }
0163        return group
0164      }
0165      private init
Categorise.swift:179
    return GroupByGen(g: seq.generate(), isEquivalent: isEquivalent)(g : G, isEquivalent: (G.Element, G.Element) -> Bool) {
0166        genr = g
0167        last = genr.next()
0168        isEq = isEquivalent
0169      }
0170    }
0171    
0172    /// :nodoc:
0173    
0174    public struct GroupBySeq
Categorise.swift:192
  func group() -> GroupBySeq<Self> {
Categorise.swift:193
    return GroupBySeq(seq: self, isEquivalent: ==)
Categorise.swift:208
    -> GroupBySeq<Self> {
Categorise.swift:209
      return GroupBySeq(seq: self, isEquivalent: isEquivalent)<S
Categorise.swift:175
  private let seq: S
Categorise.swift:176
  private let isEquivalent: (S.Generator.Element, S.Generator.Element) -> Bool
Categorise.swift:176
  private let isEquivalent: (S.Generator.Element, S.Generator.Element) -> Bool
Categorise.swift:178
  public func generate() -> GroupByGen<S.Generator> { : SequenceType> : LazySequenceType {
0175      private let seq
Categorise.swift:179
    return GroupByGen(g: seq.generate(), isEquivalent: isEquivalent): S
0176      private let isEquivalent
Categorise.swift:179
    return GroupByGen(g: seq.generate(), isEquivalent: isEquivalent): (S.Generator.Element, S.Generator.Element) -> Bool
0177      /// :nodoc:
0178      public func generate() -> GroupByGen<S.Generator> {
0179        return GroupByGen(g: seq.generate(), isEquivalent: isEquivalent)
0180      }
0181    }
0182    
0183    public extension LazySequenceType where Generator.Element : Equatable {
0184      
0185      /// Returns a lazy sequence of self, chunked into arrays of adjacent equal values
0186      /// ```swift
0187      /// [1, 2, 2, 3, 1, 1, 3, 4, 2].lazy.group()
0188      ///
0189      /// [1], [2, 2], [3], [1, 1], [3], [4], [2]
0190      /// ```
0191      @warn_unused_result
0192      func group() -> GroupBySeq<Self> {
0193        return GroupBySeq(seq: self, isEquivalent: ==)
0194      }
0195    }
0196    
0197    public extension LazySequenceType {
0198      
0199      /// Returns a lazy sequence of self, chunked into arrays of adjacent equal values
0200      /// - Parameter isEquivalent: a function that returns true if its two parameters are equal
0201      /// ```swift
0202      /// [1, 3, 5, 20, 22, 18, 6, 7].lazy.groupBy { (a,b) in abs(a - b) < 5 }
0203      ///
0204      /// [1, 3, 5], [20, 22, 18], [6, 7]
0205      /// ```
0206      @warn_unused_result
0207      func group(isEquivalent: (Generator.Element, Generator.Element) -> Bool)
0208        -> GroupBySeq<Self> {
0209          return GroupBySeq(seq: self, isEquivalent: isEquivalent)
0210      }
0211    }
0212