aerospace fork
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148// periphery:ignore:allimport OrderedCollections
extension Sequence { public func filterNotNil<Unwrapped>() -> [Unwrapped] where Element == Unwrapped? { compactMap(id) }
public func filterIsInstance<R>(of _: R.Type) -> [R] { var result: [R] = [] for elem in self { if let elemR = elem as? R { result.append(elemR) } } return result }
public var first: Element? { var iter = makeIterator() return iter.next() }
public func mapAllOrFailure<T, E>(_ transform: (Self.Element) -> Result<T, E>) -> Result<[T], E> { var result: [T] = [] for element in self { switch transform(element) { case .success(let element): result.append(element) case .failure(let errors): return .failure(errors) } } return .success(result) }
public func mapAllOrFailure<T>(_ transform: (Self.Element) -> ParsedCmd<T>) -> ParsedCmd<[T]> { var result: [T] = [] for element in self { switch transform(element) { case .cmd(let element): result.append(element) case .help(let help): return .help(help) case .failure(let cmdParsingFailure): return .failure(cmdParsingFailure) } } return .cmd(result) }
public func mapAllOrFailures<T, E>(_ transform: (Self.Element) -> Result<T, E>) -> Result<[T], [E]> { var result: [T] = [] var errors: [E] = [] for element in self { switch transform(element) { case .success(let element): result.append(element) case .failure(let error): errors.append(error) } } return errors.isEmpty ? .success(result) : .failure(errors) }
@inlinable public func minByOrDie(_ selector: (Self.Element) -> some Comparable) -> Self.Element { minBy(selector) ?? dieT("Empty sequence") }
@inlinable public func minBy(_ selector: (Self.Element) -> some Comparable) -> Self.Element? { self.min(by: { a, b in selector(a) < selector(b) }) }
@inlinable public func maxByOrDie(_ selector: (Self.Element) -> some Comparable) -> Self.Element { self.maxBy(selector) ?? dieT("Empty sequence") }
@inlinable public func maxBy(_ selector: (Self.Element) -> some Comparable) -> Self.Element? { self.max(by: { a, b in selector(a) < selector(b) }) }
@inlinable public func sortedBy(_ selector: (Self.Element) -> some Comparable) -> [Self.Element] { sorted(by: { a, b in selector(a) < selector(b) }) }
@inlinable public func sortedBy(_ selectors: [(Self.Element) -> some Comparable]) -> [Self.Element] { sorted(by: { a, b in for selector in selectors { let a = selector(a) let b = selector(b) if a < b { return true } if a > b { return false } } return false }) }
public func sumOfDouble(_ selector: (Self.Element) -> Double) -> Double { var result: Double = 0 for elem in self { result += selector(elem) } return result }
public func sumOfInt(_ selector: (Self.Element) -> Int) -> Int { var result: Int = 0 for elem in self { result += selector(elem) } return result }
public func grouped<Group>(by criterion: (_ transforming: Element) -> Group) -> [Group: [Element]] { Dictionary(grouping: self, by: criterion) }
public var withIndex: [(index: Int, value: Element)] { var index = -1 return map { index += 1 return (index, $0) } }
public func minOrDie() -> Self.Element where Self.Element: Comparable { self.min() ?? dieT("Empty sequence") }
public func maxOrDie() -> Self.Element where Self.Element: Comparable { self.max() ?? dieT("Empty sequence") }
public func toSet() -> Set<Element> where Element: Hashable { Set(self) } public func toOrderedSet() -> OrderedSet<Element> where Element: Hashable { OrderedSet(self) }
public var sequencePattern: SequencePattern<Self> { var iterator = makeIterator() guard let first = iterator.next() else { return .empty } guard let second = iterator.next() else { return .one(first) } guard let _ = iterator.next() else { return .two(first, second) } return .many }}
public enum SequencePattern<Seq: Sequence> { case empty case one(Seq.Element) case two(Seq.Element, Seq.Element) case many}