Existe alguma razão pela qual a maioria das linguagens de programação não possui operadores '!>' (Não maiores que) e '! <' (Não menos que)?

Gostaria de saber se existe alguma razão - ou se é apenas um acidente da história - que não existem operadores !>e !<na maioria das linguagens de programação?

a >= b (um OR maior igual a b) pode ser escrito como !(a < b) (a NÃO menor b) , igual a a !< b.

Essa pergunta me ocorreu quando eu estava no meio da codificação do meu próprio construtor de árvores de expressão. A maioria das linguagens de programação tem a != boperador para !(a=b), então por que não !>e !<?

ATUALIZAR:

• !<(não menor) é mais fácil de pronunciar do que >=(maior ou igual)
• !<(não menor) é mais curto para digitar do que >=(maior ou igual)
• !<(não menor) é mais fácil de entender * do que >=(maior ou igual)

* porque ORé um operador binário, seu cérebro precisa operar dois operandos (ralador, iguais), enquanto NOTé um operador unário e seu cérebro precisa operar apenas com um operando (menor).

A linguagem de programação D e a extensão do DMC para C e C ++ deram suporte a esses operadores (todas as 14 combinações), mas, curiosamente, D vai depreciar esses operadores , principalmente porque

1. o que exatamente é a !< b? É a>=b || isNaN(a) || isNaN(b). não!< é o mesmo que , porque é verdadeiro enquanto é falso. O IEEE 754 é difícil de dominar, portanto, usar o para causar confusão no manuseio do NaN - você pode procurar por esses operadores na Phobos (biblioteca padrão do D), e vários usos têm comentários ao lado para lembrar aos leitores que o NaN está envolvido,>=NaN !< NaNNaN >= NaNa !< b
2. portanto, poucas pessoas o usarão, mesmo que esses operadores existam como em D,
3. e é preciso definir mais 8 tokens para esses operadores raramente usados, o que complica o compilador por pouco benefício,
4. e sem esses operadores, ainda é possível usar o equivalente !(a < b), ou se alguém quiser ser explícito a >= b || isNaN(a) || isNaN(b), e eles são mais fáceis de ler.

Além disso, as relações (≮, ≯, ≰, ≱) raramente são vistas na matemática básica, ao contrário de !=(≠) ou >=(≥), por isso é difícil de entender para muitas pessoas.

Provavelmente, esses também são os motivos pelos quais a maioria dos idiomas não os suporta.

Porque não faz muito sentido ter dois operadores diferentes com exatamente o mesmo significado.

• “Não maior” ( !>) é exatamente o mesmo que “menor ou igual” ( <=)
• “Não menor” ( !<) é exatamente o mesmo que “maior ou igual” ( >=)

Isso não se aplica a "não é igual a" ( !=), não há operador com o mesmo significado.

Portanto, sua modificação tornaria o idioma mais complicado sem nenhum benefício.

!<é sinônimo de >=. Mais tarde, é apenas uma maneira de digitar um símbolo matemático bem definido ≥. Você está certo de que "não menos que" é usado na linguagem falada, no entanto, é coloquial e pode ser ambíguo (pode ser interpretado ≥ou mal interpretado como >). Por outro lado, programação e matemática usam terminologia claramente definida e inequívoca.

Mesmo na lógica de 3 valores, como ANSI SQL, not x < yé equivalente a x >= y, pois ambos fornecem NULLse é xou yé NULL. No entanto, existem dialetos SQL não compatíveis com ANSI, onde não são equivalentes, e eles possuem!< .

O Transact-SQL possui operadores !> (Não maiores que) e ! <(Não menores que) .

Então, além de você, alguém da Sybase Microsoft também achou que seria uma boa ideia. Assim como o Microsoft Bob! :)

Eu acho que a resposta é simplesmente que não há necessidade de um !<operador. Como você apontou na sua pergunta, já existe >=e <=com a possibilidade de negar uma expressão existente, então por que adicionar outro operador?

From RFC 1925

a perfeição foi alcançada não quando não há mais nada a acrescentar, mas quando não há mais nada a ser removido.

A adição de operadores adicionais que duplicam a funcionalidade existente não faz nada além de adicionar complexidade (desnecessária) ao idioma (e, portanto, tokenizer e analisador).

Considere também nos idiomas em que a sobrecarga do operador é possível, você teria outro operador para sobrecarregar. Considere a confusão quando bool operator<=e bool operator!>pode retornar coisas diferentes (sim, eu sei que já é possível fazer comparações inconsistentes).

Por fim, pense nas linguagens em que os métodos ou operadores são multiplamente definidos (Ruby - estou olhando para você ) e você tem um programador que usa <= enquanto outro usa!> E você tem vários estilos de código para a mesma expressão.

! <é igual a> = Agora, porque temos o segundo, não o primeiro, porque toda a linguagem implementa o operador positivo primeiro e depois a abordagem ao operador negativo, Como a implementação> = também abrange! <e <= abrange!>. e pensei que eles seriam redundantes e os ignorariam.

Sempre tente implementar o caso positivo primeiro e depois o caso negativo (:) pensamento positivo, apenas minha visão pessoal)

A razão é que os operadores de linguagens de programação tomam emprestado da tradição matemática e, na matemática, ninguém realmente usa "não maior" e "não menor", pois "menor ou igual" e "maior ou igual" fazem o mesmo trabalho.

Portanto, nas linguagens de programação, geralmente obtemos um símbolo parecido com ≠ para não igual ( !=ou /=, a menos que alguém se interesse por <>um operador textual)

e coisas que se parecem com ≤ e ≥ ( <=e >=)

Btw, eu não concordo com a sua afirmação de que NÃO é mais simples de entender e raciocinar sobre então OU. Em matemática, as provas que envolvem muitas negações (como a redução ao absurdo) geralmente são desaprovadas, se houver uma alternativa mais direta disponível. Além disso, no caso de pedidos, o conhecimento básico que temos (e que é usado ao pensar ou provar algo) é a tricotomia entre <, = e> para que qualquer declaração! <Provavelmente tenha que ser convertida em> = se você quiser fazer qualquer coisa útil com isso.

Eu culparia parcialmente o conjunto de instruções de montagem. Você tem instruções como jge"pular se for maior ou igual". Ao contrário de "pular se não for menor que".

Os criadores de compiladores podem ter optado pelo que os criadores de montagem criaram, o que presumivelmente se baseou em como ele foi rotulado ao ser projetado no chip.

...possivelmente.

Eu acho que vi algumas línguas há alguns anos atrás, onde, em vez do !=operador (não é igual a), algo como <>foi usado. Mas não consigo lembrar os nomes deles ...

Eu acho que é mais difícil de ler !(a < b)ou do a !< bque a >= b. Provavelmente, essa é a razão pela qual !<não é usado (parece feio na minha opinião).