Есть ли причина, по которой большинство языков программирования не имеют операторов '!> (Не больше) и'! <'(Не меньше)?

Интересно, есть ли какая - либо причина - или , если это не просто случайность истории - то есть нет !>и !<операторов в большинстве языков программирования?

a >= b (большее ИЛИ равно b) может быть записано как !(a < b) (НЕ Меньше b) , что равно a !< b.

Этот вопрос поразил меня, когда я занимался кодированием своего собственного конструктора деревьев выражений. Большинство языков программирования имеют a != bоператор для !(a=b), так почему нет !>и !<?

ОБНОВИТЬ:

• !<(не меньше) легче произнести, чем >=(больше или равно)
• !<(не менее) является короче , чтобы ввести , чем >=(больше или равно)
• !<(не меньше) легче понять * чем >=(больше или равно)

* потому что ORэто бинарный оператор, ваш мозг должен оперировать двумя операндами (терка, равно), а NOTунарный оператор и ваш мозг должен оперировать только одним операндом (меньшим).

Язык программирования D и расширение DMC до C и C ++ действительно поддерживают эти операторы (все 14 их комбинаций), но, что интересно, D собирается отказаться от этих операторов , главным образом потому, что

1. что именно a !< b? Это a>=b || isNaN(a) || isNaN(b). !<это не то же самое >=, потому что NaN !< NaNверно, а NaN >= NaNложно. IEEE 754 трудно освоить, поэтому использование a !< bto просто вызовет путаницу при обработке NaN - вы можете искать такие операторы в Фобосе (стандартная библиотека D), и у многих пользователей есть комментарии, чтобы напомнить читателям, что NaN вовлечен,
2. поэтому мало кто будет его использовать, даже если такие операторы существуют как в D,
3. и нужно определить еще 8 токенов для этих редко используемых операторов, что усложняет компилятору небольшую выгоду,
4. и без этих операторов можно было бы использовать эквивалент !(a < b), или, если кому-то нравится быть явным a >= b || isNaN(a) || isNaN(b), и их легче читать.

Кроме того, отношения (≮, ≯, ≰, ≱) редко встречаются в базовой математике, в отличие от !=(≠) или >=(≥), поэтому многим людям трудно это понять.

Это, вероятно, также причины, почему большинство языков не поддерживают их.

Потому что не имеет большого смысла иметь два разных оператора с одинаковым значением.

• «Не больше» ( !>) точно так же, как «меньше или равно» ( <=)
• «Не меньше» ( !<) точно так же, как «больше или равно» ( >=)

Это не относится к «не равно» ( !=), нет оператора с таким же значением.

Таким образом, ваша модификация сделает язык более сложным без какой-либо выгоды.

!<является синонимом >=. Позже это просто способ печатать четко определенный математический символ ≥. Вы правы в том, что «не меньше чем» используется в разговорной речи, однако оно является разговорным и может быть неоднозначным (может быть истолковано ≥или неверно истолковано как >). С другой стороны, в программировании и математике используется четко определенная, однозначная терминология.

Даже в 3-значной логике, такой как ANSI SQL, not x < yэквивалентно x >= y, поскольку они оба дают, NULLесли либо, xлибо yесть NULL. Однако есть не-ANSI-совместимые диалекты SQL, где они не эквивалентны, и они есть!< .

Transact-SQL имеет операторы !> (Не более) и ! <(Не менее) .

Так что, кроме вас, кто-то из Sybase Microsoft также думал, что это будет хорошая идея. Так же, как Microsoft Боб! :)

Я думаю, что ответ просто, что нет необходимости в !<операторе. Как вы указали в своем вопросе, уже >=и <=наряду с возможностью отрицать существующее выражение, так зачем добавлять еще один оператор?

Из RFC 1925

Совершенство достигается не тогда, когда нечего добавить, а когда нечего убрать.

Добавление дополнительных операторов, которые дублируют существующую функциональность, не делает ничего, кроме добавления (ненужной) сложности к языку (и, следовательно, токенизатора и анализатора).

Также учтите, что в языках, где возможна перегрузка операторов, вам потребуется перегрузить еще одного оператора. Примите во внимание путаницу, когда bool operator<=и bool operator!>могли бы вернуться разные вещи (да, я знаю, что можно уже сделать противоречивые сравнения).

Наконец, подумайте о языках, где методы или операторы определены множественно (Ruby - я смотрю на вас ), и у вас есть один программист, который использует <=, а другой использует!>, И у вас есть несколько стилей кода для одного и того же выражения.

! <равно> = Теперь почему у нас второй, а не первый, потому что все языки реализуют сначала положительный оператор, а затем приближаются к отрицательному оператору, так как реализация> = также охватывает! <и <= охватывает!>. Таким образом, создатель языка переходит к этим и думал, что они будут лишними и пропустить их.

Всегда старайтесь сначала реализовать позитивный случай, затем переходите к негативному (:) позитивное мышление, только мое личное мнение)

Причина в том, что операторы в языках программирования заимствуют из математической традиции, а в математике никто на самом деле не использует «не больше» и «не меньше», так как «меньше или равно» и «больше или равно» делают такую ​​же работу.

Таким образом, в языках программирования мы обычно получаем символ, похожий на ≠ для не равных ( !=или /=, если кто-то не увлекается <>или текстовым оператором)

и вещи, которые похожи на ≤ и ≥ ( <=и >=)

Кстати, я не согласен с твоим утверждением, что НЕ проще понять и рассуждать о том, что ИЛИ. В математике доказательства, включающие множество отрицаний (например, приведение к абсурду), обычно осуждаются, если есть более прямая альтернатива. Кроме того, в случае упорядочивания базовые знания, которыми мы располагаем (и которые используются при обдумывании или доказательстве чего-либо), - это трикотомия между <, = и>, поэтому любое утверждение! <, Вероятно, следует преобразовать в> =, если вы хотите это сделать. что-нибудь полезное с этим.

Я бы частично обвинил набор инструкций по сборке. У вас есть инструкции, такие как jge«прыгать, если больше или равно». В отличие от «прыгать, если не меньше, чем».

Авторы компиляторов, возможно, ушли от того, что придумали авторы ассемблера, что, по-видимому, основывалось на том, как он был помечен при разработке на чипе.

... возможно.

Я думаю, что видел несколько языков несколько лет назад, где вместо !=оператора (не равно) использовалось что-то вроде <>. Не могу вспомнить их имена, хотя ...

Я думаю, что это труднее читать !(a < b)или a !< bчем a >= b. Вероятно, поэтому !<не используется (на мой взгляд, это выглядит ужасно).