/** * Tae Won Ha - http://taewon.de - @hataewon * See LICENSE */ import Foundation func identity(_ input: T) -> T { return input } extension String { func without(prefix: String) -> String { guard self.hasPrefix(prefix) else { return self } let idx = self.index(self.startIndex, offsetBy: prefix.count) return String(self[idx..( _ chunk: Int = 100, queue: DispatchQueue = .global(qos: .userInitiated), transform: (Element) -> R ) -> [R] { let count = self.count let chunkedCount = Int(ceil(Float(count) / Float(chunk))) var result: [[R]] = [] var spinLock = OS_SPINLOCK_INIT DispatchQueue.concurrentPerform(iterations: chunkedCount) { idx in let startIndex = Swift.min(idx * chunk, count) let endIndex = Swift.min(startIndex + chunk, count) let mappedChunk = self[startIndex.. [Element] { var result = [Element]() for value in self { if result.contains(value) == false { result.append(value) } } return result } /** Returns an array where elements of `elements` contained in the array are substituted by elements of `elements`. This is useful when you need pointer equality rather than `Equatable`-equality like in `NSOutlineView`. If an element of `elements` is not contained in the array, it's ignored. */ func substituting(elements: [Element]) -> [Element] { let elementsInArray = elements.filter { self.contains($0) } let indices = elementsInArray.flatMap { self.index(of: $0) } var result = self indices.enumerated().forEach { result[$0.1] = elementsInArray[$0.0] } return result } } extension Array where Element: Hashable { func toDict(by mapper: @escaping (Element) -> V) -> Dictionary { var result = Dictionary(minimumCapacity: self.count) self.forEach { result[$0] = mapper($0) } return result } } func tuplesToDict(_ sequence: S) -> Dictionary where S.Iterator.Element == (K, V) { var result = Dictionary(minimumCapacity: sequence.underestimatedCount) for (key, value) in sequence { result[key] = value } return result } extension Dictionary { func mapToDict(_ transform: ((key: Key, value: Value)) throws -> (K, V)) rethrows -> Dictionary { let array = try self.map(transform) return tuplesToDict(array) } func flatMapToDict(_ transform: ((key: Key, value: Value)) throws -> (K, V)?) rethrows -> Dictionary { let array = try self.flatMap(transform) return tuplesToDict(array) } }