Excluded columns by lambda

@param functions lambda columns
@param <R>
@return AnimaQuery
185570
public <R> AnimaQuery<T> exclude(TypeFunction<T, R>... functions) {
        String[] columnNames = Arrays.stream(functions)
                .map(AnimaUtils::getLambdaColumnName)
                .collect(toList())
                .toArray(new String[functions.length]);
        return this.exclude(columnNames);
    }
995078
public Table aggregate(String colName1, AggregateFunction<?,?>... functions) {
        ArrayListMultimap<String, AggregateFunction<?,?>> columnFunctionMap = ArrayListMultimap.create();
        columnFunctionMap.putAll(colName1, Lists.newArrayList(functions));
        return aggregate(columnFunctionMap);
    }
577429
function exclude (object, excludedProperties) {
  const strippedObject = Object.assign({}, object)

  excludedProperties.forEach(excludedProperty => {
    delete strippedObject[excludedProperty]
  })

  return strippedObject
}
1366117
def reduce(self, func):
        

        # avoid RDD.reduce() which does not return an RDD
        return self.transform(
            lambda rdd: (
                rdd
                .map(lambda i: (None, i))
                .reduceByKey(func)
                .map(lambda none_i: none_i[1])
            )
        )
1270356
def exclude(*columns_to_subtract)
      columns_to_subtract = [*columns_to_subtract]
      selected_columns = self.column_names - columns_to_subtract
      
      select selected_columns.map { |c| "#{self.table_name}.#{c}" }.join(', ')
    rescue
      puts "Columns not available for `exclude`"
    end
1267087
@Override
    public ResponseToRoom ignore(String... params) {
        excludedVars.addAll(Arrays.asList(params));
        return this;
    }
120500
public static <T> Predicates<T> attributeNotIn(
            Function<? super T, ?> function,
            Iterable<?> iterable)
    {
        return new AttributePredicate<T, Object>(function, Predicates.notIn(iterable));
    }
321050
public AnimaQuery<T> notNull(String columnName) {
        conditionSQL.append(" AND ").append(columnName).append(" IS NOT NULL");
        return this;
    }
754827
public AnimaQuery<T> notEmpty(String columnName) {
        conditionSQL.append(" AND ").append(columnName).append(" != ''");
        return this;
    }
864474
public final R notIn(Collection<T> values) {
    expr().notIn(_name, values);
    return _root;
  }
75059
public <R> AnimaQuery<T> order(TypeFunction<T, R> function, OrderBy orderBy) {
        String columnName = AnimaUtils.getLambdaColumnName(function);
        return order(columnName, orderBy);
    }
550230
def _collection_function_inclusion_builder(funcs: Iterable[str]) -> NodePredicate:
    """"""
    funcs = set(funcs)

    if not funcs:
        raise ValueError('can not build function inclusion filter with empty list of functions')

    def functions_inclusion_filter(_: BELGraph, node: BaseEntity) -> bool:
        """Pass only for a node that is one of the enclosed functions."""
        return node.function in funcs

    return functions_inclusion_filter
1203525
public static final <X> Function<X,Boolean> isNullBy(final IFunction<X,?> by) {
        return FnFunc.chain(by, FnObject.isNull());
    }
1178104
function without(list, test, removedFn) {
 
   return withoutInner(list, removedFn || noop);
 
   function withoutInner(subList, removedFn) {
      return subList  
         ?  ( test(head(subList)) 
                  ? (removedFn(head(subList)), tail(subList)) 
                  : cons(head(subList), withoutInner(tail(subList), removedFn))
            )
         : emptyList
         ;
   }               
}
68296
public List<ENTITY> findExcludeColumns(Collection<String> excludeColumns, Match... matches) {
        Set<String> columns = orMapping.getAllColumns();
        for (String column : excludeColumns) {
            columns.remove(column);
        }
        return findIncludeColumns(columns, matches);
    }
1125500
def func(nargs: Optional[int] = None, nouts: Optional[int] = None, ndefs: Optional[int] = None):
    
    return lambda f: wraps(f)(WrappedFunction(f, nargs=nargs, nouts=nouts, ndefs=ndefs))
843978
@Override
	public void createFunction(ObjectPath functionPath, CatalogFunction function, boolean ignoreIfExists)
			throws FunctionAlreadyExistException, DatabaseNotExistException {
		checkNotNull(functionPath);
		checkNotNull(function);

		if (!databaseExists(functionPath.getDatabaseName())) {
			throw new DatabaseNotExistException(catalogName, functionPath.getDatabaseName());
		}

		if (functionExists(functionPath)) {
			if (!ignoreIfExists) {
				throw new FunctionAlreadyExistException(catalogName, functionPath);
			}
		} else {
			functions.put(functionPath, function.copy());
		}
	}