Dlaczego więcej języków nie ma możliwości porównania wartości z więcej niż jedną inną wartością? [Zamknięte]

Rozważ następujące:

if(a == b or c)

W większości języków należy to zapisać jako:

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

co jest nieco kłopotliwe i powtarza informacje.

Wiem, że moja powyższa przykładowa składnia jest nieco niezgrabna, ale jestem pewien, że są lepsze sposoby przekazania tego pomysłu.

Dlaczego nie oferuje tego więcej języków? Czy występują problemy z wydajnością lub składnią?

Problem ze składnią polega na tym, że wymaga ona składni.

Bez względu na to, jaką składnię ma Twój język, ludzie używający tego języka muszą się go nauczyć. W przeciwnym razie grozi im zobaczenie kodu i brak wiedzy o jego działaniu. Dlatego ogólnie uważa się za dobrą rzecz, jeśli język ma prostą składnię, która czysto obsługuje wiele przypadków.

W twoim konkretnym przykładzie próbujesz pobrać operator infix (funkcja, która przyjmuje dwa argumenty, ale jest zapisany Argument1 Operator Argument2) i próbujesz rozszerzyć go na wiele argumentów. To nie działa bardzo czysto, ponieważ cały punkt operatorów infix, o ile istnieje, polega na umieszczeniu operatora pomiędzy dwoma argumentami. Wydłużenie do (Argument1 Operator Argument2 MagicallyClearSymbol Argument3...)wydaje się nie dodawać dużo przejrzystości Equals(Arg1,Arg2,...). Infix jest zwykle używany do naśladowania konwencji matematycznych, które ludzie znają, co nie byłoby prawdą w przypadku alternatywnej składni.

Nie ma żadnych szczególnych problemów z wydajnością związanych z twoim pomysłem, poza tym, że parser musiałby poradzić sobie z gramatyką z inną regułą produkcyjną lub dwiema, co może mieć niewielki wpływ na szybkość parsowania. Może to mieć znaczenie dla języka interpretowanego lub skompilowanego w JIT, ale prawdopodobnie nie jest to duża różnica.

Większy problem z tym pomysłem polega na tym, że tworzenie wielu specjalnych przypadków w języku jest złym pomysłem .

Ponieważ jest to bezproblemowe, a jego rozwiązanie przynosi zasadniczo zerową korzyść, ale wdrożenie go przynosi niezerowe koszty.

Istniejące funkcje oparte na zakresie i takie, które praktycznie każdy język oferuje, mogą doskonale działać w tej sytuacji, jeśli skalują się do rozmiaru, w którym a == b || a == cnie można ich wyciąć.

Niektóre języki mają takie funkcje. Np. W Perl6 możemy użyć połączeń , które są „superpozycjami” dwóch wartości:

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

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

Połączenia pozwalają nam wyrażać operacje na zbiorze danych dość zwięźle, podobnie do sposobu, w jaki operacje skalarne rozkładają się na kolekcje w niektórych językach. Np. Używając Pythona z numpy, porównanie można rozłożyć na wszystkie wartości:

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

Działa to jednak tylko dla wybranych typów pierwotnych.

Dlaczego skrzyżowania są problematyczne? Ponieważ operacje na skrzyżowaniu rozkładają się na zawarte w nim wartości, sam obiekt skrzyżowania zachowuje się jak proxy dla wywołań metod - coś, co może obsłużyć kilka systemów typów oprócz typowania kaczego.

Problemów z układem typów można uniknąć, jeśli takie połączenia są dozwolone tylko jako specjalna składnia wokół operatorów porównania. Ale w tym przypadku są one tak ograniczone, że nie dodają wystarczającej wartości, aby dodać je do rozsądnego języka. To samo zachowanie można wyrazić za pomocą operacji ustawiania lub ręcznego wypisywania wszystkich porównań, a większość języków nie wierzy w dodanie zbędnej składni, jeśli istnieje już doskonale doskonałe rozwiązanie.

W językach z makrami łatwo jest dodać coś takiego, jeśli jeszcze go nie ma. Rozważ rakietę

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

W innych językach bez metaprogramowania, być może możesz przeformułować to jako sprawdzanie członkostwa w ustawieniach / listach, być może:

if a ∈ {b, c}

W niektórych (popularnych) językach ==operator nie jest przechodni. Na przykład w JavaScript 0jest równy zarówno ''i '0', ale ''i wtedy '0'nie jest sobie równy. Więcej takich dziwactw w PHP.

Oznacza to, a == b == cże dodałoby to kolejną niejednoznaczność, ponieważ może dać inny wynik w zależności od tego, czy jest interpretowany jako (a == b) & (a == c)czy (a == b) & (a == c) & (b == c).

W większości języków powinno to być trywialnie osiągalne przez napisanie Infunkcji, więc dlaczego warto włączyć ją do rzeczywistego języka?

Na przykład Linq Contains().

Dobra, dla was wszystkich pedantów, oto moja implementacja w 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 lub c)” działa w większości języków: jeśli a == b lub jeśli c nie jest ujemne, zerowe lub zerowe.

Narzekanie, że jest to gadatliwe, nie ma sensu: nie powinieneś układać kilkunastu rzeczy w warunkowe. Jeśli chcesz porównać jedną wartość z dowolną liczbą innych wartości, zbuduj podprogram.

Zwykle chcesz ograniczyć składnię do minimum i zamiast tego pozwolić, aby takie konstrukcje były definiowane w samym języku.

Na przykład w Haskell można przekonwertować dowolną funkcję z dwoma lub więcej argumentami na operator infix za pomocą odwrotnych poleceń. To pozwala napisać:

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

gdzie elemjest po prostu normalna funkcja pobierająca dwa argumenty - wartość i listę wartości - i sprawdza, czy pierwszy jest elementem drugiego.

Co jeśli chcesz użyć andzamiast or? W Haskell możesz po prostu użyć następujących poleceń zamiast czekać, aż dostawca kompilatora zaimplementuje nową funkcję:

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

Niektóre języki to oferują - do pewnego stopnia.

Może nie jako twój konkretny przykład, ale weźmy na przykład wiersz 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

Tak więc niektóre języki są w porządku z wieloma porównaniami, pod warunkiem, że wyrażasz to poprawnie.

Niestety nie działa tak, jak można by się tego spodziewać w przypadku porównań.

>>> 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
>>> 

„Co masz na myśli mówiąc, że zwraca True lub 4?” - zatrudnienie po tobie

Jednym rozwiązaniem w tym przypadku, przynajmniej w Pythonie, jest użycie go nieco inaczej:

>>> 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
>>> 

EDYCJA: Poniższe czynności również zrobiłyby coś podobnego, ponownie w Pythonie ...

>>> 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
>>> 

Niezależnie od tego, jakiego używasz języka, może nie być tak, że nie możesz tego zrobić, po prostu musisz najpierw przyjrzeć się, jak działa logika. Zazwyczaj jest to kwestia znajomości tego, o co „pytasz” język, który ma ci powiedzieć.

Metoda indexOf stosowana w macierzy, którą posiadają wszystkie języki, pozwala porównać wartość z kilkoma innymi, więc chyba specjalny operator nie ma większego sensu.

W javascript, który napisałby:

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

Pytasz, dlaczego nie możemy tego zrobić: if(a == b or c)

Python robi to bardzo skutecznie, w rzeczywistości najskuteczniej z set:

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

W przypadku testowania członkostwa „ustaw” sprawdza, czy skróty elementu są takie same, i dopiero wtedy porównuje się pod kątem równości, więc elementy b i c muszą być mieszalne, w przeciwnym razie lista bezpośrednio porównuje równość:

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

Języki w stylu APL pozwalają porównać skalar z każdym elementem w wektorze w jednej operacji. To tworzy wektor boolowski. Na przykład chciałbym bezwstydnie promować mój minimalnie funkcjonalny kalkulator apl, inca ( tłumacz online ).

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

Aby sprowadzić to do jednej wartości, możemy wykonać włącznie lub sumując i sprawdzając wartość niezerową.

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

Tak więc, jak mówią inne odpowiedzi, problemem jest składnia. Do pewnego stopnia składniowe rozwiązania nie stwierdzono, być może w dużym kosztem nauki paradygmat tablicy.