wip

Author: davdroman

Sources/Introspect.swift

@@ -79,21 +79,11 @@ extension PlatformEntity {
         return nearestAncestor
     }
 
-    func descendantsBetween(_ bottomEntity: Base, and topEntity: Base) -> [Base] {
-        var result: [Base] = []
-        var entered = false
-
-        for descendant in self.allDescendants {
-            if descendant === bottomEntity {
-                entered = true
-            } else if descendant === topEntity {
-                break
-            } else if entered {
-                result.append(descendant)
-            }
-        }
-
-        return result
+    func allDescendants(between bottomEntity: Base, and topEntity: Base) -> some Sequence<Base> {
+        self.allDescendants
+            .lazy
+            .drop(while: { $0 !== bottomEntity })
+            .prefix(while: { $0 !== topEntity })
     }
 
     func receiver<PlatformSpecificEntity: PlatformEntity>(
@@ -102,14 +92,14 @@ extension PlatformEntity {
     ) -> PlatformSpecificEntity? {
         let frontEntity = self
         guard
-            let backEntity = Array(frontEntity.ancestors).last?.entityWithTag(anchorID.hashValue),
+            let backEntity = ContiguousArray(frontEntity.ancestors).last?.entityWithTag(anchorID.hashValue),
             let commonAncestor = backEntity.nearestCommonAncestor(with: frontEntity~)
         else {
             return nil
         }
 
         return commonAncestor
-            .descendantsBetween(backEntity~, and: frontEntity~)
+            .allDescendants(between: backEntity~, and: frontEntity~)
             .compactMap { $0 as? PlatformSpecificEntity }
             .first
     }

Sources/Utils.swift

@@ -0,0 +1,28 @@
+postfix operator ~
+
+postfix func ~ <LHS, T>(lhs: LHS) -> T {
+    lhs as! T
+}
+
+postfix func ~ <LHS, T>(lhs: LHS?) -> T? {
+    lhs as? T
+}
+
+func recursiveSequence<S: Sequence>(_ sequence: S, children: @escaping (S.Element) -> S) -> AnySequence<S.Element> {
+    AnySequence {
+        var mainIterator = sequence.makeIterator()
+        // Current generator, or `nil` if all sequences are exhausted:
+        var iterator: AnyIterator<S.Element>?
+
+        return AnyIterator {
+            guard let iterator, let element = iterator.next() else {
+                if let element = mainIterator.next() {
+                    iterator = recursiveSequence(children(element), children: children).makeIterator()
+                    return element
+                }
+                return nil
+            }
+            return element
+        }
+    }
+}