Append new child and return it.
195956
def append_child(self, name, child):  # type: (str, typing.Any) -> ArTree
        """"""
        temp = ArTree(name, child)
        self._array.append(temp)
        return temp
1109736
def add_child(self, frame, after=None):
        '''
        
        '''
        frame.remove_from_parent()
        frame.parent = self
        if after is None:
            self._children.append(frame)
        else:
            index = self._children.index(after) + 1
            self._children.insert(index, frame)

        self._invalidate_time_caches()
141613
def append(self, key, value):
        """"""
        self.__items.append((key, value))

        try:
            dict_getitem(self, key).append(value)
        except KeyError:
            dict_setitem(self, key, [value])
291448
def add_child(self, item):
        """"""
        item.depth = self.depth + 1
        self.childs.append(item)
        self.childs = sorted(self.childs, key=lambda item: item.order if item.order else 999)
1274824
function appendChildren(children, el) {
	ensureArray(children)
		.forEach(append.bind(el));
	return el;
}
986515
def append(self, *other):
    
    self._data = it.chain(self._data, Stream(*other)._data)
    return self
89690
def add_child(self, child):
        
        self.children.append(child)
        child.parent = self

        if self.view and self.view.is_loaded:
            self.view.dispatch({
                'name': 'append',
                'html': child.compile(),
                'selector': '#' + str(self.id)
            })
189294
def append(self, node):
        ""
        if not isinstance(node, self.__class__):
            raise TypeError('Expected Node instance, got %r' % node)
        self.nodes.append(node)
558255
def append(self, item):
        
        try:
            self._data[self._position] = item
        except IndexError:
            self._grow()
            self._data[self._position] = item
        self._position += 1
        return self
906814
def add_child(self, child):
        
        child_id = getattr(child, 'id', None)
        if child_id:
            if not hasattr(self, 'children'):
                self.children = {}
            if child_id not in self.children:
                self.children[child_id] = child
173972
def append(self, item):
        
        if self.url:
            raise TypeError('Menu items with URL cannot have childrens')

        # Look for already present common node
        if not item.is_leaf():
            for current_item in self.items:
                if item.name == current_item.name:
                    for children in item.items:
                        current_item.append(children)
                    return

        # First insertion
        self.items.append(item)
885679
def add_child(self, **kwargs):
        """"""
        cls = get_result_class(self.__class__)

        if len(kwargs) == 1 and 'instance' in kwargs:
            # adding the passed (unsaved) instance to the tree
            newobj = kwargs['instance']
            if newobj.pk:
                raise NodeAlreadySaved("Attempted to add a tree node that is "\
                    "already in the database")
        else:
            newobj = cls(**kwargs)

        try:
            newobj._cached_depth = self._cached_depth + 1
        except AttributeError:
            pass
        if not cls.node_order_by:
            try:
                max = cls.objects.filter(parent=self).reverse(
                )[0].sib_order
            except IndexError:
                max = 0
            newobj.sib_order = max + 1
        newobj.parent = self
        newobj.save()
        return newobj
935874
def append(self, request, response):
        """"""
        request = self._before_record_request(request)
        if not request:
            return
        # Deepcopy is here because mutation of `response` will corrupt the
        # real response.
        response = copy.deepcopy(response)
        response = self._before_record_response(response)
        if response is None:
            return
        self.data.append((request, response))
        self.dirty = True
545682
public Element appendChild(Node child) {
        Validate.notNull(child);

        // was - Node#addChildren(child). short-circuits an array create and a loop.
        reparentChild(child);
        ensureChildNodes();
        childNodes.add(child);
        child.setSiblingIndex(childNodes.size() - 1);
        return this;
    }
127208
def add_child(self, node):
        """"""
        node._parent = self
        self._children.append(node)
1319600
def to_child(self, append_message="", **kwargs):
        """"""

        bad_pars = set(kwargs) - set(self._child_params)
        if bad_pars:
            raise KeyError("Invalid init params for State: %s" % ", ".join(bad_pars))

        child = copy(self)
        for k, v in kwargs.items():
            setattr(child, k, v)
        child.parent = self

        # append messages
        if not isinstance(append_message, dict):
            append_message = {"msg": append_message, "kwargs": {}}
        child.messages = [*self.messages, append_message]

        return child
253706
def replaceChild(self, new_child: AbstractNode,
                     old_child: AbstractNode) -> AbstractNode:
        """"""
        return self._replace_child(new_child, old_child)