Introduzione
Liste
Una list in F# è una collezione immutabile di zero o più valori. I valori in una lista devono avere tutti lo stesso tipo. Poiché le liste sono immutabili, una volta costruita una lista, il suo valore non può mai cambiare. Qualsiasi funzione o operatore che sembri modificare una lista (ad esempio aggiungendo un elemento) in realtà restituisce una nuova lista.
Le liste si possono definire come segue:
let empty = []
let singleValue = [5]
let threeValues = ["a"; "b"; "c"]
Il modo più comune per aggiungere un elemento a una lista è tramite l'operatore :: (cons):
let twoToFour = [2; 3; 4]
let oneToFour = 1 :: twoToFour
// => [1; 2; 3; 4]
Una lista in F# ha una testa (il primo elemento) e una coda (tutto ciò che viene dopo il primo elemento). La coda di una lista è essa stessa una lista.
Le liste si possono manipolare con funzioni e operatori definiti nel modulo List, oppure manualmente con il pattern matching, usando i pattern list e cons:
let describe list =
match list with
| [] -> "Empty list"
| head::tail -> sprintf "Non-empty list with head: %d" head
describe [] // => "Empty list"
describe [1] // => "Non-empty with head: 1"
describe [5; 7; 9] // => "Non-empty with head: 5"
Puoi anche scartare un valore durante il pattern matching; quando non ti interessa un valore in un caso specifico (cioè non hai intenzione di usare un valore), puoi usare un underscore ('_') per indicarlo:
let describe list =
match list with
| [] -> "Empty list"
| [x] -> "List with one item"
| [_; y] -> "List with two items (first item ignored)"
| _ -> "List with many items (all items ignored)"
describe [] // => "Empty list"
describe [1] // => "List with one item"
describe [5; 7] // => "List with two items (first item ignored)"
describe [5; 7; 9] // => "List with many items (all items ignored)"
Il singolo '_' dovrebbe sempre venire per ultimo nel pattern matching: ogni valore che non corrisponde a nessuno degli altri casi sarà gestito da questo caso.
Istruzioni
In questo esercizio scriverai del codice per tenere traccia di un array di linguaggi di programmazione che vuoi imparare su Exercism.
Hai sei attività, che hanno tutte a che fare con gli array.
1. Crea un nuovo array
Per tenere traccia dei linguaggi che vuoi imparare, dovrai creare un nuovo array. Definisci il binding newList, che contiene un nuovo array vuoto.
newList
// => []
2. Definisci un array esistente
Al momento hai un foglio di carta con l'elenco dei linguaggi che vuoi imparare: F#, Clojure e Haskell. Definisci il binding existingList per rappresentare questo array.
existingList
// => ["F#"; "Clojure"; "Haskell"]
3. Aggiungi un nuovo linguaggio a un array
Mentre esplori Exercism e trovi linguaggi più interessanti, vuoi aggiungerli al tuo array. Implementa la funzione addLanguage per aggiungere un nuovo linguaggio all'inizio del tuo array.
addLanguage "TypeScript" ["JavaScript"; "CoffeeScript"]
// => ["TypeScript"; "JavaScript"; "CoffeeScript"]
4. Conta i linguaggi nell'array
Contare i linguaggi uno per uno è scomodo. Implementa la funzione countLanguages per contare quanti linguaggi ci sono nel tuo array.
countLanguages ["C#"; "Racket"; "Rust"; "Ruby"]
// => 4
5. Inverti l'array
A un certo punto ti accorgi che il tuo array è in realtà in ordine inverso! Implementa la funzione reverseList per invertire il tuo array.
reverseList ["Prolog"; "C"; "Idris"; "Assembly"]
// => ["Assembly"; "Idris"; "C"; "Prolog"]
6. Verifica se l'array è entusiasmante
Anche se ami tutti i linguaggi, F# occupa un posto speciale nel tuo cuore. Per questo, un array di linguaggi ti entusiasma davvero se:
- Il primo elemento dell'array è F#.
- Il secondo elemento dell'array è F# e l'array contiene due o tre linguaggi.
Implementa la funzione excitingList per verificare se un array di linguaggi è entusiasmante:
excitingList ["Nim"; "F#"]
// => true
Esercizio di apprendimento
