Quale lingua ha integrato "inserimento lista" come parte della sintassi del codice * *?

Python supporta in realtà l'inserimento di sotto-liste arbitrarie, come parte dell'assegnazione delle slice di lista. Basta assegnare a una sezione vuota prima dell'elemento in cui si desidera inserire un nuovo elenco:

list1 = [1, 2, 3]

list1[1:1] = [10, 20, 30] # insert 3 elements at index 1
print list1 # prints [1, 10, 20, 30, 2, 3]

Molte lingue visualizzano le liste come strutture di dati sequenziali, consentendo quindi solo la manipolazione alle loro estremità. Ciò ha sia vantaggi logici legati all'implementazione: ad es. in modo sequenziale puoi gestire liste di lunghezza arbitraria sconosciuta.

Spesso quando ti trovi nella necessità di inserire un elemento nel bel mezzo di una lista, è un buon segno che quello che stai facendo è un trucco a causa di un design scadente. (La manipolazione di sys.path[0:0] di Python è un esempio.)

F # fornisce un operatore :: che viene utilizzato sia per la costruzione che per la destrutturazione:

(* this will append 1 as a head to a list containing 2 and 3 *)
let lst = 1 :: [2; 3]
> [1; 2; 3]

(* this will use pattern matching to destructure the list and return 
   the sum of first two elements; if not possible, then the first element; otherwise 0 *)
let func = function | a::b::_ -> a + b | h :: _ -> h | _ -> 0
func lst
> 3

Esiste anche un operatore @ per la concatenazione di elenchi:

(* this will return a concatenated lists *)
let longer = lst @ lst
> [1; 2; 3; 1; 2; 3]

Usando questi due, puoi inserire un elemento nel "centro" della lista in questo modo:

let a, b = [1; 2], [4; 5; 6]
let c = a @ (3 :: b)
> [1; 2; 3; 4; 5]

In questo caso stiamo parlando di elenchi concatenati, ma non di indicizzazione nella lista. Devi dividerlo con altri mezzi (chiamate di funzione) se vuoi che l'elemento sia inserito in una posizione arbitraria.

Lo stesso vale per gli altri membri della famiglia ML: SML, OCaml, Scala e anche Haskell (utilizza rispettivamente : e ++ , comunque).

Perché vorresti effettivamente inserire la lista come parte della sintassi ? È un'operazione abbastanza insolita e metterei in dubbio la saggezza di creare una sintassi speciale per questo quando una funzione regolare dovrebbe funzionare bene.

Nota che se stai usando un Lisp, è banale aggiungere nuove sintassi usando le macro.

Ecco un esempio in Clojure:

(defmacro insert [list at [start end] in target]
     (when-not (and (= "at" (name at)) (= "in" (name in))) 
       (throw (Error. "Syntax error: should be like (insert <values> at [3 4] in <target-list>)")) )
     '(let [target# ~target ] 
        (concat 
          (take ~start target#)
          ~list
          (drop ~end target#))))

(insert [:a :b :c] at [3 4] in [1 2 3 4 5])
=> (1 2 3 :a :b :c 5)

Si noti che questo non è una funzione : abbiamo creato sinceramente una nuova sintassi (vedi i simboli "at" e "in" - questo non funzionerebbe come una funzione normale)

Ancora non consiglio di fare questo (di solito dovresti preferire una funzione normale), ma la funzione è lì se vuoi ...