Modules. #

Modules have their own namespace and contain accessible static symbols. By default, importing another Cyber script returns a module with its declared symbols.

Importing. #

Import declarations create a local alias to the module referenced by the import specifier. The Cyber CLI comes with some builtin modules like math and test. If the specifier does not refer to a builtin module, it looks for a Cyber script file relative to the current script’s directory. An embedder can integrate their own module loader.

import t 'test'
t.eq(123, 123)

-- Imports are static declarations so they can be anywhere in the script.
import m 'math'
print m.cos(0)

-- Loading another Cyber script.
import foo 'bar.cy'
print foo.myFunc()
print foo.myVar

A Cyber script that is imported doesn’t evaluate its main block. Only static declarations are effectively loaded. If there is code in the main block, it will skip evaluation. In the following, only the print statement in the main.cy is evaluated.

-- main.cy
import a 'foo.cy'
print a.foo

-- foo.cy
import 'bar.cy'
var foo: 123
print foo         -- Statement is ignored.

-- bar.cy
var bar: 321
print bar         -- Statement is ignored.

You can have circular imports in Cyber. In the following example, main.cy and foo.cy import each other without any problems.

-- main.cy
import foo 'foo.cy'

func printB():
    foo.printC()

foo.printA()

-- foo.cy
import main 'main.cy'

func printA():
    main.printB()

func printC():
    print 'done'

Static variable declarations from imports can have circular references. Read more about this in Static Variables.

Modules can also be destructured using the following syntax:

import { cos, pi } 'math'
print cos(pi)

Exporting. #

All static declarations are exported when the script’s module is loaded.

func foo():         -- Exported static function.
    print 123

var bar: 234        -- Exported static variable.

type Thing object:  -- Exported type.
    a float

The annotation @hide provides a hint to editors that the static symbol should not appear in the auto-complete. Despite this, the symbol is still reachable.

Builtin Modules. #

Builtin modules are the bare minimum that comes with Cyber. The embeddable library contains these modules and nothing more. They include:

• builtins: Cyber related functions and commonly used utilities.
• math: Math constants and functions.

Incomplete: The docs for builtin modules are not completely up-to-date. They will be auto generated in the future.

builtins. #

The builtins module contains functions related to Cyber and common utilities. It is automatically imported into each script’s namespace.

Sample usage:

-- `print` and `typeid` are available without imports.
print 'hello'
var id = typeid('my str')
print id

math. #

The math module contains commonly used math constants and functions.

Sample usage:

import m 'math'

var r = 10
print(m.pi * r^2)

Std Modules. #

Std modules come with Cyber’s CLI. They include:

• os: System level functions.
• test: Utilities for testing.

Incomplete: The docs for std modules are not completely up-to-date. They will be auto generated in the future.

os. #

Cyber’s os module contains system level functions. It’s still undecided as to how much should be included here so it’s incomplete. You can still access os and libc functions yourself using Cyber’s FFI or embedding API.

Sample usage:

import os 'os'

var map = os.getEnvAll()
for map each k, v:
    print '{k} -> {v}'

type File #

type Dir #

map DirEntry #

map DirWalkEntry #

map ArgOption #

test. #

The test module contains utilities for testing.

Sample usage:

import t 'test'

var a = 123 + 321
t.eq(a, 444)