0.8.2 [Beta testing]

In this release we

• Introduced sets
• Introduced the in and notin operators

Fixed

• the comparisons of vectors
• Faster map comparisons

Refactored

• Numerous places

0.8.1 [Beta testing]

In this release we have introduced some new features, such as

• Basic multiple inheritance of limited support of accessing "mix-in" parent class(es) (which will be supported in the future)
• Support for final classes (classes that forbid inheritance)
• Several documentation improvements in the form of inline comments

We have also resolved the bugs of the crash of the application when cleaning the vectors when the interpreter runs from file:

class A
{
    func init(demo)
    {
        this.d = demo;
    }
}

var vector1 = [1,2,3];
var demo = A(vector1);
print vector1[2];  // Before the program crashes after printing out "3"
// Now resolved

0.8.0 [Beta testing]

We have brought a huge improvement here, including numerous minor code fixes. But out of them, to the end user, major improvements in Plant 0.8.0 include:

• Support of deletions of variables in global, nonlocal (survalue) or local scopes.
• Support of constant variable declaration.
• Support of mathematical functions and modules.

0.7.5 [Beta testing]

This is a striking change to the Plant programming language. Not until we introduced the std keyword have we only had builtin (functions, etc.). This is sad because it wastes a lot of usable space for global variables. And it is not friendly to the C++ programmers who are our intended users. To ensure familiarity as well as faster builtin calls, we introduced the std keyword, with striving to provide the arrangement and nomenclature same as those of C++ as possible. For example, here's what you might write before 0.7.5:

print toString(abs(-3));

Here's what you will write:

print std::any::toString(std::abs(-3));

Though it's somehow a little bit more verbose, it does enhance clarity and provides faster navigation to those builtin functions (because internally, we use GET_GLOBAL codes with hash tables inside the VM, but now we ported them out, away from the VM; as well as a new code STD has been designed).

This also ensures that we could add almost unlimited builtin functions (and classes, might be in the future). Before, we use global variables to store them. This is a hilarious waste of memory, and we cannot store more beyond PL_GET_GLOBAL_LONG (though we're sure that nobody will ever do so, but, who knows, just in case...); and storing too much builtin things will interfere the normal accesses to the user-declared global variables also. So, it's a good idea to store them separately.

Speaking of adding builtin functions, here's some useful headers (Plant jargon; borrowed from the C++ header that you need to include before you use std) that we may add in the future releases:

• vector
• map
• string
• math
• algorithm (Handles things like sorting, arranging, etc.)
• regex (Handles regular expression)
• random (Handles the generation of random numbers, etc.)
• chrono (Handles time & time zone, probably)
• filesystem (Handles files and directory; similar to Python's os.path sub-module)

(You could guess the meaning already if you are an intermediate C++ developer or more professional)

By the way, there's one header that does not exist in C++: plant. plant is a header specifically designed for the runtime instance property management, type checking (e.g. isinstance, etc.) owing to the fact that Plant is built on a dynamically typed land. It is roughly equivalent to Python's sys module (SALUTE! to pydevs after each allusion!), but rather not identical.

Ubuntu on GNU/Linux is also supported now. You could differentiate the two UNIX-compliant executables by looking at there suffixes: ./plant-darwin is for macOS, and plant is for GNU/Linux.

0.7.4 [Beta testing]

DEDICATION: TO GUIDO VAN ROSSUM, THE FATHER OF THE PYTHON PROGRAMMING LANGUAGE, AS WELL AS THOSE WHO HAVE DESIGNED THE PROMPTS AND INSTRUCTIONS OF SUCH A WONDERFUL SCRIPTING LANGUAGE, PARTICULARLY OF WHOM DESIGNED THE FIRST LINE OF THE INTERACTIVE SHELL

This patch version is really minor; it does not introduce any new features nor fixes. We just improved the first line of the interactive shell of Plant, and to pay respect to the number-one programming language (in terms of popularity, according to TIOBE) - Python, we make it more similar to one of the scripting languages that influenced Plant the most. From Plant 0.7.4 onward, the first thing you will see in the interactive shell looks like this:

Plant x.y.z (tags/git-hash, MMM dd yyyy, hh:mm:cc) [compiler-name v.compiler-version] on platform-name
Type "credits();" or "copyright();" for more information.
Plant [1] >>>

Instead of this:

Plant x.y.z (MMM dd yyyy, hh:mm:cc) [compiler-name v.compiler-version] on platform-name
Type "credits();" or "copyright();" for more information.
Plant [1] >>>

... so that you could identify the version with a higher degree of precision; before, you could only trace to the patch version (z); now, you could identify from which git hash (git-hash) are you building.

On another note, we are happy to announce that from version 0.7.5, GNU/Linux will also be supported. Ubuntu will come first.

Python 3.13.5 (tags/v3.13.5:6cb20a2, Jun 11 2025, 16:15:46) [MSC v.1943 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.

Salute!

0.7.3 [Beta testing]

Several bugs have been fixed:

• The prefix/ postfix unary operators ++ and -- have been fixed for accessing properties before performing the operations.
• Improved error messages for prefix/ postfix unary operators ++ and --: they will not increase/ decrease if they encounter invalid instructions such as ++3 or true--.

Note that delete is a reserved word now; you cannot use it as a valid identifier because deletion operations are planned and will be introduced in future releases, so do keywords like public, private etc. (please see the diff if you ask for an exhausted list of reserved words).

Several inner features have been introduced:

• Inner features: introduced the PL_SWAP operator.
• Used the functions defined previously.
• Created (0.7.2) and improved (0.7.3) the pl_tokToStr and pl_codeToStr inner functions.

0.7.2 [Beta testing]

This release does not introduce any end-user features; instead, it fixes:

• Some parameters that should be marked as const for optimizations
• Formatting
• Multi-line comments are not working at the end of the source file,
• etc.

This release does introduce the pl_tokToStr function as an inner feature.

GNU/Linux (Debian/ Ubuntu) support is believed to be introduced at the next release or two.

0.7.1 [Beta testing] "Beta"

Several features have been introduced:

• Universal architecture on macOS is supported (both ARM and Intel Macs)
• Fixed some formatting like indentations
• Fixed some instructions like plant instead of Plant, as we have changed the name of the executable
• Introduced new reserved words though they have no use currently; it prevents name crashes with the future code, including const, try, catch, throw, finally, final, etc.
• Improved memory management; fewer memory leaks
• New macOS binary is provided
• New internal features.

0.7.0 [Beta testing] "First Release"

This is the first release of Plant. Only Windows Executables will be provided as we believe that it is extremely easy to build Plant on macOS, GNU/Linux, etc.