jakebromberg

import AVFoundation
import Foundation

extension FileManager {
    func removeFileIfNecessary(at url: URL) throws {
        guard fileExists(atPath: url.path) else {
            return
        }

        do {

jakebromberg

extension Collection {
    func eachConsecutive(_ size: Int) -> Array<SubSequence> {
        let droppedIndices = indices.dropFirst(size - 1)
        return zip(indices, droppedIndices)
            .map { return self[$0...$1] }
    }
}

jakebromberg

@propertyWrapper
struct CopyOnWrite<Object> {
    var wrappedValue: Object {
        get { storage.object }
        set { 
            if !isKnownUniquelyReferenced(&storage) {
                storage = storage.copy()
            }
            storage.object = newValue 
        }

jakebromberg

struct Matrix<Element> {
  private var storage: [[Element]]
  
  init(_ storage: [[Element]]) {
    self.storage = storage
  }
}

extension Matrix: Collection {
  struct Index: Comparable {

jakebromberg

final class Node<Value>: Sequence {
  typealias NextNode = Node<Value>?

  let value: Value
  var next: NextNode

  init(value: Value, nextNode: NextNode = nil) {
    self.value = value
    self.next = nextNode
  }

jakebromberg

import Foundation

final class Threadsafe<Value> {
    init(_ value: Value) {
        self._value = value
    }
    
    var value: Value {
        return queue.sync { return _value }
    }

jakebromberg

final class Node<T>: Sequence {
    let value: T
    var next: Node<T>?
    
    init(_ value: T, next: Node<T>?) {
        self.value = value
        self.next = next
    }
    
    func makeIterator() -> List<T> {

jakebromberg

extension Sequence where Element == Int {
    func pairsOfSum(k: Int) -> [(Int, Int)] {
        var cache = [Int:Int]()
        var result = [(Int, Int)]()
        
        for i in self {
            cache[i] = k - i
        }
        
        for (num, inv) in cache {

jakebromberg

extension Sequence where Element: Comparable {
    func isAlmostIncreasingSequence() -> Bool {
        var foundMisplacedElement = false
        
        for (a, b) in zip(self, self.dropFirst()) where a >= b {
            guard !foundMisplacedElement else { return false }
            
            foundMisplacedElement = true
        }
        

jakebromberg

@import Foundation;

@interface ThreadSafe<Value>: NSProxy

- (instancetype)initWithValue:(Value)value;

@property (nonatomic, strong, readonly) Value value;

@end