Lua

# Install a package to the local directory "lua_modules"
$ luarocks install --tree lua_modules lpeg
# Create the helper script to load paths
$ cat << EOF > set_paths.lua
local version = _VERSION:match("%d+%.%d+")
package.path = 'lua_modules/share/lua/' .. version .. '/?.lua;lua_modules/share/lua/' .. version .. '/?/init.lua;' .. package.path
package.cpath = 'lua_modules/lib/lua/' .. version .. '/?.so;' .. package.cpath
EOF
# Execute your Lua script using the libraries installed in this directory
$ lua -l set_paths my_script.lua
# Running tests with busted:
$ busted --helper=set_paths

$ cat preface.lua
inspect = require "inspect"
answer = 42
$ lua -i preface.lua
Lua 5.2.4  Copyright (C) 1994-2015 Lua.org, PUC-Rio
> =answer
42
> answer = {result = 42}
> print(inspect(answer))
{
  result = 42
}
> =answer
table: 0x5616a46f8460

luarocks --local install luarepl
luarocks --local install linenoise

not nil     -- true
not not nil -- false
not "x"     -- false
not not "x" -- true
not { }     -- false
not not { } -- true

false and "truthy" -- false
nil   and "truthy" -- nil, but not converted to boolean
true  and 1        -- 1 (not converted)
"ok"  and "truthy" -- "truthy" (not converted)

> function null() print "null" end
> function one() print "one"; return 1 end
> function two() print "two"; return 2 end
> one() or two()
one
1
> null() or one() or two()
null
one
1

> _G
table: 0x55f25f32d870
> _G._G
table: 0x55f25f32d870
> _G._G._G
table: 0x55f25f32d870

do
  local a2 = 2*a
  local d = sqrt(b^2 - 4*a*c)
  x1 = (-b + d)/a2
  x2 = (-b - d)/a2
end          -- scope of `a2' and `d' ends here
print(x1, x2)

function love.load()
    -- ...
end

inspect = require "inspect"
-- Create an empty table. If this is missing, it will error out on the next
-- line: "attempt to index global 'foo' (a nil value)"
foo = {}
-- Create a function `bar` directly inside `foo`.
function foo.bar(args)
    print(inspect(args))
end
-- Exactly the same as the above, but requires a tiny bit more typing.
foo.bar = function(args)
    print(inspect(args))
end
-- Use it as any standalone function:
foo.bar()   -- nil
foo.bar(42) -- 42

> foo:bar()
{
  bar = <function 1>
}
> foo:bar(42)
{
  bar = <function 1>
}

print "hello world"            --> print("hello world")
inspect { foo, bar }           --> inspect({ foo, bar })
-- Also works without whitespace after the function name:
require"module"
inspect{ "42", 42 }
-- Use with another function:
print( inspect {42, "42"} )

> print(tonumber "42" + 1)
43

$ cat example.lua
if enable_debug_globally then
    print('Warning: bad thing happened')
end
$ cat mymodule.lua
print('Debugging enabled')
enable_debug_globally = true
$ lua example.lua
$ lua example.lua -l mymodule
$ lua -l mymodule example.lua
Debugging enabled
Warning: bad thing happened

$ lua example.lua
$ lua -e 'enable_debug_globally=true' example.lua
Warning: bad thing happened

local rgb = {r=100, g=42, b=111}  -- reference, because `type(rgb)` => table
local alpha = 0.5                 -- value, because `type(alpha)` => number

function make_opaque(color, transparency)
    color.r = 0       -- Works, modifies the passed table
    color.g = 0       -- Works, modifies the passed table
    color.b = 0       -- Works, modifies the passed table
    transparency = 0  -- WRONG! Only affects the local scope!
    print("Transparency in the local scope now is", transparency)
end

inspect = require "inspect"

print("before:", inspect(rgb))
print("before:", alpha)
make_opaque(rgb, alpha)
print("after: ", inspect(rgb))
print("after: ", alpha)         --> 0.5. Probably not what was intended.

> a = {}
> print(a)
table: 0x558dd8454510
> b = a
> print(b)
table: 0x558dd8454510
> b.example = 42
> print(a.example)
42

> orig = {"one", "two"}
> print(orig)
table: 0x55ce75805940
> copy = orig
> print(copy)
table: 0x55ce75805940
> for i, v in ipairs(copy) do print(i, v) end
1       one
2       two
> orig = {1, 2}   -- changes original by setting a new value, copy unaffected!
> for i, v in ipairs(copy) do print(i, v) end
1       one
2       two
> print(orig)
table: 0x55ce75805a10
> print(copy)
table: 0x55ce75805940

local data = {number=42, text="The answer"}
data.answer = data.number -- Makes a copy, like with any other Number variable
data.answer = 44          -- Modifies the copy, original `number` remains intact

-- We need to leverage the __index metamethod to create a true alias
setmetatable(data, {
    __index = function(table, key)
        local lookup = {
            value = 'number',
            description = 'text',
        }
        local alias = lookup[key]
        if alias then
            -- Works, but it would call again this function, then the 2nd call
            -- would reach the end, return nil, and fallback to the real table.
            -- With rawget, we bypass that. Not strictly necessary though.
            -- return table.alias
            return rawget(table, alias)
        end
        -- If not found, we implicitly return nil, and that makes Lua look for
        -- the value in the object itself the usual way.
    end
})

print(data.value)
print(data.description)

inspect = require 'inspect'
print(inspect(data))

Base = {}
Base.sharedData = 42
function Base.__tostring()
    return "Base.__tostring"
end
setmetatable(Base, Base)
print(Base)

Derived = {}
setmetatable(Derived, {__index = Base})

print("## Field sharedData is available on Derived:")
print(Derived.sharedData)

print("## Derived is not pretty printed: __tostring is not on its metatable")
print(Derived)

print("## Function __tostring can be called manually thanks to __index, but it's not a metamethod")
print(Derived:__tostring())

setmetatable(Derived, {__index = Base, __tostring = Base.__tostring})
print("## Derived is now pretty printed: __tostring refers to Base.__tostring")
print(Derived) -- Works again

function Base.__call()
    print("Implementation from Base")
end
print("## Base now can be called like a function, but Derived can not")
Base()
-- Derived() -- Error, __call not found: __index doesn't help like with sharedData.
setmetatable(Derived, {__index = Base, __call = Base.__call})
print("## After setting the metamethod directly on the metatable, it works")
Derived() -- Now it works