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, the Dataflow Programming Language . [1]
pLucid fue el primer intérprete de Lucid.
Lucid utiliza un modelo basado en la demanda para el cálculo de datos. Cada afirmació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 las secuencias.
Lucid se basa en un álgebra de historias, siendo una historia una secuencia infinita de elementos de datos. Operacionalmente, un historial puede considerarse como un registro de los valores cambiantes de una variable; las operaciones históricas como primera y siguiente pueden entenderse en la forma que sugieren sus nombres. Lucid se concibió originalmente como un lenguaje disciplinado, matemáticamente puro y de una sola tarea, 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 ha evolucionado Lucid.[1]
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 + yesperará hasta que x e y estén vinculadas 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 valores relacionados, lo que resulta en 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 + 1define una secuencia utilizando el operador 'fby' (un mnemotécnico 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 sea la variable que se utiliza):
'first x'- recupera el primer valor en la secuencia x,
'x'- el valor actual del flujo,
'next x'- recupera 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 de la secuencia x y actualiza los nuevos valores solo cuando la secuencia p hace que un truevalor esté disponible. (Sirve para ralentizar la corriente x) es decir: x upon pes la corriente x con nuevos valores que aparecen ante la verdad de p.
El cálculo se lleva a cabo definiendo filtros o funciones de transformación que actúan sobre estos flujos de datos que varían en el tiempo.
fac dónde n = 0 fby (n + 1); fac = 1 fby ( fac * (n + 1) ); fin
mentira dónde fib = 0 fby (1 fby fib + siguiente fib); fin
total dónde total = 0 fpor total + x fin;
running_avg dónde suma = primero (entrada) fby suma + siguiente (entrada); n = 1 fpor n + 1; running_avg = suma / n; fin;
principal dónde primo = 2 fby (n siempre que sea primo (n)); n = 3 fpor n+1; isprime(n) = not(divs) como divs o prime*prime > N dónde N es el n actual; divs = N mod prime eq 0; fin; fin
.png/1280px-Prime_numbers_sequence_dataflow_diagram_(Lucid).png)
qsort(a) = si eof(primero a) entonces otro sigue(qsort(b0),qsort(b1)) fi dónde p = primero a < a; b0 = a siempre que p; b1 = a siempre que no sea p; seguir(x,y) = si xhecho entonces y sobre xhecho si no x fi dónde xdone = iseod x fby xdone o iseod x; fin fin
--------> cuando sea -----> qsort --------- | ^ | | | | | no | | ^ | |---> primero | | | | | | | V | | |---> menos --- | | | | | VV---+--------> siempre que -----> qsort -----> conc -------> ifthenelse -----> | ^ ^ | | | --------> siguiente ----> primero ------> iseod -------------- | | | -------------------------------------------------- ---------
raíz cuadrada (promedio (cuadrado (a))) dónde cuadrado(x) = x*x; promedio(y) = media dónde n = 1 fpor n+1; media = primero y fpor media + d; d = (siguiente y - media)/(n+1); fin; raíz cuadrada (z) = aproximadamente asa err < 0,0001 dónde Z es la z actual; aprox = Z/2 fby (aprox + Z/aprox)/2; err = abs(cuadrado(aprox.)-Z); fin; fin
h dónde h = 1 fby merge(merge(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; fin; fin;