Implement the parse action for Combine.
160782
def _combine(self, original, loc, tokens):
        """"""
        combined_tokens = super(CombineNode, self).postParse(original, loc, tokens)
        internal_assert(len(combined_tokens) == 1, "Combine produced multiple tokens", combined_tokens)
        return combined_tokens[0]
937611
def combine(in_files, out_file, config):
    
    if not utils.file_exists(out_file):
        with file_transaction(config, out_file) as tx_out_file:
            with open(tx_out_file, "w") as out_handle:
                for in_file in in_files:
                    with open(in_file) as in_handle:
                        shutil.copyfileobj(in_handle, out_handle)
    return out_file
77780
def combine(self, other, name=None):
    """"""
    return PhaseGroup(
        setup=self.setup + other.setup,
        main=self.main + other.main,
        teardown=self.teardown + other.teardown,
        name=name)
130715
function(res) {
        var results = /** @type {Array.<!goog.result.Result>} */ (
            res.getValue());
        if (goog.array.every(results, resolvedSuccessfully)) {
          combinedResult.setValue(results);
        } else {
          combinedResult.setError(results);
        }
      }
881192
public static Action composite(final Applicable... actions) {
        return new Action(input -> {
            for (Applicable action : actions) {
                action.apply(input);
            }

            return input;
        });
    }
931533
function(action, implementation){
            this.resolvableActions                      = this.resolvableActions                        || {};
            this.resolvableActions[action]              = this.resolvableActions[action]                || {};
            this.resolvableActions[action].actionName   = this.resolvableActions[action].actionName     || action;

            implementation = implementation || RL.ResolvableAction.Types[action];
            this.resolvableActions[action] = Object.create(implementation);
            // merge could be used instead of Object.create but is less desirable
            // RL.Util.merge(this.resolvableAction.Types[action], implementation);

            if(this.resolvableActions[action].init){
                this.resolvableActions[action].init.call(this);
            }
        }
559578
function() {
    var combined = Status.VALID;
    for (var i = 0; i < arguments.length; i++) {
      var status = arguments[i];
      if (Array.isArray(status)) {
        status = Status.combine.apply(null, status);
      }
      if (status > combined) {
        combined = status;
      }
    }
    return combined;
  }
130188
def register_custom_actions(parser: argparse.ArgumentParser) -> None:
    """"""
    parser.register('action', None, _StoreRangeAction)
    parser.register('action', 'store', _StoreRangeAction)
    parser.register('action', 'append', _AppendRangeAction)
198100
def post_parse_action(self, entry):
        """"""
        if 'source_host' in entry.keys():
            host = self.ip_port_regex.findall(entry['source_host'])
            if host:
                hlist = host[0].split('.')
                entry['source_host'] = '.'.join(hlist[:4])
                entry['source_port'] = hlist[-1]
        if 'dest_host' in entry.keys():
            host = self.ip_port_regex.findall(entry['dest_host'])
            if host:
                hlist = host[0].split('.')
                entry['dest_host'] = '.'.join(hlist[:4])
                entry['dest_port'] = hlist[-1]

        return entry
937205
public @Nonnull Result combine(@Nonnull Result that) {
        if(this.ordinal < that.ordinal)
            return that;
        else
            return this;
    }
371972
function getViewCombinations(action) {
	const pathes = [action];
	const positions = [];
	let i;
	let j;

	for (i = 0; i < action.length; i++) {
		if (action[i] === '-') {
			positions.push(i);
		}
	}

	const len = positions.length;
	const combinations = [];

	for (i = 1; i < (1 << len); i++) {
		const c = [];
		for (j = 0; j < len; j++) {
			if (i & (1 << j)) {
				c.push(positions[j]);
			}
		}
		combinations.push(c);
	}

	combinations.forEach((combination) => {
		let combinationPath = action;
		combination.forEach((pos) => {
			combinationPath = replaceAt(combinationPath, pos, '/');
		});
		pathes.push(combinationPath);
	});
	return pathes;
}
1007478
public void combine(SearchFilter new_filter, int op) throws DBException
    {
        // If this is not a logical operator, throw an exception
        if ((op & LOGICAL_OPER_MASK) == 0)
        {
            throw new DBException();
            // Create a new vector consisting of just the filters
            // from the SearchFilter classes in new_filters
        }
        Vector filters = new Vector();
        filters.addElement(new_filter.getFilter());
        // Create a node for this list and return it
        m_filter = new SearchBaseNode(op, m_filter, filters);
    }
750579
def set_combiner(value, mutator, *args, **kwargs):
    
    value.add(mutator(*args, **kwargs))
    return value
776508
function parseAction ({ action, payload={}, error=false }) {
  switch (typeof action) {
    // If it's an action creator, create the action
    case 'function': return action(payload)
    // If it's an action object return the action
    case 'object': return action
    // Otherwise, create a "default" action object with the given type
    case 'string': return { type: action, payload, error }
    default: throw new Error('Invalid action definition (must be function, object or string).')
  }
}
1365273
public Context merge(final Vars vars, final Out out) {
        try {
            return prepareAst()
                    .execute(this, out, vars);
        } catch (Exception e) {
            throw completeException(e);
        }
    }
1103724
def _combine(self, x, y):
    """"""
    if x is None or y is None:
      return x or y
    if x != y:
      raise ValueError('Incompatible set of constraints provided.')
    return x
58385
function combine(type) {
  for (var _len = arguments.length, atoms = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    atoms[_key - 1] = arguments[_key];
  }

  if (typeof type !== 'string') {
    var firstAtom = type;
    atoms = [firstAtom].concat(_toConsumableArray(atoms));
    type = firstAtom.type;
  }

  var actionParams = [];
  atoms.forEach(function (atom) {
    if (atom.isMutable) {
      actionParams.push.apply(actionParams, _toConsumableArray(atom.actionParams));
    }
  });
  if (checkDuplicateParams(actionParams)) {
    throw 'Duplicate parameters when combining atoms';
  }

  var getNewState = function getNewState(state, action) {
    var newState = {};
    atoms.forEach(function (atom) {
      if (atom.isMutable) {
        var data = {};
        atom.actionParams.forEach(function (param) {
          data[param] = action[param];
        });
        newState = _extends({}, newState, atom.getNewState(state, data));
      } else {
        newState = _extends({}, newState, atom.getNewState());
      }
    });
    return newState;
  };

  return (0, _createAtom2.default)({
    isMutable: atoms.findIndex(function (atom) {
      return atom.isMutable;
    }) >= 0,
    type: type,
    actionParams: actionParams,
    getNewState: getNewState
  });
}