Lucid es un lenguaje de programación de flujo de datos diseñado para experimentar con modelos de programación que no son de von Neumann . Fue diseñado por Bill Wadge y Ed Ashcroft y descrito en el libro de 1985 Lucid, el lenguaje de programación de flujo de datos . [1]
Paradigma | Flujo de datos |
---|---|
Diseñada por | Edward A. Ashcroft William W. Wadge |
Apareció por primera vez | 1976 |
Disciplina de mecanografía | Sin tipo |
Implementaciones importantes | |
plúcido | |
Dialectos | |
GIPSY, granular lúcido | |
Influenciado por | |
YO NADO | |
Influenciado | |
SISAL , PureData , Lustre |
pLucid fue el primer intérprete de Lucid.
Modelo
Lucid utiliza un modelo impulsado por la demanda para el cálculo de datos. Cada declaración puede entenderse como una ecuación que define una red de procesadores y líneas de comunicación entre ellos a través de las cuales fluyen los datos. Cada variable es un flujo infinito de valores y cada función es un filtro o un transformador. La iteración se simula mediante los valores 'actuales' y el operador 'fby' (leído como 'seguido de') que permite la composición de los flujos.
Lucid se basa en un álgebra de historias, una historia es una secuencia infinita de elementos de datos. Desde el punto de vista operativo, se puede pensar en un historial como un registro de los valores cambiantes de una variable; las operaciones del historial, como la primera y la siguiente, se pueden entender de las formas sugeridas por sus nombres. Lucid se concibió originalmente como un lenguaje disciplinado, matemáticamente puro y de asignación única, en el que la verificación se simplificaría. Sin embargo, la interpretación del flujo de datos ha tenido una influencia importante en la dirección en la que Lucid ha evolucionado. [1]
Detalles
En Lucid (y otros lenguajes de flujo de datos ), una expresión que contiene una variable que aún no se ha vinculado espera hasta que la variable se haya vinculado, antes de continuar. Una expresión como x + y
esperará hasta que tanto x como y estén vinculados antes de regresar con la salida de la expresión. Una consecuencia importante de esto es que se evita la lógica explícita para actualizar los valores relacionados, lo que da como resultado una reducción sustancial del código, en comparación con los lenguajes convencionales.
Cada variable en Lucid es un flujo de valores. Una expresión n = 1 fby n + 1
define un flujo usando el operador 'fby' (un mnemónico para "seguido de"). fby define lo que viene después de la expresión anterior. (En este caso, la secuencia produce 1,2,3, ...). Estos operadores pueden abordar los valores de una secuencia (suponiendo que x es la variable que se utiliza):
'first x'
- obtiene el primer valor de la secuencia x,
'x'
- el valor actual del flujo,
'next x'
: obtiene el siguiente valor en la secuencia.
'asa'
- un operador que hace algo 'tan pronto como' la condición dada se vuelve verdadera.
'x upon p'
- upon es un operador que repite el valor anterior del flujo x, y actualiza los nuevos valores solo cuando el flujo p hace que un true
valor esté disponible. (Sirve para ralentizar el flujo x) es decir: x upon p
es el flujo x con nuevos valores que aparecen sobre la verdad de p.
El cálculo se lleva a cabo mediante la definición de filtros o funciones de transformación que actúan sobre estos flujos de datos que varían en el tiempo.
Ejemplos de
Factorial
fac dónde n = 0 f por (n + 1); fac = 1 fby (fac * (n + 1)); final
secuencia Fibonacci
mentira dónde fib = 0 fby (1 fby fib + siguiente fib); final
Total de una secuencia
total dónde total = 0 f por total + x final;
Promedio corriente
running_avg dónde suma = primero (entrada) f por suma + siguiente (entrada); n = 1 f por n + 1; running_avg = sum / n; final;
números primos
principal dónde primo = 2 fby (n siempre que sea primo (n)); n = 3 f por n + 2; isprime (n) = no (divs) como divs o prime * prime> N dónde N es la corriente n; divs = N mod prime eq 0; final; final
Diagrama de flujo de datos
Ordenación rápida
qsort (a) = si eof (primero a) luego un else sigue (qsort (b0), qsort (b1)) fi dónde p = primero a ; b0 = a siempre que p; b1 = a siempre que no p; seguir (x, y) = si xdone entonces y sobre xdone else x fi dónde xdone = iseod x fby xdone o iseod x; final final
Diagrama de flujo de datos
--------> siempre que -----> qsort --------- | ^ | | | | | no | | ^ | | ---> primero | | | | | | | V | | | ---> menos --- | | | | | VV--- + --------> siempre que -----> qsort -----> conc -------> ifthenelse -----> | ^ ^ | | | --------> siguiente ----> primero ------> iseod -------------- | | | -------------------------------------------------- ---------
Media cuadrática
raíz cuadrada (promedio (cuadrado (a))) dónde cuadrado (x) = x * x; avg (y) = media dónde n = 1 f por n + 1; media = primero y fpor media + d; d = (siguiente y - media) / (n + 1); final; raíz cuadrada (z) = aproximadamente como err <0.0001 dónde Z es la corriente z; aprox = Z / 2 fby (aprox + Z / aprox) / 2; err = abs (cuadrado (aprox.) -Z); final; final
Problema de Hamming
h dónde h = 1 f por fusionar (fusionar (2 * h, 3 * h), 5 * h); fusionar (x, y) = si xx <= yy entonces xx si no yy fi dónde xx = x sobre xx <= yy; yy = y sobre yy <= xx; final; final;
Diagrama de flujo de datos
Referencias
- ^ Wadge, William W .; Ashcroft, Edward A. (1985). Lucid, el lenguaje de programación de flujo de datos . Prensa académica. ISBN 0-12-729650-6. Consultado el 8 de enero de 2015 .