Introduzione a F# in Visual Studio Code

È possibile scrivere F# in Visual Studio Code con il plug-in Ionide per ottenere un'esperienza IDE (Integrated Development Environment) multipiattaforma e leggera con IntelliSense e il refactoring del codice. Visitare Ionide.io per altre informazioni sul plug-in.

Per iniziare, assicurarsi di avere installato correttamente F# e il plug-in Ionide.

Creare il primo progetto con Ionide

Per creare un nuovo progetto F#, aprire una riga di comando e creare un nuovo progetto con l'interfaccia della riga di comando di .NET:

dotnet new console -lang "F#" -o FirstIonideProject

Al termine, modificare la directory nel progetto e aprire Visual Studio Code:

cd FirstIonideProject
code .

Dopo il caricamento del progetto in Visual Studio Code, verrà visualizzato il riquadro Esplora soluzioni F# sul lato sinistro della finestra aperta. Ciò significa che Ionide ha caricato correttamente il progetto appena creato. È possibile scrivere codice nell'editor prima di questo punto nel tempo, ma una volta che ciò avviene, tutto è terminato il caricamento.

Scrivere il primo script

Dopo aver configurato Visual Studio Code per l'uso dello scripting di .NET Core, passare alla visualizzazione Esplora risorse in Visual Studio Code e creare un nuovo file. Denominarlo MyFirstScript.fsx.

Aggiungere ora il codice seguente:

let toPigLatin (word: string) =
    let isVowel (c: char) =
        match c with
        | 'a' | 'e' | 'i' | 'o' | 'u'
        | 'A' | 'E' | 'I' | 'O' | 'U' -> true
        |_ -> false
    
    if isVowel word[0] then
        word + "yay"
    else
        word[1..] + string(word[0]) + "ay"

Questa funzione converte una parola in una forma di Pig Latin. Il passaggio successivo consiste nel valutarlo usando F# Interactive (FSI).

Evidenziare l'intera funzione (deve essere lunga 11 righe). Una volta evidenziato, tenere premuto ALT e premere INVIO. Si noterà che viene visualizzata una finestra del terminale nella parte inferiore della schermata e dovrebbe essere simile alla seguente:

Questa operazione ha eseguito tre operazioni:

1. Ha avviato il processo FSI.
2. Ha inviato il codice evidenziato al processo FSI.
3. Il processo FSI ha valutato il codice inviato.

Poiché ciò che è stato inviato su era una funzione, è ora possibile chiamare tale funzione con FSI! Nella finestra interattiva digitare quanto segue:

toPigLatin "banana";;

Si dovrebbero vedere i seguenti risultati:

val it: string = "ananabay"

Ora, proviamo con una vocale come prima lettera. Immetti gli elementi seguenti:

toPigLatin "apple";;

Si dovrebbero vedere i seguenti risultati:

val it: string = "appleyay"

La funzione sembra funzionare come previsto. Congratulazioni, è stata appena scritta la prima funzione F# in Visual Studio Code ed è stata valutata con FSI.

Spiegazione del codice

Se non si è certi di cosa sta effettivamente facendo il codice, ecco una procedura dettagliata.

Come si può notare, toPigLatin è una funzione che accetta una parola come input e la converte in una rappresentazione Pig-Latin di tale parola. Di seguito sono riportate le regole seguenti:

Se il primo carattere di una parola inizia con una vocale, aggiungere "yay" alla fine della parola. Se non inizia con una vocale, spostare il primo carattere alla fine della parola e aggiungervi "ay".

Potresti aver notato quanto segue in FSI:

val toPigLatin: word: string -> string

Questo stato indica che toPigLatin è una funzione che accetta come string input (denominato word) e restituisce un altro stringoggetto . Questa operazione è nota come firma del tipo della funzione, una parte fondamentale di F# che è fondamentale per comprendere il codice F#. Si noterà anche questo aspetto se si passa il puntatore del mouse sulla funzione in Visual Studio Code.

Nel corpo della funzione si noteranno due parti distinte:

1. Una funzione interna, denominata isVowel, che determina se un determinato carattere (c) è una vocale controllando se corrisponde a uno dei modelli forniti tramite criteri di ricerca:

   let isVowel (c: char) =
       match c with
       | 'a' | 'e' | 'i' | 'o' | 'u'
       | 'A' | 'E' | 'I' | 'O' | 'U' -> true
       |_ -> false
   

2. Espressione if..then..else che controlla se il primo carattere è una vocale e costruisce un valore restituito dai caratteri di input in base a se il primo carattere è una vocale o meno:

   if isVowel word[0] then
       word + "yay"
   else
       word[1..] + string(word[0]) + "ay"
   

Il flusso di toPigLatin è quindi:

Controllare se il primo carattere della parola di input è una vocale. In caso affermativo, allegare "yay" alla fine della parola. In caso contrario, spostare il primo carattere alla fine della parola e aggiungervi "ay".

C'è un aspetto finale da notare: in F#, non esiste alcuna istruzione esplicita da restituire dalla funzione. Il motivo è che F# è basato su espressioni e l'ultima espressione valutata nel corpo di una funzione determina il valore restituito di tale funzione. Poiché if..then..else si tratta di un'espressione, la valutazione del corpo del then blocco o del corpo del else blocco determina il valore restituito dalla toPigLatin funzione.

Trasformare l'app console in un generatore Pig Latin

Le sezioni precedenti di questo articolo illustrano un primo passaggio comune per scrivere codice F#: scrivere una funzione iniziale ed eseguirla in modo interattivo con FSI. Questo è noto come sviluppo basato su REPL, dove REPL è l'acronimo di "Read-Evaluate-Print Loop". È un ottimo modo per sperimentare le funzionalità fino a quando non si ha qualcosa di funzionante.

Il passaggio successivo dello sviluppo basato su REPL consiste nello spostare il codice funzionante in un file di implementazione F#. Può quindi essere compilato dal compilatore F# in un assembly che può essere eseguito.

Per iniziare, aprire il file Program.fs creato in precedenza con l'interfaccia della riga di comando di .NET. Si noterà che il codice è già presente.

Creare quindi un nuovo module chiamato PigLatin e copiare la toPigLatin funzione creata in precedenza in questo modo:

module PigLatin =
    let toPigLatin (word: string) =
        let isVowel (c: char) =
            match c with
            | 'a' | 'e' | 'i' | 'o' | 'u'
            | 'A' | 'E' | 'I' | 'O' | 'U' -> true
            |_ -> false
        
        if isVowel word[0] then
            word + "yay"
        else
            word[1..] + string word[0] + "ay"

Questo modulo deve essere sopra la main funzione e sotto la open System dichiarazione. L'ordine delle dichiarazioni è importante in F#, quindi è necessario definire la funzione prima di chiamarla in un file.

Nella funzione chiamare ora la main funzione generatore Pig Latin sugli argomenti:

[<EntryPoint>]
let main args =
    for arg in args do
        let newArg = PigLatin.toPigLatin arg
        printfn "%s in Pig Latin is: %s" arg newArg

    0

È ora possibile eseguire l'app console dalla riga di comando:

dotnet run apple banana

Si noterà che restituisce lo stesso risultato del file di script, ma questa volta come programma in esecuzione.

Risoluzione dei problemi relativi a Ionide

Ecco alcuni modi per risolvere alcuni problemi che potrebbero verificarsi:

1. Per ottenere le funzionalità di modifica del codice di Ionide, i file F# devono essere salvati su disco e all'interno di una cartella aperta nell'area di lavoro di Visual Studio Code.
2. Se sono state apportate modifiche al sistema o sono stati installati prerequisiti Ionide con Visual Studio Code aperto, riavviare Visual Studio Code.
3. Se nelle directory del progetto sono presenti caratteri non validi, Ionide potrebbe non funzionare. Rinominare le directory del progetto in questo caso.
4. Se nessuno dei comandi Ionide funziona, controllare i tasti di scelta rapida di Visual Studio Code per verificare se si esegue l'override di tali comandi per errore.
5. Se Ionide è danneggiato nel computer e nessuno dei precedenti ha risolto il problema, provare a rimuovere la ionide-fsharp directory nel computer e reinstallare la suite di plug-in.
6. Se il caricamento di un progetto non è riuscito (il Esplora soluzioni F# visualizza questo), fare clic con il pulsante destro del mouse su tale progetto e fare clic su Visualizza dettagli per ottenere altre informazioni di diagnostica.

Ionide è un progetto open source creato e gestito dai membri della community F#. Segnalare i problemi e contribuire al repository GitHub ionide-vscode-fsharp.

È anche possibile richiedere ulteriore assistenza agli sviluppatori Ionide e alla community di F# nel canale Ionide Gitter.

Passaggi successivi

Per altre informazioni su F# e sulle funzionalità del linguaggio, vedere Presentazione di F#.