Perché esistono così poche lingue con un 'operatore' di tipo variabile?

Intendo in questo modo:

<?php
    $number1 = 5;   // (Type 'Int')
    $operator1 = +; // (Type non-existent 'Operator')
    $number2 = 5;   // (Type 'Int')
    $operator2 = *; // (Type non-existent 'Operator')
    $number3 = 8;   // (Type 'Int')

    $test = $number1 $operator1 $number2 $operator2 $number3; //5 + 5 * 8.

    var_dump($test);
?>

Ma anche in questo modo:

<?php
    $number1 = 5;
    $number3 = 9;
    $operator1 = <;

    if ($number1 $operator1 $number3) { //5 < 9 (true)
        echo 'true';
    }
?>

Sembra che nessuna lingua abbia questo - c'è una buona ragione per cui non lo fanno?

Gli operatori sono solo funzioni con nomi divertenti, con qualche sintassi speciale in giro.

In molte lingue, diverse come C ++ e Python, puoi ridefinire gli operatori sovrascrivendo metodi speciali della tua classe. Quindi gli operatori standard (ad es. +) Lavorano secondo la logica fornita (ad es. Concatenando stringhe o aggiungendo matrici o altro).

Poiché tali funzioni che definiscono l'operatore sono solo metodi, puoi passarle come faresti con una funzione:

# python
action = int.__add__
result = action(3, 5)
assert result == 8

Altre lingue consentono di definire direttamente nuovi operatori come funzioni e di utilizzarli in forma infissa.

-- haskell
plus a b = a + b  -- a normal function
3 `plus` 5 == 8 -- True

(+++) a b = a + b  -- a funny name made of non-letters
3 +++ 5 == 8 -- True

let action = (+)
1 `action` 3 == 4 -- True

Sfortunatamente, non sono sicuro che PHP supporti qualcosa del genere, e se supportarlo sarebbe una buona cosa. Utilizzare una funzione semplice, è più leggibile di $foo $operator $bar.

Esistono molte lingue che consentono una sorta di metaprogrammazione . In particolare, sono sorpreso di non avere risposta parlando della famiglia di lingue Lisp .

Da Wikipedia:

La metaprogrammazione è la scrittura di programmi per computer con la capacità di trattare i programmi come i loro dati.

Più avanti nel testo:

Lisp è probabilmente il linguaggio per antonomasia con strutture di metaprogrammazione, sia per la sua precedenza storica sia per la semplicità e la potenza della sua metaprogrammazione.

Lingue Lisp

Segue una breve introduzione a Lisp.

Un modo per vedere il codice è come una serie di istruzioni: fai questo, poi fallo, poi fai quest'altra cosa ... Questa è una lista! Un elenco di cose da fare per il programma. E ovviamente puoi avere liste all'interno di liste per rappresentare loop e così via.

Se rappresentiamo una lista contenente gli elementi a, b, c, d come questo: (abcd) otteniamo qualcosa che assomiglia a una chiamata di funzione Lisp, in cui aè la funzione, e b, c, dsono gli argomenti. In realtà il tipico "Hello World!" il programma potrebbe essere scritto in questo modo:(println "Hello World!")

Certo b, co dpotrebbero essere elenchi che valutano anche qualcosa. Quanto segue: (println "I can add :" (+ 1 3) )stampa quindi "" Posso aggiungere: 4 ".

Quindi, un programma è una serie di elenchi nidificati e il primo elemento è una funzione. La buona notizia è che possiamo manipolare le liste! Quindi possiamo manipolare i linguaggi di programmazione.

Il vantaggio di Lisp

Lisps non è tanto un linguaggio di programmazione quanto un kit di strumenti per creare linguaggi di programmazione. Un linguaggio di programmazione programmabile.

Non è molto più semplice creare nuovi operatori in Lisps, ma è anche quasi impossibile scrivere alcuni operatori in altre lingue perché gli argomenti vengono valutati quando passati alla funzione.

Ad esempio in un linguaggio di tipo C diciamo che vuoi scrivere iftu stesso un operatore, qualcosa del tipo:

my-if(condition, if-true, if-false)

my-if(false, print("I should not be printed"), print("I should be printed"))

In questo caso entrambi gli argomenti verranno valutati e stampati, in un ordine che dipende dall'ordine di valutazione degli argomenti.

In Lisps, scrivere un operatore (lo chiamiamo macro) e scrivere una funzione è più o meno la stessa cosa e viene usato allo stesso modo. La differenza principale è che i parametri di una macro non vengono valutati prima di essere passati come argomenti alla macro. Questo è essenziale per poter scrivere alcuni operatori, come ifsopra.

Lingue del mondo reale

Mostrando come sia esattamente un po 'fuori portata qui, ma ti incoraggio a provare a programmare in un Lisp per saperne di più. Ad esempio potresti dare un'occhiata a:

• Schema , un vecchio, abbastanza "puro" Lisp con un piccolo nucleo
• Common Lisp, un Lisp più grande con un sistema di oggetti ben integrato e molte implementazioni (è standardizzato ANSI)
• Racchetta un Lisp digitato
• Clojure il mio preferito, gli esempi sopra erano il codice Clojure. Un moderno Lisp in esecuzione sulla JVM. Ci sono alcuni esempi di macro Clojure anche su SO (ma questo non è il punto giusto da cui iniziare. Guarderei inizialmente koans 4clojure , braveclojure o clojure )).

Oh, a proposito, Lisp significa LISt Processing.

Per quanto riguarda i tuoi esempi

Ho intenzione di dare esempi usando Clojure di seguito:

Se riesci a scrivere una addfunzione in Clojure (defn add [a b] ...your-implementation-here... ), puoi chiamarla +così (defn + [a b] ...your-implementation-here... ). Questo è in effetti ciò che viene fatto nella vera implementazione (il corpo della funzione è un po 'più coinvolto ma la definizione è essenzialmente la stessa di quella che ho scritto sopra).

Che dire della notazione infix? Bene Clojure usa una prefixnotazione (o polacca), quindi potremmo creare una infix-to-prefixmacro che trasformerebbe il codice con prefisso in codice Clojure. Il che è sorprendentemente semplice (in realtà è uno degli esercizi macro nei koan clojure)! Può anche essere visto in natura, ad esempio vedi macro Incanter$= .

Ecco la versione più semplice dei koan spiegati:

(defmacro infix [form]
  (list (second form) (first form) (nth form 2)))

;; takes a form (ie. some code) as parameter
;; and returns a list (ie. some other code)
;; where the first element is the second element from the original form
;; and the second element is the first element from the original form
;; and the third element is the third element from the original form (indexes start at 0)
;; example :
;; (infix (9 + 1))
;; will become (+ 9 1) which is valid Clojure code and will be executed to give 10 as a result

Per guidare ulteriormente il punto, alcune citazioni di Lisp :

“Parte di ciò che distingue Lisp è che è progettato per evolversi. Puoi usare Lisp per definire nuovi operatori Lisp. Man mano che nuove astrazioni diventano popolari (programmazione orientata agli oggetti, ad esempio), risulta sempre facile implementarle in Lisp. Come il DNA, un linguaggio del genere non passa di moda. "

- Paul Graham, ANSI Common Lisp

“Programmare in Lisp è come giocare con le forze primordiali dell'universo. Sembra un lampo tra le punte delle dita. Nessun'altra lingua si sente nemmeno vicina. "

- Glenn Ehrlich, Road to Lisp

$test = $number1 $operator1 $number2 $operator2 $number3;

La maggior parte delle implementazioni linguistiche prevede un passaggio in cui un parser analizza il codice e crea un albero da esso. Ad esempio, l'espressione 5 + 5 * 8verrebbe analizzata come

  +
 / \
5   *
   / \
  8   8

grazie alla conoscenza del compilatore sulle precedenti. Se le alimentassi con variabili al posto degli operatori, non conoscerebbe l'ordine corretto delle operazioni prima di eseguire il codice. Per la maggior parte delle implementazioni sarebbe un problema serio, quindi la maggior parte delle lingue non lo consente.

Ovviamente potresti concepire un linguaggio in cui il parser analizza quanto sopra come una sequenza di espressioni e operatori, da ordinare e valutare in fase di esecuzione. Presumibilmente non c'è molta applicazione per questo.

Molti linguaggi di scripting consentono la valutazione di espressioni arbitrarie (o almeno espressioni aritmetiche arbitrarie come nel caso di expr) in fase di esecuzione. Lì potresti semplicemente combinare i tuoi numeri e operatori in un'unica espressione e lasciare che il linguaggio lo valuti. In PHP (e molti altri) viene chiamata quella funzione eval.

$test = eval("$number1 $operator1 $number2 $operator2 $number3");

Esistono anche lingue che consentono la generazione di codice in fase di compilazione. L' espressione mixin in D viene in mente, dove credo che si potrebbe scrivere qualcosa di simile

test = mixin("number1 " + operator1 + " number2 " + operator2 + "number3");

Qui operator1e operator2dovrebbero essere costanti di stringa che sono note al momento della compilazione, ad esempio i parametri del modello. number1, number2E number3sono stati lasciati come normali variabili di runtime.

Altre risposte hanno già discusso dei vari modi in cui un operatore e una funzione sono più o meno la stessa cosa, a seconda della lingua. Ma di solito c'è una differenza sintattica tra un simbolo di operatore infisso incorporato +e un nome richiamabile come operator1. Lascio i dettagli a quelle altre risposte.

Algol 68 aveva esattamente questa caratteristica. Il tuo esempio in Algol 68 sarebbe simile al seguente:

int number1 = 5;                              ¢ (Tipo 'Int') ¢
op operator1 = int ( int a , b ) a + b ; ¢ (Tipo 'Operatore' inesistente) ¢
prio operator1 = 4;
int number2 = 5;                              ¢ (Tipo 'Int') ¢
op operator2 = int ( int a , b ) a * b ;  ¢(Tipo 'Operatore' inesistente) ¢
prio operator2 = 5;
int number3 = 8;                              ¢ (Digitare 'Int') ¢

int prova = number1 operator1 numero2 operator2 number3 ; ¢ 5 + 5 * 8. ¢

var_dump ( test );

Il tuo secondo esempio sarebbe simile al seguente:

int number4 = 9;
op operator3 = bool ( int a , b ) a < b ;
prio operator3 = 3;
se numero1 $ operatore3 numero4, quindi ¢ 5 <9 (vero) ¢
stampa ( vero )
fi

Noterai che i simboli dell'operatore sono definiti e assegnati ai corpi del metodo che contengono l'operazione desiderata. Gli operatori e il loro operando sono tutti digitati e agli operatori possono essere assegnate priorità in modo che la valutazione avvenga nell'ordine corretto. Potresti anche notare che c'è una leggera differenza nel font tra il simbolo dell'operatore e un simbolo variabile.

In realtà, anche se la lingua è scritta usando i caratteri, le macchine del giorno non sono in grado di gestire i caratteri (nastro di carta e carte perforate) e viene utilizzato il trucchetto . Il programma verrebbe probabilmente inserito come:

'INT' NUMBER4 = 9;
'OP' 'OPERATOR3' = 'BOOL' ('INT' A,B) A < B;
'PRIO' 'OPERATOR3' = 3;
'IF' NUMBER1 'OPERATOR3' NUMBER4 'THEN' 'C' 5 < 9 'C'
PRINT('TRUE')
'FI'

Puoi anche giocare a giochi interessanti con la lingua quando puoi definire i tuoi simboli per gli operatori, che ho sfruttato una volta, molti anni fa ... [2].

_Riferimenti:

[1] Introduzione informale all'Algol 68 di CHLindsey e SG van der Meulen, Olanda Settentrionale, 1971 .

[2] Algol 68 Phrases, uno strumento per aiutare la scrittura di compilatori in Algol 68 , BC Tompsett, Conferenza internazionale sulle applicazioni di Algol 68, Università di East Anglia, Norwich, Regno Unito, 1976 ..