cprovatas

extension Array {
    static func ... (lhs: [Self.Element], rhs: [Self.Element]) -> [Self.Element] {
        var copy = lhs
        copy.append(contentsOf: rhs)
        return copy
    }

    static func ... (lhs: Self.Element, rhs: [Self.Element]) -> [Self.Element] {
        var copy = [lhs]
        copy.append(contentsOf: rhs)

cprovatas

// These helpers allow for basic operations to be performed while still iterating over a sequence once without
// adding all of the common boilerplate code you'd normally have to write
extension Sequence {
    // filter + forEach
    func forEach(where predicate: (Element) -> Bool, _ body: (Element) throws -> Void) rethrows {
        for element in self where predicate(element) {
            try body(element)
        }
    }

cprovatas

enum ASCIIColor: String {
    case black = "\u{001B}[0;30m"
    case red = "\u{001B}[0;31m"
    case green = "\u{001B}[0;32m"
    case yellow = "\u{001B}[0;33m"
    case blue = "\u{001B}[0;34m"
    case magenta = "\u{001B}[0;35m"
    case cyan = "\u{001B}[0;36m"
    case white = "\u{001B}[0;37m"
    case `default` = "\u{001B}[0;0m"

cprovatas

protocol TypeReflectable {
    var `Self`: Self.Type { get }
    static var `Self`: Self.Type { get }
}

extension TypeReflectable {
    var `Self`: Self.Type {
        return type(of: self)
    }

cprovatas

import UIKit

extension CGImage {
    var isBlank: Bool {
        guard let data = dataProvider?.data, let buffer = CFDataGetBytePtr(data) else { return false }
        let length = CFDataGetLength(data)
        var i = 0
        while i < length {
            if buffer[i] < 255, buffer[i + 1] < 255, buffer[i + 2] < 255 {
                return false

cprovatas

import Foundation

extension Data {
    var prettyPrintedJSONString: NSString? { /// NSString gives us a nice sanitized debugDescription
        guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
              let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
              let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }

        return prettyPrintedString
    }

cprovatas

/// throttle a procedure for the given time interval, operation identifer is used to uniquely identify operation to prevent from firing multiple times
private var throttledOperations: Set<String> = []
func dispatchThrottle(_ interval: TimeInterval, operationIdentifier: String, queue: DispatchQueue = .main, _ closure: @escaping () -> Void) {
    guard !throttledOperations.contains(operationIdentifier) else { return }
    throttledOperations.insert(operationIdentifier)
    closure()
    queue.asyncAfter(deadline: .now() + interval) {
        throttledOperations.remove(operationIdentifier)
    }
}

cprovatas

//Uses only O(n) complexity.

extension Dictionary where Key == String, Value == Any? {

    var trimmingNullValues: [String: Any] {
        var copy = self
        forEach { (key, value) in
            if value == nil {
                copy.removeValue(forKey: key)
            }

cprovatas

extension Date {
    var roundedToSecond: Date {
        let date = self
        let diff = 1000000000 - Calendar.current.component(.nanosecond, from: date)
        return Calendar.current.date(byAdding: .nanosecond, value: diff, to: date)!
    }
}

/// USAGE:
let roundedDate = Date().roundedToSecond /// zero nanoseconds

cprovatas

protocol TopLevelCollection: Codable {
    associatedtype ElementType: Codable
    var elements: [ElementType] { get set }
    init(elements: [ElementType])
}

extension TopLevelCollection {
    public init(from decoder: Decoder) throws {
        var container = try decoder.unkeyedContainer()