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

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

jakebromberg

// One note before we start: if the inhabitants of Value are a closed set,
// then making Value an enum is going to be a clearer model than using a
// protocol like this. I'm assuming you need to be able to retroactively add
// new members of Value.

// Can't use Equatable directly because of its Self requirement.
protocol HeteroEquatable {
    func isEqualTo(_ value: HeteroEquatable) -> Bool
}

jakebromberg

import AVFoundation
import Foundation

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

        do {

jakebromberg

import CoreLocation

extension CLLocation {
    public static func +(lhs: CLLocation, rhs: CLLocation) -> CLLocation {
        let summedLat  = lhs.coordinate.latitude  + rhs.coordinate.latitude
        let summedLong = lhs.coordinate.longitude + rhs.coordinate.longitude
        return CLLocation(latitude: summedLat, longitude: summedLong)
    }
    
    public static func /(lhs: CLLocation, rhs: Double) -> CLLocation {