Miranda es un lenguaje de programación puramente funcional diseñado por David Turner como sucesor de sus lenguajes de programación anteriores SASL y KRC , utilizando algunos conceptos de ML y Hope . Fue producido por Research Software Ltd. de Inglaterra (que posee una marca registrada del nombre Miranda ) [3] y fue el primer lenguaje puramente funcional en recibir soporte comercial. [ cita requerida ]
Miranda fue lanzado por primera vez en 1985 como un intérprete rápido en C para sistemas operativos de tipo Unix , con lanzamientos posteriores en 1987 y 1989. Tuvo una fuerte influencia en el lenguaje Haskell posterior. [4] Turner afirmó que los beneficios de Miranda sobre Haskell son: "Lenguaje más pequeño, sistema de tipos más simple, aritmética más simple". [5]
En 2020 se publicó una versión de Miranda como código abierto bajo una licencia BSD . El código se ha actualizado para cumplir con los estándares modernos de C ( C11 / C18 ) y para generar binarios de 64 bits. Esto se ha probado en sistemas operativos como Debian , Ubuntu , WSL /Ubuntu y macOS ( Catalina ). [5] [6]
El nombre Miranda proviene de la forma gerundiva del verbo latino miror , [7] que significa "ser admirado".
El logotipo presenta una interpretación de John William Waterhouse del personaje Miranda de La tempestad de Shakespeare .
Miranda es un lenguaje de programación puramente funcional , es decir, carece de efectos secundarios y características de programación imperativa . Un programa Miranda (llamado script ) es un conjunto de ecuaciones que definen varias funciones matemáticas y tipos de datos algebraicos . La palabra conjunto es importante aquí: el orden de las ecuaciones es, en general, irrelevante y no hay necesidad de definir una entidad antes de su uso.
Dado que el algoritmo de análisis hace un uso inteligente del diseño (sangría, mediante la regla de fuera de línea ), rara vez se necesitan declaraciones entre corchetes y los terminadores de declaraciones no son necesarios. Esta característica, inspirada en ISWIM , también se utiliza en Occam y Haskell y luego fue popularizada por Python .
Los comentarios se introducen en los scripts regulares mediante caracteres ||y continúan hasta el final de la misma línea. Una convención de comentarios alternativa afecta a todo el archivo de código fuente, conocida como " script literario ", en el que cada línea se considera un comentario a menos que comience con un >signo.
Los tipos de datos básicos de Miranda son char, numy bool. Una cadena de caracteres es simplemente una lista de char, mientras que numse convierte silenciosamente entre dos formas subyacentes: números enteros de precisión arbitraria (también conocidos como bignums) de manera predeterminada y valores de punto flotante regulares según sea necesario.
Las tuplas son secuencias de elementos de tipos potencialmente mixtos, análogas a los registros en lenguajes tipo Pascal , y se escriben delimitadas con paréntesis:
este_empleado = ( "Folland, Mary" , 10560 , Falso , 35 ) La lista , en cambio, es la estructura de datos más utilizada en Miranda. Se escribe delimitada por corchetes y con elementos separados por comas, todos los cuales deben ser del mismo tipo:
week_days = [ "Lun" , "Mar" , "Miércoles" , "Jueves" , "Viernes" ] La concatenación de listas es ++, la resta es --, la construcción es :, el dimensionamiento es #y la indexación es !, entonces:
días = días_de_la_semana ++ [ "Sáb" , "Dom" ] días = "Nil" : días días ! 0 ⇒ "Nil" días = días -- [ "Nil" ] # días ⇒ 7 Existen varios atajos para crear listas: ..se utiliza para listas cuyos elementos forman una serie aritmética, con la posibilidad de especificar un incremento distinto de 1:
fac n = producto [ 1 .. n ] suma_impar = suma [ 1 , 3 .. 100 ] Las " comprensiones de listas " (anteriormente conocidas como "expresiones ZF") ofrecen facilidades más generales y potentes para la creación de listas y se presentan en dos formas principales: una expresión aplicada a una serie de términos, por ejemplo:
cuadrados = [ n * n | n <- [ 1 .. ] ] (que se lee: lista de n al cuadrado donde n se toma de la lista de todos los enteros positivos) y una serie donde cada término es función del anterior, por ejemplo:
potencias_de_2 = [ n | n <- 1 , 2 * n .. ] Como lo implican estos dos ejemplos, Miranda permite listas con un número infinito de elementos, de las cuales la más simple es la lista de todos los números enteros positivos:[1..]
La notación para la aplicación de funciones es simplemente yuxtaposición, como en sin x.
En Miranda, como en la mayoría de los demás lenguajes puramente funcionales, las funciones son ciudadanos de primera clase , es decir, se pueden pasar como argumentos a otras funciones, devolver como resultados o incluir como elementos de estructuras de datos. Es más, una función con dos o más parámetros puede ser "parcialmente parametrizada", o currificada , al proporcionar menos argumentos que el número total de parámetros. Esto da como resultado otra función que, dados los parámetros restantes, devolverá un resultado. Por ejemplo:
suma a b = a + b incremento = suma 1 es una forma indirecta de crear una función "increment" que suma uno a su argumento. En realidad, add 4 7toma la función de dos parámetros add, la aplica para 4obtener una función de un solo parámetro que suma cuatro a su argumento y luego la aplica a 7.
Cualquier función con dos parámetros (operandos) se puede convertir en un operador infijo (por ejemplo, dada la definición de la addfunción anterior, el término $addes en todos los sentidos equivalente al +operador) y cada operador infijo que tome dos parámetros se puede convertir en una función correspondiente. Por lo tanto:
incremento = ( + ) 1 es la forma más breve de crear una función que agrega uno a su argumento. De manera similar, en
mitad = ( / 2 ) recíproco = ( 1 / ) Se generan dos funciones monoparamétricas. El intérprete entiende en cada caso cuál de los dos parámetros del operador de división se está suministrando, lo que genera funciones que dividen un número por dos y devuelven su recíproco respectivamente.
Aunque Miranda es un lenguaje de programación fuertemente tipado , no insiste en declaraciones de tipos explícitas . Si el tipo de una función no se declara explícitamente, el intérprete lo infiere a partir del tipo de sus parámetros y de cómo se utilizan dentro de la función. Además de los tipos básicos ( char, num, bool), incluye un tipo "cualquier cosa" donde el tipo de un parámetro no importa, como en la función de inversión de lista:
rev [] = [] rev ( a : x ) = rev x ++ [ a ] que se puede aplicar a una lista de cualquier tipo de datos, para lo cual la declaración explícita del tipo de función sería:
rev :: [ * ] -> [ * ] Por último, tiene mecanismos para crear y gestionar módulos de programa cuyas funciones internas son invisibles para los programas que llaman a esos módulos.
El siguiente script de Miranda determina el conjunto de todos los subconjuntos de un conjunto de números
subconjuntos [] = [ [] ] subconjuntos ( x : xs ) = [[ x ] ++ y | y <- ys ] ++ ys donde ys = subconjuntos xs y este es un script alfabetizado para una función primesque da la lista de todos los números primos
> || La lista infinita de todos los números primos.La lista de números primos potenciales comienza con todos los números enteros desde 2 en adelante;a medida que se devuelve cada primo, todos los números siguientes que se pueden obtener exactamentedividido por él se filtran de la lista de candidatos.> primos = tamiz [2..]> tamiz (p:x) = p : tamiz [n | n <- x; n mod p ~= 0]Aquí tenemos algunos ejemplos más.
max2 :: num -> num -> num max2 a b = a , si a > b = b , en caso contrario max3 :: núm - > núm - > núm max3 a b c = max2 ( max2 a b ) ( max2 a c ) multiplicar :: num -> num -> num multiplicar 0 b = 0 multiplicar a b = b + ( multiplicar ( a - 1 ) b ) fak :: núm -> núm fak 0 = 1 fak n = n * fak ( n - 1 ) numerodearticulo :: [ * ] -> num numerodearticulo [] = 0 numerodearticulo ( a : x ) = 1 + numerodearticulo x día laborable ::= Lu | Tu | Nosotros | Ju | fr | sa | Su isWorkDay :: día de la semana -> bool isWorkDay Sa = Falso isWorkDay Su = Falso isWorkDay cualquier día = Verdadero árbol * ::= E | N ( árbol * ) * ( árbol * ) nodecount :: árbol * -> num nodecount E = 0 nodecount ( N l w r ) = nodecount l + 1 + nodecount r cuentavacía :: árbol * -> num cuentavacía E = 1 cuentavacía ( N l w r ) = cuentavacía l + cuentavacía r árbolEjemplo = N ( N ( N E 1 E ) 3 ( N E 4 E )) 5 ( N ( N E 6 E ) 8 ( N E 9 E )) día de la semana Árbol = N ( N ( N E Mo E ) Tu ( N E Nosotros E )) Th ( N ( N E Fr E ) Sa ( N E Su )) insertar :: * -> calle * -> calle * insertar x E = N E x E insertar x ( N l w E ) = N l w x insertar x ( N E w r ) = N x w r insertar x ( N l w r ) = insertar x l , si x < w = insertar x r , en caso contrario list2searchtree :: [ * ] -> árbol * list2searchtree [] = E list2searchtree [ x ] = N E x E list2searchtree ( x : xs ) = insertar x ( list2searchtree xs ) maxel :: árbol * -> * maxel E = error "vacío" maxel ( N l w E ) = w maxel ( N l w r ) = maxel r minel :: árbol * -> * minel E = error "vacío" minel ( N E w r ) = w minel ( N l w r ) = minel l || Recorrer: recorrer los valores del árbol y colocarlos en una lista preorden , inorder , postorder :: árbol * -> [ * ] inorder E = [] inorder N l w r = inorder l ++ [ w ] ++ inorder r preorden E = [] preorden N l w r = [ w ] ++ preorden l ++ preorden r orden posterior E = [] orden posterior N l w r = orden posterior l ++ orden posterior r ++ [ w ] altura :: árbol * -> num altura E = 0 altura ( N l w r ) = 1 + max2 ( altura l ) ( altura r ) cantidad :: num -> num cantidad x = x , si x >= 0 cantidad x = x * ( - 1 ), de lo contrario y :: bool -> bool -> bool y Verdadero Verdadero = Verdadero y x y = Falso || Un AVL - Árbol es un árbol donde la diferencia entre los nodos secundarios no es mayor a 1 || Todavía tengo que probar esto isAvl :: árbol * -> bool isAvl E = Verdadero isAvl ( N l w r ) = y ( isAvl l ) ( isAvl r ), si cantidad (( nodecount l ) - ( nodecount r )) < 2 = Falso , de lo contrario eliminar :: * -> árbol * -> árbol * eliminar x E = E eliminar x ( N E x E ) = E eliminar x ( N E x r ) = N E ( minel r ) ( eliminar ( minel r ) r ) eliminar x ( N l x r ) = N ( eliminar ( maxel l ) l ) ( maxel l ) r eliminar x ( N l w r ) = N ( eliminar x l ) w ( eliminar x r )