Função anônima

Em programação de computadores , uma função anônima ( literal de função , expressão ou bloco ) é uma definição de função que não está vinculada a um identificador . Funções anônimas são frequentemente argumentos sendo passados ​​para funções de ordem superior ou usados ​​para construir o resultado de uma função de ordem superior que precisa retornar uma função. [1] Se a função for usada apenas uma vez, ou um número limitado de vezes, uma função anônima pode ser sintaticamente mais leve do que usar uma função nomeada. Funções anônimas são onipresentes em linguagens de programação funcional e outras linguagens com funções de primeira classe , onde elas cumprem a mesma função para o tipo de função que os literais cumprem para outros tipos de dados .

Funções anônimas se originam no trabalho de Alonzo Church em sua invenção do cálculo lambda , no qual todas as funções são anônimas, em 1936, antes dos computadores eletrônicos. [2] Em várias linguagens de programação, funções anônimas são introduzidas usando a palavra-chave lambda , e funções anônimas são frequentemente chamadas de lambdas ou abstrações lambda. Funções anônimas têm sido uma característica das linguagens de programação desde Lisp em 1958, e um número crescente de linguagens de programação modernas suportam funções anônimas.

Nomes

Os nomes "abstração lambda", "função lambda" e "expressão lambda" referem-se à notação de abstração de função no cálculo lambda, onde a função usual f ( x ) = M seria escrita x . M ) , e onde M é uma expressão que usa x . Compare com a sintaxe Python de . lambda x: M

O nome "função de seta" refere-se ao símbolo matemático " mapeia para ", xM . Compare com a sintaxe JavaScript de . [3]x => M

Usos

Funções anônimas podem ser usadas para conter funcionalidades que não precisam ser nomeadas e possivelmente para uso de curto prazo. Alguns exemplos notáveis ​​incluem closures e currying .

O uso de funções anônimas é uma questão de estilo. Usá-las nunca é a única maneira de resolver um problema; cada função anônima pode ser definida como uma função nomeada e chamada pelo nome. Funções anônimas geralmente fornecem uma notação mais breve do que definir funções nomeadas. Em linguagens que não permitem a definição de funções nomeadas em escopos locais, funções anônimas podem fornecer encapsulamento por meio de escopo localizado, no entanto, o código no corpo de tal função anônima pode não ser reutilizável ou passível de testes separados. Funções anônimas curtas/simples usadas em expressões podem ser mais fáceis de ler e entender do que funções nomeadas definidas separadamente, embora sem um nome descritivo elas possam ser mais difíceis de entender.

Em algumas linguagens de programação, funções anônimas são comumente implementadas para propósitos muito específicos, como vincular eventos a retornos de chamada ou instanciar a função para valores específicos, o que pode ser mais eficiente em uma linguagem de programação dinâmica , mais legível e menos propenso a erros do que chamar uma função nomeada.

Os exemplos a seguir foram escritos em Python 3.

Classificação

Ao tentar classificar de uma forma não padrão, pode ser mais fácil conter a lógica de classificação como uma função anônima em vez de criar uma função nomeada. A maioria das linguagens fornece uma função de classificação genérica que implementa um algoritmo de classificação que classificará objetos arbitrários. Essa função geralmente aceita uma função arbitrária que determina como comparar se dois elementos são iguais ou se um é maior ou menor que o outro.

Considere este código Python classificando uma lista de strings pelo comprimento da string:

>>>  a  =  [ 'casa' ,  'carro' ,  'bicicleta' ] 
>>>  a . sort ( chave = lambda  x :  len ( x )) 
>>>  a 
[ 'carro' ,  'bicicleta' ,  'casa' ]

A função anônima neste exemplo é a expressão lambda:

lambda  x :  comprimento ( x )

A função anônima aceita um argumento, x, e retorna o comprimento do seu argumento, que é então usado pelo sort()método como critério para classificação.

A sintaxe básica de uma função lambda em Python é

lambda  arg1 ,  arg2 ,  arg3 ,  ... :  < operação  nos  argumentos  que  retornam  um  valor >

A expressão retornada pela função lambda pode ser atribuída a uma variável e usada no código em vários lugares.

>>>  adicionar  =  lambda  a :  a  +  a 
>>>  adicionar ( 20 ) 
40

Outro exemplo seria classificar itens em uma lista pelo nome de sua classe (em Python, tudo tem uma classe):

>>>  a  =  [ 10 ,  'número' ,  11.2 ] 
>>>  a . sort ( chave = lambda  x :  x . __class__ . __name__ ) 
>>>  a 
[ 11.2 ,  10 ,  'número' ]

Observe que 11.2tem nome de classe " float", 10tem nome de classe " int" e 'number'tem nome de classe " str". A ordem classificada é " float", " int" e depois " str".

Fechamentos

Closures são funções avaliadas em um ambiente contendo variáveis ​​vinculadas . O exemplo a seguir vincula a variável "threshold" em uma função anônima que compara a entrada ao threshold.

def  comp ( limite ): 
    retornar  lambda  x :  x  <  limite

Isso pode ser usado como uma espécie de gerador de funções de comparação:

>>>  func_a  =  comp ( 10 ) 
>>>  func_b  =  comp ( 20 )

>>>  print ( func_a ( 5 ),  func_a ( 8 ),  func_a ( 13 ),  func_a ( 21 )) 
Verdadeiro  Verdadeiro  Falso  Falso

>>>  print ( func_b ( 5 ),  func_b ( 8 ),  func_b ( 13 ),  func_b ( 21 )) 
Verdadeiro  Verdadeiro  Verdadeiro Falso 

Seria impraticável criar uma função para cada função de comparação possível e pode ser muito inconveniente manter o limite por perto para uso posterior. Independentemente do motivo pelo qual um fechamento é usado, a função anônima é a entidade que contém a funcionalidade que faz a comparação.

Currying

Currying é o processo de mudar uma função para que, em vez de receber múltiplas entradas, ela receba uma única entrada e retorne uma função que aceite a segunda entrada, e assim por diante. Neste exemplo, uma função que realiza divisão por qualquer inteiro é transformada em uma que realiza divisão por um inteiro definido.

>>>  def  divide ( x ,  y ): 
...      retornar  x  /  y

>>>  def  divisor ( d ): 
...      retornar  lambda  x :  dividir ( x ,  d )

>>>  metade  =  divisor ( 2 ) 
>>>  terço  =  divisor ( 3 )

>>>  imprimir ( metade ( 32 ),  terço ( 32 )) 
16.0  10.666666666666666

>>>  imprimir ( metade ( 40 ),  terço ( 40 )) 
20.0  13.333333333333334

Embora o uso de funções anônimas talvez não seja comum com currying, ele ainda pode ser usado. No exemplo acima, a função divisor gera funções com um divisor especificado. As funções half e third curry a função divide com um divisor fixo.

A função divisora ​​também forma um fechamento ao vincular a variável d.

Funções de ordem superior

Uma função de ordem superior é uma função que recebe uma função como argumento ou retorna uma como resultado. Isso é comumente usado para personalizar o comportamento de uma função definida genericamente, geralmente uma construção de loop ou esquema de recursão. Funções anônimas são uma maneira conveniente de especificar tais argumentos de função. Os exemplos a seguir estão em Python 3.

Mapa

A função map realiza uma chamada de função em cada elemento de uma lista. O exemplo a seguir eleva ao quadrado cada elemento em um array com uma função anônima.

>>>  a  =  [ 1 ,  2 ,  3 ,  4 ,  5 ,  6 ] 
>>>  lista ( mapa ( lambda  x :  x * x ,  a )) 
[ 1 ,  4 ,  9 ,  16 ,  25 ,  36 ]

A função anônima aceita um argumento e o multiplica por si mesmo (eleva ao quadrado). A forma acima é desencorajada pelos criadores da linguagem, que sustentam que a forma apresentada abaixo tem o mesmo significado e está mais alinhada com a filosofia da linguagem:

>>>  a  =  [ 1 ,  2 ,  3 ,  4 ,  5 ,  6 ] 
>>>  [ x * x  para  x  em  a ] 
[ 1 ,  4 ,  9 ,  16 ,  25 ,  36 ]

Filtro

A função de filtro retorna todos os elementos de uma lista que são avaliados como Verdadeiro quando passados ​​para uma determinada função.

>>>  a  =  [ 1 ,  2 ,  3 ,  4 ,  5 ,  6 ] 
>>>  lista ( filtro ( lambda  x :  x  %  2  ==  0 ,  a )) 
[ 2 ,  4 ,  6 ]

A função anônima verifica se o argumento passado a ela é par. O mesmo que com map, a forma abaixo é considerada mais apropriada:

>>>  a  =  [ 1 ,  2 ,  3 ,  4 ,  5 ,  6 ] 
>>>  [ x  para  x  em  a  se  x  %  2  ==  0 ] 
[ 2 ,  4 ,  6 ]

Dobrar

Uma função fold é executada sobre todos os elementos em uma estrutura (para listas geralmente da esquerda para a direita, uma "dobra à esquerda", chamada reduceem Python), acumulando um valor conforme avança. Isso pode ser usado para combinar todos os elementos de uma estrutura em um valor, por exemplo:

>>>  de  functools  importar  reduzir 
>>>  a  =  [ 1 ,  2 ,  3 ,  4 ,  5 ] 
>>>  reduzir ( lambda  x , y :  x * y ,  a ) 
120

Isso executa

A função anônima aqui é a multiplicação dos dois argumentos.

O resultado de uma dobra não precisa ser um valor. Em vez disso, tanto o mapa quanto o filtro podem ser criados usando dobra. No mapa, o valor que é acumulado é uma nova lista, contendo os resultados da aplicação de uma função a cada elemento da lista original. No filtro, o valor que é acumulado é uma nova lista contendo apenas os elementos que correspondem à condição fornecida.

Lista de idiomas

A seguir está uma lista de linguagens de programação que suportam funções anônimas sem nome totalmente, ou parcialmente como alguma variante, ou não suportam de forma alguma.

Esta tabela mostra algumas tendências gerais. Primeiro, as linguagens que não suportam funções anônimas ( C , Pascal , Object Pascal ) são todas linguagens estaticamente tipadas. No entanto, linguagens estaticamente tipadas podem suportar funções anônimas. Por exemplo, as linguagens ML são estaticamente tipadas e fundamentalmente incluem funções anônimas, e Delphi , um dialeto de Object Pascal , foi estendido para suportar funções anônimas, assim como C++ (pelo padrão C++11 ). Segundo, as linguagens que tratam funções como funções de primeira classe ( Dylan , Haskell , JavaScript , Lisp , ML , Perl , Python , Ruby , Scheme ) geralmente têm suporte a funções anônimas para que as funções possam ser definidas e passadas tão facilmente quanto outros tipos de dados.

Exemplos de funções anônimas

Veja também

Referências

  1. ^ "Funções de ordem superior". learnyouahaskell.com . Recuperado em 3 de dezembro de 2014 .
  2. ^ Fernandez, Maribel (2009), Modelos de Computação: Uma Introdução à Teoria da Computabilidade, Tópicos de Graduação em Ciência da Computação, Springer Science & Business Media, p. 33, ISBN 9781848824348, O cálculo Lambda ... foi introduzido por Alonzo Church na década de 1930 como uma notação precisa para uma teoria de funções anônimas
  3. ^ "Expressões de função de seta - JavaScript". MDN . Recuperado em 21 de agosto de 2019 .
  4. ^ "Tipos de acesso". www.adaic.org . Recuperado em 27/06/2024 .
  5. ^ "Bash lambda". GitHub . 2019-03-08.
  6. ^ BillWagner. "Expressões Lambda - referência C#". docs.microsoft.com . Recuperado em 2020-11-24 .
  7. ^ "Suporte de fechamento". Arquivado do original em 2014-01-06 . Recuperado em 2014-01-05 .
  8. ^ "O que há de novo no ColdFusion 10". Arquivado do original em 2014-01-06 . Recuperado em 2014-01-05 .
  9. ^ "Clojure - Higher Order Functions". clojure.org . Recuperado em 2022-01-14 .
  10. ^ "Managed COBOL Reference". Documentação Micro Focus . Micro Focus . Arquivado do original em 25 de fevereiro de 2014 . Recuperado em 25 de fevereiro de 2014 .
  11. ^ "Funções - Linguagem de programação D". dlang.org . Recuperado em 2022-01-14 .
  12. ^ "Um tour pela linguagem Dart". dart.dev . Recuperado em 2020-11-24 .
  13. ^ "Métodos anônimos em Delphi - RAD Studio". docwiki.embarcadero.com . Recuperado em 2020-11-24 .
  14. ^ "Funções — Programação Dylan". opendylan.org . Recuperado em 2022-01-14 .
  15. ^ "docs/syntax". elm-lang.org . Recuperado em 2022-01-14 .
  16. ^ "Sintaxe Erlang/Elixir: Um curso intensivo". elixir-lang.github.com . Recuperado em 2020-11-24 .
  17. ^ "Erlang -- Funs". erlang.org . Recuperado em 2020-11-24 .
  18. ^ cartermp. "Expressões Lambda: A palavra-chave divertida - F#". docs.microsoft.com . Recuperado em 2020-11-24 .
  19. ^ "LAMBDA: A função definitiva de planilha do Excel". microsoft.com . 25 de janeiro de 2021 . Recuperado em 2021-03-30 .
  20. ^ "Quotations - Factor Documentation" . Recuperado em 26 de dezembro de 2015 . Uma citação é uma função anônima (um valor que denota um trecho de código) que pode ser usada como um valor e chamada usando os combinadores fundamentais.
  21. ^ "Frink". frinklang.org . Recuperado em 2020-11-24 .
  22. ^ "Funções anônimas em GoLang". GoLang Docs . 9 de janeiro de 2020 . Recuperado em 2020-11-24 .
  23. ^ "Documentação Gosu" (PDF) . Recuperado em 4 de março de 2013 .
  24. ^ "Groovy Documentation". Arquivado do original em 22 de maio de 2012. Recuperado em 29 de maio de 2012 .
  25. ^ "Função anônima - HaskellWiki". wiki.haskell.org . Recuperado em 2022-01-14 .
  26. ^ "Lambda". Haxe - O kit de ferramentas multiplataforma . Recuperado em 2022-01-14 .
  27. ^ "Funções - JavaScript | MDN". developer.mozilla.org . Recuperado em 2022-01-14 .
  28. ^ "Funções · A linguagem Julia". docs.julialang.org . Recuperado em 2020-11-24 .
  29. ^ "Higher-Order Functions and Lambdas - Linguagem de programação Kotlin". Kotlin . Recuperado em 2020-11-24 .
  30. ^ "Programação em Lua: 6". www.lua.org . Recuperado em 2020-11-24 .
  31. ^ "Maple Programming: 1.6: Funções e expressões anônimas - Application Center". www.maplesoft.com . Recuperado em 2020-11-24 .
  32. ^ "Funções anônimas - MATLAB e Simulink". www.mathworks.com . Recuperado em 2022-01-14 .
  33. ^ "Manual do Maxima 5.17.1: 39. Definição de função". maths.cnam.fr . Recuperado em 2020-11-24 .
  34. ^ "Manual do Nim". nim-lang.github.io .
  35. ^ "Exemplos de código – OCaml". ocaml.org . Recuperado em 2020-11-24 .
  36. ^ "GNU Octave: Funções Anônimas". octave.org . Recuperado em 2020-11-24 .
  37. ^ "Function Literals". Manual do usuário do OpenSCAD . Wikibooks . Recuperado em 22 de fevereiro de 2021 .
  38. ^ "perlsub - Sub-rotinas Perl - Navegador Perldoc". perldoc.perl.org . Recuperado em 2020-11-24 .
  39. ^ "PHP: Funções anônimas - Manual". www.php.net . Recuperado em 2020-11-24 .
  40. ^ "6. Expressões — documentação do Python 3.9.0". docs.python.org . Recuperado em 2020-11-24 .
  41. ^ "4.4 Funções: lambda". docs.racket-lang.org . Recuperado em 2020-11-24 .
  42. ^ "Funções". docs.raku.org . Recuperado em 2022-01-14 .
  43. ^ Sosinski, Robert (2008-12-21). "Entendendo Ruby Blocks, Procs e Lambdas". Reactive.IO. Arquivado do original em 2014-05-31 . Recuperado em 2014-05-30 .
  44. ^ "Closures: Funções anônimas que podem capturar seu ambiente - A linguagem de programação Rust". doc.rust-lang.org . Recuperado em 2022-01-14 .
  45. ^ "Funções Anônimas". Documentação Scala . Recuperado em 2022-01-14 .
  46. ^ "Recitação 3: Funções de ordem superior". www.cs.cornell.edu . Recuperado em 2022-01-14 .
  47. ^ "Closures — A linguagem de programação Swift (Swift 5.5)". docs.swift.org .
  48. ^ "Documentação - Tipos cotidianos". www.typescriptlang.org . Recuperado em 2022-01-14 .
  49. ^ "Tipo de função - Documentação Typst". typst.app . Recuperado em 2024-09-10 .
  50. ^ ab "Projetos/Vala/Tutorial - GNOME Wiki!". wiki.gnome.org . Recuperado em 2020-11-24 .
  51. ^ KathleenDollard (15 de setembro de 2021). "Expressões Lambda - Visual Basic". docs.microsoft.com . Recuperado em 2022-01-14 .
  52. ^ "Referência de linguagem/Termos/Predicados anônimos - wiki.visual-prolog.com". wiki.visual-prolog.com . Recuperado em 2022-01-14 .
  53. ^ "Pure Anonymous Function: Introdução elementar à linguagem Wolfram". www.wolfram.com . Recuperado em 2022-01-14 .
  54. ^ "Lambdas, Closures e tudo mais · Edição #1048 · ziglang/zig". GitHub . Recuperado em 21/08/2023 .
  • Métodos anônimos - quando devem ser usados? (blog sobre função anônima em Delphi)
  • Compilando expressões Lambda: Scala vs. Java 8
  • funções anônimas do php funções anônimas do php
  • Funções lambda em várias linguagens de programação
  • Funções em Go
Retrieved from "https://en.wikipedia.org/w/index.php?title=Anonymous_function&oldid=1252038929"