Manual: base

null always represents an absence of something.

null and false are the only values that produce false when converted into boolean values.

The definition of null is a bit weird because it's a legal class while being a constant.

As an internal detail, the null is an interface that is its own interface and parent.

The compiler uses control flow to implement 'and' operation, therefore this function is only there for consistency.

The compiler uses control flow to implement 'or' operation, therefore this function is only there for consistency.

The compiler uses control flow or instructions to implement 'not' operation, therefore this function is only there for consistency.

Every value has an interface. Since interfaces are first class values they also have to have an interface.

This is a mostly feature for introspection. You can use it to obtain a parent interface of an interface until you hit the object, super(object) is null.

Multimethods represent bundles of functions of fixed arity. Programmer can insert more of functions into a multimethod at any time.

During invocation multimethods calls interface() for every argument they get. The result is used to determine the function to call. If the value is missing in the table, the default -method is called. If there's no default method, then an error is raised.

It is expected that multimethods have a clear semantic and modes of failures that are obeyed by the functions put into the table.

Multimethods have an .arity field that tells their arity and a .default field that can be set. The .default field should be set only once.

Interfaces are immutable to favor the JIT compiler. This can be changed, but so far I haven't found a real need to change an interface after it has been created. It's usually just as simple to create a new interface.

Paths have mutable attributes "is_absolute", "basename", "label". There is also .push(path) -method to help in-place modify the path.

To pass path to FFI, the path object has "get_os_path" -method to convert the path into system path.

If you pass it a function or greenlet, it will convert it into a greenlet and adds it to the event queue after the duration passes.

Conceptually greenlets represent a body of work you can stop for a moment while you do a different task. Note that you are always in a greenlet. You can always put the current task to sleep, or switch to the eventloop to run a different task.

Greenlet represents a call frame that can be suspended. The arguments describe a function to call and it can be left blank. In that case the switching has to pass a function that is called inside the greenlet.

The greenlet.parent describes where the call returns once it finishes.

greenlet.switch(arguments...) suspends the current greenlet and switches to the targeted greenlet. If the greenlet hasn't started yet, the given arguments are concatenated to the initial arguments. If the greenlet is suspended, the arguments are compacted into a value and returned in the target greenlet.

A Base multimethod for converting two value into values that pair arithmetically. Coercion is used when the values cannot be found from the usual multimethod table and when the exact pairing cannot be found.

Sometimes we expect that two types are arithmetically interchangeable although they would be technically different. Therefore many arithmetic operations in Lever come with coercion as default for the time when there's not a specific method for the given operation.

This method must coerce the two values into most specific common type they share.

The conversion must make sense before doing an arithmetic operation such as addition, multiplication or substraction.

Concatenation and addition are not a same thing because the two can make sense separately in a same object. This was the case in the numpy module of the Python. We rather do not repeat that mistake.

Note that both getcwd() and chdir(path) may eventually move into fs -module.