Introdução ao F# no Visual Studio Code

Você pode gravar F# no Visual Studio Code com o plug-in do Ionide para obter uma ótima experiência de IDE (Ambiente de Desenvolvimento Integrado) multiplataforma e leve com o IntelliSense e refatorações de código. Visite Ionide.io para saber mais sobre o plug-in.

Explore F# usando scripts e o REPL

A maneira mais rápida de começar a escrever F# é com um arquivo de script (.fsx) e F# Interativo (FSI). Nenhum arquivo de projeto ou configuração de build é necessário – basta criar um arquivo e iniciar a codificação, semelhante a como você pode usar Python ou um script de shell.

Criar e executar um script

Abra um terminal e execute:

touch hello.fsx
code hello.fsx

Adicione o seguinte código ao arquivo:

printfn "Hello from F# Interactive!"

let square x = x * x

[ 1 .. 10 ]
|> List.map square
|> printfn "Squares: %A"

Execute o script diretamente do terminal:

dotnet fsi hello.fsx

Você deve ver:

Hello from F# Interactive!
Squares: [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

Usar o REPL interativo do VS Code

Os scripts são especialmente poderosos quando combinados com a integração FSI do Ionide. Crie um novo arquivo chamado MyFirstScript.fsx e adicione o seguinte código:

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"

Essa função converte uma palavra em uma forma de Pig Latin. A próxima etapa é avaliá-lo usando FSI (F# Interativo).

Realce a função inteira (deve ter 11 linhas de comprimento). Depois de realçada, segure a tecla Alt e pressione Enter. Você observará que uma janela do terminal aparece na parte inferior da tela e ela deve ser semelhante a esta:

Isso fez três coisas:

1. Iniciou o processo FSI.
2. Enviou o código realçado para o processo FSI.
3. O processo FSI avaliou o código que você enviou.

Como o que você enviou foi uma função , agora você pode chamar essa função com FSI! Na janela interativa, digite o seguinte:

toPigLatin "banana";;

Você deverá ver o seguinte resultado:

val it: string = "ananabay"

Agora, vamos tentar com uma vogal como a primeira letra. Insira o seguinte:

toPigLatin "apple";;

Você deverá ver o seguinte resultado:

val it: string = "appleyay"

A função parece estar funcionando conforme o esperado. Parabéns, você acabou de escrever sua primeira função F# no Visual Studio Code e avaliou-a com FSI!

Quando usar scripts

Os scripts são ótimos para explorar ideias, protótipos, análise de dados e tarefas de automação. Você pode referenciar pacotes NuGet diretamente em um script com #r "nuget: PackageName" — nenhum arquivo de projeto necessário.

Quando o código crescer além de um único arquivo ou precisar ser compilado e distribuído, você desejará migrar para um projeto completo. A próxima seção mostra como.

Criar seu primeiro projeto com o Ionide

Para programas maiores, bibliotecas compiladas ou código que você deseja distribuir como um aplicativo, você usará um projeto .NET. Para criar um novo projeto F#, abra uma linha de comando e crie um novo projeto com a CLI do .NET:

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

Depois de concluído, altere o diretório para o projeto e abra o Visual Studio Code:

cd FirstIonideProject
code .

Depois que o projeto for carregado no Visual Studio Code, você deverá ver o painel do Gerenciador de Soluções F# no lado esquerdo da janela aberto. Isso significa que o Ionide carregou com êxito o projeto que você acabou de criar. Você pode escrever código no editor antes desse ponto no tempo, mas depois que isso acontecer, tudo terminará de ser carregado.

Explicando o código

Se você não tiver certeza sobre o que o código está realmente fazendo, aqui está um passo a passo.

Como você pode ver, toPigLatin é uma função que usa uma palavra como sua entrada e a converte em uma representação Pig-Latin dessa palavra. As regras para isso são as seguintes:

Se o primeiro caractere em uma palavra começar com uma vogal, adicione "yay" ao final da palavra. Se ele não começar com uma vogal, mova o primeiro caractere para o final da palavra e adicione "ay" a ele.

Talvez você tenha notado o seguinte no FSI:

val toPigLatin: word: string -> string

Isso afirma que toPigLatin é uma função que usa uma string como entrada (chamada word) e retorna outra string. Isso é conhecido como a assinatura do tipo da função, uma parte fundamental de F# que é a chave para entender o código F#. Você também observará isso se passar o mouse sobre a função no Visual Studio Code.

No corpo da função, você observará duas partes distintas:

1. Uma função interna, chamada isVowel, que determina se um determinado caractere (c) é uma vogal verificando se corresponde a um dos padrões fornecidos por meio da Correspondência de Padrões .

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

2. Uma expressão if..then..else que verifica se o primeiro caractere é uma vogal e constrói um valor retornado dos caracteres de entrada com base em se o primeiro caractere era uma vogal ou não:

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

O fluxo de toPigLatin é assim:

Verifique se o primeiro caractere da palavra de entrada é uma vogal. Se for, adicione "yay" ao final da palavra. Caso contrário, mova o primeiro caractere para o final da palavra e adicione "ay" a ele.

Uma última coisa a se observar sobre isso: no F#, não há nenhuma instrução explícita a ser retornada da função. Isso ocorre porque F# é baseado em expressão e a última expressão avaliada no corpo de uma função determina o valor retornado dessa função. Como if..then..else é uma expressão, a avaliação do corpo do bloco then ou do corpo do bloco else determina o valor retornado pela função toPigLatin.

Transformar o aplicativo de console em um gerador Pig Latin

As seções anteriores neste artigo demonstraram uma primeira etapa comum na escrita de código F#: escrever uma função inicial e executá-la interativamente com FSI. Isso é conhecido como desenvolvimento controlado por REPL, onde REPL significa "Loop Read-Evaluate-Print". É uma ótima maneira de experimentar a funcionalidade até que você tenha algo funcionando.

A próxima etapa no desenvolvimento controlado por REPL é mover o código de trabalho para um arquivo de implementação F#. Em seguida, ele pode ser compilado pelo compilador F# em um assembly que pode ser executado.

Para começar, abra o arquivo Program.fs criado anteriormente com a CLI do .NET. Você observará que algum código já está lá.

Em seguida, crie um novo module chamado PigLatin e copie a função toPigLatin que você criou anteriormente nele como tal:

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"

Este módulo deve estar acima da função main e abaixo da declaração de open System. A ordem das declarações é importante em F#, portanto, você precisará definir a função antes de chamá-la em um arquivo.

Agora, na função main, chame sua função de gerador Pig Latin nos argumentos:

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

    0

Agora você pode executar seu aplicativo de console na linha de comando:

dotnet run apple banana

E você verá que ele gera o mesmo resultado que o arquivo de script, mas desta vez como um programa em execução!

Solução de problemas do Ionide

Aqui estão algumas maneiras de solucionar determinados problemas que você pode encontrar:

1. Para obter os recursos de edição de código do Ionide, seus arquivos F# precisam ser salvos em disco e dentro de uma pasta aberta no workspace do Visual Studio Code.
2. Se você fez alterações no sistema ou instalou pré-requisitos do Ionide com o Visual Studio Code aberto, reinicie o Visual Studio Code.
3. Se você tiver caracteres inválidos nos diretórios do projeto, o Ionide poderá não funcionar. Renomeie seus diretórios de projeto se esse for o caso.
4. Se nenhum dos comandos do Ionide estiver funcionando, verifique suas Associações de teclas do Visual Studio Code para ver se você está substituindo-os por acidente.
5. Se o Ionide estiver quebrado no computador e nenhum dos itens acima tiver corrigido o problema, tente remover o diretório ionide-fsharp em seu computador e reinstale o pacote de plug-ins.
6. Se um projeto não tiver sido carregado (o Gerenciador de Soluções F# mostrará isso), clique com o botão direito do mouse nesse projeto e clique em Veja os detalhes para obter mais informações de diagnóstico.

O Ionide é um projeto de software livre criado e mantido por membros da comunidade F#. Relate problemas e sinta-se à vontade para contribuir no repositório GitHub ionide-vscode-fsharp.

Você também pode solicitar mais ajuda dos desenvolvedores do Ionide e da comunidade F# no canal Ionide Gitter.

Próximas etapas

Para saber mais sobre F# e os recursos da linguagem, confira Tour de F#.