A mia conoscenza, tutti i moderni linguaggi di programmazione imperativi supportano la ricorsione nel senso che una procedura può chiamarsi. Questo non è sempre stato il caso, ma non riesco a trovare alcun dato importante con una rapida ricerca su Google. Quindi la mia domanda è:
Quali lingue non supportavano la ricorsione sin dall'inizio e quando è stato aggiunto il supporto?
Non sono sicuro che COBOL lo faccia (certamente non una volta), ma non riesco a immaginare nessuno a cui importi molto.
Fortran ha dato Fortran 90, ma richiede che tu usi la parola chiave recursive per dirgli che una subroutine è ricorsiva.
PL / I era praticamente lo stesso - la ricorsione era supportata, ma dovevi esplicitamente dire quali procedure erano ricorsive.
Dubito che ce ne siano molti di più. Quando ci si avvicina ad esso, proibire la ricorsione è stato per lo più qualcosa che IBM ha fatto nei loro progetti linguistici, per il semplice motivo che i mainframe IBM (360/370/3090 / ...) non supportano uno stack nell'hardware. Quando la maggior parte delle lingue proveniva da IBM, per lo più vietava la ricorsione. Ora che provengono tutti da altri luoghi, la ricorsione è sempre consentita (anche se devo aggiungere che alcune altre macchine, in particolare l'originale Cray 1, non avevano nemmeno il supporto hardware per uno stack).
Wikipedia dice:
Early languages like Fortran did not initially support recursion because variables were statically allocated, as well as the location for the return address.
FORTRAN 77 does not allow recursion, Fortran 90 does, (recursive routines must be explicitly declared so).
Most FORTRAN 77 compilers allow recursion, some (e.g. DEC) require using a compiler option (see compiler options chapter). The GNU g77, which conforms strictly to the Fortran 77 standard, doesn't allow recursion at all.
Il linguaggio di programmazione OpenCL non supporta la ricorsione. (vedere la sezione 6.8 della OpenCL Spec )
La motivazione attuale è a) la mancanza di spazio per gli stack profondi b) il desiderio di conoscere, in modo statico, le allocazioni totali necessarie per ottimizzare le prestazioni in presenza di insiemi di registri di grandi dimensioni e di un ampio rivestimento interno.
Questo potrebbe applicarsi ad altri linguaggi di programmazione GPU, ad es. lingue shader.
Alcuni compilatori c per microcontrollori di piccole dimensioni non supportano la ricorsione, presumibilmente perché hanno una dimensione dello stack estremamente limitata.
BASIC, nei giorni dei numeri di linea, tendeva ad avere un supporto di ricorsione scarso. Molti (tutti?) I BASIC di quel tempo supportavano le chiamate di gosub nidificate, ma non supportavano un modo semplice per passare parametri o restituire valori in un modo che rendesse utile l'auto-chiamata.
Molti primi computer hanno avuto problemi con la ricorsione, perché hanno usato le 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à), solitamente in tale in modo che fosse il codice macchina per "Salta all'istruzione successiva a quella che ha chiamato la routine".
Dipende da cosa intendi con " supporto ". Per supportare la ricorsione è necessario uno stack in cui reistanziare 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 un indicizzazione tra variabili identiche (cioè array) è possibile incrementare / decrementare un indice globale ad ogni inserisci / esci da una funzione e accedi attraverso di essa a un membro di uno o più array.
Non so se questo può essere chiamato "supporto". I fatti sono che ho scritto una funzione ricorsiva 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 nello stack della macchina.
Leggi altre domande sui tag programming-languages recursion