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
- Ano de primeiro lançamento: 2020
- Ano do lançamento mais recente: 2023 (Lua 5.4.6)
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
- README (seção de principais mudanças, em inglês).
- Lista detalhada de incompatibilidades (em inglês) com a versão anterior.
5.3
- Ano de primeiro lançamento: 2015
- Ano do último lançamento: 2020 (Lua 5.3.6)
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
- README (seção de principais mudanças, em inglês).
- Lista detalhada de incompatibilidades (em inglês) com a versão anterior.
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
- README (seção de principais mudanças, em inglês).
- Lista detalhada de incompatibilidades (em inglês) com a versão anterior. Disponível também em português.
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
- Lista detalhada de incompatibilidades (em inglês) com a versão anterior. Disponível também em português.
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.