programacion - microsoft f#
Lenguaje F#- consejos para novato (7)
Parece que en StackOveflow hay un grupo de entusiastas de F # .
Me gustaría conocer mejor este lenguaje, así que, aparte de la teoría de la programación funcional , ¿pueden indicarme los mejores puntos de partida para comenzar a usar el lenguaje F #? Quiero decir, tutoriales, instrucciones, pero antes que nada ejemplos de trabajo para tener la oportunidad de comenzar a hacer algo y disfrutar el idioma.
Muchas gracias
Andrea
@kronoz - bueno, muchas gracias por su larga respuesta, ese es un muy buen lugar para comenzar. Seguiré tus consejos y buscaré el libro @vecstasy mencionado.
ahora, déjame ir a codificar :-)
let thanksalot = "thanks a lot"
printfn "%s" (thanksalot);;
Consulte el Centro de desarrolladores de F # . También hay hubFS , un foro dedicado a F #.
He estado leyendo Real World Functional Programming
Con ejemplos en F # y C # por: Tomas Petricek
Hasta ahora, me parece muy bueno enseñar conceptos F # al mostrar las implementaciones en C # en el lateral. Ideal para programadores OO.
No para prostituirme horriblemente, pero escribí un par de publicaciones de F # en mi blog aquí y aquí . Chris Smith (chico del equipo F # en MS) tiene un artículo llamado ''F # en 20 minutos'' - parte 1 y parte 2 .
Tenga en cuenta que debe tener cuidado ya que el último CTP de F # (versión 1.9.6.0) tiene algunos cambios graves en comparación con las versiones anteriores, por lo que algunos ejemplos / tutoriales podrían no funcionar sin modificaciones.
Aquí hay un desglose rápido de algunas cosas interesantes, tal vez te puedo dar algunos consejos aquí, que son claramente muy breves y probablemente no sean geniales, ¡pero espero que te den algo con lo que jugar!: -
Primera nota: la mayoría de los ejemplos en Internet asumirán que la ''sintaxis ligera'' está activada. Para lograr esto, use la siguiente línea de código:
#light
Esto evita tener que insertar ciertas palabras clave que están presentes para la compatibilidad con OCaml y también tener que terminar cada línea con punto y coma. Tenga en cuenta que el uso de esta sintaxis significa que la sangría define el alcance. Esto quedará claro en ejemplos posteriores, todos los cuales dependen de la sintaxis ligera que se enciende.
Si está utilizando el modo interactivo, debe terminar todas las declaraciones con dos puntos y comas dobles, por ejemplo:
> #light;;
> let f x y = x + y;;
val f : int -> int -> int
> f 1 2;;
val it : int = 3
Tenga en cuenta que el modo interactivo devuelve un resultado ''val'' después de cada línea. Esto proporciona información importante sobre las definiciones que estamos haciendo, por ejemplo ''val f: int -> int -> int'' indica que una función que toma dos ints devuelve un int.
Tenga en cuenta que solo en interactivo necesitamos terminar líneas con punto y coma, cuando definimos el código F # estamos libres de eso :-)
Usted define funciones usando la palabra clave ''let''. Esta es probablemente la palabra clave más importante en todo F # y la usará mucho. Por ejemplo:-
let sumStuff x y = x + y
let sumStuffTuple (x, y) = x + y
Podemos llamar a estas funciones así:
sumStuff 1 2
3
sumStuffTuple (1, 2)
3
Tenga en cuenta que aquí hay dos maneras diferentes de definir funciones: puede separar los parámetros por espacios en blanco o especificar parámetros en ''tuplas'' (es decir, valores entre paréntesis separados por comas). La diferencia es que podemos usar la ''aplicación de función parcial'' para obtener funciones que toman menos de los parámetros requeridos usando el primer enfoque, y no con el segundo. P.ej:-
let sumStuff1 = sumStuff 1
sumStuff 2
3
Tenga en cuenta que estamos obteniendo una función de la expresión ''sumStuff 1''. Cuando podemos pasar las funciones tan fácilmente como los datos a los que se hace referencia como el lenguaje que tiene ''funciones de primera clase'', esta es una parte fundamental de cualquier lenguaje funcional como F #.
La coincidencia de patrones es bastante genial, es básicamente como una declaración de interruptor con esteroides (sí, corté esa frase de otro F # -ist :-). Puedes hacer cosas como estas:
let someThing x =
match x with
| 0 -> "zero"
| 1 -> "one"
| 2 -> "two"
| x when x < 0 -> "negative = " + x.ToString()
| _ when x%2 = 0 -> "greater than two but even"
| _ -> "greater than two but odd"
Tenga en cuenta que usamos el símbolo ''_'' cuando queremos hacer coincidir algo, pero la expresión que estamos devolviendo no depende de la entrada.
Podemos abreviar la coincidencia de patrones utilizando declaraciones if, elif y else según sea necesario:
let negEvenOdd x = if x < 0 then "neg" elif x % 2 = 0 then "even" else "odd"
Las listas F # (que se implementan como listas vinculadas debajo) pueden manipularse así:
let l1 = [1;2;3]
l1.[0]
1
let l2 = [1 .. 10]
List.length l2
10
let squares = [for i in 1..10 -> i * i]
squares
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
let square x = x * x;;
let squares2 = List.map square [1..10]
squares2
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
let evenSquares = List.filter (fun x -> x % 2 = 0) squares
evenSqares
[4; 16; 36; 64; 100]
Tenga en cuenta que la función List.map ''mapea'' la función cuadrada en la lista de 1 a 10, es decir, aplica la función a cada elemento. List.filter ''filtra'' una lista solo devolviendo valores en la lista que pasan la función de predicado provista. También tenga en cuenta la sintaxis ''diversión x -> f'' - esta es la F # lambda.
Tenga en cuenta que, a lo largo de todo el proceso, no hemos definido ningún tipo: los tipos de ''infers'' del compilador / intérprete de F #, es decir, resuelve lo que usted quiere del uso. Por ejemplo:-
let f x = "hi " + x
Aquí el compilador / intérprete determinará que x es una cadena ya que está realizando una operación que requiere que x sea una cadena. También determina que el tipo de retorno también será una cadena.
Cuando hay ambigüedad, el compilador hace suposiciones, por ejemplo:
let f x y = x + y
Aquí x y y podrían ser varios tipos, pero el compilador predeterminado es int. Si quiere definir tipos, puede usar el tipo de anotación: -
let f (x:string) y = x + y
También tenga en cuenta que hemos tenido que encerrar x: cadena entre paréntesis, a menudo tenemos que hacer esto para separar partes de una definición de función.
Dos operadores realmente útiles y muy utilizados en F # son los operadores de pipe forward y de composición de funciones |> y >> respectivamente.
Definimos |> así: -
let (|>) x f = f x
Tenga en cuenta que puede definir operadores en F #, esto es genial :-).
Esto le permite escribir cosas de una manera más clara, por ejemplo:
[1..10] |> List.map (fun x -> x * x) |> List.filter (fun x -> x % 2 = 0)
Te permitirá obtener los primeros 10 cuadrados pares. Eso es más claro que:
List.filter (fun x -> x % 2 = 0) (List.map (fun x -> x * x) [1..10])
Bueno, al menos eso creo :-)
La composición de la función definida por el operador >> se define de la siguiente manera:
let (>>) f g x = g(f(x))
Es decir, reenviar una operación solo el parámetro de la primera función permanece sin especificar. Esto es útil ya que puede hacer lo siguiente:
let mapFilter = List.map (fun x -> x * x) >> List.filter (fun x -> x % 2 = 0)
Aquí mapFilter aceptará una lista de entrada y devolverá la lista filtrada como antes. Es una versión abreviada de:
let mapFilter = l |> List.map (fun x -> x * x) |> List.filter (fun x -> x % 2 = 0)
Si queremos escribir funciones recursivas, debemos definir la función como recursiva colocando ''rec'' después de let. Ejemplos a continuación.
Algunas cosas interesantes:
Factorial
let rec fact x = if x <= 1 then 1 else x * fact (x-1)
enésimo número de Fibonacci
let rec fib n = if n <= 1 then n else fib (n-1) + fib (n-2)
FizzBuzz
let (/%) x y = x % y = 0
let fb = function
| x when x /% 15 -> "FizzBuzz"
| x when x /% 3 -> "Fizz"
| x when x /% 5 -> "Buzz"
| x -> x.ToString()
[1..100] |> List.map (fb >> printfn "%s")
De todos modos, es una breve reseña, ¡espero que ayude un poco!
Si tiene la versión actual de CTP en Visual Studio, le permite crear un proyecto de F # Tutorial, que le proporciona un Tutorial.fs, que contiene exactamente lo que su nombre sugiere.
Ese tutorial también apunta a una colección más grande de ejemplos de F # en Microsoft .
Además, hay un proyecto de F # samples en CodePlex .
Espero que esto ayude,
Michiel
Sin duda, debe comprar el excelente libro de Don Syme "Expert F #". El libro está muy bien escrito y es adecuado tanto para principiantes como para expertos. En él, encontrarás tanto material introductorio como material mucho más desafiante también. En casi 600 páginas, tiene una buena relación calidad-precio.
Descubrí que me enseñó muchas técnicas útiles para escribir C # más funcional y también para proporcionar todo el material de referencia que necesitaba para comenzar a escribir aplicaciones F # alojadas en Windows.
El libro es publicado por Apress y tiene un sitio web que lo acompaña en: http://www.expert-fsharp.com/default.aspx