enum

enum would help with speed at runtime when checking between multiple values:

enum ConnectionType {
    INET;
    INET6;
    UNIX;
};

print(INET == ConnectionType.INET);

INET and ConnectionType.INET both compile to 1, so the resulting code would be similar to:

print(1 == 1)

enum values may be assigned with an "initial" value; values assigned afterwards take the value of the former, adding one:

enum Numbers {
    ZERO = 48;
    ONE;
    TWO;
    THREE;
    FOUR;
    FIVE;
    SIX;
    SEVEN;
    EIGHT;
    NINE;
    TEN;
};

Enumeration values could also be assigned after an initial
assignment, and to any integer, negative or positive:

enum Numbers {
    NFIVE = -5;
    NFOUR;
    NTHREE;
    ZERO = 0;
    ONE;
    TWO;
    TEN = 10;
};

Enumeration values can't go backwards:

enum BadEnum {
    ONE;
    ZERO = 0; -- errors during compilation
};

const

const values are like enumerations, but only one value is assigned per statement:

--- FusionScript
const max_char = 255;
print(string.char(max_char));

--- Lua
print(255);

Unlike enumerations, const values can also be true, false, nil, or a string:

--- FusionScript
const format_pattern = "%s: %s";
print(format_pattern:format(name, message));

--- Lua
print(("%s: %s"):format(name, message))

CONSIDERATION: "%s: %s":format() is not valid Lua. Instead, the
value - if not used only as a value, for instance, as a callable or indexable
object - should be wrapped in parenthesis first.

This will be useful for:

• const and enum scanning (this issue is a prerequisite
• Speed up compilation times for files that don't need to be recompiled

This should work:

File("test.txt"):with(\file-> print(file:read("*a")));

It does not. The lexer needs to change the actual call (i.e. the .x.y:z<a>() into an array of these calls

• @module directive
• import

import

To help with using #4 across multiple files, the compiler should be aware of enums that are used cross-process. The import statement can be used to direct the compiler to both scan the module for enumerations, as well as load values from the module:

--- FusionScript
import stdlib.error {
    BaseError;
};

--- Lua
local _des_0 = require("stdlib.error")
local BaseError = _des_0.BaseError

All values can be extracted from a module, but many linters would not be aware of this. The syntax will also only work if the module has a module directive at the top of the file.

--- FusionScript
import stdlib.error *;

--- Lua
local _des_0 = require("stdlib.error")
local BaseError, Error, assert = _des_0.BaseError, _des_0.Error, _des_0.assert

Enumerations can also be included but will not show up in the compiled output:

--- FusionScript - example.fuse
import connections {
    ConnectionType;
};
print(ConnectionType.INET);
--- FusionScript - connections.fuse
-- @module connections
enum ConnectionType {
    INET;
    INET6;
    UNIX;
};

--- Lua - example.lua
print(1);
--- Lua - connections.lua
_ENV = setmetatable({}, {__index = _G})
return _ENV

An entire module can be loaded into a table, instead of having values destructured into the local scope:

--- FusionScript
import stdlib.error => error;

--- Lua
local error = require("stdlib.error");

-- @module directive

A comment that matches the pattern -- @<directive> [parameter] is considered a directive. When parsing a file, the compiler will take advantage of these comments to produce output that better matches the type of file. The -- @module directive (with a single required parameter, the name of the module) instructs the compiler that the following file should be treated as a module, which will set the environment to a contained table (to prevent leaking of values assigned globally) and return the table at the end of the file:

--- FusionScript - example.fuse
-- @module example

printf(fmt, ...)=>
    print(string.format(fmt, ...));

_ENV = setmetatable({}, {__index = _G})
function printf(fmt, ...)
    print(string.format(fmt, ...))
end
return _ENV