---
contributors:
  - ['Scott Wlaschin', 'http://fsharpforfunandprofit.com/']
translators:
  - ['Angel Arciniega', 'https://github.com/AngelsProjects']
filename: learnfsharp-es.fs
---

F# es un lenguaje de programación funcional y orientado a objetos. Es gratis y su código fuente está abierto. Se ejecuta en Linux, Mac, Windows y más.

Tiene un poderoso sistema de tipado que atrapa muchos errores de tiempo de compilación, pero usa inferencias de tipados que le permiten ser leídos como un lenguaje dinámico.

La sintaxis de F# es diferente de los lenguajes que heredan de C.

- Las llaves no se usan para delimitar bloques de código. En cambio, se usa sangría (como en Python).
- Los espacios se usan para separar parámetros en lugar de comas.

Si quiere probar el siguiente código, puede ir a [tryfsharp.org](http://www.tryfsharp.org/Create) y pegarlo en [REPL](https://es.wikipedia.org/wiki/REPL).

```fsharp
// Los comentarios de una línea se escibren con una doble diagonal
(* Los comentarios multilínea usan parentesis (* . . . *)

-final del comentario multilínea- *)

// ================================================
// Syntaxis básica
// ================================================

// ------ "Variables" (pero no realmente) ------
// La palabra reservada "let" define un valor (inmutable)
let miEntero = 5
let miFlotante = 3.14
let miCadena = "hola"           // Tenga en cuenta que no es necesario ningún tipado

// ------ Listas ------
let dosACinco = [2;3;4;5]        // Los corchetes crean una lista con
                                 // punto y coma para delimitadores.
let unoACinco = 1 :: dosACinco   // :: Crea una lista con un nuevo elemento
// El resultado es [1;2;3;4;5]
let ceroACinco = [0;1] @ dosACinco   // @ Concatena dos listas

// IMPORTANTE: las comas no se usan para delimitar,
// solo punto y coma !

// ------ Funciones ------
// La palabra reservada "let" también define el nombre de una función.
let cuadrado x = x * x          // Tenga en cuenta que no se usa paréntesis.
cuadrado 3                      // Ahora, ejecutemos la función.
                              // De nuevo, sin paréntesis.

let agregar x y = x + y           // ¡No use add (x, y)! Eso significa
                              // algo completamente diferente.
agregar 2 3                       // Ahora, ejecutemos la función.

// Para definir una función en varias líneas, usemos la sangría.
// Los puntos y coma no son necesarios.
let pares lista =
   let esPar x = x%2 = 0     // Establece "esPar" como una función anidada
   List.filter esPar lista    // List.filter es una función de la biblioteca
                              // dos parámetros: una función que devuelve un
                              // booleano y una lista en la que trabajar

pares unoACinco               // Ahora, ejecutemos la función.

// Puedes usar paréntesis para aclarar.
// En este ejemplo, "map" se ejecuta primero, con dos argumentos,
// entonces "sum" se ejecuta en el resultado.
// Sin los paréntesis, "List.map" se pasará como argumento a List.sum.
let sumaDeCuadradosHasta100 =
   List.sum ( List.map cuadrado [1..100] )

// Puedes redirigir la salida de una función a otra con "|>"
// Redirigir datos es muy común en F#, como con los pipes de UNIX.

// Aquí está la misma función sumOfSquares escrita usando pipes
let sumaDeCuadradosHasta100piped =
   [1..100] |> List.map cuadrado |> List.sum  // "cuadrado" se declara antes

// Puede definir lambdas (funciones anónimas) gracias a la palabra clave "fun"
let sumaDeCuadradosHasta100ConFuncion =
   [1..100] |> List.map (fun x -> x*x) |> List.sum

// En F#, no hay palabra clave "return". Una función siempre regresa
// el valor de la última expresión utilizada.

// ------ Coincidencia de patrones ------
// Match..with .. es una sobrecarga de la condición de case/ switch.
let coincidenciaDePatronSimple =
   let x = "a"
   match x with
    | "a" -> printfn "x es a"
    | "b" -> printfn "x es b"
    | _ -> printfn "x es algo mas"   // guion bajo corresponde con todos los demás

// F# no permite valores nulos por defecto - debe usar el tipado de Option
// y luego coincide con el patrón.
// Some(..) y None son aproximadamente análogos a los envoltorios Nullable
let valorValido = Some(99)
let valorInvalido = None

// En este ejemplo, match..with encuentra una coincidencia con "Some" y "None",
// y muestra el valor de "Some" al mismo tiempo.
let coincidenciaDePatronDeOpciones entrada =
   match entrada with
    | Some i -> printfn "la entrada es un int=%d" i
    | None -> printfn "entrada faltante"

coincidenciaDePatronDeOpciones validValue
coincidenciaDePatronDeOpciones invalidValue

// ------ Viendo ------
// Las funciones printf/printfn son similares a las funciones
// Console.Write/WriteLine de C#.
printfn "Imprimiendo un int %i, a float %f, a bool %b" 1 2.0 true
printfn "Un string %s, y algo generico %A" "hola" [1;2;3;4]

// También hay funciones printf/sprintfn para formatear datos
// en cadena. Es similar al String.Format de C#.

// ================================================
// Mas sobre funciones
// ================================================

// F# es un verdadero lenguaje funcional - las funciones son
// entidades de primer nivel y se pueden combinar fácilmente
// para crear construcciones poderosas

// Los módulos se utilizan para agrupar funciones juntas.
// Se requiere sangría para cada módulo anidado.
module EjemploDeFuncion =

    // define una función de suma simple
    let agregar x y = x + y

    // uso básico de una función
    let a = agregar 1 2
    printfn "1+2 = %i" a

    // aplicación parcial para "hornear en" los parámetros (?)
    let agregar42 = agregar 42
    let b = agregar42 1
    printfn "42+1 = %i" b

    // composición para combinar funciones
    let agregar1 = agregar 1
    let agregar2 = agregar 2
    let agregar3 = agregar1 >> agregar2
    let c = agregar3 7
    printfn "3+7 = %i" c

    // funciones de primer nivel
    [1..10] |> List.map agregar3 |> printfn "la nueva lista es %A"

    // listas de funciones y más
    let agregar6 = [agregar1; agregar2; agregar3] |> List.reduce (>>)
    let d = agregar6 7
    printfn "1+2+3+7 = %i" d

// ================================================
// Lista de colecciones
// ================================================

// Il y a trois types de collection ordonnée :
// * Les listes sont les collections immutables les plus basiques
// * Les tableaux sont mutables et plus efficients
// * Les séquences sont lazy et infinies (e.g. un enumerator)
//
// Des autres collections incluent des maps immutables et des sets
// plus toutes les collections de .NET

module EjemplosDeLista =

    // las listas utilizan corchetes
    let lista1 = ["a";"b"]
    let lista2 = "c" :: lista1    // :: para una adición al principio
    let lista3 = lista1 @ lista2   // @ para la concatenación

    // Lista de comprensión (alias generadores)
    let cuadrados = [for i in 1..10 do yield i*i]

    //  Generador de números primos
    let rec tamiz = function
        | (p::xs) -> p :: tamiz [ for x in xs do if x % p > 0 then yield x ]
        | []      -> []
    let primos = tamiz [2..50]
    printfn "%A" primos

    // coincidencia de patrones para listas
    let listaDeCoincidencias unaLista =
        match unaLista with
        | [] -> printfn "la lista esta vacia"
        | [primero] -> printfn "la lista tiene un elemento %A " primero
        | [primero; segundo] -> printfn "la lista es %A y %A" primero segundo
        | _ -> printfn "la lista tiene mas de dos elementos"

    listaDeCoincidencias [1;2;3;4]
    listaDeCoincidencias [1;2]
    listaDeCoincidencias [1]
    listaDeCoincidencias []

    // Récursion en utilisant les listes
    let rec suma unaLista =
        match unaLista with
        | [] -> 0
        | x::xs -> x + suma xs
    suma [1..10]

    // -----------------------------------------
    // Funciones de la biblioteca estándar
    // -----------------------------------------

    // mapeo
    let agregar3 x = x + 3
    [1..10] |> List.map agregar3

    // filtrado
    let par x = x % 2 = 0
    [1..10] |> List.filter par

    // mucho más - consulte la documentación

module EjemploDeArreglo =

    // los arreglos usan corchetes con barras.
    let arreglo1 = [| "a";"b" |]
    let primero = arreglo1.[0]        // se accede al índice usando un punto

    // la coincidencia de patrones de los arreglos es la misma que la de las listas
    let coincidenciaDeArreglos una Lista =
        match unaLista with
        | [| |] -> printfn "la matriz esta vacia"
        | [| primero |] -> printfn "el arreglo tiene un elemento %A " primero
        | [| primero; second |] -> printfn "el arreglo es %A y %A" primero segundo
        | _ -> printfn "el arreglo tiene mas de dos elementos"

    coincidenciaDeArreglos [| 1;2;3;4 |]

    // La biblioteca estándar funciona como listas
    [| 1..10 |]
    |> Array.map (fun i -> i+3)
    |> Array.filter (fun i -> i%2 = 0)
    |> Array.iter (printfn "el valor es %i. ")

module EjemploDeSecuencia =

    // Las secuencias usan llaves
    let secuencia1 = seq { yield "a"; yield "b" }

    // Las secuencias pueden usar yield y
    // puede contener subsecuencias
    let extranio = seq {
        // "yield" agrega un elemento
        yield 1; yield 2;

        // "yield!" agrega una subsecuencia completa
        yield! [5..10]
        yield! seq {
            for i in 1..10 do
              if i%2 = 0 then yield i }}
    // prueba
    extranio |> Seq.toList

    // Las secuencias se pueden crear usando "unfold"
    // Esta es la secuencia de fibonacci
    let fib = Seq.unfold (fun (fst,snd) ->
        Some(fst + snd, (snd, fst + snd))) (0,1)

    // prueba
    let fib10 = fib |> Seq.take 10 |> Seq.toList
    printf "Los primeros 10 fib son %A" fib10

// ================================================
// Tipos de datos
// ================================================

module EejemploDeTipoDeDatos =

    // Todos los datos son inmutables por defecto

     // las tuplas son tipos anónimos simples y rápidos
     // - Usamos una coma para crear una tupla
    let dosTuplas = 1,2
    let tresTuplas = "a",2,true

    // Combinación de patrones para desempaquetar
    let x,y = dosTuplas  // asignado x=1 y=2

    // ------------------------------------
    // Los tipos de registro tienen campos con nombre
    // ------------------------------------

    // Usamos "type" con llaves para definir un tipo de registro
    type Persona = {Nombre:string; Apellido:string}

    // Usamos "let" con llaves para crear un registro
    let persona1 = {Nombre="John"; Apellido="Doe"}

    // Combinación de patrones para desempaquetar
    let {Nombre=nombre} = persona1    // asignado nombre="john"

    // ------------------------------------
    // Los tipos de unión (o variantes) tienen un conjunto de elección
     // Solo un caso puede ser válido a la vez.
    // ------------------------------------

    // Usamos "type" con barra/pipe para definir una unión estándar
    type Temp =
        | GradosC of float
        | GradosF of float

    // Una de estas opciones se usa para crear una
    let temp1 = GradosF 98.6
    let temp2 = GradosC 37.0

    // Coincidencia de patrón en todos los casos para desempaquetar (?)
    let imprimirTemp = function
       | GradosC t -> printfn "%f gradC" t
       | GradosF t -> printfn "%f gradF" t

    imprimirTemp temp1
    imprimirTemp temp2

    // ------------------------------------
    // Tipos recursivos
    // ------------------------------------

    // Los tipos se pueden combinar recursivamente de formas complejas
    // sin tener que crear subclases
    type Empleado =
      | Trabajador of Persona
      | Gerente of Empleado lista

    let jdoe = {Nombre="John";Apellido="Doe"}
    let trabajador = Trabajador jdoe

    // ------------------------------------
    // Modelado con tipados (?)
    // ------------------------------------

    // Los tipos de unión son excelentes para modelar el estado sin usar banderas (?)
    type DireccionDeCorreo =
        | DireccionDeCorreoValido of string
        | DireccionDeCorreoInvalido of string

    let intentarEnviarCorreo correoElectronico =
        match correoElectronico with // uso de patrones de coincidencia
        | DireccionDeCorreoValido direccion -> ()   // enviar
        | DireccionDeCorreoInvalido direccion -> () // no enviar

    // Combinar juntos, los tipos de unión y tipos de registro
     // ofrece una base excelente para el diseño impulsado por el dominio.
     // Puedes crear cientos de pequeños tipos que reflejarán fielmente
     // el dominio.

    type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int }
    type Pago = Pago of float
    type DatosActivosDelCarrito = { ArticulosSinPagar: ArticuloDelCarrito lista }
    type DatosPagadosDelCarrito = { ArticulosPagados: ArticuloDelCarrito lista; Pago: Pago}

    type CarritoDeCompras =
        | CarritoVacio  // sin datos
        | CarritoActivo of DatosActivosDelCarrito
        | CarritoPagado of DatosPagadosDelCarrito

    // ------------------------------------
    // Comportamiento nativo de los tipos
    // ------------------------------------

    // Los tipos nativos tienen el comportamiento más útil "listo para usar", sin ningún código para agregar.
     // * Inmutabilidad
     // * Bonita depuración de impresión
     // * Igualdad y comparación
     // * Serialización

     // La impresión bonita se usa con %A
    printfn "dosTuplas=%A,\nPersona=%A,\nTemp=%A,\nEmpleado=%A"
             dosTuplas persona1 temp1 trabajador

    // La igualdad y la comparación son innatas
     // Aquí hay un ejemplo con tarjetas.
    type JuegoDeCartas = Trebol | Diamante | Espada | Corazon
    type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho
                | Nueve | Diez | Jack | Reina | Rey | As

    let mano = [ Trebol,As; Corazon,Tres; Corazon,As;
                 Espada,Jack; Diamante,Dos; Diamante,As ]

    // orden
    List.sort mano |> printfn "la mano ordenada es (de menos a mayor) %A"
    List.max mano |> printfn "la carta más alta es%A"
    List.min mano |> printfn "la carta más baja es %A"

// ================================================
// Patrones activos
// ================================================

module EjemplosDePatronesActivos =

    // F# tiene un tipo particular de coincidencia de patrón llamado "patrones activos"
    // donde el patrón puede ser analizado o detectado dinámicamente.

    // "clips de banana" es la sintaxis de los patrones activos

    // por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
    let (|Digito|Latra|EspacioEnBlanco|Otros|) ch =
       if System.Char.IsDigit(ch) then Digito
       else if System.Char.IsLetter(ch) then Letra
       else if System.Char.IsWhiteSpace(ch) then EspacioEnBlanco
       else Otros

    // ... y luego lo usamos para hacer que la lógica de análisis sea más clara
    let ImprimirCaracter ch =
      match ch with
      | Digito -> printfn "%c es un Digito" ch
      | Letra -> printfn "%c es una Letra" ch
      | Whitespace -> printfn "%c es un Espacio en blanco" ch
      | _ -> printfn "%c es algo mas" ch

    // ver una lista
    ['a';'b';'1';' ';'-';'c'] |> List.iter ImprimirCaracter

    // -----------------------------------------
    // FizzBuzz usando patrones activos
    // -----------------------------------------

    // Puede crear un patrón de coincidencia parcial también
    // Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
    let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None
    let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None

    // la función principal
    let fizzBuzz i =
      match i with
      | MultDe3 & MultDe5 -> printf "FizzBuzz, "
      | MultDe3 -> printf "Fizz, "
      | MultDe5 -> printf "Buzz, "
      | _ -> printf "%i, " i

    // prueba
    [1..20] |> List.iter fizzBuzz

// ================================================
// concisión
// ================================================

module EjemploDeAlgoritmo =

    // F# tiene una alta relación señal / ruido, lo que permite leer el código
    // casi como un algoritmo real

    // ------ Ejemplo: definir una función sumaDeCuadrados ------
    let sumaDeCuadrados n =
       [1..n]                   // 1) Tome todos los números del 1 al n
       |> List.map cuadrado     // 2) Elevar cada uno de ellos al cuadrado
       |> List.sum              // 3) Realiza su suma

    // prueba
    sumaDeCuadrados 100 |> printfn "Suma de cuadrados = %A"

    // ------ Ejemplo: definir una función de ordenación ------
    let rec ordenar lista =
       match lista with
       // Si la lista está vacía
       | [] ->
            []                              // devolvemos una lista vacía
       // si la lista no está vacía
       | primerElemento::otrosElementos ->  // tomamos el primer elemento
            let elementosMasPequenios =     // extraemos los elementos más pequeños
                otrosElementos              // tomamos el resto
                |> List.filter (fun e -> e < primerElemento)
                |> ordenar                  // y los ordenamos
            let elementosMasGrandes =       // extraemos el mas grande
                otrosElementos              // de los que permanecen
                |> List.filter (fun e -> e >= primerElemento)
                |> ordenar                  // y los ordenamos
            // Combinamos las 3 piezas en una nueva lista que devolvemos
            List.concat [elementosMasPequenios; [primerElemento]; elementosMasGrandes]

    // prueba
    ordenar [1;5;23;18;9;1;3] |> printfn "Ordenado = %A"

// ================================================
// Código asíncrono
// ================================================

module AsyncExample =

    // F# incluye características para ayudar con el código asíncrono
    // sin conocer la "pirámide del destino"
    //
    // El siguiente ejemplo descarga una secuencia de página web en paralelo.

    open System.Net
    open System
    open System.IO
    open Microsoft.FSharp.Control.CommonExtensions

    // Recuperar el contenido de una URL de forma asincrónica
    let extraerUrlAsync url =
        async {   // La palabra clave "async" y llaves
                  // crear un objeto "asincrónico"
            let solicitud = WebRequest.Create(Uri(url))
            use! respuesta = solicitud.AsyncGetResponse()
                // use! es una tarea asincrónica
            use flujoDeDatos = resp.GetResponseStream()
                // "use" dispara automáticamente la funcion close()
                // en los recursos al final de las llaves
            use lector = new IO.StreamReader(flujoDeDatos)
            let html = lector.ReadToEnd()
            printfn "terminó la descarga %s" url
            }

    // una lista de sitios para informar
    let sitios = ["http://www.bing.com";
                 "http://www.google.com";
                 "http://www.microsoft.com";
                 "http://www.amazon.com";
                 "http://www.yahoo.com"]

    // ¡Aqui vamos!
    sitios
    |> List.map extraerUrlAsync // crear una lista de tareas asíncrona
    |> Async.Parallel           // decirle a las tareas que se desarrollan en paralelo
    |> Async.RunSynchronously   // ¡Empieza!

// ================================================
// Compatibilidad .NET
// ================================================

module EjemploCompatibilidadNet =

    // F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta
    // perfectamente con bibliotecas .NET o Mono.

    // ------- Trabaja con las funciones de las bibliotecas existentes  -------

    let (i1success,i1) = System.Int32.TryParse("123");
    if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida"

    // ------- Implementar interfaces sobre la marcha! -------

    // Crea un nuevo objeto que implemente IDisposable
    let crearRecurso name =
       { new System.IDisposable
         with member this.Dispose() = printfn "%s creado" name }

    let utilizarYDisponerDeRecursos =
        use r1 = crearRecurso "primer recurso"
        printfn "usando primer recurso"
        for i in [1..3] do
            let nombreDelRecurso = sprintf "\tinner resource %d" i
            use temp = crearRecurso nombreDelRecurso
            printfn "\thacer algo con %s" nombreDelRecurso
        use r2 = crearRecurso "segundo recurso"
        printfn "usando segundo recurso"
        printfn "hecho."

    // ------- Código orientado a objetos -------

    // F# es también un verdadero lenguaje OO.
    // Admite clases, herencia, métodos virtuales, etc.

    // interfaz de tipo genérico
    type IEnumerator<'a> =
        abstract member Actual : 'a
        abstract MoverSiguiente : unit -> bool

    // Clase base abstracta con métodos virtuales
    [<AbstractClass>]
    type Figura() =
        // propiedades de solo lectura
        abstract member Ancho : int with get
        abstract member Alto : int with get
        // método no virtual
        member this.AreaDelimitadora = this.Alto * this.Ancho
        // método virtual con implementación de la clase base
        abstract member Imprimir : unit -> unit
        default this.Imprimir () = printfn "Soy una Figura"

    // clase concreta que hereda de su clase base y sobrecarga
    type Rectangulo(x:int, y:int) =
        inherit Figura()
        override this.Ancho = x
        override this.Alto = y
        override this.Imprimir ()  = printfn "Soy un Rectangulo"

    // prueba
    let r = Rectangulo(2,3)
    printfn "La anchura es %i" r.Ancho
    printfn "El area es %i" r.AreaDelimitadora
    r.Imprimir()

    // ------- extensión de método  -------

    // Al igual que en C#, F# puede extender las clases existentes con extensiones de método.
    type System.String with
       member this.EmpiezaConA = this.EmpiezaCon "A"

    // prueba
    let s = "Alice"
    printfn "'%s' empieza con una 'A' = %A" s s.EmpiezaConA

    // ------- eventos -------

    type MiBoton() =
        let eventoClick = new Event<_>()

        [<CLIEvent>]
        member this.AlHacerClick = eventoClick.Publish

        member this.PruebaEvento(arg) =
            eventoClick.Trigger(this, arg)

    // prueba
    let miBoton = new MiBoton()
    miBoton.AlHacerClick.Add(fun (sender, arg) ->
            printfn "Haga clic en el evento con arg=%O" arg)

    miBoton.PruebaEvento("Hola Mundo!")
```

## Más información

Para más demostraciones de F#, visite el sitio [Try F#](http://www.tryfsharp.org/Learn), o sigue la serie [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).

Aprenda más sobre F# en [fsharp.org](http://fsharp.org/).