Sequence and Collection.swift

import UIKit

indirect enum LinkedListNode<T> {
  case value(element: T, next: LinkedListNode<T>)
  case end
}

extension LinkedListNode : Sequence {
  
  typealias Iterator = LinkedListIterator<T>
  
  func makeIterator() -> LinkedListIterator<T> {
    return LinkedListIterator(current: self)
  }
  
}

struct LinkedListIterator<T> : IteratorProtocol {
  
  var current: LinkedListNode<T>
  
  mutating func next() -> T? {
    switch current {
    case let .value(element: e, next: next):
      current = next
      return e
    case .end:
      return nil
    }
  }
  
}

extension LinkedListNode : ExpressibleByArrayLiteral {
  typealias Element = T
  
  init(arrayLiteral elements: Element...) {
    // construct a linked list from its end.
    // more efficient.
    self = elements.reversed().reduce(LinkedListNode.end) { (currentNode, nextValue) -> LinkedListNode<Element> in
      return LinkedListNode.value(element: nextValue, next: currentNode)
    }
  }
}

let list: LinkedListNode<String> = ["🌟","🌟","🌟","🌟","🌟"]
list.forEach({ print($0) })
list.contains("")



let numbers = [1,2,3,4,5,6,7]
print(numbers.filter({ $0 > 3 }).count)

extension Sequence {
  
  func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int {
    var count = 0
    
    for element in self {
      if shouldCount(element) {
        count += 1
      }
    }
    
    return count
  }
  
}

print(numbers.count { $0 > 3 })

extension Sequence where Self.SubSequence : Sequence,
  Self.SubSequence.Iterator.Element == Self.Iterator.Element {

  func eachPair() -> AnySequence<(Iterator.Element, Iterator.Element)> {
    return AnySequence(zip(self, self.dropFirst()))
  }
  
}

numbers.eachPair().forEach { print($0) }