@param mixed $other

@return $this
175654
public function lessThanOrEqual($other)
    {
        $this->doCheck(function ($value) use ($other) {
            $this->throwExceptionIfFalse(
                $value <= $other,
                'Failed assertion that %s is less than %s', $value, $other
            );
        });

        return $this;
    }
485767
public function gte($other)
    {
        if (!($other instanceof self)) {
            $other = new BigInt($other);
        }
        return ($this->compare($other) >= 0);
    }
754017
public function merge(ArrayObject $other, $recursive = TRUE) {
        foreach($other as $key => $value) {
            if($recursive && $this->offsetExists($key)) {
                $ownvalue = $this->offsetGet($key);
                if($ownvalue instanceof ArrayObject && $value instanceof ArrayObject) {
                    $ownvalue->merge($value, TRUE);
                    continue;
                }
            }

            $this->offsetSet($key, $value);
        }

        return $this;
    }
977101
public function equal($other, array $options = []): Image
    {
        return $this->callEnum($other, 'relational', OperationRelational::EQUAL, $options);
    }
1317323
public function prependAll($other): Seq
    {
        if (is_array($other)) {
            return new Seq(
                array_merge(
                    array_values($other),
                    $this->data
                )
            );
        }

        if ($other instanceof Seq) {
            return $other->appendAll($this->data);
        }

        throw new \InvalidArgumentException('`$other` must be `Seq` or `array`');
    }
585217
public function merge(Config $other)
    {
        $this->tables = array_merge($this->tables, $other->getTables());
    }
341253
public function lessThan( $other )
	{
		return $this->namespaceURI == null && $other->namespaceURI ||
		$this->namespaceURI && $other->namespaceURI && $this->namespaceURI < $other->namespaceURI ||
		$this->namespaceURI == $other->namespaceURI && $this->localName < $other->localName;
	}
179954
public function equals( $other )
	{
		try
		{
			return $this->qnameValueHash == $other->qnameValueHash ||
				( $this->localName == $other->localName && $this->namespaceURI == $other->namespaceURI );
		}
		catch( \Exception $ex )
		{
			return false;
		}
	}
221730
public function ap(ApplyInterface $other)
    {
        return $this->bind(function (callable $closure) use ($other) {
            return $other->fmap($closure);
        });
    }
1101671
def update(self, other):
        
        if isinstance(other, Properties):
            other = other.defined
        for n, v in other.items():
            self.set(n, v)
        return self
167394
public function merge(self $other = null)
    {
        // Create new item
        $new = $this->copyChildless();

        // Add all children from this item
        foreach ($this->getChildren() as $child) {
            /* @var NavigationItem $child */
            $new->addChild($child->merge((null != $other) ? $other->findChildren($child) : null));
        }

        // Add all children from the other item
        if (null != $other) {
            foreach ($other->getChildren() as $child) {
                /** @var NavigationItem $child */
                if (!$new->find($child)) {
                    $new->addChild($child->merge($this->copyChildless()));
                }
            }
        }

        return $new;
    }
516001
public function intersection(Interval $other)
	{
		if ($this->isContaining($other)) {
			return $other;

		} elseif ($other->isContaining($this)) {
			return $this;

		} elseif ($this->isOverlappedFromRightBy($other)) {
			// This:  □□□□□□■■■■■■■■■■■□□□□□□□□□□□□□□□□□□□□
			// Other: □□□□□□□□□□□□■■■■■■■■■■■□□□□□□□□□□□□□□
			//    $other->from   |   | <- $this-till

			return new static($other->getLeft(), $this->getRight());

		} elseif ($other->isOverlappedFromRightBy($this)) {
			// This:  □□□□□□□□□□□□■■■■■■■■■■■□□□□□□□□□□□□□□□□□
			// Other: □□□□□□■■■■■■■■■■■□□□□□□□□□□□□□□□□□□□□□□□
			//    $this->from -> |   | <- $other-till

			return new static($this->getLeft(), $other->getRight());
		}

		$dummy = $this->left->asOpened();

		return new static($dummy, $dummy);
	}
306232
public function equals($other)
    {
        if (!($other instanceof self)) {
            $other = new BigInt($other);
        }
        return ($this->compare($other) === 0);
    }
1075215
public function mergeWith(Parsed $other)
    {
        $mergeMethod = Translations::MERGE_ADD | Translations::MERGE_PLURAL;
        if ($other->sourceStrings !== null) {
            if ($this->sourceStrings === null) {
                $this->sourceStrings = $other->sourceStrings;
            } else {
                $this->sourceStrings->mergeWith($other->sourceStrings, $mergeMethod);
            }
        }
        foreach ($other->translations as $key => $data) {
            if (isset($this->translations[$key])) {
                $this->translations[$key][1]->mergeWith($data[1], $mergeMethod);
            } else {
                $this->translations[$key] = $data;
            }
        }
    }
937530
public static function copyFrom(Query $otherQuery)
    {
        $self            = new static($otherQuery->table);
        $self->alias     = $otherQuery->alias;
        $self->joins     = $otherQuery->joins;
        $self->where     = $otherQuery->where;
        $self->orderings = $otherQuery->orderings;
        $self->offset    = $otherQuery->offset;
        $self->limit     = $otherQuery->limit;

        return $self;
    }
1140640
public function moreEq($other, array $options = []): Image
    {
        return $this->callEnum($other, 'relational', OperationRelational::MOREEQ, $options);
    }
697867
public function zipLeft($other)
    {
        if (count($other) !== count($this)) {
            throw new \InvalidArgumentException(
                'Both left and right must have same size.'
            );
        }

        if (is_array($other)) {
            return new Seq(
                array_map(
                    function ($a, $b) {
                        return new Tuple([$a, $b]);
                    },
                    $other,
                    $this->data
                )
            );
        }

        if ($other instanceof Seq) {
            return $other->zip($this->data);
        }

        throw new \InvalidArgumentException('`$other` must be `Seq` or `array`');
    }