This is a fork of LAU made by Metamist (Alexander Arvidsson) LAU as a project is dead. This fork is an attempt to revitalize Metamist's project, with a few changes to syntax & functionality.

Report Bug · Request Feature

What is LAUX?

How to use

> npm i -g laux-compiler

> lauxc watch ./laux ./lua

Workspaces

{
 "path": {
 "input": "./laux",
 "output": "./lua"
 },
 "merges": [
 {
 "filesGlob": ["atlas_jobcreator/fields/**/*.laux"],
 "output": "atlas_jobcreator/fields"
 },
 {
 "filesGlob": ["atlas_jobcreator/currencies/**/*.laux"],
 "output": "atlas_jobcreator/currencies"
 }
 ]
}

No options

> lauxc workspace

Release that merges files

> lauxc workspace -r

What does it add?

Functions

local Foo = {}
Foo.Bar = (self) => print(self) end -- Foo.Bar = function(self) print(self) end

local Foo = {}
Foo.Bar = () -> print(self) end -- Foo.Bar = function(self) print(self) end

Decorators

Note

You can currently only have one decorator per function, however, you can combine them into one larger decorator

-- These deprecated functions can be defined in
-- your library & be imported using LAUX's
-- import statement
local function deprecated(func)
 return function(...)
 local name = nil
 local index = 1
 while true do
 local info = debug.getinfo(func, "S")
 if not info then
 break
 end
 if info.what == "Lua" and info.name then
 name = info.name
 break
 end
 func = debug.getupvalue(func, index)
 if not func then
 break
 end
 index = index + 1
 end
 MsgC(Color(255, 165, 0), "[WARN] The function " .. name .. " is deprecated. Please look to using alternatives as this will cease to exist!")
 func(...)
 end
end
-- Imagine we have this TestFunc that comes from SomeLibrary,
-- we want to warn users upon each use so that they use
-- something different
@deprecated
function PrintPlayerName(ply)
 print(ply:Nick())
end

Types

function Foo(bar: string)
 -- do nothing
end

function Foo(bar)
 local __lau_type = (istable(bar) and bar.__type and bar:__type()) or type(bar)
 assert(__lau_type == "string", "Expected parameter `bar` to be type `string` instead of `" .. __lau_type .. "`")
end

function Foo(bar: string|MyAddon.Bar)
 -- do nothing
end

function Foo(bar)
 local __lau_type = (istable(bar) and bar.__type and bar:__type()) or type(bar)
 assert(__lau_type == "string" or __lau_type == "MyAddon.Bar", "Expected parameter `bar` to be type `string|MyAddon.Bar` instead of `" .. __lau_type .. "`")
end

Mutations

Note

x-- doesn't exist for obvious reasons (comments).

Note

The prefix incrementation: ++x doesn't exist.

x += 5 -- x = x + 5
x *= 2 -- x = x * 2
x /= 2 -- x = x / 2
x++ -- x = x + 1
x -= 1 -- x = x - 1.
x ||= 2 -- x = x or 2
x ..= "me" -- x = x .. "me"
x %= 2 -- x = x % 2

Shortcut Expressions

stopif i > 5 -- if (i > 5) then return end
breakif i > 2 -- if (i > 2) then break end
continueif i > 8 -- if (i > 8) then continue end

Classes

[public] Class name [extends Parent] end

Note

If we are not using a public class we need to add __type() function.
This is to avoid overlapping names for type checking

class Foo
 -- We can have static attributes
 static ENUMS = {}
 -- We can also non static attributes
 name = "Bar"
 constructor(foobar: string)
 self.foobar = foobar
 end
 setFoobar(val: string) self.foobar = val end
 getFoobar() return self.foobar end
 -- needed in non public classes
 __type()
 return "MyAddon.Foo"
 end
end
-- Don't need new keyword.
local foo1 = Foo()

class Bar extends Foo
 constructor(foobar)
 -- Because we're extending we need to use super()
 -- You need to pass the arguments your parent (extends) need
 super(foobar)
 -- Lets now get our name we got from Foo
 print(self.name)
 end
 -- Only on Bar, not Foo
 uniqueMethod() end
end

public class AtlasShop.Items.Health extends AtlasShop.Item
 -- Since this is a public class you don't need a type
 -- __type will automatically return the name of the class
end

Important

A class can implicitly define a default constructor. But, when inheriting from a default constructor class you must create a constructor to call super() if you define a field, it isn't done implicitly.

class Foo
 var = 5
end
class Bar extends Foo
end
local b = Bar()

This will create an error. To fix it create a constructor.

class Foo
 var = 5
end
class Bar extends Foo
 constructor()
 super()
 end
end
local b = Bar()

Getters and Setters

class Foo
 _get _set variable
 _get secondVariable
end

setVariable = function(self, variable)
 self.variable = variable
 return self
end,
getVariable = function(self)
 return self.variable
end,
getSecondVariable = function(self)
 return self.secondVariable
end,

Safe member navigator

if (groups?[groupKind]?.members?.name) then
end

if (((groups and groups[groupKind]) and groups[groupKind].members) and groups[groupKind].members.name) then
end

Import Statement

import print, warn, log from AtlasUI
print("Hello there!")
warn("Hello there!")
log("Hello there!")

AtlasUI.print("Hello there!")
AtlasUI.warn("Hello there!")
AtlasUI.log("Hello there!")

Spread operator

local a = { 2, 3 }
local b = { 1, ...a, 4 }
PrintTable(b) -- { 1, 2, 3, 4 }

Deconstructing

local tbl = { a = 5, b = 3 }
local { a, b } = tbl -- local a, b = tbl.a, tbl.b
print(a) -- 5
print(b) -- 3

For of statement

for i, v in pairs(tbl) do
end

for i, v of tbl do
end

Formated string

print(string.format("there are %d %s", number, string)

print(`there are ${number} ${string}`)