enum _TrieNode<Element : Equatable> {
    case leaf(Array<Element>)
    case node(Element, Array<_TrieNode<Element>>)
    
    mutating func insert<I>(_ iterator: inout I) -> _TrieNode<Element>? where I : IteratorProtocol, I.Element == Element {
        if let element = iterator.next() {
            switch self {
            case .leaf(let elements):
                let filtered = elements.filter { $0 != element }
                var items = [Element]()
                while let item = iterator.next() {
                    items.append(item)
                }
                self = .node(element, [.leaf(items)])
                return .leaf(filtered)
            case .node(let nodeElement, let children_):
                var children = children_
                for idx in 0..<children.count {
                    if children[idx].matches(element) {
                        if let additional = children[idx].insert(&iterator) {
                            children.append(additional)
                        }
                        break
                    }
                }
                self = .node(nodeElement, children)
                return nil
            }
        }
        return nil
    }
    
    func matches(_ element: Element) -> Bool {
        switch self {
        case .leaf(let elements):
            return elements.contains(element)
        case .node(let nodeElement, _):
            return nodeElement == element
        }
    }
}

struct Trie<Element : Equatable> {
    var nodes = [_TrieNode<Element>]()
    
    mutating func insert<C>(_ elements: C) where C : Sequence, C.Iterator.Element == Element {
        var iter = elements.makeIterator()
        if let element = iter.next() {
            for idx in 0..<nodes.count {
                if nodes[idx].matches(element) {
                    if let additional = nodes[idx].insert(&iter) {
                        nodes.append(additional)
                    }
                    return
                }
            }
        }
    }
}

var trie = Trie<String.Element>()
trie.insert("hello")
trie.insert("hello world")

GenericCache(0x1005d54f8): cyclic metadata dependency detected, aborting