Como ustedes saben microsoft dio un vuelco importante a su mirada al open source y yo dispuesto a evolucionar tambien me anime a cambiar y a mirar de forma diferente sus productos.
Por lo tanto hoy voy a probar F#. F# es supuestamente un derivado de ML, pero la verdad que por lo que vi es una involución.
Entre las ventajas podemos nombrar, es open source, es multiplataforma, fuertemente tipado y multiparadigma (objeto y funcional) aunque es sobre todo funcional. Por lo tanto se puede utilizar el modelo de objetos para mantener estados, y en las situaciones que es más fácil resolver el problema de forma funcional, se puede utilizar.
Mi primera impresión con el lenguaje es que es similar a C# pero se escriben las cosas de forma diferente, nada más pero es mi opinión.
Estoy hablando demasiado, veamos algo de código:
let mutable sum = 0
for i = 0 to 100 do
if i%2 <> 0 then sum <- sum + i
printfn "the sum of odd numbers from 0 to 100 is %A" sum
Este pedazo de código se puede apreciar que no es un lenguaje funcional puro sino que permite sentencias for y mutables.
Otros detalles:
- el operador de asignación es el <-
- usa el if then como Pascal
- el for tiene un inicio y final (o desde hasta) como pascal!
- Con let declaramos los mutables (variables) o inmutables
También tiene listas por compresión, veamos un ejemplo
let list2 = [for i=0 to 4 do yield i*i]
A la vez tiene secuencias y arreglos.
let array0 = [| 1 .. 10 |]
Los arreglos son bastante inteligentes:
// get slice from element 2 through 6
array0.[2..6]
// get slice from element 4 to the end
array0.[4..]
// get the slice from the start to element 6
array0.[..6]
// get all the elements (copy the whole array)
array0.[*]
Una cosa muy interesante es el operador |> que es similar al operador | de unix. Lo que permite es que el resultado de una función sea la entrada de otra de forma que componer funciones sea simple, veamos un ejemplo:
seq { 0..100 }
|> Seq.filter (fun n -> n%2<>0)
|> Seq.sum
|> printfn "the sum of odd number from 0 to 100 is %A"
Es hora de ver una clase en F#:
// define a Point2D class
type Point2D() =
// define field x
let mutable x = 0.0
// define X property
member this.X with get() = x
and set(v) = x <- v
// define Y property using an auto-implemented property
member val Y = 0.0 with get, set
// define a function to get the distance from the current point
member this.GetDistance(point:Point2D) =
let xDif = this.X - point.X
let yDif = this.Y - point.Y
let distance = sqrt(xDif**2. + yDif**2.)
distance
La primera impresión es "como extraño los {} y el punto y coma. Y hace minutos los odiaba. Luego de esto podemos ver que se esta definiendo un nuevo tipo, es decir una clase en un tipo. Luego creo que todo es bastante entendible, se define una propiedad y sus geters y seters y luego la función que calcula la distancia.
También tiene monad y patter matching, mira:
type MyClass() =
member this.PrintValue(?value:int) =
match value with
| Some(n) -> printfn "value is %A" n
| None -> printfn "sorry, no value"
Muy a vuelo de pájaro fue una primera probada de F#
Dejo link:
http://fsharp.org/
