F Sharp (lenguaje de programación)

No confundir con F (lenguaje de programación) o F * (lenguaje de programación) .

Lenguaje de programación de Microsoft

El título correcto de este artículo es F # . La sustitución del # se debe a restricciones técnicas .

F#

F # logomark
Paradigma	Multi-paradigma : funcional , imperativo , orientado a objetos , metaprogramación , reflexivo , concurrente
Familia	ML
Diseñada por	Don Syme , investigación de Microsoft
Desarrollador	Microsoft , la Fundación de software F #
Apareció por primera vez	2005 ; Hace 16 años , versión 1.0 ( 2005 )
Lanzamiento estable	5.0 [1]  / 10 de noviembre de 2020 ; Hace 10 meses (10 November 2020)
Versión de vista previa	5.0 vista previa / 2 de abril de 2019 ; Hace 2 años [2] (2019-04-02)
Disciplina de mecanografía	Estático , fuerte , inferido
SO	Multiplataforma : .NET , .NET Framework , Mono
Licencia	Licencia MIT [3] [4]
Extensiones de nombre de archivo	.fs, .fsi, .fsx, .fsscript
Sitio web	fsharp .org
Influenciado por
C # , Erlang , Haskell , [5] ML , OCaml , [6] [7] Python , Scala
Influenciado
C # , [8] Elm , F * , LiveScript
Programación de F Sharp en Wikilibros

F # (pronunciado fa sostenido ) es un funcional-en primer lugar, de uso general, inflexible , multi-paradigma de lenguaje de programación que abarca funcional , imperativa y programación orientada a objetos métodos. F # se usa con mayor frecuencia como un lenguaje de Common Language Infrastructure (CLI) multiplataforma en .NET , pero también puede generar JavaScript ^[9] y código de unidad de procesamiento de gráficos (GPU). ^[10]

F # es desarrollado por F # Software Foundation , ^[11] Microsoft y colaboradores abiertos. Un compilador multiplataforma de código abierto para F # está disponible en F # Software Foundation. ^[12] F # es un lenguaje totalmente compatible con Visual Studio ^[13] y JetBrains Rider . ^[14] Existen plug-ins que soportan F # para muchos editores ampliamente utilizados, más notablemente la extensión Ionide para Visual Studio Code , e integraciones para otros editores como Vim y Emacs .

F # es un miembro de la familia de lenguajes ML y se originó como una implementación de .NET Framework de un núcleo del lenguaje de programación OCaml . ^{[6] [7]} También ha sido influenciado por C # , Python , Haskell , ^[5] Scala y Erlang .

Historia

Versiones

En el transcurso de su desarrollo, el lenguaje ha pasado por varias versiones:

Versión	Especificación de idioma	Fecha	Plataformas	Tiempo de ejecución
F # 1.x		Mayo de 2005 [15]	Ventanas	.NET 1.0 - 3.5
F # 2.0	Agosto de 2010	Abril de 2010 [16]	Linux , macOS , Windows	.NET 2.0 - 4.0, Mono
F # 3.0	Noviembre 2012	Agosto de 2012 [17]	Linux , macOS , Windows ; JavaScript , [9] GPU [10]	.NET 2.0 - 4.5, Mono
F # 3.1	Noviembre de 2013	Octubre de 2013 [18]	Linux , macOS , Windows ; JavaScript , [9] GPU [10]	.NET 2.0 - 4.5, Mono
F # 4.0	Enero de 2016	Julio de 2015 [19]
F # 4.1	Mayo de 2018	Marzo de 2017 [20]	Linux , macOS , Windows , JavaScript , [9] GPU [10]	.NET 3.5 - 4.6.2, .NET Core , Mono
F # 4.5		Agosto de 2018 [21]	Linux , macOS , Windows , JavaScript , [9] GPU [10]	.NET 4.5 - 4.7.2, [22] .NET Core SDK 2.1.400 [23]
F # 4.6		Marzo de 2019 [24]	Linux , macOS , Windows , JavaScript , [9] GPU [10]	.NET 4.5 - 4.7.2, [25] .NET Core SDK 2.2.300 [26]
F # 4.7		Septiembre de 2019 [27]	Linux , macOS , Windows , JavaScript , [9] GPU [10]	.NET 4.5 - 4.8, [28] .NET Core SDK 3.0.100 [29]
F # 5.0		Noviembre de 2020 [30]	Linux , macOS , Windows , JavaScript , [9] GPU [10]	.NET SDK 5.0.100 [31]

Evolución del lenguaje

F # utiliza un proceso de ingeniería y desarrollo abierto. El proceso de evolución del lenguaje es administrado por Don Syme de Microsoft Research como el dictador benevolente de por vida (BDFL) para el diseño del lenguaje, junto con la F # Software Foundation. Microsoft y Microsoft Research diseñaron versiones anteriores del lenguaje F # mediante un proceso de desarrollo cerrado.

F # se origina en Microsoft Research , Cambridge, Reino Unido. El lenguaje fue diseñado e implementado originalmente por Don Syme , ^[6] según quien en el equipo de fsharp, dicen que la F es para "Diversión". ^[32] Andrew Kennedy contribuyó al diseño de unidades de medida . ^[6] Microsoft ha desarrollado Visual F # Tools para Visual Studio. ^[6] La F # Software Foundation desarrolló el compilador y las herramientas de código abierto de F #, incorporando la implementación del compilador de código abierto proporcionada por el equipo de Microsoft Visual F # Tools. ^[11]

Resumen de versiones

	Funciones agregadas
F # 1.0	Programación funcional Sindicatos discriminados Registros Tuplas La coincidencia de patrones Abreviaturas de tipo Programación orientada a objetos Estructuras Archivos de firmas Archivos de secuencias de comandos Programación imperativa Módulos (sin functores) Módulos anidados Interoperabilidad .NET
F # 2.0	Patrones activos Unidades de medida Expresiones de secuencia Programación asincrónica Programación de agentes Miembros de extensión Argumentos nombrados Argumentos opcionales Rebanado de matriz Citas Interoperabilidad nativa Expresiones de computación
F # 3.0 [33]	Proveedores de tipos Expresiones de consulta LINQ Atributo CLIMutable Cuerdas entre comillas triples Auto-propiedades Unidades de medida proporcionadas
F # 3.1 [34]	Campos de tipo de unión con nombre Extensiones a la división de matrices Mejoras en la inferencia de tipos
Fa # 4.0 [35]	Printf en valores unificados Inicializadores de propiedades de extensión Tipos proporcionados no nulos Constructores primarios como funciones Parámetros estáticos para los métodos proporcionados Interpolación de printf Gramática extendida #if Atributo Tailcall Múltiples instancias de interfaz Args de tipo opcional Diccionarios de parámetros
F # 4.1 [36]	Estructurar tuplas que interactúan con tuplas de C # Estructura de anotaciones para registros Anotaciones de estructura para sindicatos discriminados de caso único Guiones bajos en literales numéricos Atributos del argumento de información de la persona que llama Tipo de resultado y algunas funciones de resultado básicas Tipos y módulos mutuamente referenciales dentro del mismo archivo Sintaxis de "módulo" implícita en módulos con nombre compartido como tipo Devoluciones de Byref, que admiten el consumo de métodos de devolución de referencias de C # Mejoras en los mensajes de error Soporte para 'fijo'
Fa # 4.5 [30]	Alineación de versiones de binario, paquete e idioma Soporte para 'Span <T>' y tipos relacionados Capacidad para producir devoluciones 'byref' El tipo 'voidptr' Los tipos 'inref <' T> 'y' outref <'T>' para representar los byref de solo lectura y solo escritura Estructuras 'IsByRefLike' Estructuras 'IsReadOnly' Soporte de método de extensión para 'byref <' T> '/' inref <'T>' / 'outref <' T> ' '¡fósforo!' palabra clave en expresiones de cálculo Upcast relajado con 'rendimiento' en expresiones de F # seq / list / array Sangría relajada con expresiones de lista y matriz Casos de enumeración emitidos como públicos
Fa # 4.7 [37]	Rendimientos implícitos No más subrayado doble requerido Relajaciones de sangría para parámetros pasados ​​a constructores y métodos estáticos función 'nombre de' Clases estáticas abiertas
F # 5.0 [38]	FSharp.Core ahora apunta únicamente a netstandard2.0 Referencias de paquetes en scripts de F # Soporte para portátiles Jupyter, nteract y VSCode Interpolación de cadenas Soporte para nameof Declaraciones de tipo abierto Rebanado mejorado Mejoras en las cotizaciones de F # Expresiones de cálculo aplicativo Seguimiento de pila mejorado en F # async y otras expresiones de cálculo Interoperabilidad de .NET mejorada Rendimiento mejorado de mapas y conjuntos en FSharp.Core Rendimiento del compilador mejorado Análisis de compilador mejorado para autores de bibliotecas

Descripción general del idioma

Programación funcional

F # es un lenguaje de programación funcional. Esto significa que en F # las funciones se enfatizan más que los objetos y la estructura y otras construcciones de programación tradicionales. F # es un lenguaje funcional primero fuertemente tipado que usa inferencia de tipos . F # también permite anotaciones de tipo explícitas y las requiere en algunas situaciones.

F # es un lenguaje basado en expresiones que utiliza una evaluación entusiasta y, en algunos casos, una evaluación perezosa . Cada declaración en F #, incluidas las ifexpresiones, las tryexpresiones y los bucles, es una expresión componible con un tipo estático. ^{[39] Las} funciones y expresiones que no devuelven ningún valor tienen un tipo de retorno de unit. F # usa la letpalabra clave para vincular valores a un nombre. ^[39] Por ejemplo:

sea  x  =  3  +  4

une el valor 7al nombre x.

Los nuevos tipos se definen mediante la typepalabra clave. Para la programación funcional, F # proporciona tipos de tupla , registro , unión discriminada , lista , opción y resultado . ^[39] Una tupla representa un conjunto de n valores, donde n ≥ 0. El valor n se denomina aridad de la tupla. Una tupla de 3 se representaría como (A, B, C), donde A, B y C son valores de tipos posiblemente diferentes. Una tupla puede usarse para almacenar valores solo cuando el número de valores se conoce en tiempo de diseño y permanece constante durante la ejecución.

Un registro es un tipo en el que se nombran los miembros de datos. A continuación, se muestra un ejemplo de definición de registro:

 escriba  R  =  {  Nombre  :  cadena  Edad  :  int  }

Los registros se pueden crear como archivos . La palabra clave se usa para crear una copia de un registro, como en , que crea un nuevo registro copiando y cambiando el valor del campo (asumiendo que se nombró el registro creado en el último ejemplo ).let r = { Name="AB"; Age=42 }with{ r with Name="CD" }rNamer

Una unión discriminada tipo es un tipo seguro versión de uniones C . Por ejemplo,

 tipo  A  =  |  UnionCaseX  de  cadena  |  UnionCaseY  de  int

Los valores del tipo de unión pueden corresponder a cualquier caso de unión. Los tipos de valores que lleva cada caso de unión se incluyen en la definición de cada caso.

El tipo de lista es una lista enlazada inmutable representada mediante una notación ( es el operador contras ) o una abreviatura como . Se escribe una lista vacía . El tipo de opción es un tipo de unión discriminada con opciones o . Los tipos de F # pueden ser genéricos , implementados como tipos .NET genéricos.head::tail::[item1; item2; item3][]Some(x)None

F # admite funciones y cierres lambda . ^[39] Todas las funciones en F # son valores de primera clase y son inmutables. ^{[39] Las} funciones se pueden cursar . Al ser valores de primera clase, las funciones se pueden pasar como argumentos a otras funciones. Al igual que otros lenguajes de programación funcional, F # permite la composición de funciones (informática) utilizando los operadores >>y <<.

F # proporciona expresiones de secuencia ^[40] que definen una secuenciaseq { ... }, lista[ ... ]o matriz[| ... |]mediante código que genera valores. Por ejemplo,

 seq  {  para  b  en  0  ..  25  hacer  si  b  <  15  entonces  produce  b * b  }

forma una secuencia de cuadrados de números del 0 al 14 al filtrar los números del rango de números del 0 al 25. Las secuencias son generadores : los valores se generan a pedido (es decir, se evalúan con pereza ), mientras que las listas y las matrices se evalúan con entusiasmo .

F # usa la coincidencia de patrones para vincular valores a nombres. La coincidencia de patrones también se utiliza al acceder a uniones discriminadas: el valor de la unión se compara con las reglas de patrón y se selecciona una regla cuando una coincidencia tiene éxito. F # también admite Patrones activos como una forma de coincidencia de patrones extensible. ^[41] Se utiliza, por ejemplo, cuando existen múltiples formas de emparejar un tipo. ^[39]

F # admite una sintaxis general para definir cálculos de composición llamados Expresiones de cálculo . Las expresiones de secuencia, los cálculos asincrónicos y las consultas son tipos particulares de expresiones de cálculo. Las expresiones de cálculo son una implementación delpatrón demónadas. ^[40]

Programación imperativa

El soporte de F # para programación imperativa incluye

• for bucles
• while bucles
• matrices , creadas con la [| ... |]sintaxis
• tabla hash , creada con la dict [ ... ]sintaxis o el System.Collections.Generic.Dictionary<_,_>tipo.

Los valores y campos de registro también se pueden etiquetar como mutable. Por ejemplo:

// Definir 'x' con el valor inicial '1' let  mutable  x  =  1 // Cambiar el valor de 'x' a '3' x  <-  3

Además, F # admite el acceso a todos los tipos y objetos de CLI, como los definidos en el System.Collections.Genericespacio de nombres que definen estructuras de datos imperativas.

Programación orientada a objetos

Al igual que otros lenguajes de Common Language Infrastructure (CLI), F # puede usar tipos de CLI a través de la programación orientada a objetos. ^{[39] El} soporte de F # para la programación orientada a objetos en expresiones incluye:

• Notación de puntos, p. Ej., x.Name
• Expresiones de objeto, p. Ej., { new obj() with member x.ToString() = "hello" }
• Construcción de objetos, p. Ej., new Form()
• Pruebas de tipo, por ejemplo, x :? string
• Coacciones de tipo, por ejemplo, x :?> string
• Argumentos con nombre, p. Ej., x.Method(someArgument=1)
• Establecedores nombrados, por ejemplo, new Form(Text="Hello")
• Argumentos opcionales, por ejemplo, x.Method(OptionalArgument=1)

El soporte para la programación orientada a objetos en patrones incluye

• Pruebas de tipo, por ejemplo, :? string as s
• Patrones activos, que se pueden definir sobre tipos de objetos ^[41]

Las definiciones de tipo de objeto de F # pueden ser definiciones de clase, estructura, interfaz, enumeración o tipo delegado, correspondientes a las formas de definición que se encuentran en C # . Por ejemplo, aquí hay una clase con un constructor que toma un nombre y una edad y declara dos propiedades.

/// Una definición de tipo de  objeto simple tipo Persona ( nombre  :  cadena ,  edad  :  int )  =  miembro  x . Nombre  =  nombre del  miembro  x . Edad  =  edad

Programación asincrónica

F # admite la programación asincrónica a través de flujos de trabajo asincrónicos . ^[42] Un flujo de trabajo asincrónico se define como una secuencia de comandos dentro de un async{ ... }, como en

let  asynctask  =  async  {  let  req  =  WebRequest . Crear ( url )  ¡déjelo!  respuesta  =  req . GetResponseAsync ()  usa  stream  =  response . GetResponseStream ()  usa  streamreader  =  new  System . IO . StreamReader ( stream )  return  streamreader . ReadToEnd ()  }

El let!indica que la expresión de la derecha (obtener la respuesta) debe realizarse de forma asincrónica, pero el flujo solo debe continuar cuando el resultado esté disponible. En otras palabras, desde el punto de vista del bloque de código, es como si obtener la respuesta fuera una llamada de bloqueo, mientras que desde el punto de vista del sistema, el hilo no se bloqueará y puede usarse para procesar otros flujos. mientras que el resultado necesario para este no está disponible.

El bloque asincrónico se puede invocar utilizando la Async.RunSynchronouslyfunción. Se pueden ejecutar varios bloques asíncronos en paralelo usando la Async.Parallelfunción que toma una lista de asyncobjetos (en el ejemplo, asynctaskes un objeto asíncrono) y crea otro objeto asíncrono para ejecutar las tareas en las listas en paralelo. El objeto resultante se invoca mediante Async.RunSynchronously. ^{[42] La} inversión de control en F # sigue este patrón. ^[42]

Programación paralela

La programación en paralelo se admite en parte a través de Async.Parallel, Async.Starty otras operaciones que ejecutan bloques asincrónicos en paralelo.

La programación paralela también es compatible a través de los Array.Paralleloperadores de programación funcional en la biblioteca estándar de F #, el uso directo del System.Threading.Tasksmodelo de programación de tareas, el uso directo del grupo de subprocesos .NET y subprocesos .NET y a través de la traducción dinámica del código F # a motores de ejecución paralelos alternativos como Código GPU ^[10] .

Unidades de medida

El sistema de tipo F # admite unidades de medida para verificar números. ^[43] La función de unidades de medida se integra con la inferencia de tipo F # para requerir anotaciones de tipo mínimas en el código de usuario. ^[44]

Metaprogramación

F # permite algunas formas de personalización de sintaxis a través de la metaprogramación para admitir la incorporación de lenguajes específicos de dominio personalizados dentro del lenguaje F #, particularmente a través de expresiones de cálculo. ^[39]

F # incluye una función para la metaprogramación en tiempo de ejecución llamada citas. ^[45] Una expresión de comillas se evalúa como una representación de árbol de sintaxis abstracta de las expresiones de F #. De manera similar, [<ReflectedDefinition>]también se puede acceder a las definiciones etiquetadas con el atributo en su forma de cotización. Las citas de F # se utilizan para varios propósitos, incluso para compilar código F # en código JavaScript ^[9] y GPU ^[10] . (Las citas representan sus expresiones de código F # como datos para su uso por otras partes del programa, al tiempo que requieren que sea un código F # sintácticamente correcto).

Programación rica en información

F # 3.0 introdujo una forma de metaprogramación en tiempo de compilación a través de la generación de tipo extensible estáticamente denominada proveedores de tipo F #. ^{[46] Los} proveedores de tipos de F # permiten que el compilador de F # y las herramientas se amplíen con componentes que proporcionan información de tipo al compilador bajo demanda en el momento de la compilación. Los proveedores de tipo F # se han utilizado para brindar acceso fuertemente tipado a fuentes de información conectadas de una manera escalable, incluido el gráfico de conocimiento de Freebase . ^[47]

En F # 3.0, las funciones de expresión de cálculo y citas de F # se combinan para implementar consultas LINQ . ^[48] Por ejemplo:

// Utilice el proveedor de tipos de OData para crear tipos que se puedan utilizar para acceder a la base de datos Northwind. abrir  Microsoft.FSharp.Data.TypeProvidersescriba  Northwind  =  ODataService < "http://services.odata.org/Northwind/Northwind.svc" > let  db  =  Northwind . GetDataContext ()// Una expresión de consulta. deje  query1  =  query  {  para el  cliente  en  db . Los clientes  no  seleccionar  al cliente  }

La combinación de proveedores de tipos, consultas y programación funcional fuertemente tipada se conoce como programación rica en información . ^[49]

Programación de agentes

F # admite una variación del modelo de programación Actor a través de la implementación en memoria de agentes asincrónicos ligeros. Por ejemplo, el siguiente código define un agente y publica 2 mensajes:

dejar  contador  =  MailboxProcessor . Iniciar ( bandeja de entrada divertida  -> let rec loop n = async { do printfn "n =% d, esperando ..." n let! Msg = inbox . Receive () return ! Loop ( n + msg ) } loop 0 )                     

Herramientas de desarrollo

• Visual Studio , con las herramientas de Visual F # de Microsoft instaladas, se puede utilizar para crear, ejecutar y depurar proyectos de F #. Las herramientas de Visual F # incluyen una consola interactiva de bucle de lectura-evaluación-impresión (REPL) alojada en Visual Studio que puede ejecutar código F # tal como está escrito. Visual Studio para Mac también es totalmente compatible con proyectos de F #.
• Visual Studio Code contiene soporte completo para F # a través de la extensión Ionide .
• F # se puede desarrollar con cualquier editor de texto. Existe soporte específico en editores como Emacs .
• JetBrains Rider está optimizado para el desarrollo de F # Code a partir de la versión 2019.1. ^[50]
• LINQPad es compatible con F # desde la versión 2.x.

Áreas de aplicación

F # es un lenguaje de programación de propósito general .

Programación web

El SAFE Pila es un F # pila de extremo a extremo para desarrollar aplicaciones web. Utiliza ASP.NET Core en el lado del servidor y Fable en el lado del cliente. ^[51]

Una opción alternativa de F # de extremo a extremo es el marco WebSharper . ^[52]

Desarrollo de aplicaciones multiplataforma

F # se puede usar junto con Visual Studio Tools para Xamarin para desarrollar aplicaciones para iOS y Android . La biblioteca Fabulous proporciona una interfaz funcional más cómoda.

Programación analítica

Entre otros, F # se utiliza para programación financiera cuantitativa, ^[53] comercio de energía y optimización de carteras, ^[54] aprendizaje automático, ^[55] inteligencia empresarial ^[56] y juegos sociales en Facebook . ^[57]

En la década de 2010, F # se ha posicionado como una alternativa optimizada a C # . La capacidad de secuencia de comandos de F # y la compatibilidad entre idiomas con todos los productos de Microsoft lo han hecho popular entre los desarrolladores. ^[58]

Scripting

F # se puede utilizar como lenguaje de secuencias de comandos, principalmente para secuencias de comandos de bucle de lectura, evaluación e impresión (REPL) de escritorio . ^[59]

Comunidad de código abierto

La comunidad de código abierto de F # incluye F # Software Foundation ^[11] y el Grupo de código abierto de F # en GitHub . ^[12] Entre los proyectos populares de código abierto de F # se incluyen:

• Fable , un transpiler de F # a Javascript basado en Babel .
• Paket , un administrador de paquetes alternativo para .NET que aún puede usar repositorios NuGet , pero tiene una administración de versiones centralizada.
• FAKE , un sistema de compilación compatible con F #.
• Giraffe , un middleware funcionalmente orientado para ASP.NET Core .
• Suave , un servidor web ligero y una biblioteca de desarrollo web.

Compatibilidad

F # presenta un "modo de compatibilidad ML" heredado que puede compilar directamente programas escritos en un gran subconjunto de OCaml de forma aproximada, sin functores, objetos, variantes polimórficas u otras adiciones.

Ejemplos de

A continuación se muestran algunas pequeñas muestras:

// Este es un comentario para un programa de muestra de Hello World. printfn  "¡Hola mundo!"

Una clase Person con un constructor que toma un nombre y una edad y dos propiedades inmutables.

/// Este es un comentario de documentación para una definición de tipo. tipo  Persona ( nombre  :  cadena ,  edad  :  int )  =  miembro  x . Nombre  =  nombre del  miembro  x . Edad  =  edad /// instanciación de clase let  mrSmith  =  Person ( "Smith" ,  42 )

Un ejemplo simple que se usa a menudo para demostrar la sintaxis de los lenguajes funcionales es la función factorial para enteros de 32 bits no negativos, que se muestra aquí en F #:

/// Usando la expresión de coincidencia de patrones, deje  rec  factorial  n  =  emparejar  n  con  |  0  ->  1  |  _  ->  n  *  factorial  ( n  -  1 )/// Para las funciones de un solo argumento hay azúcar sintáctico (función de coincidencia de patrones): let  rec  factorial  =  function  |  0  ->  1  |  n  ->  n  *  factorial  ( n  -  1 ) /// Usando el operador de pliegue y rango, sea  factorial  n  =  [ 1 .. n ]  |>  Seq . pliegue  (*)  1

Ejemplos de iteraciones:

/// iteración utilizando un 'para' bucle dejó  printList  lst  =  para  x  en  lst  no  printfn  "% d"  x/// La iteración utilizando una función de orden superior vamos  printList2  LST  =  Lista . iter  ( printfn  "% d" )  lst/// La iteración utilizando una función recursiva y el patrón coincidente dejar que  rec  printList3  LST  =  partido  LST  con  |  []  ->  ()  |  h  ::  t  ->  printfn  "% d"  h  printList3  t

Ejemplos de Fibonacci:

/// Fórmula del número de Fibonacci let  fib  n  =  let  rec  g  n  f0  f1  =  emparejar  n  con  |  0  ->  f0  |  1  ->  f1  |  _  ->  g  ( n  -  1 )  f1  ( f0  +  f1 )  g  n  0  1/// Otro enfoque: una secuencia infinita perezosa de números de Fibonacci deja  fibSeq  =  Seq . desplegar  ( diversión  ( a , b )  ->  Algunos ( a + b ,  ( b ,  a + b )))  ( 0 , 1 )// Imprime incluso fibs [ 1  ..  10 ] |>  Lista . map  fib |>  List . filter  ( fun  n  ->  ( n  %  2 )  =  0 ) |>  printList// Lo mismo, utilizando una expresión de la lista [  de  i  en  1 .. 10  do  dejar que  r  =  fib  i  si  r  %  2  =  0  entonces  producir  r  ] |>  imprimeLista

Un programa de muestra de Windows Forms:

// Abra la biblioteca de Windows Forms, abra  System.Windows.Forms// Cree una ventana y establezca algunas propiedades let  form  =  new  Form ( Visible = true ,  TopMost = true ,  Text = "Welcome to F #" )// Crea una etiqueta para mostrar algo de texto en la forma let  label  =  let  x  =  3  +  ( 4  *  5 )  new  Label ( Text  =  sprintf  "x =% d"  x )// Agrega la etiqueta al formulario del formulario . Controles . Agregar ( etiqueta )// Finalmente, ejecute el formulario [< System . STAThread >] Aplicación . Ejecutar ( formulario )

Ejemplo de programación paralela asíncrona (CPU paralela y tareas de E / S):

/// Un detector de números primos simple let  isPrime  ( n : int )  =  let  bound  =  int  ( sqrt  ( float  n ))  seq  { 2  ..  bound }  |>  Seq . forall  ( divertido  x  ->  n  %  x  <>  0 )// Estamos usando flujos de trabajo asíncronos let  primeAsync  n  =  async  {  return  ( n ,  isPrime  n )  }/// Devuelve primos entre myn usando múltiples subprocesos let  primes  m  n  =  seq  { m  ..  n }  |>  Seq . map  primeAsync  |>  Async . Paralelo  |>  Asíncrono . Ejecutar sincrónicamente  |>  Array . filter  snd  |>  Array . mapa  fst// Ejecuta una prueba primes  1000000  1002000  |>  Array . iter  ( printfn  "% d" )

Ver también

• OCaml
• C#
• .NET Framework

Notas

1. https://devblogs.microsoft.com/dotnet/announcing-f-5/ .
2. https://www.infoq.com/news/2019/04/FSharp-Nulls
3. "Licencia de F # Software Foundation" .
4. "Licencia F # de Microsoft" .
5. Syme, Granicz y Cisternino (2007 : 2)
6. "F # Reconocimientos históricos" . Consultado el 24 de noviembre de 2012 .
7. Syme, Don (2006). "Aprovechando los componentes de metaprogramación .NET de F #" . [F #] tiene sus raíces en el diseño de Core ML y, en particular, tiene un lenguaje central ampliamente compatible con el de OCaml.
8. para async
9. La Fundación de software F #. "Uso de F # para aplicaciones web" . Consultado el 30 de julio de 2020 .
10. La Fundación de software F #. "Uso de F # para la programación de GPU" . Archivado desde el original el 25 de diciembre de 2019 . Consultado el 25 de diciembre de 2019 .
11. La Fundación de software F #. "La Fundación de Software F #" . Consultado el 24 de noviembre de 2012 .
12. La Fundación de software F #. "F # Compiler (edición de código abierto) @ github" . Consultado el 24 de noviembre de 2012 .
13. "Desarrollar con Visual F # en Visual Studio" . Consultado el 30 de julio de 2020 .
14. "F #" . Consultado el 30 de julio de 2020 .
15. Syme, Don. "F # 1.0.8 lanzado" . Microsoft . Consultado el 7 de septiembre de 2014 .
16. Syme, Don. "F # 2.0 lanzado como parte de Visual Studio 2010" . Microsoft . Consultado el 7 de septiembre de 2014 .
17. Zander, Jason. "Visual Studio 2012 y .NET Framework 4.5 lanzados a la web" . Microsoft . Consultado el 7 de septiembre de 2014 .
18. "Visual Studio 2013 lanzado a la web" . Microsoft . Consultado el 7 de septiembre de 2014 .
19. "Anunciando el RTM de Visual F # 4.0" . Microsoft . Consultado el 15 de septiembre de 2015 .
20. "Anuncio de F # 4.1 y Visual F # Tools para Visual Studio 2017" . Consultado el 8 de marzo de 2017 .
21. "Anuncio de F # 4.5" . Microsoft . Consultado el 14 de agosto de 2018 .
22. https://www.nuget.org/packages/FSharp.Core/4.5.0
23. "Descargar .NET Core 2.1 (Linux, macOS y Windows)" . Microsoft . Consultado el 13 de mayo de 2021 .
24. "Anuncio de F # 4.6" . Microsoft . Consultado el 29 de marzo de 2019 .
25. https://www.nuget.org/packages/FSharp.Core/4.6.0
26. "Descargar .NET Core 2.2 (Linux, macOS y Windows)" . Microsoft . Consultado el 13 de mayo de 2021 .
27. "Anunciando F # 4.7" . Microsoft . Consultado el 23 de septiembre de 2019 .
28. https://www.nuget.org/packages/FSharp.Core/4.7.0
29. "Descargar .NET Core 3.0 (Linux, macOS y Windows)" . Microsoft . Consultado el 13 de mayo de 2021 .
30. https://devblogs.microsoft.com/dotnet/announcing-f-5/
31. "Descargar .NET 5.0 (Linux, macOS y Windows)" . Microsoft . Consultado el 13 de mayo de 2021 .
32. Edwards, Kathryn (23 de diciembre de 2008). "El AZ de los lenguajes de programación: F #" . networkworld.com . IDG . Consultado el 8 de agosto de 2016 .
33. McNamara, Brian. "Más sobre las características del idioma F # 3.0" . Microsoft . Consultado el 7 de septiembre de 2014 .
34. McNamara, Brian. "Anuncio de una versión preliminar de F # 3.1" . Microsoft . Consultado el 7 de septiembre de 2014 .
35. "Anunciando el RTM de Visual F # 4.0" . Consultado el 8 de marzo de 2017 .
36. "Anuncio de F # 4.1 y Visual F # Tools para Visual Studio 2017" . Consultado el 8 de marzo de 2017 .
37. https://devblogs.microsoft.com/dotnet/announcing-f-4-7/
38. https://devblogs.microsoft.com/dotnet/announcing-f-5/
39. "Descripción general del idioma F #" (PDF) . Consultado el 14 de diciembre de 2007 .
40. "Algunos detalles sobre las expresiones de cálculo F #" . Consultado el 14 de diciembre de 2007 .
41. "Coincidencia de patrones en F # Parte 2: Patrones activos" . Consultado el 24 de noviembre de 2012 .
42. "Introducción a los flujos de trabajo asincrónicos de F #" . Consultado el 14 de diciembre de 2007 .
43. "Unidades de medida (F #)" . Consultado el 24 de noviembre de 2012 .
44. "Unidades de medida en F #: Parte uno, Introducción de unidades" . Consultado el 24 de noviembre de 2012 .
45. "Citas de código (F #)" . Consultado el 24 de noviembre de 2012 .
46. "Proveedores de tipo" . Consultado el 24 de noviembre de 2012 .
47. "Informe de tecnología nueva de Microsoft Research: soporte de lenguaje fuertemente tipado para fuentes de información a escala de Internet" . Consultado el 24 de noviembre de 2012 .
48. "Expresiones de consulta (F #)" . Consultado el 24 de noviembre de 2012 .
49. "F # 3.0 - Proveedores de tipo LINQ + = Programación rica en información" . Consultado el 24 de noviembre de 2012 .
50. Alexander Kurakin. "¡Rider 2019.1 inicia su programa de acceso anticipado!" .
51. "Fable: JavaScript del que puede estar orgulloso!" . fable.io . Consultado el 9 de diciembre de 2017 .
52. Intellifactory. "Inicio de WebSharper" . Consultado el 24 de noviembre de 2012 .
53. "Estudios de caso de Microsoft: Microsoft Visual Studio 2012 - empresa de servicios financieros" . Consultado el 25 de noviembre de 2012 .
54. "F # para optimización de cartera y comercio de energía" . Consultado el 25 de noviembre de 2012 .
55. "Estudio de caso de Microsoft: Grange Insurance" . Consultado el 25 de noviembre de 2012 .
56. "Aprendiendo con F #" . Consultado el 25 de noviembre de 2012 .
57. "Trabajo de F # en Facebook Social Gaming" . Consultado el 25 de noviembre de 2012 .
58. "Testimonios de desarrolladores de F #" . Consultado el 25 de mayo de 2021 .
59. "Secuencias de comandos en F #" . Consultado el 17 de enero de 2020 .

Referencias

• Syme, Don ; Granicz, Adam; Cisternino, Antonio (2007), Experto F # , Apress
• Harrop, Jon (2010), Visual F # 2010 para Computación técnica , Consultoría Flying Frog
• Pickering, Robert (2007), Fundamentos de F # , Apress
• Smith, Chris (2009), Programación F # , O'Reilly
• Petricek, Tomas (2009), Programación funcional del mundo real con ejemplos en F # y C # , Publicaciones Manning
• Hansen, Michael; Rischel, Hans (2013), Programación funcional con F # , Cambridge University Press
• Astborg, Johan (2013), F # para finanzas cuantitativas , Packt Publishing
• Lundin, Mikael (2015), Pruebas con F # , Packt Publishing

enlaces externos

Wikilibros tiene un libro sobre el tema: Programación de F Sharp

• Sitio web oficial The F # Software Foundation
• El grupo de código abierto F # en GitHub
• El Centro para desarrolladores de Visual F #
• Tsunami, un F # IDE de escritorio integrable
• Cloud Tsunami, un Silverlight F # IDE integrable
• Pruebe F #, para aprender F # en un navegador web
• Sitio de fragmentos de F #
• El blog del equipo de Visual F #
• El sitio web original de Microsoft Research para F #
• Planeta F #
• The F # Survival Guide, diciembre de 2009 (libro basado en la web)
• La especificación del lenguaje F #
• Introducción a la programación de F #
• Un tutorial que muestra el proceso de llegar a un diseño funcional; incluye codificación de prueba y paralela