Token.swift

/// Useful for maintaining a strong reference to
/// something which would otherwise be deinitialized.
public final class Token<A> {
  public let id: A
  private let dispose: (A) -> Void

  /// Create a new token
  ///
  /// - Parameters:
  ///   - id: A unique identifier for this token.
  ///   - dispose: Should keep a reference to
  /// any object you want to persist. When this
  /// Token is destroyed, this function is called,
  /// allowing you to cleanup that object.
  public init(_ id: A, dispose: @escaping (A) -> Void) {
    self.id = id
    self.dispose = dispose
  }

  deinit { dispose(id) }

  /// Make an iterator of Tokens based on a sequence of ids.
  ///
  /// - Parameters:
  ///   - sequence: The sequence of ids to use for the Tokens.
  ///   - dispose: The dispose function to use for all Tokens. Recieves ids as parameters.
  static func sequence<S>(from sequence: S, dispose: @escaping (S.Element) -> Void) -> AnyIterator<Token<S.Element>> where S: Sequence {
    var ids = sequence.makeIterator()
    return AnyIterator {
      ids.next().map { Token<S.Element>($0, dispose: dispose) }
    }
  }
}


extension Token where A: Equatable {
  public static func ==(lhs: Token, rhs: Token) -> Bool {
    return lhs.id == rhs.id
  }
}

extension Token where A: Hashable {
  public var hashValue: Int {
    return id.hashValue
  }
}

extension Token where A: Comparable {
  public static func < (lhs: Token, rhs: Token) -> Bool {
    return lhs.id < rhs.id
  }

  public static func > (lhs: Token, rhs: Token) -> Bool {
    return lhs.id > rhs.id
  }

  public static func <= (lhs: Token, rhs: Token) -> Bool {
    return lhs.id <= rhs.id
  }

  public static func >= (lhs: Token, rhs: Token) -> Bool {
    return lhs.id >= rhs.id
  }
}