oisdk

extension GeneratorType {
  mutating func any(predicate: Element -> Bool) -> Bool {
    return next().map { el in predicate(el) || any(predicate) } ?? false
  }
  mutating func all(predicate: Element -> Bool) -> Bool {
    return next().map { el in predicate(el) && all(predicate) } ?? true
  }
}

var i = 0

oisdk

private extension GeneratorType {
  mutating func any(@noescape pred: Element -> Bool) -> Bool {
    return next().map { el in pred(el) || any(pred) } ?? false
  }
  mutating func all(@noescape pred: Element -> Bool) -> Bool {
    return next().map { el in pred(el) && all(pred) } ?? true
  }
}

public extension SequenceType {

oisdk

private extension GeneratorType {
  mutating func foldr<T>(initial: T, @noescape combine: (Element, T) -> T) -> T {
    return next().map { combine($0, foldr(initial, combine: combine) ) } ?? initial
  }
}
public extension SequenceType {
  func foldr<T>(initial: T, @noescape combine: (Generator.Element, T) -> T) -> T {
    var g = self.generate()
    return g.foldr(initial, combine: combine)
  }

oisdk

import Foundation

extension String {
  func containsUppercase() -> Bool {
    return unicodeScalars.contains {
      NSCharacterSet
        .uppercaseLetterCharacterSet()
        .longCharacterIsMember(UInt32($0))
    }
  }

oisdk

import Foundation

extension String.UnicodeScalarView.Generator {
  mutating func hasUpper() -> Bool {
    return next().map {
      NSCharacterSet
        .uppercaseLetterCharacterSet()
        .longCharacterIsMember(UInt32($0))
      || hasUpper()
    } ?? false

oisdk

extension GeneratorType {
  mutating func find(pred: Element -> Bool) -> Element? {
    return next().flatMap { el in pred(el) ? el : find(pred) }
  }
}

oisdk

public struct FlatMapGen<G : GeneratorType, S : SequenceType> : GeneratorType {
  
  private let transform: G.Element -> S
  private var g : G
  private var innerGen : S.Generator?
  
  public mutating func next() -> S.Generator.Element? {
    for ; innerGen != nil; innerGen = g.next().map(transform)?.generate() {
      if let next = innerGen?.next() {
        return next

oisdk

func map<T, U, V>(vals: (T?, U?), transform: (T, U) -> V) -> V? {
  if let x = vals.0, y = vals.1 {
    return transform(x, y)
  } else {
    return nil
  }
}

func map<T, U, V>(val0: T?, _ val1: U?, transform: (T, U) -> V) -> V? {
  if let x = val0, y = val1 {

oisdk

func ==<T : Equatable>(lhs: T?, rhs: T) -> Bool {
  return lhs.map{$0 == rhs} ?? false
}
func ==<T : Equatable>(lhs: T, rhs: T?) -> Bool {
  return rhs == lhs
}
func ==<T : Equatable>(lhs: T?, rhs: T?) -> Bool {
  return lhs.map{$0 == rhs} ?? false
}

oisdk

struct Map {
  
  private let matrix: [[String]]
  private let locations: [String:(Int, Int)]
  private let xBounds, yBounds: ClosedInterval<Int>
  
  init(_ locs: [[String]]) {
    matrix = locs
    var dict: [String:(Int, Int)] = [:]
    for (y, row) in locs.enumerate() {