Lucid (programmeringssprog) - Lucid (programming language)

Klar

Paradigme	Dataflow
Designet af	Edward A. Ashcroft William W. Wadge
Først dukkede op	1976
Skrive disciplin	Typeløs
Større implementeringer
pLucid
Dialekter
GIPSY, granulær Lucid
Påvirket af
JEG SVØMMER
Påvirket
Sisal , PureData , Luster

Lucid er et programmeringssprog til dataforløb designet til at eksperimentere med ikke- Neumann programmeringsmodeller. Det blev designet af Bill Wadge og Ed Ashcroft og beskrevet i 1985-bogen Lucid, Dataflow Programming Language .

pLucid var den første tolk for Lucid.

Model

Lucid bruger en efterspørgselsstyret model til dataregistrering. Hver erklæring kan forstås som en ligning, der definerer et netværk af processorer og kommunikationslinjer mellem dem, gennem hvilke data strømmer. Hver variabel er en uendelig strøm af værdier, og hver funktion er et filter eller en transformer. Iteration simuleres af 'aktuelle' værdier og 'fby' (læst som 'efterfulgt af') operatør, der tillader sammensætning af streams.

Lucid er baseret på en algebra af historier, hvor en historie er en uendelig række af dataelementer. Operativt kan en historie betragtes som en registrering af de skiftende værdier for en variabel, historikoperationer som første og næste kan forstås på måder, der foreslås af deres navne. Lucid blev oprindeligt opfattet som et disciplineret, matematisk rent, single-task sprog, hvor verifikation ville blive forenklet. Men den dataflow har fortolkning været en vigtig indflydelse på den retning, som Lucid har udviklet sig. [1]

detaljer

I Lucid (og andre sprog for dataflytning ) venter et udtryk, der indeholder en variabel, der endnu ikke er bundet, indtil variablen er bundet, inden den fortsætter. Et udtryk som x + y venter, indtil både x og y er bundet, før de vender tilbage med output af udtrykket. En vigtig konsekvens af dette er, at eksplicit logik til opdatering af relaterede værdier undgås, hvilket resulterer i betydelig reduktion af kode sammenlignet med almindelige sprog.

Hver variabel i Lucid er en strøm af værdier. Et udtryk n = 1 fby n + 1 definerer en strøm ved hjælp af operatøren 'fby' (en hukommelse for "efterfulgt af"). fby definerer, hvad der kommer efter det forrige udtryk. (I dette tilfælde producerer strømmen 1,2,3, ...). Værdierne i en strøm kan adresseres af disse operatorer (forudsat at x er den variabel, der bruges):

'first x' - henter den første værdi i strømmen x,

'x' - strømens aktuelle værdi

'next x' - henter den næste værdi i strømmen.

'asa' - en operatør, der gør nogle ting 'så snart' den givne betingelse bliver sand.

'x upon p' - upon er en operatør, der gentager den gamle værdi af stream x og kun opdaterer til de nye værdier, når stream p stiller en true værdi til rådighed. (Det tjener til at bremse strømmen x) dvs. x upon p er strømmen x med nye værdier, der vises på sandheden af ​​p.

Beregningen udføres ved at definere filtre eller transformationsfunktioner, der virker på disse tidsvarierende datastrømme.

Eksempler

Faktor

fac
  where
    n = 0 fby (n + 1);
    fac = 1 fby ( fac * (n + 1) );
  end

Fibonacci-sekvens

fib
  where
    fib = 0 fby ( 1 fby fib + next fib );
  end

I alt af en sekvens

total
  where
     total = 0 fby total + x
  end;

Løbende gennemsnit

running_avg
  where 
     sum = first(input) fby sum + next(input);
     n = 1 fby n + 1;
     running_avg = sum / n;
  end;

Primtal

prime
  where
     prime = 2 fby (n whenever isprime(n));
     n = 3 fby n+2;
     isprime(n) = not(divs) asa divs or prime*prime > N
                     where
                       N is current n;
                       divs = N mod prime eq 0;
                     end;
  end

Dataflowdiagram

Hurtig sortering

qsort(a) = if eof(first a) then a else follow(qsort(b0),qsort(b1)) fi
  where
     p = first a < a;
     b0 = a whenever p;
     b1 = a whenever not p;
     follow(x,y) = if xdone then y upon xdone else x fi
                     where
                        xdone = iseod x fby xdone or iseod x; 
                     end
  end

Dataflowdiagram

    --------> whenever -----> qsort ---------
   |             ^                           |
   |             |                           |
   |            not                          |
   |             ^                           |
   |---> first   |                           |
   |       |     |                           |
   |       V     |                           |
   |---> less ---                            |
   |             |                           |
   |             V                           V
---+--------> whenever -----> qsort -----> conc -------> ifthenelse ----->
   |                                                       ^   ^
   |                                                       |   |
    --------> next ----> first ------> iseod --------------    |
   |                                                           |
    -----------------------------------------------------------

Geometriske middelværdi

sqroot(avg(square(a)))
  where
     square(x) = x*x;
     avg(y)    = mean
        where
          n = 1 fby n+1;
          mean = first y fby mean + d;
          d = (next y - mean)/(n+1);
        end;
     sqroot(z) = approx asa  err < 0.0001
        where
          Z is current z;
          approx = Z/2 fby (approx + Z/approx)/2;
          err    = abs(square(approx)-Z);
        end;
   end

Hamming problem

h
   where
     h = 1 fby merge(merge(2 * h, 3 * h), 5 * h);
     merge(x,y) = if xx <= yy then xx else yy fi
        where 
          xx = x upon xx <= yy;
          yy = y upon yy <= xx;
        end;
   end;

Dataflowdiagram

Referencer

eksterne links

• pLucid