Add uniq() to SequenceType

[shimesaba9]

No description provided.

[rothomp3]

This is not actually the right way to do this, because it's O(n^2). See http://airspeedvelocity.net/2015/08/03/arrays-linked-lists-and-performance/ for details. You should switch to using a temporary array and a plain old for loop, despite the ugliness.

[kaandedeoglu]

@rothomp3 beat me to it :) yes reduce can really suffer performance-wise. here's an elegant answer I stumbled upon a few month back (it's a global function in this case, but making it into a protocol extension is trivial)

func uniq<S: SequenceType, E: Hashable where E == S.Generator.Element>(source: S) -> [E] {
  var seen = [E: Bool]()
  return source.filter { seen.updateValue(true, forKey: $0) == nil }
}

http://stackoverflow.com/a/33984316/870155

[oisdk]

The dictionary is probably unnecessary - there's no need to store the Bool values. You could do the same with just a Set:

extension SequenceType where Generator.Element : Hashable {

  public func uniq() -> [Generator.Element] {
    var prevs: Set<Generator.Element> = []
    return filter { el in
      if prevs.contains(el) { return false }
      prevs.insert(el)
      return true
    }
  }
}

Which is maybe a little more efficient. Both the Dictionary and Set versions translate easily into a lazy method:

extension LazySequenceType where Generator.Element : Hashable {

  public func uniq() -> LazyFilterSequence<Self> {
    var prevs: Set<Generator.Element> = []
    return lazy.filter { el in
      if prevs.contains(el) { return false }
      prevs.insert(el)
      return true
    }
  }
}

However, there's another problem with these implementations: they rely on side-effects from filter's closure, which is generally discouraged (I think). For instance, the function would be broken if the closure was evaluated more than once, or in a different order. So it's maybe best to have a more imperative for loop:

extension SequenceType where Generator.Element : Hashable {

  public func uniq() -> [Generator.Element] {
    var prevs: Set<Generator.Element> = []
    var uniqs: [Generator.Element] = []
    for el in self where !prevs.contains(el) {
      prevs.insert(el)
      uniqs.append(el)
    }
    return uniqs
  }
}

But then the lazy version would need to be more complex as well. (You'd probably have to write a custom struct, similar to the standard library's LazyFilterSequence. This is the kind of thing I mean)

Considering all that, I'm not sure what the function or method would add over just using the standard Set initialiser. The order of the elements is retained, and there's a possible lazy version, but it's a lot of extra complexity for maybe not much extra functionality.

[gribozavr]

Thank you for your PR. This is a change to the library API, so it should follow the Swift Evolution Process. Please write an informal proposal and send it to swift-evolution@swift.org.

[tkremenek]

Closing because this is not how we propose library changes.

[shimesaba9]

I got it.
Thank you for review.