Merges this Curies with another instance of Curies and returns the merged instance.

@param other merged Curies
@return a merged copy of this and other
199945
public Curies mergeWith(final Curies other) {
        final Curies merged = copyOf(this);
        other.curies.forEach(merged::register);
        return merged;
    }
262760
@SuppressWarnings("unchecked")
    public static <T> List<T> concat(final Iterable<T> first, final Iterable<T> ... other) {
        List<T> list = newArrayList(first);
        for (Iterable<T> iter : other) {
            list.addAll(newArrayList(iter));
        }
        return list;
    }
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
806927
public TupleCombiner cloneOf()
    {
    TupleCombiner other = new TupleCombiner();
    other.setTupleSize( getTupleSize());
    other.setIncludedVars( new HashSet<VarNamePattern>( getIncludedVars()));
    other.setExcludedVars( new HashSet<VarNamePattern>( getExcludedVars()));
    other.setOnceTuples( new HashSet<TupleRef>( IteratorUtils.toList( getOnceTuples())));
    return other;
    }
116465
def merge!(other)
      self.class.coerce(other).to_h.each { |name, values| set name, values }
    end
715398
def merge(other)
      self.class.new.tap do |result|
        result.merge!(self)
        result.merge!(other)
      end
    end
395892
public void mergeWith(OptionalBoolean other) {
		if (state == other.state) {
			// no change in state
		} else if (state == State.UNSET) {
			state = other.state;
		} else if (other.state == State.UNSET) {
			// no change in state
		} else {
			state = State.CONFLICTING;
		}
	}
1277897
void merge(Settings other) {
    for (int i = 0; i < COUNT; i++) {
      if (!other.isSet(i)) continue;
      set(i, other.flags(i), other.get(i));
    }
  }
1074823
@Override
    public void merge(ROC other) {
        if (this.thresholdSteps != other.thresholdSteps) {
            throw new UnsupportedOperationException(
                    "Cannot merge ROC instances with different numbers of threshold steps ("
                            + this.thresholdSteps + " vs. " + other.thresholdSteps + ")");
        }
        this.countActualPositive += other.countActualPositive;
        this.countActualNegative += other.countActualNegative;
        this.auc = null;
        this.auprc = null;
        this.rocCurve = null;
        this.prCurve = null;


        if (isExact) {
            if (other.exampleCount == 0) {
                return;
            }

            if (this.exampleCount == 0) {
                this.exampleCount = other.exampleCount;
                this.probAndLabel = other.probAndLabel;
                return;
            }

            if (this.exampleCount + other.exampleCount > this.probAndLabel.size(0)) {
                //Allocate new array
                val newSize = this.probAndLabel.size(0) + Math.max(other.probAndLabel.size(0), exactAllocBlockSize);
                INDArray newProbAndLabel = Nd4j.create(DataType.DOUBLE, newSize, 2);
                newProbAndLabel.put(new INDArrayIndex[]{interval(0, exampleCount), all()}, probAndLabel.get(interval(0, exampleCount), all()));
                probAndLabel = newProbAndLabel;
            }

            INDArray toPut = other.probAndLabel.get(interval(0, other.exampleCount), all());
            probAndLabel.put(new INDArrayIndex[]{
                            interval(exampleCount, exampleCount + other.exampleCount), all()},
                    toPut);
        } else {
            for (Double d : this.counts.keySet()) {
                CountsForThreshold cft = this.counts.get(d);
                CountsForThreshold otherCft = other.counts.get(d);
                cft.countTruePositive += otherCft.countTruePositive;
                cft.countFalsePositive += otherCft.countFalsePositive;
            }
        }

        this.exampleCount += other.exampleCount;
    }
213124
public Stoichiometry combineWith(Stoichiometry other) {
		Set<SubunitCluster> combinedClusters = new LinkedHashSet<>();
		combinedClusters.addAll(this.orderedClusters);
		combinedClusters.addAll(other.orderedClusters);

		Stoichiometry combinedStoichiometry;
		if (this.strategy == StringOverflowStrategy.CUSTOM) {
			combinedStoichiometry = new Stoichiometry(new ArrayList<>(combinedClusters),this.customStringGenerator);
		} else {
			combinedStoichiometry = new Stoichiometry(new ArrayList<>(combinedClusters),this.strategy,false);
		}
		return combinedStoichiometry;
	}
337404
def union(self, other):
        

        obj = self._clone()
        obj.union_update(other)
        return obj
20492
public UpdateDescription merge(@Nullable final UpdateDescription otherDescription) {
    if (otherDescription != null) {
      for (final Map.Entry<String, BsonValue> entry : this.updatedFields.entrySet()) {
        if (otherDescription.removedFields.contains(entry.getKey())) {
          this.updatedFields.remove(entry.getKey());
        }
      }
      for (final String removedField : this.removedFields) {
        if (otherDescription.updatedFields.containsKey(removedField)) {
          this.removedFields.remove(removedField);
        }
      }

      this.removedFields.addAll(otherDescription.removedFields);
      this.updatedFields.putAll(otherDescription.updatedFields);
    }

    return this;
  }
357746
def merge(self, other):
        # type: (TentativeType) -> None
        
        for hashables in other.types_hashable:
            self.add(hashables)
        for non_hashbles in other.types:
            self.add(non_hashbles)
28183
def merge(self, other):
        
        for child_name, child in other.children.items():
            self.add_child(child_name, child)
29697
public void merge(VersionRows other) {
		conceptRows.addAll(other.conceptRows);
		relationshipRows.addAll(other.relationshipRows);
		concreteDomainRows.addAll(other.getConcreteDomainRows());
                attributeDomainRows.addAll(other.getAttributeDomainRows());
		owlRows.addAll(other.getConcreteDomainRows());
	}
297657
public void union(GeneralSubtrees other) {
        if (other != null) {
            for (int i = 0, n = other.size(); i < n; i++) {
                add(other.get(i));
            }
            // Minimize this
            minimize();
        }
    }
999697
def merge(self, other):
        
        ignore = self.ignore
        extra = self.extras
        if isinstance(other, Dict):
            other_keys = other.keys
            ignore += other.ignore
            extra += other.extras
        elif isinstance(other, (list, tuple)):
            other_keys = list(other)
        elif isinstance(other, dict):
            return self.__class__(other, *self.keys)
        else:
            raise TypeError('You must merge Dict only with Dict'
                            ' or list of Keys')
        return self.__class__(*(self.keys + other_keys), ignore_extra=ignore,
                              allow_extra=extra)