Check $what less $than or not

@param  mixed $what
@param  mixed $than

@return bool
775320
protected function less($what, $than): bool
    {
        if ($this->inclusive) {
            return $what <= $than;
        }
        return $what < $than;
    }
956638
public function isBetweenExclusive(Instant $from, Instant $to) : bool
    {
        return $this->isAfter($from) && $this->isBefore($to);
    }
575091
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof ExpressionNode)) {
            return false;
        }

        if ($this->getOperator() != $other->getOperator()) return false;

        $thisLeft = $this->getLeft();
        $otherLeft = $other->getLeft();
        $thisRight = $this->getRight();
        $otherRight = $other->getRight();

        if ($thisLeft === null) {
            return $otherLeft === null && $thisRight->compareTo($otherRight);
        }

        if ($thisRight === null) {
            return $otherRight=== null && $thisLeft->compareTo($otherLeft);
        }

        return $thisLeft->compareTo($otherLeft) && $thisRight->compareTo($otherRight);
    }
853122
private function isWherePart($where): bool
    {
        if (is_array($where)) {
            return
                array_key_exists('___operator', $where) &&
                array_key_exists('___where', $where) &&
                array_key_exists('___condition', $where);
        }

        return false;
    }
883638
function contains($item, callable $callback = null) {
        if ($callback === null) {
            $callback = __NAMESPACE__ . '\\compare';
        }
        foreach ($this->avl as $pair) {
            /**
             * @var Pair $pair
             */
            if (call_user_func($callback, $pair->second, $item) === 0) {
                return true;
            }
        }

        return false;
    }
21299
function IS($action,$module,$bundle,$output){
		$match = true;

		if($action != '' && $action != $this->action ){
			$match = false;
		}
		if($module != '' && $module != $this->module ){
			$match = false;
		}
		if($bundle != '' && $bundle != $this->bundle ){
			$match = false;
		}
		if($match){
			return $output;
		}
		return '';
	}
906249
protected function to($what, &$out, $until = false, $allowNewline = false) {
if (is_string($allowNewline)) {
$validChars = $allowNewline;
} else {
$validChars = $allowNewline ? "." : "[^\n]";
}
if (!$this->match('('.$validChars.'*?)'.\ATPCore\Lessc::preg_quote($what), $m, !$until)) return false;
if ($until) $this->count -= strlen($what); // give back $what
$out = $m[1];
return true;
}
878222
public function andNotBetween($key, $min, $max)
    {
        $value = sprintf('%s NOT BETWEEN ? AND ?', $key);
        return $this->andAdd($value, [$min, $max]);
    }
126009
public function isBetweenInclusive(Instant $from, Instant $to) : bool
    {
        return $this->isAfterOrEqualTo($from) && $this->isBeforeOrEqualTo($to);
    }
107668
public function or_where($wheres = array())
	{
		if (count($wheres) > 0)
		{
			if ( ! isset($this->wheres['$or']) or ! is_array($this->wheres['$or']))
			{
				$this->wheres['$or'] = array();
			}

			foreach ($wheres as $wh => $val)
			{
				$this->wheres['$or'][] = array($wh => $val);
			}
		}
		return $this;
	}
789873
protected function whereBetween(Builder $query, $where)
    {
        $between = $where['not'] ? 'not between' : 'between';

        return $this->wrap($where['column']).' '.$between.' ? and ?';
    }
898803
function contains($item, callable $comparator = null) {
        $compare = $comparator ?: [$this, 'areEqual'];

        $storage = $this->storage;
        for (reset($storage); key($storage) !== null; next($storage)) {
            /**
             * @var Pair $pair
             */
            $pair = current($storage);
            if (call_user_func($compare, $item, $pair->second)) {
                return true;
            }
        }
        return false;
    }
850889
public function compareTo($other): bool {
        if(!($other instanceof $this)) {
            return FALSE;
        }
        if($this->getFileName() !== $other->getFileName()) {
            return FALSE;
        }
        return TRUE;
    }
653985
public static function endsWith(?string $what, ?string $where): bool
    {
        // check is not empty string
        if (self::likeEmpty($what) || self::likeEmpty($where)) {
            return false;
        }

        $suffix = self::sub($where, -self::length($what));
        return $suffix === $what;
    }
249952
public static function change($what, $how) {
		switch ($what) {
			case 'layout':
				self::$settings['mvc']['controller_layout'] = $how;
				break;
			case 'view':
				self::$settings['mvc']['controller_view'] = $how;
				break;
		}
	}
356148
public function greaterThan(array $options) {
        if (isset($options['element'])) {
            if (isset($this->data[$options['element']])) {
                $than = ' "' . $this->cleanElement($options['element']) . '"';
                if ($this->elementData > $this->data[$options['element']] || (empty($this->elementData) && $this->elementData !== 0)) {
                    return true;
                }
            }
        } else if (isset($options['value'])) {
            $than = $options['value'];
            if ($this->elementData > $options['value']) {
                return true;
            }
        }

        $this->addError($this->checkMessage('Value must be greater than ' . $than, $options));
        return false;
    }
1334510
public function rule_between_num( $key, $value, $min, $max )
	{
		if ( !$this->rule_min_num( $key, $value, $min ) )
		{
			return false;
		}
		if ( !$this->rule_max_num( $key, $value, $max ) )
		{
			return false;
		}
		return true;
	}