• Add documentation for the language in the wiki section.
• Add documentation for the language interoperability with Go in he wiki section.
• Include examples.

Is your feature request related to a problem? Please describe.
Add a new function for arrays, tuples and hash called cap which calls the underlying slice or map cap

Describe the solution you'd like
This should create two new functions, one internally and the other externally to objects.

obj.__cap__()

cap(obj)

Remove complicate statements

• redo
• try-except
• raise

Update documentation:

• Update project description
• Add release binaries
• Magic methods
• Default symbols
• How to embed
• API functions
• How to extend the language
• New statements
• New binary operators

Is your feature request related to a problem? Please describe.
Plasma right now only supports positive indexing of value inside arrays, negative indexing should work the same as described by python

my_array = [0, 1, 2, 3]
my_array[-1] # Should return 3

Describe the solution you'd like
Add a condition in array/tuple index function to transform negative indexes to positive indexes

Compile the last IR to a byte array that can be passed to a virtual machine

Delete statement is a special keyword that internally remove symbols in case a expression or selector is given, in case of index expression the special methods __del__ of the object is called

A thread safe virtual machine can be shared in a program without the use of mutexes or any sync operation.

Characteristics:

• Share the same internal symbol table between all calls
• Values are also thread safe, meaning the user can operate with them without being afraid of race condition them
• Context based meaning each time a plasma program is executed a new context is created

The simplified VM will hide all the low level plasma operations to a simpler user friendly API:

Expected methods:

• NewVM: creates a new virtual machine
• vm.Execute: executes the precompiled bytecode
• vm.ExecuteString: compiles a program string and then executes its bytecode
• vm.Load: Loads Go created objects to the VM
• Compile: precompiles a plasma program to a bytecode slice

is binary operator is used to check if the class that a value has is the same as the targeted one.

Internally it is equivalent to:

my_value.__class__() == MyClass

Lowercase all the standard library and magic methods to be consistent and mnemotechnic friendly

defer statement works similar to the Go defer statement, calling a function at the end of other function body

• ToValue/FromValue Documentation
• Add new magic functions

The syntax check pass will check that:

• defer, return and yield are only inside gen and def
• break and continue are only inside for, until, while and do-while

Implements binary operator returns true if the class of value is a target class or if any of its bases is or implements the class

Is your feature request related to a problem? Please describe.

Map Struct function to Plasma Objects

Describe the solution you'd like

Using reflection, also scan for the functions of an struct an map them to the plasma object

This pass will return a new IR called AST2 that will be in charge of simplifying this AST1 nodes:

• Unary and Binary expressions to selector calls
• Parentheses to expressions
• for and until to while loops
• unless and switch statements to if statement
• unless one liner to if one liner
• return and yield multiple results to single result (expression on 1, and tuple on multiple)
• Literals to nodes representing directly the types

Returns a instance of self as it was the targeted class

Is your feature request related to a problem? Please describe.
Stop the usage of the magic method __len__ by creating a wrapper that also could call low level function to return the length of the underlying object.

Describe the solution you'd like
The API of this new len function will be:

len(obj) # returns an integer with the length of the underlying object

Finally implement the yield generators

• Improve the developer experience of interoperating the language with existing Go code.

This could be made by applying some kind of facade structure on top of the module to easy the work pipe

Features:

• Color print errors
• On not none last value result, print value
• Control-C kills the running statement
• exit function that exits the REPL

String and Bytes:

• join
• split
• upper
• lower
• count
• index

Array:

• append
• clear
• index
• pop
• insert
• remove

Int and Float:

• big_endian
• little_endian
• from_big
• from_small

This pass will generate a new IR called AST3 in charge of transforming and simplifying most of AST2 nodes:

Is your feature request related to a problem? Please describe.
Create a new function that will let the end user reserve memory for arrays, tuples and hash maps.

Describe the solution you'd like
The new API should look like:

obj.__reserve__(size)

reserve(obj, size)

The readme should include:

• Description
• Logo
• Quick language example
• Quick embed example
• Quick extend language example
• Link to contribution guidelines
• Code quality badge
• Go version badge