Boolean class represents a value that is either
Byte class represents a wrapper over a single
Byte value. A
is always unsigned, giving it a range from 0 to 255.
Byte literals are written
using 't' as the suffix on an
ByteString class represents a bag of bytes. A
ByteString may have '\0'
values embedded within it. It may also have data that is not valid as utf-8.
ByteString class currently does not support any primitive operations.
Coroutine is similar to a
Function, except that it can also yield values
at different points along its lifetime. Every
Coroutine has a callstack that
belongs to it, as well as an exception state. A
Coroutine's status can be
discovered by one of the is_ methods.
Double class exists as a wrapper over a C double.
File class provides a wrapper over a C FILE * struct. A
File is closed
automatically when a scope exits (though not immediately). However, it is also
possible to manually close a
Function class represents a block of code to be called, which may or may
not produce a value.
Function values are first-class, and can be passed around
as arguments, placed into a
List, and so on.
Hash class provides a mapping between a key and a value.
Hash values can
be created through
[key1 => value1, key2 => value2, ...]. When writing a
Hash, the key is the first type, and the value is the second.
Integer class is Lily's native numeric type. Internally, it is a wrapper
over a C int64_t.
List class represents a container of a given type, written as
List[<inner type>]. A
List value can be accessed through a positive index or
a negative one (with negative indexes being an offset from the end). Attempting
to access an invalid index will produce
String class provides a wrapper over a C char *. The
String class is
guaranteed to have a single '\0' terminator. Additionally, a
guaranteed to always be valid utf-8.
Tuple class provides a fixed-size container over a set of types.
is ideal for situations where a variety of data is needed, but a class is too