Este documento explica cómo Luan difiere de Lua como se describe en el Manual de Referencia de Lua 5.3.
Lua es uno de los lenguajes más simples disponibles, pero Luan es aún más simple. Esto significa que Luan elimina más de lo que agrega. La mayoría de lo que se agrega se hace en la librería, no en el lenguaje en sí.
Luan está implementado en Java y está estrechamente integrado con Java. Esto lo convierte en un excelente lenguaje de scripting para Java.
Luan agrega un tipo binario que Lua no tiene. Esto se debe a que las cadenas de Lua pueden representar binarios mientras que las cadenas de Luan no pueden.
El tipo Nil de Luan se implementa como el null de Java. El tipo Boolean de Luan se implementa como el tipo Boolean de Java. El tipo Number de Luan se implementa como el tipo Number de Java. El tipo String de Luan se implementa como el tipo String de Java. Los números reales pueden ser cualquier subclase de la clase Number de Java.
Las funciones de Luan pueden estar escritas en Luan o pueden ser envoltorios alrededor de métodos nativos de Java. Cualquier método de Java puede ser llamado como una función de Luan.
El tipo java de Luan es un reemplazo para el userdata de Lua. Un valor java de Luan no es más que un objeto Java que no cae en uno de los otros tipos reconocidos.
El tipo binario de Luan es el tipo byte[ ] de Java, que es un arreglo de bytes.
El tipo tabla de Luan es igual a su equivalente en Lua, pero implementado en Java.
Luan no tiene el tipo hilo de Lua que en realidad no son hilos sino corrutinas. Luan tiene hilos reales. Esto es particularmente valioso para el servicio web donde cada solicitud es manejada por un hilo. Pero la sincronización de hilos es demasiado complicada para los programadores de aplicaciones. Por lo tanto, Luan hace que los objetos mutables sean inmutables cuando se vuelven accesibles por múltiples hilos. Esto elimina la necesidad de sincronización de hilos. Si hay necesidad de compartir estado mutable entre hilos, hay funciones especiales para esto.
Luan no tiene un entorno global en absoluto, no hay _G. Por defecto, Luan tampoco define _ENV, pero si lo defines como una tabla local en un fragmento, entonces actúa como lo hace en Lua. Cuando _ENV no está definido, no hay variables globales y un nombre de variable no reconocido produce un error de compilación.
Cada módulo se inicializa con una función local: require. El módulo luego usa esta función para obtener acceso a lo que necesite.
Luan tiene la función error pero no tiene pcall o xpcall. Luan agrega la sentencia try en su lugar. Los errores de Luan se implementan como una tabla de errores, no como un objeto de mensaje.
Luan solo tiene metatablas para tablas, no para otros tipos.
Luan no soporta el metamétodo call. No hay nada que se pueda hacer con el metamétodo call que no se pueda hacer más limpiamente con cierres, por lo que se dejó fuera.
Luan utiliza la recolección de basura de Java. Luan no tiene métodos especiales de recolección de basura.
Luan aún no tiene tablas débiles, pero esto se agregará.
Luan no tiene corrutinas. Las corrutinas son un concepto complejo que no se necesita en un lenguaje simple, por lo que se dejó fuera.
A diferencia de Lua, Luan considera el final de una línea como el final de una sentencia. Esto detecta errores y fomenta la legibilidad. Si deseas continuar una sentencia en otra línea, puedes usar una barra invertida seguida de un salto de línea que se tratará como espacio en blanco.
Luan tiene un conjunto de palabras clave similar a Lua y tiene las mismas otras convenciones léxicas.
Por defecto, no hay variables globales y una variable indefinida produce un error de compilación. Para habilitar variables globales, se debe definir _ENV. Evitar variables globales hace que sea mucho más fácil detectar errores en tiempo de compilación.
Luan agrega los terminadores de bloque end_do, end_for, end_function, end_if, end_try, y end_while. Estos se pueden usar para terminar el tipo de bloque apropiado, pero end también se puede usar para terminar cualquier bloque.
La mayoría de las sentencias en Luan son las mismas que en Lua. Solo se enumerarán aquellas sentencias que difieren.
La sentencia if, while, y repeat de Luan son las mismas que en Lua excepto que la expresión de condición debe devolver un valor booleano. Cualquier otro tipo de valor producirá un error. Esto ayuda a detectar errores y hace que el código sea más legible.
Luan agrega la sentencia continue que se usa dentro de bucles.
Luan no tiene una sentencia goto.
Luan no tiene una sentencia for numérica. Luan solo tiene una sentencia for genérica. En lugar de la sentencia for numérica, Luan utiliza la función range en una sentencia for genérica como esta:
for i in range(from,to,step) do block end
La sentencia for genérica de Luan es más simple que la versión de Lua porque Luan solo usa una expresión, no una lista de expresiones. Así que una sentencia for como:
for var_1, ···, var_n in exp do block end
es equivalente al código:
do
local f = exp
while true do
local var_1, ···, var_n = f()
if var_1 == nil then break end
block
end
end
A diferencia de Lua, Luan tiene una sentencia try. Ver Sentencia Try en el Manual de Referencia de Luan. Esto también elimina la necesidad de la función pcall de Lua que Luan no tiene.
A diferencia de Lua, Luan permite que las expresiones or y and sean sentencias independientes. Esto es útil en casos como este:
x==5 or error "x debería ser 5"
Las sentencias de plantilla son una adición de Luan que no existe en Lua. Ver Sentencias de Plantilla en el Manual de Referencia de Luan.
A diferencia de Lua, Luan no realiza conversiones automáticas de cadenas a números.
Los operadores bit a bit parecen ser una nueva adición a Lua 5.3 y no existían en Lua 5.2. Luan no soporta operadores bit a bit, pero estos se pueden agregar si hay necesidad.
El único cambio en Luan es que not debe tomar un argumento booleano. Esto ayuda a detectar errores y hace que el código sea más legible.
A diferencia de Lua, Luan convierte todos los operandos de concatenación a cadenas.
A diferencia de Lua, Luan considera un fin_de_línea como un separador de campo en un constructor de tablas.
A diferencia de Lua, Luan no permite que se pasen argumentos adicionales no nulos a una función. En Luan, esto causa un error. Este cambio ayuda a encontrar errores de codificación que serían muy difíciles de detectar de otra manera.
Luan no soporta el estilo de llamada a función orientada a objetos de Lua v:name(args). La programación orientada a objetos se realiza en Luan usando cierres, por lo que esta característica no es necesaria.
Luan no soporta llamadas de cola adecuadas. Debido a que Java no soporta esto de manera limpia, se dejó fuera.
Las expresiones de comillas invertidas son una adición de Luan que no existe en Lua. Ver Comillas Invertidas en el Manual de Referencia de Luan.