Per quanto ne so, tutti i moderni linguaggi di programmazione imperativa supportano la ricorsione nel senso che una procedura può chiamare se stessa. Questo non è sempre stato il caso, ma non riesco a trovare fatti concreti con una rapida ricerca su Google. Quindi la mia domanda è:
Quali lingue non hanno supportato la ricorsione sin dall'inizio e quando è stato aggiunto tale supporto?
Risposte:
Non sono sicuro che COBOL lo faccia (certamente non lo è stato in una sola volta), ma non riesco nemmeno a immaginare che a nessuno importi molto.
Fortran ha da allora Fortran 90, ma richiede l'utilizzo della recursiveparola chiave per indicare che una subroutine è ricorsiva.
PL / I era praticamente lo stesso - la ricorsione era supportata, ma dovevi dirlo esplicitamente quali procedure erano ricorsive.
Dubito che ce ne siano molti di più però. Quando si arriva a questo, proibire la ricorsione era principalmente qualcosa che IBM faceva nei loro progetti linguistici, per la semplice ragione che i mainframe IBM (360/370/3090 / ...) non supportano uno stack nell'hardware. Quando la maggior parte delle lingue proveniva da IBM, proibivano principalmente la ricorsione. Ora che provengono tutti da altri posti, la ricorsione è sempre consentita (anche se dovrei aggiungere che alcune altre macchine, in particolare l'originale Cray 1, non avevano neanche il supporto hardware per uno stack).
notably the original cray 1Quindi, non hai bisogno di ricorsione per clonare i dinosauri? Immagino che spetti a noi scimmie oscillare tra gli alberi.
Wikipedia dice:
Le prime lingue come Fortran inizialmente non supportavano la ricorsione perché le variabili erano allocate staticamente, così come la posizione per l'indirizzo di ritorno.
http://en.wikipedia.org/wiki/Subroutine#Local_variables.2C_recursion_and_re-entrancy
FORTRAN 77 non consente la ricorsione, lo fa Fortran 90 (le routine ricorsive devono essere esplicitamente dichiarate così).
La maggior parte dei compilatori FORTRAN 77 consente la ricorsione, alcuni (ad es. DEC) richiedono l'utilizzo di un'opzione di compilazione (vedere il capitolo Opzioni di compilazione). GNU g77, che è strettamente conforme allo standard Fortran 77, non consente affatto la ricorsione.
Il linguaggio di programmazione OpenCL non supporta la ricorsione. (vedere la sezione 6.8 delle specifiche OpenCL )
L'attuale motivazione per questo è a) una mancanza di spazio per stack profondi b) il desiderio di conoscere, staticamente, le allocazioni totali necessarie al fine di ottimizzare le prestazioni in presenza di grandi set di registri e di un ampio allineamento.
Questo potrebbe applicarsi anche ad altri linguaggi di programmazione GPU, ad esempio linguaggi shader.
Alcuni compilatori c per piccoli microcontrollori non supportano la ricorsione, presumibilmente perché hanno dimensioni dello stack estremamente limitate.
BASIC, ai tempi dei numeri di riga, tendeva ad avere scarso supporto alla ricorsione. Molti (tutti?) BASIC di quel tempo supportavano le chiamate nidificate di gosub, ma non supportavano un modo semplice per passare parametri o restituire valori in un modo che rendesse utile l'auto-chiamata.
Molti dei primi computer avevano problemi con la ricorsione, perché usavano istruzioni di chiamata che scrivevano l'indirizzo di ritorno all'inizio della routine chiamata (PDP8, la famiglia di macchine IAS, probabilmente più architetture con cui non ho familiarità), di solito in modo tale che era il codice macchina per "Vai all'istruzione dopo quello che chiamava la routine".
Dipende da cosa intendi per " supporto ". Per supportare la ricorsione è necessario uno stack in cui ri-istanziare le variabili locali ad ogni rientro.
Anche se il linguaggio non ha il concetto di variabili locali, se ha il concetto di "subroutine" e ha un modo per gestire l'indicizzazione tra variabili identiche (aka array) è possibile incrementare / decrementare un indice globale ad ogni entrata / uscita di una funzione e accedervi attraverso un membro di uno o più array.
Non so se questo può essere chiamato "supporto". I fatti sono che ho scritto funzioni ricorsive con ZX-Spectrum BASIC, come ho fatto in Fortran77 come in COBOL ... sempre con quel trucco.
Il linguaggio assembly non supporta direttamente la ricorsione - devi "farlo da solo", in genere spingendo i parametri sullo stack della macchina.
CALLun'istruzione, che spinge automaticamente l'IP nello stack prima di passare alla subroutine e RETun'istruzione che inserisce l'indirizzo di ritorno nell'IP. Non c'è motivo per cui non sia possibile CALLil proprio punto di ingresso.
void f() { f(); }è ricorsivo.