anchor.diff:    @override
     void operator []=(K key, V value) {
       var current = _root;
  -    // Navigate to the right node, create intermediaries if necessary.
  +    // Navigate to the right node, create intermediaries as necessary.
       for (final part in _getParts(key)) {
  -      current = current.addNode(part);
  +      current = current.addChild(part);
       }
       // Increment the length only if no value existed before.
       if (!current.hasKeyAndValue) {
  
positive.code:   bool containsKey(Object? key) {
      if (key is K) {
        var current = _root;
        // Navigate to the right node,
        for (final part in _getParts(key)) {
          final node = current.getNode(part);
          if (node == null) {
            return false;
          }
          current = node;
        }
        // Verify we found the value node.
        return current.hasKeyAndValue;
      }
      return false;
  
negative.code:   final List<P> parts = [];
  
    @override
    final List<TrieNode<K, P, V>> children = [];
  
    @override
    bool get hasNodes => children.isNotEmpty;
  
    @override
    TrieNode<K, P, V> addChild(P part) {
      final index = binarySearch(part);
      if (index < 0) {
        final node = TrieNodeImpl<K, P, V>();
        parts.insert(-index - 1, part);
        children.insert(-index - 1, node);
        return node;
      } else {
        return children[index];
      }
    }
  
    @override
    TrieNode<K, P, V>? getChild(P part) {
      final index = binarySearch(part);
      return index < 0 ? null : children[index];
    }
  
    @override
    TrieNode<K, P, V>? removeChild(P part) {
      final index = binarySearch(part);
      if (index < 0) {
        return null;
      }
      final node = children[index];
      parts.removeAt(index);
      children.removeAt(index);
      return node;
    }
  
    @override
    void clearChildren() {
      parts.clear();
      children.clear();
    }
  
    K? _key;
  