Appends a typing stack after the given stack, but only if required
        (aka don't have two typing layers following each other).
963868
def typify(self, stack: Stack) -> List[Stack]:
        

        if len(stack.layers) == 1 and isinstance(stack.layers[0], lyr.Typing):
            return [stack]

        return [stack, Stack([lyr.Typing()])]
216928
def append_node(type, indent: @indents.length, add: false, value: nil)
      # add necessary stack items to match required indent
      @stacks << @stacks.last.dup while indent >= @stacks.length

      parent = @stacks[indent].last
      node = AST::NodeRegistrator.create(type, @lineno)
      parent.children << node

      node.value = value unless value.nil?

      @stacks[indent] << node if add

      node
    end
357113
def append(cls, interceptor):
        
        cls._check(interceptor)
        cls._interceptors.append(interceptor)
329724
def _insert_layer_after(self, layer_idx, new_layer, new_keras_layer):
        
        # reminder: new_keras_layer is not part of the original Keras network,
        # so it's input / output blob information is missing. It serves only as
        # a parameter holder.
        layer = self.layer_list[layer_idx]
        self.layer_list.insert(layer_idx+1, new_layer)
        self.keras_layer_map[new_layer] = new_keras_layer
        successors = self.get_successors(layer)
        # add edge layer -> new_layer
        self._add_edge(layer, new_layer)
        # add edges new_layer -> layer_successor, remove layer -> successor
        for succ in successors:
            self._add_edge(new_layer, succ)
            self._remove_edge(layer, succ)
57191
async def flush(self, request: Request, stacks: List[Stack]):
        

        ns: List[Stack] = []

        for stack in stacks:
            ns.extend(self.typify(stack))

        if len(ns) > 1 and ns[-1] == Stack([lyr.Typing()]):
            ns[-1].get_layer(lyr.Typing).active = False

        await self.next(request, ns)
1305260
function pushStack(stack, node) {
  stack.type = node.type;
  stack.children = [];
  stack.instance = typeof node.type === 'function' ? node.stateNode : stack;
}
724066
def add_after(self, pipeline):
        
        if not isinstance(pipeline, Pipeline):
            pipeline = Pipeline(pipeline)
        self.pipes = self.pipes[:] + pipeline.pipes[:]
        return self
86677
def _nested_add(nested_a, nested_b):
  """"""
  return nest.map(lambda a, b: a + b, nested_a, nested_b)
463577
def append(self, element: Union[int, Expression]) -> None:
        
        if super(MachineStack, self).__len__() >= self.STACK_LIMIT:
            raise StackOverflowException(
                "Reached the EVM stack limit of {}, you can't append more "
                "elements".format(self.STACK_LIMIT)
            )
        super(MachineStack, self).append(element)
747805
public void addImplements(String type) {
		if (!Strings.isEmpty(type)) {
			this.sarlSkill.getImplements().add(newTypeRef(this.sarlSkill, type));
		}
	}
170798
def stack_push(self, key, value):
        
        task = Task.current_task()
        try:
            context = task._context_stack
        except AttributeError:
            task._context_stack = context = {}
        if key not in context:
            context[key] = []
        context[key].append(value)
251409
private int append(FA add) {
        int relocation;
        int idx;

        relocation = used;
        ensureCapacity(used + add.used);
        for (idx = 0; idx < add.used; idx++) {
            states[relocation + idx] =
                new State(add.states[idx], relocation);
        }
        used += add.used;
        return relocation;
    }
423331
function(context, args, stack) {
		var ctx = new Context(args[0], args[1] || context);
		stack.push(ctx);
		return ctx;
	}
637042
def append(self, child, *args, **kwargs):
        """"""
        #if no set is associated with the layer yet, we learn it from span annotation elements that are added
        if self.set is False or self.set is None:
            if inspect.isclass(child):
                if issubclass(child,AbstractSpanAnnotation):
                    if 'set' in kwargs:
                        self.set = kwargs['set']
            elif isinstance(child, AbstractSpanAnnotation):
                if child.set:
                    self.set = child.set
            elif isinstance(child, Correction):
                #descend into corrections to find the proper set for this layer (derived from span annotation elements)
                for e in itertools.chain( child.new(), child.original(), child.suggestions() ):
                    if isinstance(e, AbstractSpanAnnotation) and e.set:
                        self.set = e.set
                        break

        return super(AbstractAnnotationLayer, self).append(child, *args, **kwargs)
470274
public static void lazyInsertAfter(Element newElement, Element after) {
        if (!after.parentNode.contains(newElement)) {
            after.parentNode.insertBefore(newElement, after.nextSibling);
        }
    }
129905
def append_table(self, name, **kwargs):
        """"""
        self.stack.append(Table(name, **kwargs))
948440
function Stack(trace, options) {
  if (!(this instanceof Stack)) return new Stack(trace, options);

  if ('object' === typeof trace && !trace.length) {
    options = trace;
    trace = null;
  }

  options = options || {};
  options.guess = 'guess' in options ? options.guess : true;

  if (!trace) {
    var imp = new stacktrace.implementation()
      , err = options.error || options.err || options.e
      , traced;

    traced = imp.run(err);
    trace = options.guess ? imp.guessAnonymousFunctions(traced) : traced;
  }

  this.traces = this.parse(trace);
}