Stiltiende programmering - Tacit programming

Programmeringsparadigmer

Tavs programmering , også kaldet punktfri stil , er et programmeringsparadigme , hvor funktionsdefinitioner ikke identificerer de argumenter (eller "punkter"), som de fungerer på. I stedet definitionerne blot komponere andre funktioner, blandt hvilke er combinators der manipulerer argumenterne. Stiltiende programmering er af teoretisk interesse, fordi den strenge brug af sammensætning resulterer i programmer, der er godt tilpasset til ligeværdige ræsonnementer. Det er også den naturlige stil for visse programmeringssprog , herunder APL og dets derivater og sammenkædede sprog som Forth . Manglen på argument navngivning giver point-fri stil et ry for at være unødigt uklar, derfor epitetet "meningsløs stil".

Unix scripting bruger paradigmet med rør .

Nøgleidéen i stiltiende programmering er at hjælpe med at operere på det passende abstraktionsniveau.

Eksempler

Python

Tavs programmering kan illustreres med følgende Python -kode. En række operationer som f.eks. Følgende: 

def example(x):
    y = foo(x)
    z = bar(y)
    w = baz(z)
    return w

... er skrevet i punktfri stil som sammensætningen af ​​en sekvens af funktioner uden parametre: 

from functools import partial, reduce
def compose(*fns):
    return partial(reduce, lambda v, fn: fn(v), fns)

example = compose(foo, bar, baz)

For et mere komplekst eksempel kan Haskell -koden p = ((.) f) . goversættes til: 

p = partial(compose, partial(compose, f), g)


Funktionel programmering

Et enkelt eksempel (i Haskell ) er et program, der beregner summen af ​​en liste med tal. Vi kan definere sumfunktionen rekursivt ved hjælp af en spids stil (jf. Værdi -niveau programmering ) som: 

sum (x:xs) = x + sum xs
sum [] = 0

Ved hjælp af en fold kan vi dog erstatte dette med: 

sum xs = foldr (+) 0 xs

Og så er argumentet ikke nødvendigt, så dette forenkler til 

sum = foldr (+) 0

som er punktfri.

Et andet eksempel bruger funktionssammensætning : 

p x y z = f (g x y) z

Følgende Haskell-lignende pseudokode viser, hvordan man reducerer en funktionsdefinition til dens punktfri ækvivalent: 

p = \x -> \y -> \z -> f (g x y) z
  = \x -> \y -> f (g x y)
  = \x -> \y -> (f . (g x)) y
  = \x -> f . (g x)
  (* Here the infix compose operator "." is used as a curried function. *)
  = \x -> ((.) f) (g x)
  = \x -> (((.) f) . g) x

p = ((.) f) . g

Endelig for at se et komplekst eksempel forestille dig et kortfilterprogram, der tager en liste, anvender en funktion på det og derefter filtrerer elementerne baseret på et kriterium 

mf criteria operator list = filter criteria (map operator list)

Det kan udtrykkes punktfrit som 

mf = (. map) . (.) . filter

Bemærk, at som nævnt tidligere refererer punkterne i 'point-free' til argumenterne, ikke til brug af prikker; en almindelig misforståelse.

Et par programmer er blevet skrevet for automatisk at konvertere et Haskell-udtryk til en punktfri form.

APL familie

I J forekommer den samme slags punktfri kode i en funktion, der er beregnet til at beregne gennemsnittet af en liste (matrix) med tal: 

avg=: +/ % #

+/summerer elementerne i arrayet ved at kortlægge ( /) summation ( +) til arrayet. %dividerer summen med antallet af elementer ( #) i arrayet.

Eulers formel udtrykt stiltiende: 

cos =: 2 o. ]
sin =: 1 o. ]
Euler =: ^@j. = cos j. sin

( j.er en primitiv funktion, hvis monadiske definition er 0j1gange x, og hvis dyadiske definition er x+0j1×y.) De samme stiltiende beregninger udtrykt i Dyalog APL : 

avg ← +⌿ ÷ ≢

cos ← 2 ○ ⊢
sin ← 1 ○ ⊢
j   ← {⍺←0 ⋄ ⍺+0j1×⍵}  ⍝ this part is not tacit
Euler ← *∘j = cos j sin

Stack-baseret

I stakorienterede programmeringssprog (og sammenkædede sprog , hvoraf de fleste er stakbaserede), bruges punktfrie metoder almindeligt. For eksempel kan en procedure til beregning af Fibonacci -tallene ligne følgende i PostScript : 

/fib
{
   dup dup 1 eq exch 0 eq or not
   {
      dup 1 sub fib
      exch 2 sub fib
      add
   } if
} def

Unix pipeline

Hovedartikel: Pipeline (Unix)

I Unix -scripting er funktionerne computerprogrammer, der modtager data fra standardindgang og sender resultaterne til standardoutput . For eksempel, 

sort | uniq -c | sort -rn

er en stiltiende eller punktfri sammensætning, der returnerer optællingerne af sine argumenter og argumenterne i rækkefølgen for faldende tællinger. 'Sort' og 'uniq' er funktionerne, '-c' og '-rn' styrer funktionerne, men argumenterne nævnes ikke. Røret '|' er sammensætningsoperatøren.

På grund af den måde, rørledninger fungerer på, er det normalt kun muligt at sende et "argument" ad gangen i form af et par standard input/output -strøm. Selvom ekstra filbeskrivelser kan åbnes fra navngivne rør , udgør dette ikke længere en punktfri stil.

Se også

Referencer

eksterne links