Skip to content

Latest commit

 

History

History
71 lines (48 loc) · 2.4 KB

File metadata and controls

71 lines (48 loc) · 2.4 KB

In Haskell, le liste sono una delle strutture dati più utilizzate e versatili. Esse rappresentano sequenze di elementi dello stesso tipo. Haskell fornisce una vasta gamma di funzioni per manipolare le liste, molte delle quali sono definite nel modulo Prelude, che è importato automaticamente in ogni programma Haskell. Ecco alcune delle funzioni più comuni per lavorare con le liste in Haskell:

  1. head: Restituisce il primo elemento di una lista. Da notare che head su una lista vuota genera un errore.

    head [1, 2, 3] -- Risultato: 1
  2. tail: Restituisce tutti gli elementi di una lista eccetto il primo. Anche questa funzione genera un errore se applicata a una lista vuota.

    tail [1, 2, 3] -- Risultato: [2, 3]
  3. length: Calcola la lunghezza di una lista.

    length [1, 2, 3] -- Risultato: 3
  4. null: Verifica se una lista è vuota.

    null [] -- Risultato: True
  5. reverse: Inverte l'ordine degli elementi di una lista.

    reverse [1, 2, 3] -- Risultato: [3, 2, 1]
  6. map: Applica una funzione a ogni elemento di una lista, restituendo una nuova lista con i risultati.

    map (+1) [1, 2, 3] -- Risultato: [2, 3, 4]
  7. filter: Seleziona gli elementi di una lista che soddisfano un predicato.

    filter odd [1, 2, 3, 4] -- Risultato: [1, 3]
  8. foldl e foldr: Riducono una lista a un singolo valore accumulando gli elementi della lista da sinistra (foldl) o da destra (foldr) usando una funzione specificata.

    foldl (+) 0 [1, 2, 3] -- Risultato: 6
    foldr (+) 0 [1, 2, 3] -- Risultato: 6
  9. concat: Concatena una lista di liste in una singola lista.

    concat [[1, 2], [3, 4]] -- Risultato: [1, 2, 3, 4]
  10. take e drop: take restituisce i primi n elementi di una lista, mentre drop scarta i primi n elementi.

    take 2 [1, 2, 3, 4] -- Risultato: [1, 2]
    drop 2 [1, 2, 3, 4] -- Risultato: [3, 4]
  11. elem: Verifica se un elemento è presente in una lista.

    elem 2 [1, 2, 3] -- Risultato: True

Queste funzioni rappresentano solo la punta dell'iceberg di ciò che è possibile fare con le liste in Haskell, ma sono sicuramente tra le più usate e utili per la maggior parte delle operazioni comuni.