FP (programmeringssprog) - FP (programming language)

FP
Paradigme Funktionsniveau
Designet af John Backus
Først dukkede op 1977
Dialekter
FP84
Påvirket af
APL
Påvirket
FL , Haskell

FP (forkortelse for funktionel programmering ) er et programmeringssprog oprettet af John Backus for at understøtte programmeringsparadigmet på funktionsniveau . Det gør det muligt at opbygge programmer fra et sæt generelt nyttige primitiver og undgå navngivne variabler (en stil, også kaldet stiltiende programmering eller "punktfri"). Det blev stærkt påvirket af APL, som blev udviklet af Kenneth E. Iverson i begyndelsen af ​​1960'erne.

FP-sproget blev introduceret i Backus's Turing Award- artikel fra 1977 , "Kan programmering frigøres fra von Neumann-stilen?", Med underteksten "en funktionel stil og dens programmernes algebra." Papiret vakte interesse for funktionel programmeringsforskning, hvilket til sidst førte til moderne funktionelle sprog (som stort set er baseret på lambda calculus paradigme) og ikke det funktionsniveau paradigme, Backus havde håbet på. I sit Turing-prispapir beskrev Backus, hvordan FP-stilen er forskellig:

Et FP-system er baseret på brugen af ​​et fast sæt kombinerende former kaldet funktionelle former. Disse plus enkle definitioner er det eneste middel til at opbygge nye funktioner fra eksisterende. de bruger ingen variabler eller erstatningsregler, og de bliver operationerne for en tilknyttet algebra af programmer. Alle funktionerne i et FP-system er af en type: de kortlægger objekter på objekter og tager altid et enkelt argument.

FP selv fandt aldrig meget brug uden for den akademiske verden. I 1980'erne skabte Backus et efterfølger-sprog, FL , som var et internt projekt hos IBM Research.

Oversigt

De værdier, som FP-programmer kortlægger i hinanden, omfatter et sæt, der lukkes under sekvensdannelse : 

if x1,...,xn are values, then the sequence 〈x1,...,xn〉 is also a value

Disse værdier kan bygges fra ethvert sæt atomer: booleanske, heltal, realer, tegn osv .: 

boolean   : {T, F}
integer   : {0,1,2,...,∞}
character : {'a','b','c',...}
symbol    : {x,y,...}

⊥ er den udefinerede værdi eller bunden . Sekvenser er bundbevarende : 

〈x1,...,⊥,...,xn〉  =  ⊥

FP-programmer er funktioner f, som hver kortlægger en enkelt værdi x i en anden: 

f:x represents the value that results from applying the function f 
    to the value x

Funktionerne er enten primitive (dvs. forsynet med FP-miljøet) eller er bygget fra primitiverne ved programdannende operationer (også kaldet funktionaliteter ).

Et eksempel på primitiv funktion er konstant , som omdanner en værdi x til den konstantværdige funktion x̄ . Funktionerne er strenge : 

f:⊥ = ⊥

Et andet eksempel på en primitiv funktion er vælgerfunktionsfamilien , betegnet med 1 , 2 , ... hvor: 

i:〈x1,...,xn〉  =  xi  if  1 ≤ i ≤ n
              =  ⊥   otherwise

Funktioner

I modsætning til primitive funktioner fungerer funktionaliteter på andre funktioner. For eksempel har nogle funktioner en enhedsværdi , såsom 0 til tilføjelse og 1 til multiplikation . Den funktionelle enhed producerer en sådan værdi, når den anvendes til en funktion f, der har en: 

unit +   =  0
unit ×   =  1
unit foo =  ⊥

Dette er kernefunktionaliteterne i FP: 

composition  f∘g        where    f∘g:x = f:(g:x)

construction [f1,...,fn] where   [f1,...,fn]:x =  〈f1:x,...,fn:x〉

condition (h ⇒ f;g)    where   (h ⇒ f;g):x   =  f:x   if   h:x  =  T
                                             =  g:x   if   h:x  =  F
                                             =  ⊥    otherwise

apply-to-all  αf       where   αf:〈x1,...,xn〉  = 〈f:x1,...,f:xn〉

insert-right  /f       where   /f:〈x〉             =  x
                       and     /f:〈x1,x2,...,xn〉  =  f:〈x1,/f:〈x2,...,xn〉〉
                       and     /f:〈 〉             =  unit f

insert-left  \f       where   \f:〈x〉             =  x
                      and     \f:〈x1,x2,...,xn〉  =  f:〈\f:〈x1,...,xn-1〉,xn〉
                      and     \f:〈 〉             =  unit f

Ligningsfunktioner

Ud over at være konstrueret fra primitiver af funktionaliteter, kan en funktion defineres rekursivt af en ligning, hvor den enkleste slags er: 

f ≡ Ef

hvor E f er et udtryk bygget fra primitiver, andre definerede funktioner og funktionssymbolet f i sig selv ved hjælp af funktionaliteter.

FP84

FP84 er en udvidelse af FP til at omfatte uendelige sekvenser , programmeringsdefinerede kombinationsformer (analoge med dem, som Backus selv tilføjede til FL , hans efterfølger til FP) og doven evaluering . I modsætning til FFP, en anden af ​​Backus 'egne variationer på FP, skelner FP84 en klar skelnen mellem objekter og funktioner: dvs. sidstnævnte er ikke længere repræsenteret af sekvenser af førstnævnte. FP84's udvidelser opnås ved at fjerne FP-begrænsningen om, at sekvenskonstruktion kun anvendes på ikke- objekter: I FP84 lukkes hele universet af udtryk (inklusive dem, hvis betydning er ⊥) under sekvenskonstruktion.

FP84s semantik er legemliggjort i en underliggende algebra af programmer, et sæt af funktionsniveau- lighed, der kan bruges til at manipulere og ræsonnere omkring programmer.

Referencer

  • Ofre enkelhed for nemheds skyld: Hvor trækker du grænsen? , John H. Williams og Edward L. Wimmers, IBM Almaden Research Center, Proceedings of the FIfteenth Annual ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages, San Diego, CA, januar 1988.

eksterne links