F sostenido (lenguaje de programación)

F# utiliza un proceso de desarrollo e ingeniería abierto. Don Syme, de Microsoft Research, es el responsable vitalicio del diseño del lenguaje, junto con la F# Software Foundation. Las versiones anteriores de F# fueron diseñadas por Microsoft y Microsoft Research mediante un proceso de desarrollo cerrado.

F# se incluyó por primera vez en Visual Studio en la edición de 2010 , al mismo nivel que Visual Basic (.NET) y C# (aunque como opción), y permanece en todas las ediciones posteriores, lo que hace que el lenguaje esté ampliamente disponible y cuente con un buen soporte.

F# tiene su origen en Microsoft Research, Cambridge, Reino Unido. El lenguaje fue diseñado e implementado originalmente por Don Syme , ^{[ 5 ]} según quien en el equipo de fsharp, dicen que la F es de "Fun" (diversión). ^{[ 41 ]} Andrew Kennedy contribuyó al diseño de las unidades de medida. ^{[ 5 ]} Las herramientas Visual F# para Visual Studio son desarrolladas por Microsoft. ^{[ 5 ]} 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. ^{[ 10 ]}

F# es un lenguaje funcional fuertemente tipado con una gran cantidad de capacidades que normalmente solo se encuentran en lenguajes de programación funcional , a la vez que admite las características de la programación orientada a objetos disponibles en C#. En conjunto, estas características permiten escribir programas en F# con un estilo completamente funcional y también permiten combinar estilos funcionales y orientados a objetos.

Ejemplos de características funcionales son:

• Todo es una expresión
• Inferencia de tipos (utilizando la inferencia de tipos de Hindley-Milner )
• Funciona como ciudadanos de primera clase
• Funciones anónimas con semántica de captura (es decir, cierres )
• Variables y objetos inmutables
• Soporte de evaluación perezoso
• Funciones de orden superior
• Funciones anidadas
• Zurra
• Coincidencia de patrones
• Tipos de datos algebraicos
• Tuplas
• Comprensión de listas
• Soporte para patrones de mónadas (denominado expresiones de computación ^{[ 53 ]} )
• Optimización de llamadas de cola ^{[ 54 ]}

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

Sea x = 3 + 4

vincula el valor 7al nombre x.

Los nuevos tipos se definen usando la typepalabra clave. Para la programación funcional, F# proporciona los tipos tupla , registro , unión discriminada , lista , opción y resultado . ^{[ 55 ]} Una tupla representa un conjunto de n valores, donde n ≥ 0. El valor n se llama aridad de la tupla. Una 3-tupla se representaría como (A, B, C), donde A, B y C son valores de tipos posiblemente diferentes. Una tupla se puede usar 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 de dato cuyos miembros tienen nombre. Aquí hay un ejemplo de definición de registro:

tipo R = { Nombre : cadena Edad : entero }

Los registros se pueden crear como . La palabra clave se utiliza para crear una copia de un registro, como en , que crea un nuevo registro copiando y cambiando el valor del campo (suponiendo que el registro creado en el último ejemplo se llamaba ).letr={Name="AB";Age=42}with{rwithName="CD"}rNamer

Un tipo de unión discriminada es una versión segura en cuanto a tipos de las uniones de C. Por ejemplo,

tipo A = | UnionCaseX de cadena | UnionCaseY de entero

Los valores del tipo de unión pueden corresponder a cualquiera de los casos de unión. Los tipos de los valores que contiene 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 cons ) o una notación abreviada como . Una lista vacía se escribe . 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 genéricos de .NET.head::tail::[item1;item2;item3][]Some(x)None

F# admite funciones lambda y cierres . ^{[ 55 ]} Todas las funciones en F# son valores de primera clase e inmutables. ^{[ 55 ]} Las funciones pueden currificarse . Al ser valores de primera clase, las funciones pueden pasarse como argumentos a otras funciones. Al igual que otros lenguajes de programación funcional, F# permite la composición de funciones mediante los operadores >>`and` .<<

F# proporcionaexpresiones de secuencia ^{[ 56 ]} que definen una secuenciaseq { ... }, lista[ ... ]o matriz[| ... |]a través de código que genera valores. Por ejemplo,

secuencia { para b en 0 .. 25 hacer si b < 15 entonces generar b * b }

Se forma una secuencia de cuadrados de números del 0 al 14 filtrando los números del rango del 0 al 25. Las secuencias son generadores : los valores se generan bajo demanda (es decir, se evalúan de forma diferida ), mientras que las listas y los arreglos se evalúan de forma inmediata.

F# utiliza la coincidencia de patrones para vincular valores a nombres. La coincidencia de patrones también se utiliza al acceder a uniones discriminadas: la unión se compara con las reglas del patrón y se selecciona una regla cuando hay una coincidencia. F# también admite patrones activos como una forma de coincidencia de patrones extensible. ^{[ 57 ]} Se utiliza, por ejemplo, cuando existen múltiples formas de coincidencia en un tipo. ^{[ 55 ]}

F# admite una sintaxis general para definir cálculos compositivos llamadoexpresiones de cálculo . Las expresiones de secuencia, los cálculos asíncronos y las consultas son tipos particulares de expresiones de cálculo. Las expresiones de cálculo son una implementación delmónada. ^{[ 56 ]}

El soporte de F# para la programación imperativa incluye:

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

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

// Definir 'x' con 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 la CLI, como los definidos en el System.Collections.Genericespacio de nombres que define las estructuras de datos imperativas.

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

• Notación de puntos, por ejemplo,x.Name
• Expresiones de objetos, por ejemplo,{newobj()withmemberx.ToString()="hello"}
• Construcción de objetos, por ejemplo,newForm()
• Pruebas de tipo, por ejemplo,x:?string
• Coerciones de tipo, por ejemplo,x:?>string
• Argumentos con nombre, por ejemplo,x.Method(someArgument=1)
• Setters con nombre, por ejemplo,newForm(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,:?stringass
• Patrones activos, que pueden definirse sobre tipos de objetos ^{[ 57 ]}

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

/// Definición de un tipo de objeto simple: tipo Persona ( nombre : cadena , edad : entero ) = miembro x . Nombre = nombre miembro x . Edad = edad

F# admite la programación asíncrona a través de flujos de trabajo asíncronos . ^{[ 58 ]} Un flujo de trabajo asíncrono se define como una secuencia de comandos dentro de un async{ ... }, como en

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 () }

Esto let!indica que la expresión de la derecha (obtener la respuesta) debe ejecutarse de forma asíncrona, 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 bloqueante, mientras que desde el punto de vista del sistema, el hilo no se bloqueará y podrá utilizarse para procesar otros flujos hasta que el resultado necesario para este esté disponible.

El bloque asíncrono puede invocarse mediante la Async.RunSynchronouslyfunción. Se pueden ejecutar varios bloques asíncronos en paralelo mediante 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 de las listas en paralelo. El objeto resultante se invoca mediante Async.RunSynchronously. ^{[ 58 ]}

La inversión de control en F# sigue este patrón. ^{[ 58 ]}

Desde la versión 6.0, F# admite la creación, el consumo y la devolución directa de tareas .NET. ^{[ 59 ]}

open System.Net.Http let fetchUrlAsync ( url : string ) = // string -> Task<string> task { use client = new HttpClient () let! response = client . GetAsync ( url ) let! content = response . Content . ReadAsStringAsync () do ! Task . Delay 500 return content }// Uso let fetchPrint () = let task = task { let! data = fetchUrlAsync "https://example.com" printfn $ "{data}" } task . Wait ()

La programación paralela se admite en parte a través de Async.Parallely Async.Startotras operaciones que ejecutan bloques asíncronos 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 de .NET y los subprocesos de .NET y a través de la traducción dinámica del código F# a motores de ejecución paralela alternativos como el código GPU ^{[ 9 ]} .

El sistema de tipos de F# admite la comprobación de unidades de medida para números: ^{[ 60 ]} las unidades de medida, como metros o kilogramos, se pueden asignar a valores de punto flotante, enteros sin signo ^{[ 61 ]} y enteros con signo. Esto permite al compilador comprobar que la aritmética que involucra estos valores es dimensionalmente consistente, lo que ayuda a prevenir errores de programación comunes al garantizar que, por ejemplo, las longitudes no se sumen erróneamente a las horas.

La función de unidades de medida se integra con la inferencia de tipos de F# para requerir anotaciones de tipo mínimas en el código del usuario. ^{[ 62 ]}

[< Medida >] tipo m // metro [< Medida >] tipo s // segundosea ​​distancia = 100 . 0 < m > // float<m> sea tiempo = 5 . 0 < s > // float<s> sea velocidad = distancia / tiempo // float<m/s>[< Medida >] tipo kg // kilogramo [< Medida >] tipo N = ( kg * m )/( s ^ 2 ) // Newtons [< Medida >] tipo Pa = N /( m ^ 2 ) // Pascales[< Medida >] tipo días let better_age = 3u < días > // uint<días>

El verificador de tipos estático de F# proporciona esta funcionalidad en tiempo de compilación, pero las unidades se eliminan del código compilado. Por consiguiente, no es posible determinar la unidad de un valor en tiempo de ejecución.

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

F# incluye una característica para la metaprogramación en tiempo de ejecución llamada comillas. ^{[ 63 ]} Una expresión de comillas se evalúa a una representación abstracta en forma de árbol sintáctico de las expresiones de F#. De manera similar, las definiciones etiquetadas con el atributo también se pueden acceder en su forma de comillas. Las comillas de F# se utilizan para diversos fines, incluyendo la compilación de código F# a JavaScript ^{[ 8 ]} y código GPU ^{[ 9 ]} . Las comillas representan sus expresiones de código F# como datos para su uso por otras partes del programa, requiriendo que sea código F# sintácticamente correcto.[<ReflectedDefinition>]

F# 3.0 introdujo una forma de metaprogramación en tiempo de compilación mediante la generación de tipos estáticamente extensibles, denominada proveedores de tipos de F#. ^{[ 64 ]} Los proveedores de tipos de F# permiten extender el compilador y las herramientas de F# con componentes que proporcionan información de tipos al compilador bajo demanda en tiempo de compilación. Los proveedores de tipos de F# se han utilizado para brindar acceso fuertemente tipado a fuentes de información conectadas de manera escalable, incluyendo el grafo de conocimiento de Freebase . ^{[ 65 ]}

En F# 3.0, las características de expresiones de comillas y cálculos de F# se combinan para implementar consultas LINQ . ^{[ 66 ]} Por ejemplo:

// Utilice el proveedor de tipos OData para crear tipos que puedan usarse para acceder a la base de datos Northwind. open Microsoft.FSharp.Data.TypeProviderstipo Northwind = ODataService < "http://services.odata.org/Northwind/Northwind.svc" > let db = Northwind . GetDataContext ()// Una expresión de consulta. let query1 = query { for customer in db . Customers do select customer }

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

F# admite una variación del modelo de programación de actores mediante la implementación en memoria de agentes asíncronos ligeros. Por ejemplo, el siguiente código define un agente y publica 2 mensajes:

tipo Mensaje = | Encolar cadena | Desencolar AsyncReplyChannel < Opción < cadena >>​​// Proporciona acceso concurrente a una lista de cadenas let listManager = MailboxProcessor . Start ( fun inbox -> let rec messageLoop list = async { let! msg = inbox . Receive () match msg with | Enqueue item -> return ! messageLoop ( item :: list )| Desencolar replyChannel -> coincidir lista con | [] -> replyChannel . Reply Ninguno devolver ! lista messageLoop | cabeza :: cola -> replyChannel . Reply ( Alguna cabeza ) devolver ! cola messageLoop }// Iniciar el bucle con una lista vacía messageLoop [] )// Uso async { // Encolar algunas cadenas listManager . Post ( Encolar "Hola" ) listManager . Post ( Encolar "Mundo" )// Desencolar y procesar las cadenas let! str = listManager . PostAndAsyncReply ( Dequeue ) str |> Option . iter ( printfn "Dequeued: %s" )} |> Async . Start

SAFE Stack es una pila F# de extremo a extremo para desarrollar aplicaciones web. Utiliza ASP.NET Core en el lado del servidor y Fable en el lado del cliente. ^{[ 71 ]}

Entre las alternativas de extremo a extremo para F# se incluyen el framework WebSharper y el framework Oxpecker. ^{[ 72 ]}

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

Entre otros usos, F# se utiliza para la programación de finanzas cuantitativas, ^{[ 73 ]} el comercio de energía y la optimización de carteras, ^{[ 74 ]} el aprendizaje automático, ^{[ 75 ]} la inteligencia empresarial ^{[ 76 ]} y los juegos sociales en Facebook . ^{[ 77 ]}

En la década de 2010, F# se posicionó como una alternativa optimizada a C# . Su capacidad de scripting y su compatibilidad entre lenguajes con todos los productos de Microsoft lo hicieron popular entre los desarrolladores. ^{[ 78 ]}

F# se puede utilizar como lenguaje de scripting, principalmente para scripting de bucle de lectura-evaluación-impresión (REPL) de escritorio. ^{[ 79 ]}