Merge this assembly with another.
Obeys the rules of array_merge

@param Assembler $other

@return $this
359275
public function merge(Assembler $other)
    {
        //N.B. reflection used so as to not expose values
        //via some public method
        $refl = new \ReflectionObject($other);
        $reflValues = $refl->getProperty('values');
        $reflValues->setAccessible(true);
        $oValues = $reflValues->getValue($other);
        if (count($oValues) == 0) {
            return $this;
        }

        $this->values = array_merge($this->values, $oValues);

        return $this;
    }
708637
private function arrayMergeRecursive(array &$left, array &$right)
    {
        $merged = $left;
        foreach ($right as $key => $value) {
            if (is_array($value) && isset($merged[$key]) && is_array($merged[$key])) {
                $merged[$key] = $this->arrayMergeRecursive($merged[$key], $value);
            } else {
                if (is_numeric($key)) {
                    if (! in_array($value, $merged)) {
                        $merged[] = $value;
                    }
                } else {
                    $merged[$key] = $value;
                }
            }
        }

        return $merged;
    }
977407
public static function merge($left, $right)
	{
		if (is_array($left) && is_array($right)) {
			foreach ($left as $key => $val) {
				if (is_int($key)) {
					$right[] = $val;
				} else {
					if (isset($right[$key])) {
						$val = static::merge($val, $right[$key]);
					}
					$right[$key] = $val;
				}
			}

			return $right;

		} elseif ($left === NULL && is_array($right)) {
			return $right;

		} else {
			return $left;
		}
	}
489813
public function merge()
    {
        $args = func_get_args();

        foreach ($args as $arg) {
            if (!($arg instanceof \SplPriorityQueue)) {
                throw new \InvalidArgumentException('Only \SplPriorityQueue can merge.');
            }

            $queue = clone $arg;

            $queue->setExtractFlags(self::EXTR_BOTH);

            foreach ($queue as $item) {
                $this->insert($item['data'], $item['priority']);
            }
        }

        return $this;
    }
635228
public function merge(Validation $validation) {
        $this->getValidation()->merge($validation, $this->getName());
        return $this;
    }
264883
protected function mergeValues(array $values, $merge = true)
    {
        $this->values = $merge ? array_merge($this->values, $values) : $values;
        return $this;
    }
574067
public function outerProduct(Vector $other): Matrix
    {
        $literal = [];

        for ($i = 0; $i < $this->getSize(); $i++) {
            for ($j = 0; $j < $other->getSize(); $j++) {
                $literal[$i][$j] = $this->toArray()[$i] * $other->toArray()[$j];
            }
        }

        return new Matrix($literal);
    }
880216
private function mergeConfiguration($left, $right)
	{
		if (is_array($left) && is_array($right)) {
			foreach ($left as $key => $val) {
				if (is_int($key)) {
					$right[] = $val;
				} else {
					if (isset($right[$key])) {
						$val = $this->mergeConfiguration($val, $right[$key]);
					}
					$right[$key] = $val;
				}
			}

			return $right;

		} elseif ($left === NULL && is_array($right)) {
			return $right;

		} else {
			return $left;
		}
	}
494887
public function mergeAnalysis(
        ClassAnalysis $other)
    {
        $this->bad_definitions = array_merge_recursive(
            $this->bad_definitions,
            $other->bad_definitions
        );
        $this->missing_definitions = array_merge_recursive(
            $this->missing_definitions,
            $other->missing_definitions
        );
    }
548169
public function mergeContext(array $moreContext)
    {
        $this->context = array_replace_recursive(isset($this->context) ? $this->context : [], $moreContext);

        return $this;
    }
477094
public function merge($headers) {

        foreach ($headers as $key => $value) {
            $this->set($key, $value);
        }

        return $this;

    }
272406
public static function union(self $a, self $b): self
    {
        return new self(array_merge($a->toArray(), $b->toArray()));
    }
1220237
public static function concat($one, $other)
    {
        Arguments::define(
            Boa::either(
                Boa::lst(),
                Boa::string()
            ),
            Boa::either(
                Boa::lst(),
                Boa::string()
            )
        )->check($one, $other);

        $oneType = TypeHound::fetch($one);
        $twoType = TypeHound::fetch($other);

        if ($oneType !== $twoType) {
            throw new MismatchedArgumentTypesException(
                __FUNCTION__,
                $one,
                $other
            );
        }

        if ($oneType === ScalarTypes::SCALAR_STRING) {
            return $one . $other;
        }

        return ArrayMap::of($one)->append(ArrayMap::of($other))->toArray();
    }
952919
public function merge( array $members )
    {
        foreach( $members as $offset => $value ) {
            $this->offsetSet( $offset, $value );
        }
        return $this;
    }
148343
public function lessThan($other)
    {
        $this->doCheck(function ($value) use ($other) {
            $this->throwExceptionIfFalse(
                $value < $other,
                'Failed assertion that %s is less than %s', $value, $other
            );
        });

        return $this;
    }
250385
def merge(self, other):
        """"""
        log.debug('Merging: %s and %s' % (self.serialize(), other.serialize()))
        for k in self.keys():
            for new_item in other[k]:
                if new_item not in self[k]:
                    self[k].append(new_item)
        log.debug('Result: %s' % self.serialize())
        return self
249873
public function merge(Hash $other, Closure $closure = null)
    {
        return $this->mergeInto(clone $this, $other, $closure);
    }