Returns a function that adds its argument to the given collection.
185413
public static <T> Function<T, Void> addTo(final Collection<T> collection) {
        return new Function<T, Void>() {
            public Void apply(T arg) {
                collection.add(arg);
                return null;
            }
        };
    }
1355474
public final <C extends Collection<? super T>> C copyInto(C collection) {
        requireNonNull(collection);
        for (T item : this) {
            collection.add(item);
        }
        return collection;
    }
884639
def extend_with(func):
    """"""
    if not func.__name__ in ArgParseInator._plugins:
        ArgParseInator._plugins[func.__name__] = func
634446
function add() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    var acc = args[0];
    for (var i = 1; i < args.length; i++) {
        acc = _add_two(acc, args[i]);
    }
    return acc;
}
757812
def add_collection(self, identifier_collection):
        
        try:
            new_source_identifiers = identifier_collection.source_identifiers
            self.source_identifiers.update(new_source_identifiers)
        except AttributeError:
            msg = "Invalid identifier collection passed as argument"
            raise AttributeError(msg)
965107
public Token add( Function function ) {
        Token t = new Token(function);
        push( t );
        return t;
    }
418090
public static <T> Collection<T> addAll(Collection<T> list, T... array)
    {
        for (T item : array)
        {
            list.add(item);
        }
        return list;
    }
188213
@SuppressWarnings("unchecked")
        public <Coll extends CollectionFuncSup<T>> Coll add(T t) {
                Collection<T> coll = (Collection<T>) iterable;
                coll.add(t);
                return (Coll) this;
        }
1346802
function(collection){
	Array.apply(this);
	if(arguments.length >= 1){
		for(var i=0,len = collection.length;i<len;i++){
			var item = collection[i];
			if(this.indexOf(item) < 0){
				this.push(item);
			}
		}
	}
 }
373907
def all_with(self, x):
        """"""

        _args = []

        for arg in self.all:
            if is_collection(x):
                for _x in x:
                    if _x in arg:
                        _args.append(arg)
                        break
            else:
                if x in arg:
                    _args.append(arg)

        return Args(_args, no_argv=True)
227530
public static <T> T callAsCollection(T obj, Consumer<Collection<T>> function) {
		if (obj == null)
			return null;
		List<T> list = new ArrayList<T>();
		list.add(obj);
		function.accept(list);
		return obj;
	}
467928
function (list, func, args) {
				var out = [];
				for (var i = 0, j = list.length; i < j; i++) {
					out.push([ list[i][func].apply(list[i], args), list[i] ]);
				}
				return out;
			}
814261
public void add(K key, V value) {
    if (treatCollectionsAsImmutable) {
      Collection<V> newC = cf.newCollection();
      Collection<V> c = map.get(key);
      if (c != null) {
        newC.addAll(c);
      }
      newC.add(value);
      map.put(key, newC); // replacing the old collection
    } else {
      Collection<V> c = map.get(key);
      if (c == null) {
        c = cf.newCollection();
        map.put(key, c);
      }
      c.add(value); // modifying the old collection
    }
  }
287535
@SuppressWarnings({"unchecked", "ManualArrayToCollectionCopy"})
    public static <E, T extends E> Collection<E> addAll(Collection<E> c, T... array){
        for(T obj: array)
            c.add(obj);
        return c;
    }
1358605
public static <T> Collection<T> addAll(Collection<T> collection, T[] values) {
		if (null != collection && null != values) {
			for (T value : values) {
				collection.add(value);
			}
		}
		return collection;
	}
694416
public void addArg(FunctionLibFunctionArg arg) {
	arg.setFunction(this);
	argument.add(arg);
	if (arg.getDefaultValue() != null) hasDefaultValues = true;
    }
403439
function listenCollection(collection, listener) {
    collection.forEach(function listenModel(model) {
        listen(model, listener);
    });

    collection.on('add', function onAdd(model) {
        listen(model, listener);
        listener();
    });
}