Lu-a-Bá - O bê-a-bá de Lua para a comunidade lusófona

Versões

A distribuição padrão de Lua é, como na maior parte dos programas de computador, versionada. Cada nova versão traz mudanças que podem ser a remoção de algo que não faz mais sentido, a correção de um problema, a melhoria de um recurso existente ou um novo recurso.

As versões de lua seguem o formato X.Y (por exemplo, 5.0). Para uma mesma versão, diferentes lançamentos podem ser realizados para correções de problemas.

Lançamentos diferentes seguem o padrão X.Y.Z, onde Z é o número do lançamento. Diferentes versões não oferecem nenhuma garantia de compatibilidade binária. Por outro lado, lançamentos de uma mesma versão são compatíveis.

Não é possível saber com precisão quais versões de Lua são utilizadas atualmente, porém ao procurar por projetos que utilizam Lua veremos uma preponderância de quatro versões suportadas: 5.1, 5.2, 5.3 e 5.4.

Isto não é por acaso. Além de serem as quatro versões mais recentes, todas as quatro possuem a especificação ainda disponível na página principal do projeto Lua, e ainda são oferecidas em repositórios de vários sistemas operacionais, o que dá às quatro versões um estado não oficial de “versão corrente”. Na prática, porém, cabe destacar que apenas a versão 5.4 ainda segue em desenvolvimento.

Embora existam algumas mudanças de uma versão para outra, é possível escrever código que funcione para as quatro versões, quando isso for desejável. Geralmente isso é adequado quando se deseja migrar de uma versão mais antiga para uma versão mais nova (já que o contrário é no mínimo incomum).

Seja como for, saber o que mudou de uma versão para outra é importante, especialmente entre essas quatro versões mais utilizadas. Essas mudanças são muito bem documentadas nas especificações de cada versão. Portanto o foco deste documento não é exatamente elencar o que mudou, mas comentar algumas consequências dessas mudanças e cuidados que o programador deve ter, em vista dessas mudanças.

5.4

Algumas das grandes mudanças na versão 5.4 foram “internas”, ou seja, sem grandes consequências visíveis na linguagem Lua e na API C. A exemplo disto temos agora um novo método para coleta de lixo (geracional), que já havia sido planejada para versões anteriores, porém acabou se tornando viável apenas nesta versão. Outra mudança interna foi o uso de um novo algoritmo para a função math.random().

Porém houve também importantes mudanças mais visíveis. Exemplo disto é a manipulação de co-rotinas que agora permite explicitamente fechar uma co-rotina via biblioteca coroutine em Lua, e reiniciar uma co-rotina ao seu estado inicial via API. Outra grande mudança é a inclusão de constantes e variáveis “fecháveis”, que em conjunto com as funções de manipulação de co-rotina trazem novas possibilidades para a programação funcional em Lua.

Dentre as mudanças na API, podemos destacar também a possibilidade de múltiplos valores Lua embutidos em um userdata (user values). Antes apenas um uservalue era possível. Isso mudou um pouco as funções de configuração e acesso a user values.

Mais informações

5.3

Na versão 5.3 a biblioteca bit32 que havia surgido na versão anterior é depreciada, tendo em vista que agora existem operadores que implementam a mesma funcionalidade, tornando mais prático a execução de operações bit a bit. E surge também a biblioteca utf8, que adiciona um suporte básico a manipulação de caracteres UTF-8.

Outro destaque é a representação de números como inteiros de 64 bits por padrão. Apenas quando há uma parte fracionária, os números passam a ser representados por tipos de ponto flutuante. Cabe destacar que os operadores bit a bit surgidos nesta versão operam sobre uma representação de inteiros de 64 bits, diferente da biblioteca bit32, que operava sobre inteiros de 32 bits.

Outra novidade interessante é a possibilidade de associação de valores Lua aos tipos userdata. Isso dá muito mais flexibilidade e versatilidade a esses tipos, que agora podem usufruir dos tipos Lua como parte de si, provendo uma interface mais natural com as partes do programa escritas em Lua.

Também é possível realizar serialização e de-serialização com as novas funções string.pack() e string.unpack(), que manipulam um conjunto de bytes em uma cadeia de caracteres de maneira compacta e com padrões de acesso bem definidos.

Por fim, mas não menos importante, há um conjunto de mudanças que melhoram a ergonomia da programação com Lua, tanto na API (com as novas funções lua_seti() e lua_geti(), para acesso a tabelas, por exemplo), como na biblioteca padrão (com a nova função table.move() e a não necessidade de asteriscos em io.read(), por exemplo), além do novo operador de divisão arredondada para baixo (//).

Mais informações

5.2

A versão 5.2 não é marcada por poucas grandes mudanças, mas sim por várias pequenas mudanças que juntas compõem uma grande mudança relevante. Talvez o maior destaque seja para o conceito de ambientes, que já existia em versões anteriores, mas que assume uma nova denotação.

Ambientes passam a não existir mais para funções C, apenas funções Lua, e são armazenados na tabela _ENV. Manipular essa tabela altera o ambiente, de modo que as funções getfenv() e setfenv() se tornam obsoletas. O ambiente global é compartilhado por padrão para toda nova função sob a forma dessa tabela _ENV, determinando o que estará disponível para a função em questão.

Essa mudança tem consequências também para a construção de módulos, que agora pode fazer uso da tabela _ENV em Lua. Em C, não é mais possível utilizar ambientes, porém ainda é válido utilizar tabelas como upvalues compartilhados entre as funções de um módulo.

Neste sentido, a função module() foi depreciada em favor de uma abordagem mais genérica, utilizando os recursos da linguagem (tabelas, escopo léxico), além do fato de que se convencionou a partir de então que módulos não criem objetos globais.

Outra mudança maior foi a criação do módulo bit32 na biblioteca padrão, de modo que Lua passou a ter suporte a operações de bit a bit em inteiros de 32 bits com sinal. Para além disso, a função loadstring() foi depreciada, uma vez que a função load() passa a trabalhar também com cadeias de caracteres como argumentos para definição dos trechos que executará.

Mais informações

5.1

Dentre os principais destaques desta versão estão um novo esquema de coleta de lixo incremental, que ajudou a prevenir contra a incidência de longas pausas, e um novo sistema de módulos, que de certo modo padronizou ainda mais a criação de módulos em Lua (utilizando a função module()).

É importante frisar, no entanto, que esse esquema de criação de módulos não durou muito, (vide a versão 5.2, sobre a depreciação da função module()).

Algumas outras novidades importantes foram uma nova semântica para funções com número arbitrário de argumentos (varargs), um novo operador para cálculo do resto de divisões (operador modulo, ou seja, %), comentários longos e cadeias longas que podem ser aninhados, usando diferentes níveis, e metatabelas em tipos que não são tabelas (como cadeias de caracteres e userdata).

Mais informações

5.0

A versão 5.0 não é objeto de estudo do projeto Lu-a-Bá. Entretanto, essa versão foi um marco importante na história da linguagem. Foi uma grande mudança, que iniciou um novo ciclo de desenvolvimento de maior maturidade na linguagem, o qual permanece em andamento até hoje. Além disso, a versão 5.0 é mencionada em muitos dos materiais discutidos no Lu-a-Bá. Deste modo, ela também é destacada aqui.

Dentre algumas das grandes mudanças podemos elencar o suporte total a escopo léxico, co-rotinas, o novo mecanismo de laços for genéricos, metatabelas e metamétodos, comentários longos (isto é, de blocos), o tipo booleano e uma padronização sobre a distribuição de módulos usando tabelas Lua.

Outro aspecto interessante a se observar é que esta foi a primeira versão de Lua a utilizar a licença MIT. Versões anteriores (desde a versão 2.1) já utilizavam uma licença permissiva (e também compatível com a GPL), porém era uma licença personalizada, o que causou bastante controvérsia. Quando reconhecida como compatível pela Free Software Foundation, a mudança para a licença MIT já havia sido conduzida.

Para mais informações sobre o trajeto seguido desde a concepção inicial da linguagem até o momento atual, vale conferir também a apresentação da evolução de Lua no HOPL III.