Programação tácita

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar

A programação tácita , também chamada de estilo livre de pontos , é um paradigma de programação em que as definições de funções não identificam os argumentos (ou "pontos") sobre os quais operam. Em vez disso, as definições apenas compõem outras funções, entre as quais estão os combinadores que manipulam os argumentos. A programação tácita é de interesse teórico, porque o uso estrito da composição resulta em programas bem adaptados ao raciocínio equacional . [1] É também o estilo natural de certas linguagens de programação , incluindo APL e seus derivados, [2] elinguagens concatenativas como Forth . A falta de nomeação de argumentos dá ao estilo sem pontos uma reputação de ser desnecessariamente obscuro, daí o epíteto "estilo sem sentido". [1]

O script Unix usa o paradigma com pipes .

A ideia chave na programação tácita é ajudar a operar no nível apropriado de abstração.

Exemplos

Python

A programação tácita pode ser ilustrada com o seguinte código Python . Uma sequência de operações como a seguinte:

def  exemplo ( x ): 
    return  baz ( bar ( foo ( x )))

... é escrito em estilo point-free como a composição de uma sequência de funções, sem parâmetros: [3]

de  functools  import  parcial ,  reduza 
def  compose ( * fns ): 
    retorne  parcial ( reduza ,  lambda  v ,  fn :  fn ( v ),  fns )

exemplo  =  compor ( foo ,  bar ,  baz )

Para um exemplo mais complexo, o código Haskell p = ((.) f) . gpode ser traduzido como:

p  =  parcial ( compor ,  parcial ( compor ,  f ),  g )

Programação funcional

Um exemplo simples (em Haskell ) é um programa que calcula a soma de uma lista de números. Podemos definir a função soma recursivamente usando um estilo pontiagudo (cf. programação em nível de valor ) como:

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

No entanto, usando uma dobra , podemos substituir isso por:

soma  xs  =  dobrar  ( + )  0  xs

E então o argumento não é necessário, então isso simplifica para

soma  =  dobra  ( + )  0

que é sem pontos.

Outro exemplo usa composição de função :

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

O seguinte pseudocódigo semelhante a Haskell expõe como reduzir uma definição de função ao seu equivalente sem pontos:

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 ) 
  ( *  Aqui  o  operador de composição  infixo "." é usado como uma função curry . * ) = \ x -> (( . ) f ) ( g x ) = \ x -> ((( . ) f ) . g ) x        
        
         

p  =  (( . )  f )  .  g

Finalmente, para ver um exemplo complexo, imagine um programa de filtro de mapa que pega uma lista, aplica uma função a ela e, em seguida, filtra os elementos com base em um critério

 lista de operadores de critérios  mf = critérios de filtro ( lista de operadores de mapa )       

Pode ser expresso sem pontos [4] como

mf  =  ( .map ) .  _ ( . ) . filtro    

Observe que, como dito anteriormente, os pontos em 'point-free' referem-se aos argumentos, não ao uso de pontos; um equívoco comum. [5]

Alguns programas foram escritos para converter automaticamente uma expressão Haskell em uma forma sem pontos.

Família APL

Em J , o mesmo tipo de código sem pontos ocorre em uma função feita para calcular a média de uma lista (array) de números:

média =:  +/  %  #

+/soma os itens do array mapeando ( /) soma ( +) para o array. %divide a soma pelo número de elementos ( #) na matriz.

Fórmula de Euler expressa tacitamente:

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

( j.é uma função primitiva cuja definição monádica é 0j1vezes x e cuja definição diádica é x+0j1×y.) Os mesmos cálculos tácitos expressos em Dyalog APL :

média   +  ÷  

cos   2   
sin   1   
EulerCalc    cos  +  0j1  ×  sin    ⍝ 0j1 é o que normalmente é escrito como i 
EulerDirect  * 0J1 ×⊢             ⍝ Igual a ¯12○⊢ 
⍝ Os 2 métodos produzem o mesmo resultado? 
EulerCheck  EulerDirect = EulerCalc 
EulerCheck  ¯1  1  2  3      
1  1  1  1    
⍝ Sim, até agora tudo bem!

Baseado em pilha

Em linguagens de programação orientadas a pilha ( e concatenativas , a maioria das quais são baseadas em pilha ) , métodos livres de pontos são comumente usados . Por exemplo, um procedimento para calcular os números de Fibonacci pode ter a seguinte aparência em PostScript :

/fib 
{ 
   dup  dup  1  eq  exch  0  eq  ou  não 
   { 
      dup  1  sub  fib 
      exch  2  sub  fib 
      add 
   }  if 
}  def

Pipeline Unix

Em scripts Unix, as funções são programas de computador que recebem dados da entrada padrão e enviam os resultados para a saída padrão . Por exemplo,

classificar | uniq -c | classificar -rn

é uma composição tácita ou sem pontos que retorna as contagens de seus argumentos e os argumentos, na ordem decrescente de contagens. O 'sort' e 'uniq' são as funções, o '-c' e '-rn' controlam as funções, mas os argumentos não são mencionados. O tubo '|' é o operador de composição.

Devido à maneira como os pipelines funcionam, normalmente só é possível passar um "argumento" por vez na forma de um par de fluxo de entrada/saída padrão. Embora descritores de arquivos extras possam ser abertos a partir de pipes nomeados , isso não constitui mais um estilo sem pontos.

Veja também

Referências

  1. ^ a b Manuel Alcino Pereira da Cunha (2005) Cálculo do Programa sem Pontos
  2. ^ W. Neville Holmes, ed. (2006) Computadores e Pessoas
  3. ^ "Código de nome não valores" . Concatenative.org . Recuperado em 13 de setembro de 2013 .
  4. ^ pipermail
  5. ^ "Pointfree - HaskellWiki" . wiki.haskell.org . Recuperado 2016-06-05 .

Links externos