Instruções passo a passo: seu primeiro programa em F#

Artigo
06/10/2015

Visual Studio 2010 inclui uma nova linguagem de programação, F#. F# é uma linguagem multiparadigma que suporta programação funcional além da tradicional programação orientada a objeto e conceitos .NET. Os exemplos a seguir apresentam alguns dos seus recursos e sintaxe. Os exemplos mostram como declarar variáveis simples, escrever e testar funções, criar tuplas e listas e também como definir e usar uma classe.

Dica

Seu computador pode mostrar nomes ou locais diferentes para alguns dos elementos da interface do usuário do Visual Studio nas instruções a seguir. A edição do Visual Studio que você possui e as configurações que você usa determinam esses elementos. Para obter mais informações, consulte Personalizando configurações de desenvolvimento no Visual Studio.

Para criar um novo aplicativo de console.

No menu File, aponte para New, e em seguida, clique em Project.
Se você não puder ver o Visual F# no painel de Categorias de Modelos, clique em Outras Linguagens, e então em Visual F#. O painel de Modelos no centro lista os modelos F#.
Olhe para a parte superior do painel de Modelos para certificar-se de que o .NET Framework 4 aparece na caixa Estrutura de Destino.
Clique em Aplicativo F# na lista de modelos.
Digite um nome para o seu projeto no campo Nome.
Clique em OK.

O novo projeto aparece no Gerenciador de Soluções.

Para usar a palavra-chave let (deixar em inglês) para declarar e usar identificadores

Copie e cole o seguinte código em Program.fs. Você está associando cada identificador, anInt, aString e anIntSquared, a um valor.
```
let anInt = 5
let aString = "Hello" 
// Perform a simple calculation and bind anIntSquared to the result. 
let anIntSquared = anInt * anInt
```
Dica

Se você não puder ver o código no modo de exibição clássico, certifique-se de que o Filtro de Linguagem no cabeçalho sob o título do tópico está definido para incluir F#.

Para ver os resultados na janela do F# interativo

Selecione as expressões let no procedimento anterior.
Clique com o botão direito na área selecionada e clique em Enviar ao Interativo. Alternativamente, pressione ALT+ENTER.
A janela do F# Interativo abre e os resultados da interpretação das expressões let são exibidos, conforme mostrado nas seguintes linhas. Os tipos são inferidos dos valores especificados.

val anInt : int = 5

val aString : string = "Hello"

val anIntSquared : int = 25

Para ver os resultados em uma janela do Prompt de Comando

Adicione as seguintes linhas a Program.fs.

System.Console.WriteLine(anInt)
System.Console.WriteLine(aString)
System.Console.WriteLine(anIntSquared)

Pressione CTRL+F5 para executar o código. Uma janela do Prompt de Comando que contém os valores seguintes aparece.

5

Hello

25

Você pode verificar os tipos inferidos ao colocar o ponteiro do mouse sobre nomes dos identificadores anInt, aString, e anIntSquared nas declarações prévias de WriteLine.

Para definir e executar uma função

Use uma expressão let para definir uma função quadrática, como mostrado no código a seguir. A função tem um parâmetro, n, e retorna o quadrado do argumento enviado a n.

let square n = n * n
// Call the function to calculate the square of anInt, which has the value 5. 
let result = square anInt
// Display the result.
System.Console.WriteLine(result)

Pressione CTRL+F5 para executar o código. O resultado exibido é 25.
Uma função recursiva requer uma expressão let rec. O exemplo a seguir define uma função que calcula o fatorial do parâmetro n.
```
let rec factorial n = 
    if n = 0 
    then 1 
    else n * factorial (n - 1)
System.Console.WriteLine(factorial anInt)
```
Pressione CTRL+F5 para executar a função. O resultado exibido é 120, o fatorial de 5.

Para criar coleções: listas e tuplas

Uma maneira de agregar valores é usar uma tupla, como mostrado no código a seguir.

let turnChoices = ("right", "left")
System.Console.WriteLine(turnChoices)
// Output: (right, left) 

let intAndSquare = (anInt, square anInt)
System.Console.WriteLine(intAndSquare)
// Output: (5,25)

Uma outra maneira de agregar valores é usar uma lista, como mostrado no código a seguir.
```
// List of best friends. 
let bffs = [ "Susan"; "Kerry"; "Linda"; "Maria" ] 
```
Adicione um novo melhor amigo à lista usando o operador “cons” (::). Observe que a operação não altera o valor de bffs. O valor de bffs é imutável e não pode ser alterado.
```
// Bind newBffs to a new list that has "Katie" as its first element.
let newBffs = "Katie" :: bffs
```
Use printfn para exibir as listas. A função printfn mostra os elementos individuais que estão contidos em valores estruturados.
```
printfn "%A" bffs
// Output: ["Susan"; "Kerry"; "Linda"; "Maria"]
printfn "%A" newBffs
// Output: ["Katie"; "Susan"; "Kerry"; "Linda"; "Maria"]
```
Você pode visualizar os resultados pressionando CTRL+F5 ou selecionando uma seção de código e em seguida pressionar ALT+ENTER.

Para criar e usar uma classe

O código a seguir cria uma classe Person que possui duas propriedades, Name e Age. Name é uma propriedade somente leitura. O seu valor é imutável, como são a maioria dos valores na programação funcional. Você pode criar valores mutáveis em F# se você precisar, mas você deve defini-los explicitamente como mutáveis. Na definição de classe a seguir, o valor de Age é armazenado em um variável local mutável, internalAge. O valor de internalAge pode ser alterado.

// The declaration creates a constructor that takes two values, name and age. 
type Person(name:string, age:int) =
    // A Person object's age can be changed. The mutable keyword in the 
    // declaration makes that possible. 
    let mutable internalAge = age

    // Declare a second constructor that takes only one argument, a name. 
    // This constructor calls the constructor that requires two arguments, 
    // sending 0 as the value for age. 
    new(name:string) = Person(name, 0)

    // A read-only property. 
    member this.Name = name
    // A read/write property. 
    member this.Age
        with get() = internalAge
        and set(value) = internalAge <- value

    // Instance methods. 
    // Increment the person's age. 
    member this.HasABirthday () = internalAge <- internalAge + 1

    // Check current age against some threshold. 
    member this.IsOfAge targetAge = internalAge >= targetAge

    // Display the person's name and age. 
    override this.ToString () = 
        "Name:  " + name + "\n" + "Age:   " + (string)internalAge

Para testar a classe, declare dois objetos Person faça algumas alterações, e exiba os resultados, como mostrado no código a seguir.

// The following let expressions are not part of the Person class. Make sure 
// they begin at the left margin. 
let person1 = Person("John", 43)
let person2 = Person("Mary")

// Send a new value for Mary's mutable property, Age.
person2.Age <- 15
// Add a year to John's age.
person1.HasABirthday()

// Display results.
System.Console.WriteLine(person1.ToString())
System.Console.WriteLine(person2.ToString())
// Is Mary old enough to vote?
System.Console.WriteLine(person2.IsOfAge(18))

As seguintes linhas são exibidas.

Name: John

Age: 44

Name: Mary

Age: 15

False

Para visualizar outros exemplos no tutorial do F#

No menu File, aponte para New, e em seguida, clique em Project.
Se você não puder ver o Visual F# no painel de Categorias de Modelos, clique em Outras Linguagens, e então em Visual F#. O painel de Modelos no centro lista os modelos F#.
Olhe para a parte superior do painel de Modelos para certificar-se de que o .NET Framework 4 aparece na caixa Estrutura de Destino.
Clique em Tutorial do F# na lista de modelos.
Clique em OK.
O tutorial aparece no Gerenciador de Soluções.

Próximas etapas

Para mais informações sobre programação funcional e exemplos adicionais, consulte Funções como valores de primeira classe (F#). Para obter mais informações sobre tuplas, listas, expressões let, definições de função, classes, membros, e muitos outros tópicos, consulte Referência da linguagem F#.

Consulte também

Conceitos

Funções como valores de primeira classe (F#)

Outros recursos

Visual F#

Referência da linguagem F#