repository·main·Indexed 18 days ago
https://github.com/raku/nqpA lightweight, Raku-like environment designed as a small runtime footprint for virtual machines, used for building compilers and libraries for platforms including MoarVM, the JVM, and JavaScript. It includes 6model, a framework for implementing object-oriented features through meta-objects and representations, and provides tools like nqp-m for executing scripts and a REPL.
The rubyish implementation includes several Ruby-inspired features, but note that some behaviors (like string concatenation and truthiness) follow Rakuish rules.
'...', %q{...}, interpolating strings "...#{...}", and %Q{...}.%w[aa bb cc].if...then...elsif...else...endif, unless...end, while, until, and for loops.for val in [10, 20, 30] do ... endfor kv in h do ... end (iterates by pairs).grep(arr) {|n| n % 2 == 0}).def foo(bar:42, baz:).<<EOF ... EOF and interpolating <<"END" ... END.Trig::PI = 3.1415926.~ operator. The + operator is strictly for arithmetic addition.>, ==, <=.gt, eq, le.0, '0', and '' are all considered false.hash<key> or curlies hash{'key'}.key and value built-ins to access elements during iteration.# Hash iteration example
for item in {"apples" => 20, "bananas" => 35, "potatos" => 12}
puts "#{key item} are #{value item} cents per Kg"
endA meta-object is a standard object that defines the behavior of other objects. It contains methods that respond to specific events in a type's lifetime (like method dispatch or type creation).
Key concepts:
find_method) to drive internal logic, the specific names of your meta-object methods (like add_method) are conventions you define..HOW macro to access the meta-object of an instance.class SimpleMetaObject {
has %!methods;
method new_type() {
my $meta-object := self.new();
return nqp::newtype($meta-object, 'HashAttrStore');
}
method add_method($type, $name, $code) {
%!methods{$name} := $code;
}
method find_method($type, $name) {
%!methods{$name}
}
}To implement an object system, follow this four-step workflow:
Core Formula: meta-object (behavior) + representation (storage/allocation) = full implementation of an OO type.
To define a multi-line documentation block, use the =begin and =end syntax. If you provide an identifier to the =begin tag, you must provide the exact same identifier to the =end tag to close the block.
=begin my_block
This is some multi-line
documentation text.
=end my_blockYou can create single-line documentation entries using the =identifier syntax. Any word can be used as an identifier except for the reserved word cut. These entries can be placed inside a POD block.
=identifier This is a documentation entryTo optimize memory and identity, the VM uses parameterization interning. When deserializing multiple compilation units (SCs) that contain identical parameterizations, the first unit's parameterization is reused ('wins').
An entry in the Parameterization Interning Data section is included only if:
Each entry follows this structure:
In 6model, a type object is the handle created when you pair a meta-class with a representation. It serves as the primary mechanism for creating new instances of an object.
Depending on your language's paradigm, you should use type objects as follows:
Use the type object as the handle for creating instances. You can:
If your target language supports objects but does not support methods, 6model is still a viable fit. You are not required to implement methods within the meta-object to handle add_method or find_method operations.
Implications:
s-table (specifically the method cache and v-table slots). This overhead is per-type, not per-instance, and is minimal (a few pointers per type).In the 6model architecture, representations (REPRs) are responsible for memory layout, while meta-objects handle type-ness (dispatch, type checking, etc.).
When a meta-object's type definition is complete, it must configure the REPR. This configuration is performed via the REPR composition protocol using the nqp::composetype primitive.
To avoid complex object system dependencies, the protocol is defined entirely using standard arrays and hashes. A top-level hash is passed to the REPR, where each key represents a specific part of the protocol and its value provides the necessary configuration data.
Code references are handled based on whether the code is static or dynamic:
Occurs when the VM has never invoked the code during compilation. The thunk for dynamic compilation is tagged with a STATIC_CODE_REF property and placed in the SC. Serialization includes the SC owning the code and the code ref index.
When dynamic compilation occurs, the SC is updated with the code ref to the compiled code, which is then tagged as a static code reference (including the owning SC).
Because meta-object method calls can be heavyweight, 6model allows meta-objects to publish "caches" that provide low-level, high-speed views of their data to the VM. The meta-object remains the authoritative source and is responsible for updating these caches.
Supported cache types:
is-a or does-a operations.