Perché l'operatore di assegnazione assegna al lato sinistro?

Ho iniziato a insegnare a un amico a programmare di recente (stiamo usando Python) e quando abbiamo iniziato a discutere della creazione di variabili e dell'operatore di assegnazione, mi ha chiesto perché il valore a destra è assegnato al nome a sinistra e non viceversa .

Non ci avevo pensato troppo prima, perché mi sembrava naturale, ma lei disse che da sinistra a destra le sembrava più naturale, poiché è così che la maggior parte di noi legge le lingue naturali.

Ci ho pensato e ho concluso che rende il codice molto più facile da leggere, dal momento che i nomi assegnati (a cui il programmatore dovrà riutilizzare) sono facilmente visibili, allineati a sinistra.

aligned = 2
on = 'foo' + 'bar' + 'foobar'
the = 5.0 / 2
left = 2 + 5

Al contrario di:

2 = aligned 
'foo' + 'bar' + 'foobar' = on
5.0 / 2 = the 
2 + 5 = right 

# What were the names again...?

Ora mi chiedo se ci sono anche altri motivi per questo standard. C'è una storia dietro? O c'è qualche motivo tecnico per cui questa è una buona opzione (non so molto sui compilatori)? E ci sono dei linguaggi di programmazione che assegnano al lato destro?

Idem @paxdiablo. I primi linguaggi di programmazione sono stati scritti da matematici - in realtà lo erano tutti. In matematica, secondo il suo principio - leggere da sinistra a destra - ha senso il modo in cui funziona.

x = 2y - 4.

In matematica, diresti questo: Sia x uguale a 2y -4.

Inoltre, anche in algebra lo fai. Quando risolvi un'equazione per una variabile, isola la variabile che stai risolvendo sul lato sinistro. cioè y = mx + b;

Inoltre, una volta che un'intera famiglia di lingue, come la famiglia C, ha una certa sintassi, è più costoso cambiare.

BASIC, uno dei primi linguaggi informatici aveva la forma "corretta" di:

10 LET AREA = HEIGHT * WIDTH

che corrisponde alla mentalità matematica di specificare una variabile, come "Sia H l'altezza dell'oggetto".

COBOLera anche simile con la sua COMPUTEaffermazione. Come per molti modi di fare le cose, potrebbe essere stata semplicemente una decisione arbitraria portata avanti in molte lingue.

In realtà, esiste un linguaggio di programmazione che assegna al lato destro: TI-BASIC ! Non solo, ma non usa '=' come operatore di assegnazione, ma utilizza piuttosto una freccia nota come operatore "STO".

esempi:

5→A
(A + 3)→B
(A - B)→C

Nell'esempio sopra, vengono dichiarate tre variabili e vengono dati valori. A sarebbe 5, B sarebbe 8 e C sarebbe -3. La prima dichiarazione / assegnazione può essere letta "store 5 as A".

Per quanto riguarda il motivo per cui TI-BASIC utilizza un tale sistema per l'assegnazione, lo attribuisco al fatto che è un linguaggio di programmazione per una calcolatrice. L'operatore "STO" sui calcolatori TI veniva spesso utilizzato nelle normali operazioni della calcolatrice dopo il calcolo di un numero. Se fosse un numero che l'utente voleva ricordare, avrebbero premuto il pulsante "STO" e il caclulator avrebbe richiesto loro un nome (attivando automaticamente il blocco alfa in modo che i tasti producessero lettere anziché numeri):

Sin(7 + Cos(3))
                    -.26979276
Ans→{variable name}
                    -.26979276

e l'utente può nominare la variabile come preferisce. Dovendo attivare il blocco alfa, digitare il nome, quindi premere "STO" e premere il tasto "Ans" sarebbe stato troppo ingombrante per le normali operazioni. Poiché tutte le funzioni della calcolatrice sono disponibili in TI-BASIC, nessun altro operatore di assegnazione è stato aggiunto poiché "STO" ha eseguito la stessa attività, anche se al contrario rispetto alla maggior parte delle altre lingue.

(Aneddoto: TI-BASIC è stata una delle prime lingue che ho imparato, quindi quando ho iniziato a studiare Java al college mi sono sentito come se l'assegnazione alla SINISTRA fosse insolita e "arretrata"!)

Euristico 1: di fronte a più di un modo possibile di fare qualcosa durante la progettazione di una lingua, scegli quella più comune, più intuitiva, altrimenti finirai con Perl +.

Ora, come è più naturale (almeno per un madrelingua inglese)? Diamo un'occhiata a come scriviamo / diciamo cose in inglese:

Steven ora ha 10 anni (invece di 10 anni Steven ora). Pesa più di 190 libbre (rispetto a più di 190 libbre che peso).

Nel codice:

steven = 10
i > 190

Quanto segue sembra anche più naturale:

"Se Mary ha 18 anni, allora può avere una caramella". "Se ho meno di 21 anni, chiederò a te mio fratello di tequila".

if (mary == 18) { ... }
if (i < 21) { ... }

di:

"Se 18 anni Mary è ..." "Se 21 è maggiore della mia età ..."

Ora il codice:

if (18 == mary) { ... }
if (21 > i) { ... }

Si noti che ciò non è naturale né per i programmatori né per i parlanti di lingua inglese. Le frasi sembrano yoda-speak e il codice è soprannominato yoda-condizioni. Questi potrebbero essere utili in C ++, ma sono sicuro che la maggior parte delle persone sarebbe d'accordo: se un compilatore potesse fare il lavoro pesante e alleviare la necessità di condizioni di yoda, la vita sarebbe un po 'più facile.

Certo, ci si potrebbe abituare a qualsiasi cosa. Ad esempio, il numero 81 è scritto come:

Eighty One (inglese) Eighty e one (spagnolo) One and Eighty (tedesco).

Finalmente ce ne sono 4! = 24 modi validi per dire "la mela verde giace sul tavolo" in russo - l'ordine (quasi) non ha importanza, tranne che "on" deve unirsi a "table". Quindi, se sei un madrelingua russo (per esempio), allora potresti non preoccuparti se uno scrive a = 10o 10 = aperché entrambi sembrano ugualmente naturali.

Mentre la linguistica è una materia affascinante, non l'ho mai studiata formalmente e non conosco molte lingue. Spero di aver fornito abbastanza contro-esempi.

È iniziato con FORTRAN negli anni '50. Dove FORTRAN era un'abbreviazione di FORmula TRANslation - le formule in questione erano semplici equazioni algebriche che per convenzione assegnano sempre a sinistra.

Il suo quasi contemporaneo COBOL invece doveva essere simile all'inglese e assegnato alla destra (per lo più!).

MOVE 1 TO COUNTER.
ADD +1 TO LINE-CNT.
MULTIPLY QTY BY PRICE GIVING ITEM-PRICE.

Bene, come ha sottolineato @ diceguyd30, ci sono entrambe le notazioni.

• <Identifier> = <Value>significa "lascia che l' identificatore sia valore ". O per espanderlo: Definisci (o ridefinisci) la variabile Identificatore su Valore .
• <Value> -> <Identifier>significa "store Value to Identifier ". O per espanderlo: inserisci il valore nella posizione designata dall'identificatore .

Naturalmente, in genere l' identificatore può in realtà essere qualsiasi valore L.

Il primo approccio onora il concetto astratto di variabili, il secondo approccio riguarda più l'archiviazione effettiva.

Si noti che il primo approccio è comune anche nelle lingue, che non hanno compiti. Si noti inoltre, che la definizione di variabile e l'assegnazione sono relativamente vicini <Type> <Identifier> = <Value>vs. <Identifier> = <Value>.

Come già accennato, abbastanza bene tutti i primi linguaggi informatici hanno funzionato in questo modo. Ad esempio FORTRAN, che è arrivato molti anni prima di BASIC.

In realtà ha molto senso avere la variabile assegnata a sinistra dell'espressione di assegnazione. In alcune lingue, potresti avere diverse routine sovraccaricate con SAME NAME, che restituiscono diversi tipi di risultati. Consentendo al compilatore di visualizzare prima il tipo della variabile assegnata, sa quale routine sovraccarica chiamare o quale cast implicito generare quando si converte da (es.) Un numero intero in un float. È una spiegazione semplicistica, ma spero che tu abbia l'idea.

Potrebbe essere un residuo dei primi algoritmi di analisi. Ricorda che l'analisi del LR fu inventata solo nel 1965, e potrebbe anche essere che i parser LL avessero problemi (entro i limiti di tempo e di spazio delle macchine in quel momento) andando in senso contrario. Tener conto di:

identifier = function();
function();

I due sono chiaramente non chiariti dal secondo token. D'altro canto,

function() = identifier;
function();

Non è divertente. Questo peggiora quando inizi a nidificare le espressioni di assegnazione.

function(prev_identifier = expression) = identifier;
function(prev_identifier = expression);

Naturalmente, più facile disambiguare per le macchine significa anche più facile disambiguare per gli umani. Un altro semplice esempio potrebbe essere la ricerca dell'inizializzazione di un determinato identificatore.

identifier1 = expressionOfAnArbitraryLength;
identifier2 = expressionOfAReallyReallyReallyArbitraryLength;
identifier3 = expression;
identifier4 = AlongLineExpressionWithAFunctionCallWithAssignment(
    identifier = expr);

Facile, basta guardare in alto a sinistra. Lato destro, d'altra parte

expressionOfAnArbitraryLength = identifier1;
expressionOfAReallyReallyReallyArbitraryLength = identifier2;
expression = identifier3;
AlongLineExpressionWithAFunctionCallWithAssignment(expr = identifier
    ) = identifier4;

Soprattutto quando non puoi grepperforare le carte, è molto più difficile trovare l'identificatore che desideri.

Le lingue di assemblaggio hanno la destinazione come parte del codice operativo sinistro. Le lingue di livello superiore tendevano a seguire le convenzioni delle lingue precedenti.

Quando vedi =(o :=per i dialetti pasquali), potresti pronunciare quelli come is assigned the value, quindi la natura da sinistra a destra avrà senso (perché leggiamo anche da sinistra a destra nella maggior parte delle lingue). Poiché i linguaggi di programmazione sono stati sviluppati principalmente da persone che leggono da sinistra a destra, le convenzioni sono rimaste bloccate.

È un tipo di dipendenza dal percorso . Suppongo che se la programmazione informatica fosse stata inventata da persone che parlavano ebraico o arabo (o qualche altra lingua da destra a sinistra), allora sospetto che avremmo messo la destinazione sulla destra.

Per quel che vale, la maggior parte delle dichiarazioni in COBOL leggono da sinistra a destra, in modo che i due operandi sono stati nominati prima, e la destinazione ultima, come: multiply salary by rate giving tax.

Non suggerirò comunque che il tuo studente potrebbe preferire COBOL, per paura di essere (giustamente) segnalato per fare un commento così basso, non sincero e insipido! :-)

ha detto che da sinistra a destra le sembrava più naturale, poiché è così che la maggior parte di noi legge le lingue naturali.

Penso che questo sia un errore. Da un lato, puoi dire "assegna 10 a x" o "sposta 10 a x". D'altra parte, puoi dire "imposta x su 10" o "x diventa 10".

In altre parole, a seconda della scelta del verbo, la variabile assegnata a potrebbe essere o meno il soggetto e potrebbe essere o meno sulla sinistra. Quindi "ciò che è naturale" dipende solo interamente dalla tua abituale scelta di parole per rappresentare il compito.

In pseudocodice l'operatore di assegnazione è molto comunemente scritto a destra. Per esempio

2*sqrt(x)/(3+y) -> z

Nei calcolatori Casio, anche varianti non programmabili, la variabile di assegnazione viene visualizzata sulla destra

A+2B → C

In Forth anche la variabile è sulla destra

expression variable !

In x86, la sintassi Intel ha la destinazione a sinistra, ma la sintassi GAS inverte l'ordine, creando confusione per molte persone, in particolare sulle istruzioni relative all'ordine dei parametri come sottrazione o confronti. Queste istruzioni sono le stesse in 2 dialetti diversi

mov rax, rbx    ; Intel syntax
movq %rbx, %rax ; GAS syntax

Entrambi spostano il valore in rbx su rax. Nessun altro linguaggio di assemblaggio che conosco scriva la destinazione sulla destra come GAS.

Alcune piattaforme mettono l'espressione a sinistra e la variabile a destra:

MOVE expression TO variable      COBOL
expression → variable            TI-BASIC, Casio BASIC
expression -> variable           BETA, R
put expression into variable     LiveCode

https://en.wikipedia.org/wiki/Assignment_%28computer_science%29#Notation

La maggior parte delle lingue assegna il valore a sinistra, uno dei motivi è facile da allineare gli operatori, più facile da leggere e riconoscere la variabile, poiché gli operatori di assegnazione e le posizioni delle variabili non varieranno selvaggiamente nelle righe, ed è più facile da leggere come msgstr "lascia che la variabile sia un valore".

Tuttavia, alcune persone preferiscono dire "sposta il valore da x a y" e scrivono la variabile sulla destra.

Penso che segua un modo logico di pensare.
Prima deve esserci una casella (variabile), quindi inserire un oggetto (valore) al suo interno.
Non metti l'oggetto in aria e poi metti una scatola attorno ad esso.