Imoprting modules
System libraries
This is how including other libraries works, for example include fmt module from standard library:
use fmt: mod[std] = {fmt};
def main: mod[init] = {
fmt::log.warn("Last warning!...")
}
To use only the log namespace of fmt module:
use log mod[std] = {fmt::log};
def main: mod[init] = {
pro[] main: int = {
log.warn("Last warning!...")
}
}
But let’s say you only wanna use ONLY the warn functionality of log namespace from fmt module:
use warn mod[std] = {fmt::log.warn};
def main: mod[init] = {
pro[] main: int = {
warn("Last warning!...")
}
}
Local libraries
To include a local package (example, package name bender), then we include the folder where it is, followed by the package name (folder is where files are located, package is the name defned with mod[])
use bend: mod[loc] = {../folder/bender};
Then to acces only a namespace:
use space: mod[loc] = {../folder/bender::space};
Definig modules
Main module
Every file in a folder is part of a package, which means everything in the folder that uses the same package name, share the same scope. Two pakages can’t exist in same folder.
def shko: mod[] = {
// implementation
}
If a package is an executable, it should have pro[] main: int to tell the compiler where to start.
use log mod[std] = {fmt::log};
def shko: mod[] = {
pro[] main: int = {
log.warn("Last warning!...")
}
}
To save the fingers and some brackets, we use a short hand of package declaration at the very top of the page (like golang):
def shko: mod[]
use log mod[std] = {fmt::log};
pro[] main: int {
log.warn("Last warning!...")
}
Namespaces
A namespace can be defined in three ways:
- in a subfolder
- same folder, but in a new file
- or the same file
and is done by using slash when outside the main module
def shko/other: mod[] = {
pro[] main: int = {
// implementation
}
// implementation
}
or in the same module file:
def shko: mod[] = {
pro[] main: int = {
// implementation
}
def shko/other: mod[] = {
// implementation
}
}
Scopes
Every file in a folder is part of one package, thus they share the same scope. Thus two varibles with same name at global scope cant be defined. However, this is kind of special for functions. Functions of the same name and same amount of parameters (so identical functions, not function overloading) can be defined in two different files. When called, the one on the same file is used.
In case a function exists in two files and is called from thrid one, then this can be resolved in two ways. First when the package is defined, the priority shoud be defined too like: def shko: mod[pri=5], this a function with same name, in a different file, with def shko: mod[pri=4] would be called before. If no proorities are defined, then the function in files with name of the files as priority. So the function add() in “file1.shko” would be called before “file2.shko”.
file1.fol
use log mod[std] = {fmt::log};
def shko: mod[] = {
var globalVar = 5 // first instance of a constant $globalVar variable
pro[] main: int {
log.info( add(5,6) ) // calling function in different file but same package (shko)
log.info( sub(8,3) ) // this function is from the same file and not form file2
}
fun sub(a, b: int): int = {
return .sub(a, b)
}
}
file2.fol
use log mod[std] = {fmt::log};
def shko: mod[] = {
var globalVar = 5 // this throws an error, as it was declared before
fun add(a, b: int): int = {
return .add(a, b)
}
fun sub(a, b: int): int = { // this does not throw error, even another function has the name
return .sub(a, b)
}
}
file3.fol
use log mod[std] = {fmt::log};
def shko: mod[] = {
fun add(a, b: int): int = {
return .add(a, b)
}
}
Blocks of code
Block statement is used for scopes where members get destroyed when scope is finished. And there are two ways to define a block: unnamed blocks and named blocks
Unnamed blocks
Are simply scopes, that may or may not return value, and are represented as: { //block }
def shko: mod[] = {
pro[] main: int = {
{
.echo("simple type block")
}
.echo({ return "return type block" })
}
}
If the block is prepended with a dot in front like: .{ //block } then, when block is isolated on runtime too, in case of error, will not exit the program. it is meant for testing only
def shko: mod[] = {
var const: int = 5
pro[] main: int = {
.{
const = 6; // this throws an error, but the program doen't exit
}
.echo(const) // this still returns the value 5
}
}
Named blocks
Blocks can be used as labels too, when we want to unconditionally jump to a specific part of the code.
def shko/other: mod[] = {
pro[] main: int = {
def block: blk[] = { // $block A named block that can be referenced
// implementation
}
def mark: blk[] // $mark A named block that can be referenced, usually for "jump" statements
}
}
Unit tests
Blocks defined with type tst, have access to the module (or namespace) defined in tst["name", access].
def test1: tst["sometest", shko] = {}
def "some unit testing": tst[shko] = {}