Passo a passo: Seu primeiro F# programa

Artigo
02/25/2013

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.

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 de 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

Observação
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 de linguagem do F#.

Consulte também

Conceitos

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

Outros recursos

F# Visual

Referência de linguagem do F#

Compartilhar via