Por que mais idiomas não conseguem comparar um valor com mais de um outro valor? [fechadas]

Considere o seguinte:

if(a == b or c)

Na maioria dos idiomas, isso precisa ser escrito como:

if(a == b or a == c)

que é um pouco complicado e repete as informações.

Sei que minha sintaxe de amostra acima é um pouco desajeitada, mas tenho certeza de que existem maneiras melhores de transmitir a ideia.

Por que mais idiomas não oferecem isso? Há problemas de desempenho ou sintaxe?

O problema da sintaxe é - que requer sintaxe.

Qualquer que seja a sintaxe do seu idioma, as pessoas que o usam precisam aprender. Caso contrário, eles correm o risco de ver o código e não saber o que ele faz. Portanto, geralmente é considerado bom se um idioma tiver uma sintaxe simples que lide com muitos casos.

No seu exemplo específico, você está tentando pegar um operador infix (uma função que aceita dois argumentos, mas está gravada Argument1 Operator Argument2) e tentando estendê-lo para vários argumentos. Isso não funciona de maneira muito limpa, porque todo o ponto dos operadores de infix, na medida em que existe um, é colocar o operador entre os dois argumentos. A extensão para (Argument1 Operator Argument2 MagicallyClearSymbol Argument3...)não parece acrescentar muita clareza Equals(Arg1,Arg2,...). O Infix também é normalmente usado para emular convenções matemáticas com as quais as pessoas estão familiarizadas, o que não seria verdade para uma sintaxe alternativa.

Não haveria nenhum problema específico de desempenho associado à sua ideia, além do fato de o analisador precisar lidar com uma gramática com outra regra de produção ou duas, o que pode ter um pequeno efeito na velocidade da análise. Isso pode fazer alguma diferença para uma linguagem interpretada ou compilada pelo JIT, mas provavelmente não uma grande diferença.

O maior problema com a idéia é que fazer muitos casos especiais em um idioma tende a ser uma má idéia .

Porque não é um problema, e resolvê-lo traz basicamente nenhum benefício, mas sua implementação traz um custo diferente de zero.

As funções existentes baseadas em intervalo e que praticamente todos os idiomas oferecem podem funcionar perfeitamente bem nessa situação se forem dimensionadas para um tamanho em a == b || a == cque não serão cortadas.

Alguns idiomas possuem esses recursos. Por exemplo, no Perl6, podemos usar junções , que são "superposições" de dois valores:

if $a == any($b, $c) {
    say "yes";
}

# syntactic sugar for the above
if $a == $b | $c {
    say "yes";
}

As junções nos permitem expressar operações de um conjunto de dados de maneira bastante sucinta, semelhante à maneira como as operações escalares distribuem as coleções em alguns idiomas. Por exemplo, usando Python com numpy, a comparação pode ser distribuída por todos os valores:

import numpy as np
2 == np.array([1, 2, 3])
#=> np.array([False, True, False], dtype=np.bool)
(2 == np.array([1, 2, 3])).any()
#=> True

No entanto, isso funciona apenas para tipos primitivos selecionados.

Por que as junções são problemáticas? Como as operações em uma junção distribuem sobre os valores contidos, o próprio objeto de junção se comporta como um proxy para chamadas de método - algo que poucos sistemas de tipos, além da digitação com patos, podem lidar.

Problemas no sistema de tipos podem ser evitados se tais junções forem permitidas apenas como sintaxe especial em torno dos operadores de comparação. Mas, neste caso, eles são tão limitados que não agregam valor suficiente para serem adicionados a qualquer linguagem sã. O mesmo comportamento pode ser expresso usando operações definidas ou explicitando manualmente todas as comparações, e a maioria dos idiomas não acredita em adicionar sintaxe redundante se já houver uma solução perfeitamente adequada.

Em idiomas com macros, é fácil adicionar algo assim se ainda não estiver lá. Considere Raquete

(define-syntax-rule (equal-any? a b ...)
  (or (equal? a b) ...))
(equal-any? "a" "b" "a")
> #t

Em outros idiomas sem metaprogramação, talvez você possa reformular isso como verificação de associação de conjunto / lista, talvez:

if a ∈ {b, c}

Em alguns idiomas (populares), o ==operador não é transitivo. Por exemplo, no JavaScript 0é igual a ambos ''e '0', mas então ''e '0'não são iguais um ao outro. Mais dessas peculiaridades em PHP.

Isso significa que a == b == cadicionaria outra ambiguidade, pois poderia gerar um resultado diferente, dependendo de ser interpretado como (a == b) & (a == c)ou (a == b) & (a == c) & (b == c).

Na maioria dos idiomas, isso deve ser trivialmente possível ao escrever uma Infunção; então, por que torná-la parte da linguagem real?

Linq, por exemplo, tem Contains().

Tudo bem, para todos os pedantes, aqui está minha implementação em C #:

public static bool In<T>(this T obj, params T[] values)
{
    for(int i=0; i < values.Length; i++)
    {
        if (object.Equals(obj, values[i]))
            return true;
    }
    return false;
}

"if (a == b ou c)" funciona na maioria dos idiomas: se a == b ou se c não for negativo, nulo ou zero.

Reclamar que é detalhado erra o objetivo: você não deve acumular uma dúzia de coisas em uma condição. Se você precisar comparar um valor a um número arbitrário de outros valores, crie uma sub-rotina.

Geralmente, você deseja manter sua sintaxe no mínimo e permitir que essas construções sejam definidas no próprio idioma.

Por exemplo, no Haskell, você pode converter qualquer função com dois ou mais argumentos em um operador infix usando backticks. Isso permite que você escreva:

if a `elem` [b, c] then ... else ...

onde elemé apenas uma função normal usando dois argumentos - um valor e uma lista de valores - e verifica se o primeiro é um elemento do segundo.

E se você quiser usar em andvez de or? No Haskell, você pode simplesmente usar o seguinte, em vez de esperar que o fornecedor do compilador implemente um novo recurso:

 if all (== a) [b, c] then ... else ...

Alguns idiomas oferecem isso - até certo ponto.

Talvez não seja o seu exemplo específico , mas tome por exemplo uma linha Python:

def minmax(min, max):
    def answer(value):
        return max > value > min
    return answer

inbounds = minmax(5, 15)
inbounds(7) ##returns True
inbounds(3) ##returns False
inbounds(18) ##returns False

Portanto, alguns idiomas são adequados com várias comparações, desde que você a expresse corretamente.

Infelizmente, ele não funciona exatamente como você esperaria para comparações.

>>> def foo(a, b):
...     def answer(value):
...         return value == a or b
...     return answer
... 
>>> tester = foo(2, 4)
>>> tester(3)
4
>>> tester(2)
True
>>> tester(4)
4
>>> 

"O que você quer dizer ele retorna True ou 4?" - o aluguel depois de você

Uma solução nesse caso, pelo menos com o Python, é usá-lo de maneira um pouco diferente:

>>> def bar(a, b):
...     def ans(val):
...             return val == a or val == b
...     return ans
... 
>>> this = bar(4, 10)
>>> this(5)
False
>>> this(4)
True
>>> this(10)
True
>>> this(9)
False
>>> 

EDIT: O seguinte também faria algo semelhante, novamente em Python ...

>>> def bar(a, b):
...     def answer(val):
...             return val in (a, b)
...     return answer
... 
>>> this = bar(3, 5)
>>> this(3)
True
>>> this(4)
False
>>> this(5)
True
>>> 

Portanto, qualquer que seja o idioma que você esteja usando, pode não ser que você não consiga fazê-lo, apenas que você deve primeiro examinar mais de perto como a lógica realmente funciona. Normalmente, é apenas uma questão de saber o que você está 'realmente pedindo' o idioma para lhe dizer.

O método indexOf, usado em uma matriz, que quase todas as línguas têm, permite comparar um valor a várias outras, então acho que um operador especial não faz muito sentido.

Em javascript que escreveria:

if ( [b, c].indexOf(a) != -1 ) { ....  }

Você pergunta por que não podemos fazer isso: if(a == b or c)

O Python faz isso de maneira muito eficiente, de fato, com mais eficiência set:

if a in set([b, c]):
    then_do_this()

Para teste de associação, 'set' verifica se os hashes do elemento são iguais e só então compara a igualdade; portanto, os elementos, bec devem ser laváveis; caso contrário, uma lista compara diretamente a igualdade:

if a in [b, c]:
    then_do_this()

As linguagens no estilo APL permitem comparar um escalar com cada elemento em um vetor em uma única operação. Isso produz um vetor booleano. Por exemplo, gostaria de promover descaradamente a minha calculadora de aplicativos de recursos mínimos, o inca ( intérprete on-line ).

   a<5
5 
   b<4
4 
   c<5
5 
   a=b c
0 1 

Para reduzir isso a um valor único, podemos fazer uma inclusão ou somar e verificar se há zero.

   0!+/a=b c
1 
   c<6
6 
   0!+/a=b c
0

Portanto, como as outras respostas dizem, o problema é de sintaxe. Até certo ponto, as soluções de sintaxe ter sido encontrado, com o custo talvez pesada de aprender o paradigma matriz.