Cell

Cell is an actor system, intended to make it easy to parallelize programs.

Programs are written in cell, but cell also makes it trivial to interface with C code.

Packages

Each cell package has a .cell directory at its root. .ce files within this directory can be launched as cell actors, and .cm files can be imported with the 'use' statement.

File search

When a file is imported, cell will search the following locations:

The current package
Imported packages
The cell standard library

Files leading with an underscore are not available to import from a package (but are OK for within a package)

For example, consider this project: prosperon/ prosperon/sprite.cm prosperon/render.cm prosperon/_help.cm prosperon/render.c prosperon/ui/ prosperon/ui/button.cm

sprite.cm can use(render); but an outside package must use(prosperon/render). sprite can use(help), but an outside package cannot use(prosperon/help).

A file like render.c above will be compiled into a dynamic library for the target platform (ie, on macos a .dylib), named the name of the package, 'prosperon.dylib'. For a local package, it will be local.dylib.

In the case above, the js_prosperon_render_use function will be found in the prosperon.dylib, and the result of that will be passed to render.cm as 'this', allowing for trivial extension.

If a C function OR a .cm file is found for a particular import, searching stops, preventing, for example, accidentally applying a .cm file from a local find to a package that has one which is similarly named.

Importing packages

Each package has a list of packages it depends on. They can use their own naming convention for them. Packages are imported from URLs, so, gitea.pockle.world/john/prosperon imports 'prosperon'; but, when importing, you can say, 'renderer = gitea.pockle.world/john/prosperon', and that means you can use(renderer/sprite), etc.

Modules

Modules have a .cm extension. Modules return a single value.

Programs

Programs have a .ce extension. Programs do not return a value.

The scripting language

Cell is basically javascript, but with some key modifications:

blobs instead of arraybuffers, which are written and read bit by bit
All equivalences are hard; there is only != and ==, and they do what !== and === do in javascript
There is no undefined, only null
'var' acts like let, and 'def' acts like const; there is no let and const
logging is done with the global 'log' object; log.console outputs to console, log.error outputs an error, etc.
All numbers are dec64, and are all therefore exact; no floating point rounding errors.
All closures act like _ =>, and close over the 'this' variable
Arrays are distinct from objects
There is no 'delete' operator, just assign to null
There is no 'with'
There are no property descriptors, objects are more like records that can hold functions, numbers, anything.
stone() makes an object immutable, forever

2.9 KiB Raw Blame History