Modules. #

Modules contain accessible static symbols under a defined namespace. By default, importing another Cyber script returns its module with exported 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'
try 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'
export var foo: 123
print foo         -- Statement is ignored.

-- bar.cy
export 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'

export func printB():
    foo.printC()

foo.printA()

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

export func printA():
    main.printB()

export 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. #

Use the export prefix in front of static declarations to indicate that it should be exported when the script’s module is loaded.

export func foo():
    print 123

export var bar: 234

Builtin Modules. #

Cyber currently contains the builtin modules:

• core: Cyber related functions and commonly used utilities.
• math: Math constants and functions.
• os: System level functions.
• test: Utilities for testing.

Core Module. #

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

Sample usage:

print 'hello'
contents = readFile 'foo.txt'
print contents

Math Module. #

The math module contains commonly used math constants and functions.

Sample usage:

import m 'math'

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

Os Module. #

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'

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

type File #

type Dir #

map DirEntry #

map DirWalkEntry #

Test Module. #

The test module contains utilities for testing.

Sample usage:

import t 'test'

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