Edición de «F Sharp»

{{título erróneo|F#}}
[[Archivo:F Sharp logo.svg|miniaturadeimagen|Logo o representación gráfica del F#]]
'''F#''' (pronunciado '''F Sharp''' en inglés) es un [[lenguaje de programación multiparadigma]] de [[código abierto]],<ref>{{Cita web
| url = http://blogs.msdn.com/b/fsharpteam/archive/2012/09/24/announcing-the-f-3-0-open-source-code-drop.aspx | título = 
Announcing the F# 3.0 Open Source Code Drop | autor = dsyme | fechaacceso = 24 de septiembre de 2012}}</ref> para la [[.NET|plataforma
.NET]], que conjunta la [[programación funcional]] con las disciplinas [[programación imperativa|imperativa]] y 
[[programación orientada a objetos|orientada a objetos]]. Es una variante del lenguaje de programación [[ML (lenguaje de programación)|ML]] y es compatible
con la implementación [[Ocaml|Objective Caml]]. F# fue inicialmente desarrollado por Don Syme de [[Microsoft Research]], pero
actualmente está siendo desarrollado por la División de Desarrolladores de [[Microsoft]] y es distribuido como un lenguaje
totalmente soportado en la [[.NET|plataforma .NET]] y [[Microsoft Visual Studio|Visual Studio 2010, 2012, 2013, 2015 y 2017]].<ref>{{Cita web | url =
http://blogs.msdn.com/somasegar/archive/2007/10/17/f-a-functional-programming-language.aspx | título = F# - A functional
Programming Language | autor = S. Somasegar | fechaacceso = 18 de octubre de 2007}}</ref>

F# es un lenguaje fuertemente tipado que utiliza inferencia de tipos. Como resultado, los tipos no necesitan estar
declarados explícitamente por el programador; estos serán deducidos por el compilador durante el proceso de compilación. Sin
embargo, F# también permite la declaración explícita de tipos de datos. Por ser un lenguaje .NET, F# soporta los objetos y tipos de .NET; F# permite al programador programar de una manera que se asemeja más a como pensamos. Por ejemplo: en la cafetería para pedir un café, nosotros generalmente no le decimos al mesero exactamente los pasos para hacer el café, solo pedimos un café con ciertas características. De tal forma que tenemos menos espacio para cometer errores, porque simplemente escribimos menos código. También facilita enormemente la creación de código asincrónico y paralelo, cosa que en otros lenguajes de .NET nos llevaría mucho más tiempo.

== General ==

=== Programación Funcional ===
F# es un lenguaje de programación primeramente funcional, fuertemente tipado, que usa la inferencia de tipos. Los tipos no
necesitan ser explícitamente declarados por el programador; serán deducidos en proceso de compilación. F# también permite 
notaciones explícitas de tipos y requiere de esto en algunas situaciones. F# es un lenguaje de expresiones basadas en evaluación impaciente. Las funciones y expresiones que no retornan ningún valor tienen como tipo de retorno <code>unit</code>. F# usa la palabra clave <code>let</code> para enlazar valores a nombres. Por ejemplo:

<syntaxhighlight lang="fsharp">
let x = 3 + 4
</syntaxhighlight>
enlaza el valor <code>7</code> al nombre <code>x</code>.

Nuevos tipos son definidos usando la palabra clave <code>type</code>. Para una programación funcional, F# provee los tipos 
''tuple'', ''record'', ''discriminated union'', ''list'' y ''option''. Una ''[[n-tuple|tupla]]'' representa una colección de 
''n'' valores. El valor ''n'' es llamado la [[aridad]] de la tupla. Una 3-tuple podría ser representado como <code>(A, B, C)</code>, donde A, B y C son valores con posiblemente diferentes tipos. Una tupla puede ser usada solamente para almacenar 
valores cuando el número de valores es conocido en tiempo de diseño y permanece constante durante la ejecución. 

Un ''record'' es un tipo donde los datos son nombrados, por ejemplo: <code>{ Name:string; Age:int }</code>. Los récords 
pueden ser creados como <code>{ Name="AB"; Age=42 }</code>. La palabra clave <code>with</code> es usada para crear una copia 
de un récord, por ejemplo: <code>{ r with Name="CD" }</code>, el cual crea un nuevo récord copiando <code>r</code> y 
cambiando el valor del campo <code>Name</code> (asumiendo que el récord creado en el ejemplo anterior fue nombrado 
<code>r</code>).

Un tipo [[tagged union|discriminated union]] es un [[type-safe]] versión de [[union (computer science)|las uniones de C]]. 

Por ejemplo: 
<syntaxhighlight lang="fsharp">
 type A = 
    | UnionCaseX of string
    | UnionCaseY of int
</syntaxhighlight>
Los valores de la unión pueden corresponder a cualquiera de los dos casos de unión. Los tipos de los valores de cada caso de 
unión es incluido en la definición de cada caso. El tipo ''list'' es una [[linked list|lista enlazada]] inmutable representada usando la notación <code>head::tail</code> (<code>::</code> el operador [[cons]]) o de forma de encabezado corto <code>[item1; item2; item3]</code>. Una lista vacía se denota como <code>[]</code>. El tipo ''option'' es un tipo de unión discriminada con elección <code>Some(x)</code> o <code>None</code>. Los tipos de F# pueden ser [[generic programming|genéricos]], implementado como tipos genéricos de .NET. 

F# soporta [[lambda calculus|funciones lambda]] y [[closure (computing)|clausuras]]. Todas las funciones en F# son
inmutables. Las funciones pueden ser [[curry function|curried]]. Las funciones pueden ser pasadas como argumento a otras 
funciones. Como otros lenguajes de programación funcional, F# permite [[function composition|la composición de funciones]] 
usando el operador <code>>></code>.

F# provee ''expresiones de secuencia''<ref name="seq"/> que define una secuencia <code>seq { ... }</code>, lista <code>[ ... 

]</code> o array <code>[| ... |]</code> a través de código que genera valores. Por ejemplo:
<syntaxhighlight lang="fsharp">
 seq { for b in 0 .. 25 do 
           if b < 15 then 
               yield b*b }
</syntaxhighlight>
forma una secuencia de los cuadrados de los números de 0 a 14 filtrando afuera por los números que están en un rango de 0 a 
25. Las secuencias son generadas a medida que va haciendo falta (i.e. are [[lazy evaluation|evaluación lazy]]), mientras que 
las listas y arrays son evaluadas impacientemente. F# usa [[pattern matching]] para enlazar valores a nombres. Pattern matching es también usado cuando se está accediendo a uniones discriminadas. F# también soporta ''Active Patterns'' como un pattern matching extendido.<ref name="activePatterns" /> Este es usado, por ejemplo, cuando existen múltiples formas de matchear con un tipo. F# soporta una sintaxis general para la definición de composiciones llamado ''computation expressions''. Secuencias de expresiones, computaciones asíncronas y consultas son clases particulares de ''computation expressions''. "Computation expressions" son una implementación de [[monad (functional programming)|monad]] pattern.<ref name="seq">{{cita web | url = http://blogs.msdn.com/dsyme/archive/2007/09/22/some-details-on-f-computation-expressions-aka-monadic-or-workflow-syntax.aspx 

| título = Some Details on F# Computation Expressions | fechaacceso = 14 de diciembre de 2007}}</ref>

=== Programación Imperativa ===

F# soporta la programación imperativa e incluye
* <code>for</code> [[Control flow#Loops|ciclos]]
* <code>while</code> [[Control flow#Loops|ciclos]]
* [[array data structure|arrays]], creados con la sintaxis <code>[| ... |]</code>
* [[Associative array|hash table]], creado con la sintaxis <code>dict [ ... ]</code> o 

<code>System.Collections.Generic.Dictionary<_,_></code> type). 
Valores y campos de records también pueden ser etiquetados como <code>mutable</code>. Por ejemplo:
<syntaxhighlight lang="fsharp">
// Define 'x' con valor inicial '1'
let mutable x = 1
// Cambia el valor de 'x' a '3'
x <- 3
</syntaxhighlight>
También, F# soporta acceso a todos los tipos y objetos del CLI como los definidos en:

<code>System.Collections.Generic</code>.

=== Programación orientada a objetos ===

F# como recursos para programar orientado objetos incluye:
* dot-notation (e.g. <code>x.Name</code>)
* expresiones de objetos (e.g. <code>{ new obj() with member x.ToString() = "hello" }</code>)
* construcción de objetos (e.g. <code>new Form()</code>)
* tipos tests (e.g. <code>x :? string</code>)
* type coercions (e.g. <code>x :?> string</code>)
* argumentos (e.g. <code>x.Method(someArgument=1)</code>) 
* setters (e.g. <code>new Form(Text="Hello")</code>) 
* argumentos opcionales (e.g. <code>x.Method(OptionalArgument=1)</code>

En los patterns para programar con objetos se incluye:
* type tests (e.g. <code>:? string as s</code>) 
* active patterns, el cual puede ser definido sobre tipos de objetos.<ref name="activePatterns">{{cita web | url = 

http://www.developerfusion.com/article/133772/pattern-matching-in-f-part-2-active-patterns/ | título = Pattern Matching in F# 

Part 2 : Active Patterns | fechaacceso = 24 de noviembre de 2012}}</ref> 

Las definiciones de objetos en F# pueden ser clases, estructuras (struct), interfaz, enum o delegados, correspondiendo a las 
formas de definición encontradas en [[C Sharp|C#]]. Por ejemplo, aquí se muestra una clase con un 
constructor tomando un nombre y una edad, y declarando dos propiedades.
<syntaxhighlight lang="fsharp">
/// Una simple definición de tipo de objeto
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age
</syntaxhighlight>

=== Programación Asíncrona ===

F# soporta programación asíncrona a través de ''asynchronous workflows''.<ref name="aw"/> "Asynchronous workflow" es definido 
como una secuencia de comandos dentro de un <code>async{ ... }</code>, por ejemplo:
<syntaxhighlight lang="fsharp">
let asynctask = 
    async { let req = WebRequest.Create(url) 
            let! response = req.GetResponseAsync()
            use stream = response.GetResponseStream()
            use streamreader = new System.IO.StreamReader(stream)
            return streamreader.ReadToEnd() 
</syntaxhighlight>
El <code>let!</code> permite que el resto del bloque async pueda ser definido como un delegado y pasado como [[Callback (informática)]] de una operación asíncrona. Esto soluciona el problema de la [[inversion of 
control|inversión de control]].<ref name="aw"/> El bloque async es invocado usando la función <code>Async.RunSynchronously</code>. Múltiples bloques async son ejecutados en paralelo usando la función 
<code>Async.Parallel</code> que toma una lista de objetos <code>async</code> (en el ejemplo, <code>asynctask</code> es un 
objeto async) y crea otro objeto async para correr las tareas en las listas en paralelo. Luego, el objeto resultante es 
invocado usando <code>Async.RunSynchronously</code>.<ref name="aw">{{cita web | url = http://blogs.msdn.com/dsyme/archive/2007/10/11/introducing-f-asynchronous-workflows.aspx | título = Introducing F# Asynchronous Workflows | fechaacceso = 14 de diciembre de 2007}}</ref>

=== Programación en Paralelo ===

La programación en paralelo es soportada parcialmente a través de <code>Async.Parallel</code>, <code>Async.Start</code> y 
otras operaciones que corren bloques asíncronos en paralelo.

=== Meta-programación ===

F# permite algunas formas de [[metaprogramming|sintaxis personalizadas]] con el fin de darle soporte a un incrustamiento 
personalizado, particularmente a través de "computation expressions".

F# incluye un plugin para meta-programación en tiempo de ejecución llamado quotations.<ref name="quotations">{{cita web | url=http://msdn.microsoft.com/en-us/library/dd233212.aspx  | título = Code Quotations (F#) | fechaacceso = 24 de noviembre de 2012}}</ref> Una expresión quotation evalúa una representación de sintaxis abstracta de expresiones de F#. Una definición etiquetada con el atributo <code>[<ReflectedDefinition>]</code> puede también ser accedida de la forma quotation. Las F# quotations son usadas 
para varios propósitos incluyendo compilar código F# a [[JavaScript]] y [[Graphics processing unit|GPU]].

=== Information Rich ===

F# 3.0 introdujo una forma de meta-programación en tiempo de compilación a través de una generación de tipos estáticamente 
extensibles llamados F# type providers.<ref name="typeproviders">{{cita web | url = http://msdn.microsoft.com/en-us/library/hh156509.aspx | título = Type Providers | fechaacceso = 24 de noviembre de 2012}}</ref> F# type providers permite al compilador de F# y herramientas ser extendidas con componentes que proporcionan información de tipo al compilador. F# type providers ha sido usado para dar acceso a tipos fuertemente tipados para conectar el origen de la información en una manera escalable.<ref>{{cita web | url = http://blogs.msdn.com/b/dsyme/archive/2012/09/21/new-tech-report-from-microsoft-research-strongly-typed-language-support-for-internet-scale-information-sources.aspx | título = New Tech Report from Microsoft Research: Strongly-Typed Language Support for Internet-Scale Information Sources | fechaacceso = 24 de noviembre de 2012}}</ref>

En F# 3.0 el F# quotation y las computation expression son combinadas para implementar consultas [[LINQ]].<ref name="queries">{{cita web | url = http://msdn.microsoft.com/en-us/library/vstudio/hh225374.aspx | título = Query Expressions (F#) | fechaacceso = 24 de noviembre de 2012}}</ref> Por ejemplo:
<syntaxhighlight lang="fsharp">
// Usa el OData type provider para crear tipos que puedan ser usados para acceder a Northwind database.
open Microsoft.FSharp.Data.TypeProviders
type Northwind = ODataService<"http://services.odata.org/Northwind/Northwind.svc">
let db = Northwind.GetDataContext()

// A query expression.
let query1 = query { for customer in db.Customers do
                     select customer }
</syntaxhighlight>

La combinación de type providers, consultas y programación funcional fuertemente tipado es conocido como ''information rich
programming''.<ref name="irp">{{cita web | url = http://www.infoq.com/news/2011/09/Fsharp-3.0 | título = F# 3.0 – LINQ + Type
Providers = Information Rich Programming | fechaacceso = 24 de noviembre de 2012}}</ref>

=== Agente ===

F# soporta una variante del modelo de programación [[Actor model|Actor]] a través de la implementación en memoria de agentes 
asíncronos. Por ejemplo, el siguiente código define un agente y envía 2 mensajes: 
<syntaxhighlight lang="fsharp">
let counter =
    MailboxProcessor.Start(fun inbox ->
        let rec loop n =
            async { do printfn "n = %d, waiting..." n
                    let! msg = inbox.Receive()
                    return! loop(n+msg) }
        loop 0)
counter.Post(5);;
counter.Post(17);;
</syntaxhighlight>

== Herramientas de Desarrollo ==

F# puede ser desarrollado con cualquier editor de texto. Hay soportes específicos para él en varios editores, por ejemplo [[Emacs]].

La herramienta Visual F# de [[Microsoft]] incluye completa integración en el IDE [[Microsoft Visual Studio|Visual Studio]]. 
Con el servicio del lenguaje instalado, Visual Studio puede ser usado para crear proyectos de F# y el Visual Studio debugger 
usado para depurar código F#. Además las herramientas de Visual F# vienen con una consola interactiva que puede ser usada 
para ejecutar código F# como está siendo escrito. 

[[WebSharper]] es una plataforma para la utilización de JavaScript and HTML5.
[[MonoDevelop]] es un entorno de desarrollo integrado para Linux, Mac y Windows incluyendo soporte para una consola interactiva.
[[SharpDevelop]] soporta F# desde la versión 3.0.
[[LINQPad]] soporta F# desde la versión 2.X.

== Áreas de Aplicación ==

F# es un [[General-purpose programming language|lenguaje de propósito general]].

=== Programación Web ===

F# es usado en conjunto con ASP.NET, [[knockoutJS]] y otros frameworks del lado del servidor y del lado del cliente.<ref 
name="webstacks">{{cita web | url = http://fsharp.org/webstacks/ | título = Web Stacks for F# | fechaacceso = 24 de noviembre de 2012 | urlarchivo = https://web.archive.org/web/20130503040304/http://fsharp.org/webstacks/ | fechaarchivo = 3 de mayo de 2013 }}</ref> 

F# es una parte central del framework [[WebSharper]] donde el código F# es ejecutado como un código .NET en el servidor y 
como código [[JavaScript]] en el lado cliente.

=== Scripting ===

F# es sobre todo usado como un lenguaje de scripting, principalmente para escritorio.<ref>{{cita web | url = 
http://blogs.msdn.com/b/chrsmith/archive/2008/09/12/scripting-in-f.aspx | título = Scripting in F#| fechaacceso = 25 de noviembre de 2012}}</ref>

== Comunidad Código Abierto ==

La comunidad de código abierto de F# incluye la F# Software Foundation y la F# Open Source Group at GitHub.
== Ejemplos ==

Un corto y pequeño ejemplo:
<syntaxhighlight lang="fsharp">
// Esto es un comentario para el programa de ejemplo Hello World.
printfn "Hello World!"
</syntaxhighlight>

Una clase persona con un constructor que espera name, age y dos propiedades.
<syntaxhighlight lang="fsharp">
/// Este es el comentario para la documentacion de la definicion de un tipo
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age
</syntaxhighlight>

Un simple ejemplo que es sobre todo usado para demostrar la sintaxis de un lenguaje [[factorial function|funcional]]:
<syntaxhighlight lang="fsharp">
/// Este es el comentario para la documentación de una función
let rec factorial n =
    match n with
    | 0 -> 1
    | _ -> n * factorial (n - 1)
</syntaxhighlight>

Ejemplos de iteraciones:
<syntaxhighlight lang="fsharp">
/// Iteración usando un ciclo 'for'
let printList lst = 
    for x in lst do 
        printfn "%d" x

/// Iteración usando una función de alto nivel 
let printList2 lst = 
    List.iter (printfn "%d") lst

/// Iteración usando una función recursiva y pattern matching
let rec printList3 lst =
    match lst with 
    | [] -> ()
    | h :: t -> 
        printfn "%d" h
        printList3 t
</syntaxhighlight>

Ejemplos de Fibonacci:
<syntaxhighlight lang="fsharp">
/// Numero n de fibonacci
let rec fib n =
    match n with
    | 0 | 1 -> n
    | _ -> fib (n - 1) + fib (n - 2)

/// Otra aproximación, una secuencia lazy infinita de fibonacci 
let fibSeq = Seq.unfold (fun (a,b) -> Some(a+b, (b, a+b))) (1,1)

// Imprime los números de fibonacci pares 
[1 .. 10]
|> List.map fib
|> List.filter (fun n -> (n % 2) = 0)
|> printList

// Algunas cosas usando listas
[ for i in 1..10 do
    let r = fib i
    if r % 2 = 0 then yield r ]
|> printList
</syntaxhighlight>
Un ejemplo con Windows Forms:
<syntaxhighlight lang="fsharp">
// Abre la librería Windows Forms 
open System.Windows.Forms

// Crea una ventana y setea algunas propiedades 
let form = new Form(Visible=true, TopMost=true, Text="Welcome to F#")

// Crea una etiqueta para mostrar algún texto en el formulario 
let label =
    let x = 3 + (4 * 5)
    new Label(Text = sprintf "x = %d" x)

//Añade la etiqueta al formulario
form.Controls.Add(label)

// Finalmente, corre el formulario 
[<System.STAThread>]
Application.Run(form)
</syntaxhighlight>
Ejemplo de programación paralela asíncrona:
<syntaxhighlight lang="fsharp">
/// Detectando números primos
let isPrime (n:int) =
   let bound = int (sqrt (float n))
   seq {2 .. bound} |> Seq.forall (fun x -> n % x <> 0) 

// Usando async workflows 
let primeAsync n =
    async { return (n, isPrime n) }

/// Retornando primos entre m y n usando hilos
let primes m n =
    seq {m .. n}
        |> Seq.map primeAsync
        |> Async.Parallel
        |> Async.RunSynchronously
        |> Array.filter snd
        |> Array.map fst

// Corriendo una prueba 
primes 1000000 1002000
    |> Array.iter (printfn "%d")
</syntaxhighlight>

== Véase también ==
* [[C Sharp|C#]]
* [[Clojure]]
* [[Haskell]]
* [[Mono (software)|Mono]]
* [[ML (lenguaje de programación)|ML]]
* [[.NET Framework]]
* [[OCaml]]
* [[Python]]
* [[Scala (lenguaje de programación)|Scala]]

== Notas ==
{{listaref}}

== Referencias ==
* {{Cite document| first1=Don |last1=Syme |author1-link=Don Syme |first2=Adam |last2=Granicz |first3=Antonio|last3=Cisternino |title=Expert F# |year=2007 |publisher=[[Apress]]| ref=harv| postscript=<!--None-->}}
* {{Cite document| first1=Jon |last1=Harrop |title=Visual F# 2010 for Technical Computing |year=2010 |publisher=Flying Frog Consultancy| ref=harv| postscript=<!--None-->}}
* {{Cite document| first1=Robert |last1=Pickering |title=Foundations of F# |year=2007 |publisher=[[Apress]]| ref=harv|postscript=<!--None-->}}
* {{Cite document|first=Chris |last=Smith |title=Programming F# |year=2009|publisher=[[O'Reilly Media|O'Reilly]]|ref=harv|postscript=<!--None-->}}
* {{Cite document |first=Tomas |last=Petricek |title=Real World Functional Programming With Examples in F# and C# |year=2009|publisher=Manning Publications |ref=harv |postscript=<!--None-->}}
* [https://www.visualstudio.com/es/vs/whatsnew/ Microsoft inc. (2017). https://www.visualstudio.com/es/vs/whatsnew/]
* [https://web.archive.org/web/20170312195940/https://line.do/es/lenguajes-de-programacion/m9e/vertical Lenguajes de programación (2015). https://web.archive.org/web/20170312195940/https://line.do/es/lenguajes-de-programacion/m9e/vertical]

== Enlaces externos ==

* [http://fsharp.org The F# Software Foundation]
* [http://fsharp.github.io The F# Open Source Group at GitHub]
* [http://fsharp.net The Visual F# Developer Center] {{Wayback|url=http://fsharp.net/ |date=20081119161341 }}
* [https://web.archive.org/web/20121130163443/http://www.tryfsharp.org/ Try F#, for learning F# in your browser]
* [http://fssnip.net F# Snippets Site]
* [http://blogs.msdn.com/fsharpteam The Visual F# team blog]
* [http://research.microsoft.com/fsharp The original Microsoft Research website for F#]
* [http://feedproxy.google.com/planet_fsharp Planet F#] {{Wayback|url=http://feedproxy.google.com/planet_fsharp |date=20090213202656 }}
* [https://web.archive.org/web/20110715231625/http://www.ctocorner.com/fsharp/book/default.aspx The F# Survival Guide, Dec 2009 (Web-based book)]
* [http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html The F# 3.0 Language Specification]
* [http://www.developerfusion.com/article/122079/intro-to-f/ An introduction to F# programming]

{{Control de autoridades}}
[[Categoría:Plataforma .NET]]
[[Categoría:Lenguajes de programación multiparadigma]]
[[Categoría:Código abierto]]
[[Categoría:Software que utiliza la licencia Apache]]