Primeros pasos en F#

Veremos en este post la instalación de F#, el lenguaje funcional de Microsoft, y los primeros comandos que podemos ejecutar. Dejaremos para más adelante el tratamiento de programación funcional en general, el uso de F# desde el Visual Studio, y el compilador que contiene.

El lenguaje F# se viene desarrollando desde hace años, de la mano de su creador Don Syme y sus colaboradores. Pueden ver el sitio de F# en:

http://research.microsoft.com/fsharp/fsharp.aspx

Ahí leemos:

Combining the efficiency, scripting, strong typing and productivity of ML with the stability, libraries, cross-language working and tools of .NET.

F# is a programming language that provides the much sought-after combination of type safety, performance and scripting, with all the advantages of running on a high-quality, well-supported modern runtime system.

No he visto que en esa página actualmente tengan publicado la última distribución, usaré en esta prueba la versión que se publicó hace unos días:

F# 1.9.3.4 download

El enlace me lo pasó el bueno de Paulo Arancibia.

Instalando F#

Los programas de soporte se instalan desde un .msi. Algunas pantallas de instalación:

 

 

El último paso puede tardar varios minutos. Vean que instala soporte de F# en el propio Visual Studio. Yo estoy usando el VS 2005 Professional. F# tiene soporte de VS 2003. Igualmente, veremos que podemos usar un compilador y un intérprete desde la línea de comando, si no tenemos Visual Studio. También puede instalarse sobre Mono.

Al terminar la instalación, nos queda un directorio c:\Program Files\FSharp-1.9.3.4:

Vean que hasta queda un .sh para instalar en Mono.

En el menú de programas aparece:

El intérprete fsi

Tenemos a nuestra disposición un programa interactivo, desde el menú que nos queda, o disponible desde bin\fsi.exe:

C:\Program Files\FSharp-1.9.3.4\bin>fsi MSR F# Interactive, (c) Microsoft Corporation, All Rights Reserved F# Version 1.9.3.4, compiling for .NET Framework Version v2.0.50727 NOTE: NOTE: See 'fsi --help' for flags NOTE: NOTE: Commands: #r <string>;; reference (dynamically load) the given DLL. NOTE: #I <string>;; add the given search path for referenced DLLs. NOTE: #use <string>;; accept input from the given file. NOTE: #load <string> ...<string>;; NOTE: load the given file(s) as a compilation unit. NOTE: #time;; toggle timing on/off. NOTE: #types;; toggle display of types on/off. NOTE: #quit;; exit. NOTE: NOTE: Visit the F# website at http://research.microsoft.com/fsharp. NOTE: Bug reports to fsbugs@microsoft.com. Enjoy!


Usando let


Si ingresamos


> let x = 10;;

obtenemos:

val x : int

El ;; indica al programa que tiene que compilar y ejecutar lo ingresado. Notemos que de esta forma, x es un identificador, que contiene un valor de tipo entero. F# es un lenguaje tipado, y el tipo lo infiere a medida que vamos definiendo las expresiones.

Si ahora pedimos

> x;;

(el > no lo ingresamos, es parte del “prompt” que nos muestra el programa fsi) obtenemos

val it : int = 10

La conducta de fsi es imprimir al expresión y su tipo. Vean que aparece it: es la variable que usa cuando no especificamos que una expresión se asigna a un identificador (vamos a ver que variable no es variable en F#… :-)

Definiendo funciones


Usando el mismo let, podemos definir funciones:

>  let dup x = x * 2;;
val dup : int -> int

La segunda línea indica que dup es un valor de tipo función que recibe un entero y devuelve un entero. Esto es fundamental en F#: las funciones son valores, como cualquier otro. El identificador dup ahora referencia a esa función.

Si lo aplicamos:

> dup 10;;
val it : int = 20

Para ver que una función es un valor como cualquier otro, veamos de pasar una función como parámetro:

> let apply f x = f (f x);;
val apply : (‘a -> ‘a) -> ‘a -> ‘a

El resultado es algo más críptico. El ‘a se refiere a un tipo aún no definido. Don Syme, el creador de F#, estuvo antes involucrado en la definición e implementación de Generics en .NET 2.0. Acá aparece algo de esa influencia.

Si pedimos

> apply dup 2;;

obtenemos

val it : int = 8

que es es lo mismo que haber pedido

> dup (dup 2);;

Conclusión


Para quien no esté familiarizado a la programación funcional, el concepto de función como valor de primera clase, ciudadano del lenguaje con los mismos derechos y deberes que los otros valores, es algo extraño. Para el que haya visto alguna de las primeras implementaciones de Lisp, y el cálculo lambda de Church, será una especie de deja vu.

Lo interesante de F# es que no sólo soporta este tipo de programación, sino, que abandonando la pretension de ser un lenguaje funcional puro, también soporta programación procedural, de objetos, y notablemente, el uso de todo el framework de .NET. Todo esto es lo que ha hecho que haya sido adoptado en varios ámbitos. Desde un proyecto de “research” de Microsoft, ha ido creciendo hasta hoy. Veremos qué lugar ocupa en el futuro, dentro de la panoplia de lenguajes que tenemos disponibles.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com/

This entry was posted in 6269, 8848, 8871. Bookmark the permalink.

One Response to Primeros pasos en F#

  1. Hola Ángel:
    Esto tiene cara de MathLab ¿no es cierto?
    Muy interesante.

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>