Merge the `others` schema into this instance.

        The values will all be read from the provider of the original object.
437990
def merge(cls, *others):
        
        for other in others:
            for k, v in other:
                setattr(cls, k, BoundValue(cls, k, v.value))
610160
def merge(self, another):
        
        if isinstance(another, Result):
            another = another.errors
        self.errors = self.merge_errors(self.errors, another)
382358
function(other) {
      if (!other) {
        return;
      }
      
      // This does the inverse of _mergeMagicFields.
      this.id = other.id;
      this.createdAt = other.createdAt;
      this.updatedAt = other.updatedAt;

      this._copyServerData(other._serverData);

      this._hasData = true;
    }
773688
def merge(self, other):
        
        other = StringCell.coerce(other)
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            return self
        elif self.is_entailed_by(other):
            self.value = other.value
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge string '%s' with '%s'" % \
                    (self, other))
        else:
            self._perform_merge(other)
        return self
1277818
def merge(self, schema):
        
        for item in schema.attributes.items():
            if item[0] in self.attributes:
                continue
            self.all.append(item[1])
            self.attributes[item[0]] = item[1]
        for item in schema.elements.items():
            if item[0] in self.elements:
                continue
            self.all.append(item[1])
            self.elements[item[0]] = item[1]
        for item in schema.types.items():
            if item[0] in self.types:
                continue
            self.all.append(item[1])
            self.types[item[0]] = item[1]
        for item in schema.groups.items():
            if item[0] in self.groups:
                continue
            self.all.append(item[1])
            self.groups[item[0]] = item[1]
        for item in schema.agrps.items():
            if item[0] in self.agrps:
                continue
            self.all.append(item[1])
            self.agrps[item[0]] = item[1]
        schema.merged = True
        return self
116465
def merge!(other)
      self.class.coerce(other).to_h.each { |name, values| set name, values }
    end
586050
private void merge(FieldNumberTree other) {
    for (Key key : other.children.keySet()) {
      FieldNumberTree value = other.children.get(key);
      if (!this.children.containsKey(key)) {
        this.children.put(key, value);
      } else {
        this.children.get(key).merge(value);
      }
    }
  }
1331641
def merge(self, others, merge_conditions, common_ancestor=None):
        
        merging_occurred = False

        for o in others:
            for region_id, region in o._regions.items():
                if region_id in self._regions:
                    merging_occurred |= self._regions[region_id].merge(
                        [region], merge_conditions, common_ancestor=common_ancestor
                    )
                else:
                    merging_occurred = True
                    self._regions[region_id] = region

        return merging_occurred
428930
def merge(self, other):
        
        other = self.coerce(other)
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            # other is a subset of self
            return self
        elif self.is_entailed_by(other):
            # self is a subset of other.
            self.values = other.values.copy()
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge set with %s" % (str(other)))
        else:
            # merge mutual information
            if self.values:
                self.values = self.values.intersection(other.values)
            else:
                self.values = other.values.copy()
        return self
982381
def merge(self, other):
        
        if not isinstance(other, NameVariants):
            raise TypeError("NameVariants isinstance can be merge with"
                            "other isinstance of the same class")
        for key in self.variants:
            self.variants[key] = self.variants[key] or other.variants[key]

        return self
800951
def merge(self, other):
        
        if not isinstance(other, DictCell):
            raise Exception("Incomparable")
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            return self
        elif self.is_entailed_by(other):
            self.__dict__['p'] = other.__dict__['p'].copy()
        elif not self.is_contradictory(other):
            # partial information in both, add from other
            for o_key, o_val in other:
                if not o_key in self.__dict__['p']:
                    self.__dict__['p'][o_key] = o_val
                else:
                    self.__dict__['p'][o_key].merge(o_val)
        else:
            raise Contradiction("Dictionaries are contractory, cannot Merge")
        return self
615494
def merge(other_lookup_context)
      new_lookup_hash = lookup_hash.dup
      new_lookup_hash[:language_codes] |= other_lookup_context.language_codes

      other_lookup_context.language_codes.each do |language_code|
        new_lookup_hash[language_code] ||= {}
        new_lookup_hash[language_code].merge!(other_lookup_context.lookup_hash[language_code])
      end

      LookupContext.new(new_lookup_hash)
    end
546450
def absorb(self, other):
        
        if not isinstance(other, self.__class__):
            raise TypeError("`other` has to be a instance of %s!" %
                            self.__class__)

        for attr, value in other.items():
            if value is not None:
                setattr(self, attr, deepcopy(value))
927364
def merge(self, other):
        
        other = self.coerce(other)
        if list_diff(self.domain, other.domain) != []:
            raise Exception("Incomparable orderings. Different domains")
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            return self
        elif self.is_entailed_by(other):
            self.low, self.high = other.low, other.high
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge %s and %s" % (self, other))
        else:
            # information in both
            to_i = self.to_i
            self.low = self.domain[max(map(to_i, [self.low, other.low]))]
            self.high =self.domain[min(map(to_i, [self.high, other.high]))]
        return self
398502
def merge_values(src, new):
    """"""
    if isinstance(src, dict) and isinstance(new, dict):
        return merge_dicts(src, new)
    else:
        if not isinstance(src, list):
            src = [src]
        if not isinstance(new, list):
            new = [new]

        return merge_lists(src, new)
28183
def merge(self, other):
        
        for child_name, child in other.children.items():
            self.add_child(child_name, child)
748997
def merge(other)
      old_attributes = attributes
      other_attributes = other.is_a?(Hash) ? other : other.attributes

      old_attributes.merge!(other_attributes) do |key, old_value, new_value|
        case key
        when :clusters, :contexts, :users
          old_value + new_value.reject do |new_mapping|
            old_value.any? { |old_mapping| old_mapping[:name] == new_mapping[:name] }
          end
        else
          case old_value
          when Array
            (old_value + new_value).uniq
          when Hash
            old_value.merge(new_value) do |_key, inner_old_value, inner_new_value|
              inner_old_value.nil? ? inner_new_value : inner_old_value
            end
          when NilClass
            new_value
          else
            warn "key is #{key} old val is #{old_value.inspect} and new val is #{new_value.inspect}"
            old_value
          end
        end
      end

      self.class.new(old_attributes)
    end