Pourquoi la plupart des langages de programmation seulement binaire de l'égalité des opérateurs de comparaison?

Question

Dans les langues naturelles, nous disons "un peu de couleur est une couleur primaire si la couleur est rouge, bleu ou jaune."

Dans chaque langage de programmation que j'ai vu, cela se traduit par quelque chose comme:

isPrimaryColor = someColor == "Red" or someColor == "Blue" or someColor == "Yellow"

Pourquoi n'est-il pas une syntaxe qui correspond de plus près à la phrase anglaise. Après tout, on ne dit pas "un peu de couleur est une couleur primaire si la couleur est rouge, ou que la couleur est le bleu, ou que la couleur est jaune."

Je me rends compte tout simplement isPrimaryColor = someColor == ("Red" or "Blue" or "Yellow") parce qu'au lieu de Rouge, de Bleu et de Jaune, ils pourraient être de type boolean déclaration, auquel cas la logique booléenne s'applique, mais que penser de quelque chose comme:

isPrimaryColor = someColor ( == "Red" or == "Blue" or == "Yellow")

Comme un bonus supplémentaire que la syntaxe de permettre plus de flexibilité, de dire que tu voulais voir si un nombre est compris entre 1 et 100 ou 1000 et 2000, on pourrait dire:

someNumber ((>= 1 and <=100) or (>=1000 and <=2000))

Edit:

Réponses très intéressantes, et le point de prise que je devrais apprendre plus de langues. Après avoir lu les réponses, je suis d'accord que pour un usage strictement comparaison d'égalité quelque chose de similaire pour définir l'appartenance est une façon claire et concise d'exprimer la même chose (pour les langues qui ont de support de langue pour concis inline listes ou des ensembles et des tests d'adhésion)

L'une des questions qui m'est venue est que si la valeur de comparaison est le résultat d'un calcul fastidieux une variable temporaire devrait être (bien, devrait être) créé. L'autre problème est qu'il peut y avoir différentes évaluations qui doivent être vérifiées, comme "le résultat d'un calcul fastidieux devraient être les premiers et entre 200 et 300"

Ces scénarios sont également couverts par plusieurs langages fonctionnels (bien que selon la langue ne peut pas être plus concis), ou de toute autre langue que peut prendre une fonction comme paramètre. Par exemple pour l'exemple précédent pourrait être

MeetsRequirements(GetCalculatedValue(), f(x):x > 200, f(x):x < 300, IsPrime)

Answer 1

Je pense que la plupart des gens considèrent quelque chose comme

isPrimaryColor = ["Red", "Blue", "Yellow"].contains(someColor)

assez clair qu'ils n'ont pas besoin de syntaxe.

Answer 2

En python, vous pouvez faire quelque chose comme ceci:

color = "green"

if color in ["red", "green", "blue"]:
    print 'Yay'

Il est appelé in de l'opérateur, qui teste l'appartenance.

Answer 3

En perl 6, vous pouvez le faire avec des jonctions:

if $color eq 'Red'|'Blue'|'Green' {
    doit()
}

Alternativement, vous pourriez le faire avec la smart opérateur de match (~~). La suite est à peu près équivalent python if value in list: de la syntaxe, sauf qu' ~~ fait beaucoup plus dans d'autres contextes.

if ($color ~~ qw/Red Blue Green/) {
    doit()
}

Les parens aussi la rendre valide perl 5 (>=5.10); en perl 6, ils sont facultatifs.

Answer 4

En Haskell, il est facile de définir une fonction pour faire cela:

matches x ps = foldl (||) False $  map (\ p -> p x) ps

Cette fonction prend une valeur d'une liste de prédicats (de type a -> Bool) et les retours True si l'un des prédicats correspond à la valeur.

Cela vous permet de vous quelque chose comme ceci:

isMammal m = m `matches` [(=="Dog"), (=="Cat"), (=="Human")]

La bonne chose est qu'il ne doit pas seulement être l'égalité, vous pouvez utiliser n'importe quoi avec le type correct:

isAnimal a = a `matches` [isMammal, (=="Fish"), (=="Bird")]

Answer 5

Ruby

Figurant dans la liste:

irb(main):023:0> %w{red green blue}.include? "red"
=> true
irb(main):024:0> %w{red green blue}.include? "black"
=> false

Numérique, Gamme:

irb(main):008:0> def is_valid_num(x)
irb(main):009:1>   case x
irb(main):010:2>     when 1..100, 1000..2000 then true
irb(main):011:2>     else false
irb(main):012:2>   end
irb(main):013:1> end
=> nil
irb(main):014:0> is_valid_num(1)
=> true
irb(main):015:0> is_valid_num(100)
=> true
irb(main):016:0> is_valid_num(101)
=> false
irb(main):017:0> is_valid_num(1050)
=> true