     return lhs.currect1 == rhs.currect1 && lhs.currect2 == rhs.currect2
 }
 
-extension SequenceType {
-    
-    @warn_unused_result
-    public func concat<S : SequenceType where Generator.Element == S.Generator.Element>(with: S) -> ConcatSequence<Self, S> {
+public extension SequenceType {
+    
+    @warn_unused_result
+    func concat<S : SequenceType where Generator.Element == S.Generator.Element>(with: S) -> ConcatSequence<Self, S> {
         return ConcatSequence(base1: self, base2: with)
     }
 }
 
-extension CollectionType {
-    
-    @warn_unused_result
-    public func concat<S : CollectionType where Generator.Element == S.Generator.Element>(with: S) -> ConcatCollection<Self, S> {
+public extension CollectionType {
+    
+    @warn_unused_result
+    func concat<S : CollectionType where Generator.Element == S.Generator.Element>(with: S) -> ConcatCollection<Self, S> {
         return ConcatCollection(base1: self, base2: with)
     }
 }
 
-extension CollectionType where Index : BidirectionalIndexType {
-    
-    @warn_unused_result
-    public func concat<S : CollectionType where Generator.Element == S.Generator.Element, S.Index : BidirectionalIndexType>(with: S) -> ConcatBidirectionalCollection<Self, S> {
+public extension CollectionType where Index : BidirectionalIndexType {
+    
+    @warn_unused_result
+    func concat<S : CollectionType where Generator.Element == S.Generator.Element, S.Index : BidirectionalIndexType>(with: S) -> ConcatBidirectionalCollection<Self, S> {
         return ConcatBidirectionalCollection(base1: self, base2: with)
     }
 }
 
-extension LazySequenceType {
-    
-    @warn_unused_result
-    public func concat<S : SequenceType where Elements.Generator.Element == S.Generator.Element>(with: S) -> LazySequence<ConcatSequence<Elements, S>> {
+public extension LazySequenceType {
+    
+    @warn_unused_result
+    func concat<S : SequenceType where Elements.Generator.Element == S.Generator.Element>(with: S) -> LazySequence<ConcatSequence<Elements, S>> {
         return ConcatSequence(base1: self.elements, base2: with).lazy
     }
 }
 
-extension LazyCollectionType {
-    
-    @warn_unused_result
-    public func concat<S : CollectionType where Elements.Generator.Element == S.Generator.Element>(with: S) -> LazyCollection<ConcatCollection<Elements, S>> {
+public extension LazyCollectionType {
+    
+    @warn_unused_result
+    func concat<S : CollectionType where Elements.Generator.Element == S.Generator.Element>(with: S) -> LazyCollection<ConcatCollection<Elements, S>> {
         return ConcatCollection(base1: self.elements, base2: with).lazy
     }
 }
 
-extension LazyCollectionType where Elements.Index : BidirectionalIndexType {
-    
-    @warn_unused_result
-    public func concat<S : CollectionType where Elements.Generator.Element == S.Generator.Element, S.Index : BidirectionalIndexType>(with: S) -> LazyCollection<ConcatBidirectionalCollection<Elements, S>> {
+public extension LazyCollectionType where Elements.Index : BidirectionalIndexType {
+    
+    @warn_unused_result
+    func concat<S : CollectionType where Elements.Generator.Element == S.Generator.Element, S.Index : BidirectionalIndexType>(with: S) -> LazyCollection<ConcatBidirectionalCollection<Elements, S>> {
         return ConcatBidirectionalCollection(base1: self.elements, base2: with).lazy
     }
 }
 
-extension LazySequenceType {
-    
-    @warn_unused_result
-    public func append(newElement: Elements.Generator.Element) -> LazySequence<ConcatSequence<Elements, CollectionOfOne<Elements.Generator.Element>>> {
+public extension LazySequenceType {
+    
+    @warn_unused_result
+    func append(newElement: Elements.Generator.Element) -> LazySequence<ConcatSequence<Elements, CollectionOfOne<Elements.Generator.Element>>> {
         return self.concat(CollectionOfOne(newElement))
     }
 }
 
-extension LazyCollectionType {
-    
-    @warn_unused_result
-    public func append(newElement: Elements.Generator.Element) -> LazyCollection<ConcatCollection<Elements, CollectionOfOne<Elements.Generator.Element>>> {
+public extension LazyCollectionType {
+    
+    @warn_unused_result
+    func append(newElement: Elements.Generator.Element) -> LazyCollection<ConcatCollection<Elements, CollectionOfOne<Elements.Generator.Element>>> {
         return self.concat(CollectionOfOne(newElement))
     }
 }
 
-extension LazyCollectionType where Elements.Index : BidirectionalIndexType {
-    
-    @warn_unused_result
-    public func append(newElement: Elements.Generator.Element) -> LazyCollection<ConcatBidirectionalCollection<Elements, CollectionOfOne<Elements.Generator.Element>>> {
+public extension LazyCollectionType where Elements.Index : BidirectionalIndexType {
+    
+    @warn_unused_result
+    func append(newElement: Elements.Generator.Element) -> LazyCollection<ConcatBidirectionalCollection<Elements, CollectionOfOne<Elements.Generator.Element>>> {
         return self.concat(CollectionOfOne(newElement))
     }
 }

    }
}

extension CollectionType where Generator.Element : Equatable {
    
    /// Returns a subsequence, until a element equal to `value`, containing the
    /// initial elements.

    }
}

public extension Set {
    
    /// Return `true` if all of elements in `seq` is `x`.
    @warn_unused_result
    func all(x: Element) -> Bool {
        
        switch self.count {
        case 0:
            return true
        case 1:
            return self.first == x
        default:
            return false
        }
    }
}

public extension SequenceType {
    
    /// Return first of elements in `seq` satisfies `predicate`.
