daehn

public struct CountedSet<Element : Hashable> : Hashable, CollectionType, ArrayLiteralConvertible {

    public typealias Index = SetIndex<Element>
    public typealias Generator = SetGenerator<Element>
    private var backingSet = Set<Element>()
    private var countMapping = [Int: UInt]()

    private var debugCountMapping: [Element : UInt] {
        var result = [Element : UInt]()
        backingSet.forEach { element in

daehn

import Foundation

// Defining this breaks the behaviour of the existing '||' operator in some cases
public func ||(lhs: NSPredicate, rhs: NSPredicate) -> NSPredicate {
    return NSCompoundPredicate(orPredicateWithSubpredicates: [lhs, rhs])
}

func foo() {
    let cards = [String: [String]]()
    let startingContactIndex: UInt = 3

daehn

struct Car {
    let made: String
}

func compareDumps(lhs: Any, rhs: Any) -> Bool {
    var (lhsDump, rhsDump) = (String(), String())
    dump(lhs, to: &lhsDump)
    dump(rhs, to: &rhsDump)
    return lhsDump == rhsDump
}

daehn

NSMutableDictionary *vibrationParameters = [[NSMutableDictionary alloc] init];
vibrationParameters[@"VibePattern"] = @[@YES, @100];
vibrationParameters[@"Intensity"] = @1;

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wimplicit-function-declaration"
AudioServicesStopSystemSound(kSystemSoundID_Vibrate);
AudioServicesPlaySystemSoundWithVibration(kSystemSoundID_Vibrate, nil, vibrationParameters);
#pragma clang diagnostic pop

daehn

public extension IteratorProtocol {

    mutating public func any(_ predicate: (Element) throws -> Bool) rethrows -> Bool {
        guard let current = next() else { return false }
        return try predicate(current) || any(predicate)
    }

    mutating public func all(_ predicate: (Element) throws -> Bool) rethrows -> Bool {
        guard let current = next() else { return true }
        return try predicate(current) && all(predicate)

daehn

import UIKit
import PlaygroundSupport

PlaygroundPage.current.needsIndefiniteExecution = true


extension Comparable {
    /// Clamp the value between `low` and `high`
    func clamp(_ low: Self, _ high: Self) -> Self {

daehn

extension DispatchQueue {

    /// Helper method to use when reading from a resource
    /// that is being isolated by this queue.
    ///
    /// Using this method retriving a value like this:
    /// ```
    /// var result: T?
    /// queue.sync {
    ///     result = resource["key"]

daehn

extension String {

    subscript(index: Int) -> Character {
        return self[startIndex.advancedBy(index)]
    }

    subscript(range: Range<Int>) -> String {
        let start = startIndex.advancedBy(range.startIndex)
        let end = startIndex.advancedBy(range.endIndex)

daehn

import Foundation
import SystemConfiguration

extension Notification.Name {
    public static let reachabilityChanged = Notification.Name(rawValue: "reachabilityChanged")
}

protocol ReachabilityObserver: class {
    func reachabilityDidChange(_ reachability: Reachability)
}

daehn

import Foundation

final class Log: NSObject {

    enum Topic: String {
        case network, app
    }

    private enum Level: String {
        case info = ""