| F# | |
|---|---|
| clase de idioma |
multiparadigma : funcional , orientado a objetos , generalizado , programación imperativa |
| Apareció en | 2005 |
| Autor | Investigación de Microsoft |
| Desarrollador | Microsoft y la Fundación de Software F Sharp [d] |
| extensión de archivo | .fs, o .fsi_.fsx.fsscript |
| Liberar | 6.0 ( 19 de octubre de 2021 ) |
| sistema de tipos | estricto |
| sido influenciado | Objetivo Caml , C# , Haskell |
| Licencia | Licencia de software Apache |
| Sitio web | fsharp.org |
| sistema operativo | Software multiplataforma ( .NET Framework , Mono ) |
| Archivos multimedia en Wikimedia Commons | |
F# (pronunciado ef-sharp ) es un lenguaje de programación multiparadigma de la familia de lenguajes .NET que admite la programación funcional además de la programación imperativa ( de procedimiento ) y orientada a objetos . La estructura de F# es similar a la de OCaml en muchos aspectos, con la única diferencia de que F# se implementa sobre las bibliotecas y el tiempo de ejecución de .NET . El lenguaje fue desarrollado por Don Syme en Microsoft Research en Cambridge , y actualmente está siendo desarrollado por la División de Desarrolladores de Microsoft. F# se integra muy de cerca con el entorno de desarrollo de Visual Studio y está incluido en la distribución de Visual Studio 2010/2012/2013/2015/2017/2019/2022; También se han desarrollado compiladores para Mac y Linux [1] .
Microsoft ha integrado el entorno de desarrollo F# en Visual Studio 2010 y versiones más recientes.
El 4 de noviembre de 2010, el código para el compilador de F# y sus bibliotecas principales se publicó bajo la Licencia Apache 2.0 [2] .
El código F# es de tipo seguro , a menudo más compacto que el código C# similar , debido a la inferencia de tipos . F# tiene una tipificación fuerte, las conversiones de tipos implícitas están completamente ausentes, lo que elimina por completo los errores asociados con la conversión de tipos.
Las características como la programación genérica y las funciones de orden superior permiten escribir algoritmos genéricos abstractos que manipulan estructuras de datos parametrizados (por ejemplo , matrices , listas , gráficos , árboles ).
En muchos idiomas, la mayoría de los valores son variables. Por ejemplo, el siguiente código C++ xalmacenará el valor 3 en una variable:
int x = 2 ; x ++ ;En F#, por el contrario, todos los valores son constantes por defecto. F# permite variables, lo que requiere que marques específicamente los valores como mutables con la palabra mutable:
let x = 2 // inmutable let mutable y = 2 // variable x <- 3 // error y <- 3 // Ok. y=3F# también tiene tipos de referencia y objetos que también pueden contener valores mutables. Sin embargo, la mayor parte del código son funciones puras , lo que evita muchos errores y facilita la depuración. Además, se simplifica la paralelización de programas. Con todo esto, el código rara vez se vuelve más complicado que un código similar en un lenguaje imperativo.
Una de las ideas principales detrás de F# es asegurarse de que se pueda acceder fácilmente al código y los tipos existentes en un lenguaje de programación funcional desde otros lenguajes .NET. Los programas de F# se compilan en ensamblajes CLR (archivos con extensiones .exe y .dll); sin embargo, para ejecutarlos, debe instalar un paquete de tiempo de ejecución además de .NET Framework.
Una característica interesante (y una diferencia con OCaml ) es el control del anidamiento lógico de construcciones de código mediante la sangría de un número arbitrario de espacios (y solo espacios). Los caracteres de tabulación no se admiten para este fin. Esto lleva a discusiones constantes en los foros de desarrolladores experimentados que están acostumbrados a usar pestañas en otros lenguajes de programación.
F# es un lenguaje de programación compilado que utiliza el lenguaje intermedio común (CIL) como lenguaje intermedio, al igual que los programas escritos en C# o VB.NET .
Junto con el compilador de F# (fsc), también hay un intérprete de F# (fsi) que ejecuta el código de F# de forma interactiva.
La característica distintiva del compilador de F# y del intérprete de F# es la capacidad de tratar el código de dos maneras diferentes: inmediatamente (de forma predeterminada) y diferido (el programador debe especificarlo explícitamente en el código fuente). En el caso de la interpretación inmediata, las expresiones se evalúan de antemano en el momento en que se inicia la ejecución del programa, independientemente de que se llamen durante la ejecución del programa o no. En este caso, el rendimiento de la ejecución del programa a menudo disminuye y los recursos del sistema (por ejemplo, la memoria) se desperdician. En el caso de la interpretación de código perezoso, las expresiones se evalúan solo en el momento en que se accede directamente a ellas durante la ejecución del programa. Esto salva al programa de las desventajas anteriores, pero reduce la previsibilidad en términos de cantidad y secuencia de uso de recursos (tiempo de procesador, memoria, dispositivos de E/S, etc.) en varias etapas de ejecución del programa.
La sintaxis de F# se basa en la notación matemática y la programación es algo similar al álgebra , lo que hace que F# sea similar a Haskell . Por ejemplo, cuando define un nuevo tipo, puede especificar que las variables de ese tipo sean " enteros o cadenas ". Esto es lo que parece:
tipo myType = IntVal de int | StringVal de cadenaUn ejemplo importante de tales tipos es Option, que contiene un valor de algún tipo o nada.
tipo Opción <a> = Ninguno | _ _ algo de unEs un tipo de F# estándar y se usa a menudo en situaciones en las que el resultado de algún código (como una búsqueda en una estructura de datos) es un valor que podría no devolverse.
El código es también una notación matemática. La siguiente construcción es equivalente a f(x) = x + 1 en álgebra:
sea f x = x + 1F# funciona así: el tipo “ f” es “ int -> int”, es decir, la función toma un número entero como entrada y produce un número entero como salida.
F# te permite acceder a absolutamente todo lo que hay en FCL . La sintaxis para trabajar con bibliotecas .NET en este sentido es lo más parecida posible a la sintaxis de C# . Las funciones de lenguaje se notan cuando se usa la gama completa de funciones de F#. Por ejemplo, el siguiente código aplica una función a los elementos de una lista :
let rec map func lst = emparejar lst con | [] -> [] | head :: tail -> func head :: map func tail let miLista = [ 1 ; 3 ; 5 ] let newList = map ( fun x -> x + 1 ) myList" newList" es ahora " [2;4;6]".
El análisis de la lista en esta función se realiza utilizando otra potente función de coincidencia de patrones . Le permite especificar patrones, cuando coinciden, se calculan las ocurrencias correspondientes del operador de coincidencia. El primer patrón "[]" significa una lista vacía. La segunda es una lista que consta del primer elemento y la cola (que puede ser una lista arbitraria, incluida una vacía). En la segunda muestra, el valor de la cabeza está asociado con la variable de la cabeza y el valor de la cola con la cola (los nombres pueden ser arbitrarios). Por lo tanto, además de la tarea principal, la muestra también le permite descomponer estructuras de datos complejas. Por ejemplo, en el caso del tipo Opción, la coincidencia de patrones se ve así:
unir x con | Algunos v -> printfn "Valor encontrado %d". v | Ninguno -> printfn "No se encontró nada". | Ninguno -> printfn "Hola"El lenguaje admite expresiones generadoras definidas para conjuntos { … }, listas [ … ]y matrices. [| … |] Por ejemplo:
vamos a probar n = [ para i en 0 .. n hacer si i % 2 = 0 entonces producir i ]La función de mapa es una de las funciones de lista estándar contenidas en el módulo Lista. También hay funciones para otras estructuras de datos declaradas en los módulos Array, Set, Option.
Una herramienta útil es el operador de tubería hacia adelante (|>), que le permite escribir cadenas de llamadas de función en orden inverso. Como resultado, se produce el siguiente código (los valores intermedios se indican en los comentarios):
[ 1 ; 2 ; 5 ] |> Lista . mapa ((+) 1 ) // [2; 3; 6] |> Lista . filtrar ( divertido x -> x % 2 = 0 ) // [2; 6] |> Lista . suma // 8El uso del operador |>elimina la necesidad de una gran cantidad de corchetes y también cambia la percepción visual del código. Y ahora este código se lee así: tome tal y tal lista, agregue 1 a cada elemento, luego deje solo los elementos pares, devuelva su suma. Es decir, describe la secuencia de acciones realizadas en el objeto original, en el orden en que ocurre en la computadora.
La siguiente es una pequeña demostración de cómo las características de .NET amplían F#. Un ejemplo son las aplicaciones en ventana y el manejo de eventos. El procesamiento de eventos significa que algunas acciones en el programa ocurren solo como reacción a ciertos eventos: acciones del usuario, conexión del dispositivo, etc. El proyecto se puede crear tanto en Visual Studio como en cualquier documento de texto, que luego se envía al compilador de F# ( fsc).
// abierto: conexión de módulos y espacios de nombres para usar // valores, clases y otros módulos contenidos en ellos. open System.Windows.Forms // - clases Form (ventana), Button (botón), etc. // Beep - una señal de sonido // Algunos parámetros más se pasan como argumentos de pitido que no usamos let beep _ = System . consola _ Beep () // crea una ventana con el nombre de ventana programáticamente. ¡Necesitas llamar a una función de palabra de visualización, por ejemplo, Application.Run (ventana)! // Visible: valor booleano, si la ventana es visible // TopMost: si la ventana se muestra en primer plano (el orden de las ventanas con el mismo valor en orden inverso al de la llamada) // Texto: el texto de la ventana title let window = new Form ( Visible = true , TopMost = true , Text = " " , Top = 0 , Left = 0 , Height = 512 , Width = 768 ) ventana . Estado de ventana <- Estado de ventana de formulario . Normal // Ventana normal (, Minimizada, Maximizada). Simplemente no está incluido en el constructor de ventanas para el ejemplo . ClientSizeChanged . Agregar ventana de pitido . _ pulsación de tecla Agregar ventana de pitido . _ pulsación de tecla Agregar ventana de pitido . _ tecla arriba Agregar aplicación de pitido . Ejecutar ventana // ventana de visualizaciónFunción factorial recursiva de forma nativa:
let rec fac n = si n < 2 entonces 1 else n * fac ( n - 1 )Función factorial recursiva optimizada para recursión de cola.
let factorial num = let rec fac num acc = emparejar num con | x cuando x < 2 -> acc |_ -> fac ( num - 1 ) ( acc * num ) fac num 1Una función factorial, en estilo imperativo, usando estado mutable.
let factorial num = si num < 2 entonces 1 else let mutable fac = 1 for i in [ 2 .. num ] do fac <- fac * i facFunción factorial usando pliegue de lista y multiplicación al curry:
sea fac n = Lista . doblar (*) 1 [ 1 .. n ]Función recursiva para calcular números de Fibonacci utilizando el método de coincidencia de patrones:
let rec fib n a b = hacer coincidir n con | 0 -> un | 1 -> segundo | _ -> mentira ( n - 1 ) segundo ( un + segundo )
| Lenguajes de programación | |
|---|---|
| |
| .RED | |
|---|---|
| Implementaciones | |
| Arquitectura | |
| Infraestructura | |
| Idiomas de Microsoft | |
| Otros idiomas | |
| Fundamentos de Windows | |
| Componentes | |
| comparaciones |
|
| Tecnologías futuras | |
| Recursos informativos | |
| Investigación de Microsoft (MSR) | |||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Principales proyectos |
| ||||||||||||||
| Laboratorios MSR |
| ||||||||||||||
| Categoría | |||||||||||||||
| Software de Microsoft gratuito y de código abierto | |||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| información general |
| ||||||||||||
| Software _ |
| ||||||||||||
| Licencias | |||||||||||||
| Temas relacionados |
| ||||||||||||
| Categoría | |||||||||||||