Walkthrough: Seu primeiro programa F#

Artigo
08/04/2011

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

Observação
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 Configurações do 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 conseguir ver Visual F# no Categorias de modelos de painel, clique em Outros idiomase em seguida, clique em Visual F#. O modelos de os modelos de F# de lista do painel no centro.
Examine a parte superior da modelos de painel para certificar-se de que .NET Framework 4 consta o Target Framework caixa.
Clique em F# o aplicativo na lista de modelos.
Digite um nome para o seu projeto no nome campo.
Clique em OK.

O novo projeto aparece na Solution Explorer.

Para usar a palavra-chave permite declarar e usar identificadores

Copie e cole o seguinte código em Program.fs. Você está ligando cada identificador, anInt, aString, e anIntSquared, para um valor.

let anInt = 5
let aString = "Hello"
// Perform a simple calculation and bind anIntSquared to the result.
let anIntSquared = anInt * anInt

Observação
Se você não conseguir ver o código no modo de exibição clássico, certifique-se de que o Filtro de linguagem no cabeçalho abaixo o tópico o título é definido para incluir F#.

Para ver os resultados na janela F# interativo

Selecione o let expressões no procedimento anterior.
Clique com o botão direito na área selecionada e clique em Enviar para interativo. Como alternativa, Pressione ALT + ENTER.
O F# interativo janela abre e os resultados de interpretar o let expressões são exibidas, conforme mostrado no seguinte 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 de Prompt de comando

Adicione as seguintes linhas para Program.fs.

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

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

5

Hello

25

Você pode verificar os tipos inferidos posicionando o ponteiro do mouse nos nomes de identificador anInt, aString, e anIntSquared no anterior WriteLine instruções.

Para definir e executar uma função

Use um let a expressão para definir uma função multiplies, conforme mostrado no código a seguir. A função possui um parâmetro, ne retorna o quadrado do argumento enviado para 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 um let rec expressão. 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 forma de agregar valores é por meio de uma tupla, conforme 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)

Outra forma de agregar valores é por meio de uma lista, conforme mostrado no código a seguir.
```
// List of best friends.
let bffs = [ "Susan"; "Kerry"; "Linda"; "Maria" ] 
```
Adicionar um novo melhor amigo à lista usando o "contras" operador (::). 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 listas. Função printfn mostra os elementos individuais que estão contidos no valores estruturados.
```
printfn "%A" bffs
// Output: ["Susan"; "Kerry"; "Linda"; "Maria"]
printfn "%A" newBffs
// Output: ["Katie"; "Susan"; "Kerry"; "Linda"; "Maria"]
```
Você pode exibir os resultados, pressionando CTRL + F5 ou selecionando uma seção do código e em seguida, pressionando ALT + ENTER.

Para criar e usar uma classe.

O código a seguir cria um Person classe que tem duas propriedades, Name e Age. Nameé uma propriedade somente leitura. Seu valor é imutável, pois a maioria dos valores na programação funcional. Você pode criar valores mutáveis em F#, se você precisar deles, mas você deve defini-los explicitamente como mutáveis. Na definição de classe seguinte, o valor de Age é armazenado em uma 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 duas Person objetos, faça algumas alterações e exibir os resultados, conforme 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 exibir outros exemplos do tutorial do F#

No menu File, aponte para New, e em seguida, clique em Project.
Se você não conseguir ver Visual F# no Categorias de modelos de painel, clique em Outros idiomase em seguida, clique em Visual F#. O modelos de os modelos de F# de lista do painel no centro.
Examine a parte superior da modelos de painel para certificar-se de que .NET Framework 4 consta o Target Framework caixa.
Clique em F# Tutorial na lista de modelos.
Clique em OK.
O tutorial é exibido na Solution Explorer.

Próximas etapas

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