Tutorial: Implementar el primer programa en F#

Artículo
08/10/2011

Visual Studio 2010 incluye un nuevo lenguaje de programación, F#. F# es un lenguaje multiparadigma que admite la programación funcional además de la programación tradicional orientada a objetos y conceptos de .NET. En los siguientes ejemplos, se muestran algunas de sus características y su sintaxis. En los ejemplos, se muestra cómo declarar variables simples, escribir y probar funciones, crear tuplas y listas, así como definir y usar una clase.

Nota

Es posible que su equipo muestre nombres o ubicaciones diferentes para algunos de los elementos de la interfaz de usuario de Visual Studio incluidos en las instrucciones siguientes. La edición de Visual Studio que se tenga y la configuración que se utilice determinan estos elementos. Para obtener más información, vea Valores de configuración de Visual Studio.

Para crear una aplicación de consola

En el menú Archivo, elija Nuevo y haga clic en Proyecto.
Si no aparece Visual F# en el recuadro Categorías de plantillas, haga clic en Otros lenguajes y, a continuación, haga clic en Visual F#. En el recuadro Plantillas que se encuentra en el centro aparecen las plantillas de F#.
Compruebe la parte superior del recuadro Plantillas para asegurarse de que .NET Framework 4 aparece en el cuadro Versión de .NET Framework de destino.
Haga clic en Aplicación de F# en la lista de plantillas.
Escriba un nombre para el proyecto en el campo Nombre.
Haga clic en Aceptar.

El nuevo proyecto aparecerá en el Explorador de soluciones.

Para usar la palabra clave let a fin de declarar y usar identificadores

Copie y pegue el código siguiente en Program.fs. De este modo, enlaza cada identificador, anInt, aString y anIntSquared, a un valor.
```
let anInt = 5
let aString = "Hello"
// Perform a simple calculation and bind anIntSquared to the result.
let anIntSquared = anInt * anInt
```
Nota

Si no puede ver el código en la vista clásica, asegúrese de que la opción Filtro de lenguaje situada en el encabezado bajo de título del tema está definida para incluir F#.

Para ver los resultados en la ventana F# Interactive

Seleccione las expresiones let del procedimiento anterior.
Haga clic con el botón secundario en el área seleccionada y, a continuación, haga clic en Enviar a Interactive. Asimismo, puede presionar las teclas ALT+ENTRAR.
Se abre la ventana F# Interactive y aparecen los resultados de la interpretación de las expresiones let, los cuales se muestran en las siguientes líneas. Los tipos se deducen de los valores especificados.

val anInt : int = 5

val aString : string = "Hello"

val anIntSquared : int = 25

Para ver los resultados en una ventana del símbolo del sistema

Agregue las siguientes líneas a Program.fs.

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

Presione CTRL+F5 para ejecutar el código. Aparecerá una ventana del símbolo del sistema con los siguientes valores.

5

Hello

25

Para comprobar los tipos deducidos, sitúe el puntero del mouse sobre los nombres de los identificadores anInt, aString y anIntSquared en las anteriores instrucciones WriteLine.

Para definir y ejecutar una función

Use una expresión let para definir una función de cuadrado, tal y como se muestra en el siguiente código. La función tiene un parámetro, n, y devuelve el cuadrado del 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)
```
Presione CTRL+F5 para ejecutar el código. El resultado es 25.
Una función recursiva requiere una expresión let rec. En el siguiente ejemplo, se define una función que calcula el factorial del parámetro n.
```
let rec factorial n = 
    if n = 0 
    then 1 
    else n * factorial (n - 1)
System.Console.WriteLine(factorial anInt)
```
Presione CTRL+F5 para ejecutar la función. El resultado es 120, el factorial de 5.

Para crear colecciones: listas y tuplas

Para agregar valores, se puede usar una tupla, tal y como se muestra en el siguiente código.

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

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

También se puede usar una lista, tal y como se muestra en el siguiente código.
```
// List of best friends.
let bffs = [ "Susan"; "Kerry"; "Linda"; "Maria" ] 
```
Para agregar un nombre a la lista de mejores amigos, use el operador "cons" (::). Observe que la operación no cambia el valor de bffs. El valor de bffs es inmutable y no se puede modificar.
```
// Bind newBffs to a new list that has "Katie" as its first element.
let newBffs = "Katie" :: bffs
```
Use printfn para mostrar las listas. La función printfn muestra los elementos individuales de valores estructurados.
```
printfn "%A" bffs
// Output: ["Susan"; "Kerry"; "Linda"; "Maria"]
printfn "%A" newBffs
// Output: ["Katie"; "Susan"; "Kerry"; "Linda"; "Maria"]
```
Para ver los resultados, presione CTRL+F5 o seleccione una sección del código y, a continuación, presione ALT+ENTRAR.

Para crear y usar una clase

En el siguiente código, se crea una clase Person con dos propiedades, Name y Age. La propiedad Name es de solo lectura. Su valor es inmutable, al igual que la mayoría de los valores en la programación funcional. Es posible crear valores mutables en F# pero hay que definirlos explícitamente como tal. En la siguiente definición de clase, el valor de Age está almacenado en una variable local mutable, internalAge. El valor de internalAge es susceptible de cambio.

// 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 probar la clase, declare dos objetos Person, realice algunos cambios y, a continuación, muestre los resultados, tal y como se refleja en el siguiente código.

// 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))

Se muestran las siguientes líneas.

Name: John

Age: 44

Name: Mary

Age: 15

False

Para ver otros ejemplos en el tutorial de F#

En el menú Archivo, elija Nuevo y haga clic en Proyecto.
Si no aparece Visual F# en el recuadro Categorías de plantillas, haga clic en Otros lenguajes y, a continuación, haga clic en Visual F#. En el recuadro Plantillas que se encuentra en el centro aparecen las plantillas de F#.
Compruebe la parte superior del recuadro Plantillas para asegurarse de que .NET Framework 4 aparece en el cuadro Versión de .NET Framework de destino.
Haga clic en Tutorial de F# en la lista de plantillas.
Haga clic en Aceptar.
El tutorial aparecerá en el Explorador de soluciones.

Pasos siguientes

Para obtener más información sobre la programación funcional y ejemplos adicionales, vea Funciones como valores de primera clase (F#). Para obtener más información sobre tuplas, listas, expresiones let, definiciones de funciones, clases, miembros y muchos otros temas, vea Referencia del lenguaje F#.