Concatenate two semigroups.

@param  Semigroup $that
@return Semigroup
178662
public function concat(Semigroup $that): Semigroup {
        if (!$that instanceof self) {
            throw new \LogicException('Semigroup cannot concatenate two distinct types.');
        }
        return new Sum($this->value + $that->value);
    }
334441
public static function concat()
    {
        $args = func_get_arg();
        $string = '';

        foreach ($args as $arg) {
            $string .= $arg;
        }

        return $string;
    }
925291
public function remainder($that) : BigInteger
    {
        $that = BigInteger::of($that);

        if ($that->value === '0') {
            throw DivisionByZeroException::divisionByZero();
        }

        $remainder = Calculator::get()->divR($this->value, $that->value);

        return new BigInteger($remainder);
    }
718846
function combine () {
  const c = Array.prototype.concat.apply([], arguments)
    .map((expression) => '(' + expression.source + ')')
    .join('|')
  return new RegExp(c)
}
1248454
public function merge(Condition $condition)
    {
        $this->expressions = array_merge($this->expressions, $condition->toArray());

        return $this;
    }
318417
public static function concat()
    {
        $args = func_get_args();
        $separator = array_shift($args);

        $output = null;
        foreach ($args as $string) {
            $output .= $string . $separator;
        }

        $output = rtrim($output, $separator);
        return $output;
    }
543954
public function concat()
    {
        $args = func_get_args();
        array_unshift($args, $this->sfa);

        // Concat this iterator, and variadic args
        $class = new ReflectionClass('Qaribou\Iterator\ConcatIterator');
        $concatIt = $class->newInstanceArgs($args);

        // Create as new immutable's iterator
        return new static($concatIt);
    }
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;
    }
488278
public function union( $graphs /* graphs ... */ ) {
		$graphs = is_array( $graphs ) ? $graphs : func_get_args();

		$this->unions[] = implode( ' UNION', array_map( function( GraphBuilder $graph ) {
			return ' {' . $graph->getSPARQL() . ' }';
		}, $graphs ) );

		return $this;
	}
1198779
public function append($s)
    {
        if ($s instanceof Buffer) {
            $s = $s->buffer;
        }
        $this->buffer .= $s;
        $this->length = strlen($this->buffer);
        return $this;
    }
1131995
public function merge(self $that)
    {
        $this->statements += $that->statements;
        $this->coveredStatements += $that->coveredStatements;
        $this->lineCoverage = null; // clear previous data
    }
1138557
public function merge($options)
    {
        $other_options = self::parse($options);
        if ($other_options->apiKey === null) {
            $other_options->apiKey = $this->apiKey;
        }
        $other_options->headers = array_merge($this->headers, $other_options->headers);
        return $other_options;
    }
272406
public static function union(self $a, self $b): self
    {
        return new self(array_merge($a->toArray(), $b->toArray()));
    }
772970
public function append($other): self
    {
        if (is_array($this->elements) && !is_array($other) && !($other instanceof \Traversable)) {
            $all = $this->elements;
            $all[] = $other;
            return new self($all);
        }

        $appendIterator = new \AppendIterator();
        $appendIterator->append($this->getIterator());
        $appendIterator->append(castToIterator($other));
        return new self($appendIterator, $this->type);
    }
1078822
public function addMultiLanguage(...$parameters)
    {
        if (count($parameters) === 1) {
            $this->routes['ml'][] = ['closure' => $parameters[0], 'groupArgs' => []];
        } elseif (count($parameters) === 2) {
            $this->routes['ml'][] = ['closure' => $parameters[1], 'groupArgs' => $parameters[0]];
        } else {
            throw new \InvalidArgumentException;
        }
    }
1270246
public static function Concat( $context, $args )
	{
		$sb = array();
		if ( count( $args ) < 2 )
		    throw XPath2Exception::withErrorCodeAndParams( "XPST0017", Resources::XPST0017,
				array(
					"concat",
					count( $args ),
					XmlReservedNs::xQueryFunc,
				)
			);

		foreach ( $args as $arg )
			if ( ! $arg instanceof Undefined )
				$sb[] = CoreFuncs::Atomize( CoreFuncs::StringValue( $context, $arg ) );

		$result = implode( "", $sb );
		return XPath2Item::fromValueAndType( $result, XmlSchema::$String );
	}
314499
public function concat(...$others)
    {
        return static::of(
            Std::foldl(
                function ($carry, $part) {
                    return $carry . (string) $part;
                },
                $this->contents,
                $others
            ),
            $this->encoding
        );
    }