Replaces the output of the source or mutator with the output
    of the subsequent mutator. This is the default combiner.
423269
def replace_combiner(value, mutator, *args, **kwargs):
    
    args = list(args) + [value]
    return mutator(*args, **kwargs)
549899
def merge(value,
          default='',
          omit_opts=False,
          omit_master=False,
          omit_pillar=False):
    '''
    
    '''
    ret = None
    if not omit_opts:
        if value in __opts__:
            ret = __opts__[value]
            if isinstance(ret, six.string_types):
                return ret
    if not omit_master:
        if value in __pillar__.get('master', {}):
            tmp = __pillar__['master'][value]
            if ret is None:
                ret = tmp
                if isinstance(ret, six.string_types):
                    return ret
            elif isinstance(ret, dict) and isinstance(tmp, dict):
                tmp.update(ret)
                ret = tmp
            elif (isinstance(ret, (list, tuple)) and
                    isinstance(tmp, (list, tuple))):
                ret = list(ret) + list(tmp)
    if not omit_pillar:
        if value in __pillar__:
            tmp = __pillar__[value]
            if ret is None:
                ret = tmp
                if isinstance(ret, six.string_types):
                    return ret
            elif isinstance(ret, dict) and isinstance(tmp, dict):
                tmp.update(ret)
                ret = tmp
            elif (isinstance(ret, (list, tuple)) and
                    isinstance(tmp, (list, tuple))):
                ret = list(ret) + list(tmp)
    if ret is None and value in DEFAULTS:
        return DEFAULTS[value]
    return ret or default
327823
def _organize_output(output, combine_map, file_key, combine_arg_keys):
    
    out_map = collections.defaultdict(list)
    extra_args = collections.defaultdict(list)
    final_args = collections.OrderedDict()
    extras = []
    for data in output:
        cur_file = data.get(file_key)
        if not cur_file:
            extras.append([data])
        else:
            cur_out = combine_map[cur_file]
            out_map[cur_out].append(cur_file)
            extra_args[cur_out].append([data[x] for x in combine_arg_keys])
            data[file_key] = cur_out
            if cur_out not in final_args:
                final_args[cur_out] = [data]
            else:
                extras.append([data])
    combine_args = [[v, k] + _get_extra_args(extra_args[k], combine_arg_keys)
                    for (k, v) in out_map.items()]
    return combine_args, list(final_args.values()) + extras
1112404
def mutate(self):
        
        self._client.post('{}/mutate'.format(Instance.api_endpoint), model=self)

        return True
695816
public Context merge(final OutputStream out, final String encoding) {
        return merge(Vars.EMPTY, new OutputStreamOut(out, InternedEncoding.intern(encoding), engine));
    }
1296658
public Mutations<S> combineWith(final Mutations<S> other) {
        IntArrayList result = new IntArrayList(mutations.length + other.mutations.length);

        //mut2 pointer
        int p2 = 0, position0 = 0, delta = 0;

        for (int p1 = 0; p1 < mutations.length; ++p1) {

            position0 = getPosition(mutations[p1]);

            while (p2 < other.mutations.length && // There are mutations in m2
                    (getPosition(other.mutations[p2]) < position0 + delta || // Before current point
                            (getPosition(other.mutations[p2]) == position0 + delta && // On the current point and it is insertion
                                    getRawTypeCode(other.mutations[p2]) == RAW_MUTATION_TYPE_INSERTION)))
                appendInCombine(result, Mutation.move(other.mutations[p2++], -delta));

            switch (getRawTypeCode(mutations[p1])) {
                case RAW_MUTATION_TYPE_INSERTION:
                    if (p2 < other.mutations.length && getPosition(other.mutations[p2]) == delta + position0) {
                        if (getTo(mutations[p1]) != getFrom(other.mutations[p2]))
                            throw new IllegalArgumentException();

                        if (isSubstitution(other.mutations[p2]))
                            appendInCombine(result, (mutations[p1] & (~LETTER_MASK)) | (other.mutations[p2] & LETTER_MASK));

                        ++p2;
                    } else
                        appendInCombine(result, mutations[p1]);
                    ++delta;
                    break;
                case RAW_MUTATION_TYPE_SUBSTITUTION:
                    if (p2 < other.mutations.length && getPosition(other.mutations[p2]) == delta + position0) {

                        if (getTo(mutations[p1]) != getFrom(other.mutations[p2]))
                            throw new IllegalArgumentException();

                        if (isSubstitution(other.mutations[p2])) {
                            if (getFrom(mutations[p1]) != getTo(other.mutations[p2]))
                                appendInCombine(result, (mutations[p1] & (~LETTER_MASK)) | (other.mutations[p2] & LETTER_MASK));
                        } else if (isDeletion(other.mutations[p2]))
                            appendInCombine(result, createDeletion(position0, getFrom(mutations[p1])));
                        else
                            throw new RuntimeException("Insertion after Del. or Subs.");

                        ++p2;

                    } else
                        appendInCombine(result, mutations[p1]);

                    break;
                case RAW_MUTATION_TYPE_DELETION:
                    --delta;
                    appendInCombine(result, mutations[p1]);
                    break;
            }

        }

        while (p2 < other.mutations.length)
            appendInCombine(result, Mutation.move(other.mutations[p2++], -delta));

        return new Mutations<S>(alphabet, result.toArray(), true);
    }
607553
def concatenate(input_files, output_file):
    
    from .modules import utils, concat

    if not isinstance(input_files, (list, tuple)):
        raise RuntimeError('Concatenate takes a list of input files.')

    return {
        'dependencies_fn': utils.no_dependencies,
        'compiler_fn': concat.concatenate_input_files,
        'input': input_files,
        'output': output_file,
        'kwargs': {},
    }
963250
function customizer(destination, source) {
  // If we're not working with a plain object, copy the value as is
  // If source is an array, for instance, it will replace destination
  if (!isPlain(source)) {
    return source;
  }

  // If the new value is a plain object but the first object value is not
  // we need to create a new object for the first object to merge with.
  // This makes it consistent with how merge() works by default
  // and also protects from later changes the to first object affecting
  // the second object's values.
  if (!isPlain(destination)) {
    return mergeOptions(source);
  }
}
1272286
def combine(self, node, othernode, op=None, unary_op=None, register=False,
                aliasing_type=False):
        
        if self.result[othernode] is self.builder.UnknownType:
            if node not in self.result:
                self.result[node] = self.builder.UnknownType
            return

        if aliasing_type:
            self.combine_(node, othernode, op or operator.add,
                          unary_op or (lambda x: x), register)
            for a in self.strict_aliases[node]:
                self.combine_(a, othernode, op or operator.add,
                              unary_op or (lambda x: x), register)
        else:
            self.combine_(node, othernode, op or operator.add,
                          unary_op or (lambda x: x), register)
572871
private static void replaceRepositoryInputForValues(ArtifactoryClientConfiguration configuration,
                                                        Run build, String resolverReleaseInput,
                                                        String resolverSnapshotInput, Map<String, String> env) {
        if (StringUtils.isBlank(resolverReleaseInput) || StringUtils.isBlank(resolverSnapshotInput)) {
            build.setResult(Result.FAILURE);
            throw new IllegalStateException("Input for resolve repositories cannot be empty.");
        }
        String resolveReleaseRepo = Util.replaceMacro(resolverReleaseInput, env);
        String resolveSnapshotRepo = Util.replaceMacro(resolverSnapshotInput, env);
        if (StringUtils.isBlank(resolveReleaseRepo) || StringUtils.isBlank(resolveSnapshotRepo)) {
            build.setResult(Result.FAILURE);
            throw new IllegalStateException("Resolver repository variable cannot be replaces with empty value.");
        }
        configuration.resolver.setDownloadSnapshotRepoKey(resolveSnapshotRepo);
        configuration.resolver.setRepoKey(resolveReleaseRepo);
    }
866513
def capture_content
      original, @_output = output, Output.new
      yield
      original.widgets.concat(output.widgets) # todo: test!!!
      output.to_s
    ensure
      @_output = original
    end
1203260
public void replace(PushbackReader in, int bufferSize, Writer out, String format) throws IOException
    {
        InputReader reader = Input.getInstance(in, bufferSize);
        ObsoleteSimpleReplacer fsp = new ObsoleteSimpleReplacer(format);
        replace(reader, out, fsp);
    }
939439
public static <T> Mutator<T> mutate(T t) {
    Objects.requireNonNull(t);
    return new Mutator<>(t);
  }
621197
def deep_merge(source, options = {})
      default_opts = {:preserve_unmergeables => true}
      DeepMerge::deep_merge!(source, self, default_opts.merge(options))
    end
1037608
function merge(source, target) {
    if (target == null) {
        return clone(source);
    }
    if (source == null) {
        return clone(target);
    }
    if (typeof source !== 'object' || typeof target !== 'object') {
        return clone(target);
    }
    const merge = (source, target) => {
        Object.keys(target).forEach(key => {
            if (source[key] == null) {
                source[key] = target[key];
            } else if (typeof source[key] === 'object') {
                if (typeof target[key] === 'object') {
                    merge(source[key], target[key]);
                } else {
                    source[key] = target[key];
                }
            } else {
                source[key] = target[key];
            }
        });

        return source;
    };

    return merge(clone(source), clone(target));
}
818256
private void merge(Map<String, NodeT> source, Map<String, NodeT> target) {
        for (Map.Entry<String, NodeT> entry : source.entrySet()) {
            String key = entry.getKey();
            if (!target.containsKey(key)) {
                target.put(key, entry.getValue());
            }
        }
    }
455118
def convert_merge(builder, layer, input_names, output_names, keras_layer):
    
    # Get input and output names
    output_name = output_names[0]

    mode = _get_elementwise_name_from_keras_layer(keras_layer)
    builder.add_elementwise(name = layer, input_names = input_names,
            output_name = output_name, mode = mode)