Açúcar sintático

Origem: Wikipédia, a enciclopédia livre.
Saltar para a navegação Saltar para a pesquisa

Em ciência da computação, um açúcar sintático é uma sintaxe dentro da linguagem de programação que tem por finalidade tornar suas construções mais fáceis de serem lidas e expressas. Ela faz com que o uso da linguagem se torne "mais doce" para o uso humano, permitindo que suas funcionalidades sejam expressas mais claramente, mais concisamente ou, ainda, como um estilo alternativo preferido por alguns.

Por exemplo, algumas linguagens de programação proveem uma sintaxe especial para referência e atualização de elementos. De forma abstrata, uma referência de Array é um processo simples de dois argumentos: um array e um vetor de subscript, que podem ser expressados assim: get_array(Array, vector(i,j)). Ao invés disso, muitas linguagens oferecem uma sintaxe diferenciada como Array[i,j]. De forma similar, uma atualização de um elemento array é próxima disto: set_array(Array, vector(i,j), value), mas em muitas linguagens constata-se isto também: Array[i,j] = value.

De forma geral, uma construção na linguagem pode ser chamada de Syntactic Sugar se for removida sem causar nenhum efeito sobre o que a linguagem pode fazer: a funcionalidade e o poder de expressividade permanecerão os mesmos.

Origem[editar | editar código-fonte]

O termo "sintática açucarada" foi criado por Peter J. Landin em 1964 para descrever a sintaxe de um ALGOL simples - como a linguagem de programação que foi definida semanticamente nos termos da aplicação das expleções do Cálculo lambda,[1][2] centrada na substituição léxica do λ com "where".

Construída na distinção entre as construções essenciais da linguagem e a Sintática Açucarada feita por Landin, em 1991, Matthias Felleisen propôs uma codificação do poder expressivo para se alinhar com as "crenças largamente sustentadas" na literatura. Ele definiu "mais expressivo" como, sem as construções de linguagem em questão, um programa deveria ser completamente reordenado.[3]

Outras linguagens de programação, como CLU, ML e Scheme, estenderam essa definição para o que dentro do núcleo de linguagem seria definido como construções essenciais. O que fosse conveniente, características de nível superior poderia ser "desaçucaradas" e decompostas para aquele subconjunto.[4] Essa é, de fato, a prática matemática de se construir a partir do que é primitivo.

Exemplos notáveis[editar | editar código-fonte]

  • Atribuição ampliada ou atribuição composta: por exemplo:a += b equivale a a = a + b em C e linguagens similares.
  • Atribuições paralelas: várias combinações podem ser combinadas em uma única afirmação. Por exemplo: a = x; b = y pode ser escrito como a, b = x, y (considerando que todas as variáveis são distintas). É usada, particularmente, quando se vai trocar os valores de duas variáveis.
  • Operador: Usar um operador é semanticamente equivalente a chamar uma função. Por exemplo: a + b * c é igual a add(a, multiply(b, c)).
  • Em Linguagem C o a[i] nota é uma sintática açucarada para *(a + i).[5].
  • O using em C# garante que certos objetos estão dispostos corretamente. O compilador expande a afirmação em um quadro try-finally.[6]
  • Compreensão de listas em Python.
  • Decoradores em Python.

Críticas[editar | editar código-fonte]

Alguns programadores pensam que essa sintaxe é fútil e não importante. Certamente, formas especiais de sintaxe fazem com que uma linguagem seja menos uniforme e sua especificação mais complexa, além de poder causar problemas como tornar programas grandes e complexos. Esse ponto de vista é amplamente espalhada na comunidade Lisp, uma vez que ela possui uma sintaxe muito simples e regular e pode ser facilmente modificada.[2]

Notas e referências

  1. Landin, Peter J. (1964). «The mechanical evaluation of expressions» (PDF). Computer Journal. 6 (4): 308-320. doi:10.1093/comjnl/6.4.308. Consultado em 21 de julho de 2014. 
  2. a b Abelson & Sussman 1996, Chapter 1, footnote 11.
  3. Felleisen, Matthias (dezembro de 1991). «On the Expressive Power of Programming Languages». Springer-Verlag. Science of Computer Programming. 17 (1-3): 35–75. doi:10.1016/0167-6423(91)90036-W. Consultado em 19 de julho de 2014. 
  4. Barbara Liskov, "A History of CLU", MIT Laboratory for Computer Science Technical Report 561 (1993)
  5. Eric S. Raymond (11 de outubro de 1996). The New Hacker's Dictionary - 3rd Edition. [S.l.]: MIT Press. p. 432. ISBN 978-0-262-68092-9. Consultado em 5 de agosto de 2012. 
  6. «using Statement (C# Reference)». Consultado em 16 de setembro de 2014. 

Referências[editar | editar código-fonte]

  • Abelson, Harold; Sussman, Gerald Jay; Sussman, Julie. Structure and Interpretation of Computer Programs.Cambridge, MA: MIT Press. ISBN 0-262-51087-1. [S.l.: s.n.] 
  • Landin, Peter J. (fevereiro–março de 1965). «A Correspondence Between ALGOL 60 and Church's Lambda-Notation: Parts I and II». Communications of the ACM. 8 (2.3): 89–101, 158–165. doi:10.1145/363744.363749 
  • Landin, Peter J. (Maio, 1965). "Programming Without Imperatives - An Example". UNIVAC Systems Programming Research.
  • Landin, Peter J. (Julho, 1965). "Getting Rid of Labels". UNIVAC Systems Programming Research.
  • Landin, Peter J. (Agosto, 1965). "A Generalization of Jumps and Labels". UNIVAC Systems Programming Research., reprinted in "Higher-Order and Symbolic Computation" 11. 1998. pp. 125–143.
  • Perlis, A. J. (September 1982). "Epigrams on programming". ACM SIGPLAN Notices (New York, NY, USA: Association for Computing Machinery) 17 (9): 7–13. [1]. Archived from the original on January 17, 1999.

Este artigo foi originalmente baseado em material do Free On-line Dictionary of Computing que é licenciado sob a GFDL.