First, you should try seeing if you can get into the Runtime environment. Assuming you have it properly installed, you can simply run Runtime in the terminal. Note the uppercase R.

Runtime runs code in two seperate ways, either in the live interpreter, which is what you're looking at here, or it can directly run files, in which there will be no pretty visuals. You can also run files directly in the live interpreter using the Include() function, but we will take a proper look at that later.

This guide is written under the assumption that you have atleast a cursory level understanding of programming, however you might be able to follow along even if you don't.

Everything in Runtime is either object or value. This makes learning the workings of the language extremely simple, in exchange for making the process of actually writing code quite a bit harder.

This might leave you with some questions. If str is an object, then what are values?
The answer is quite simple, the literal, which is assigned to str, IS the value. In this case the str object acts as a short of container for the literal, as values cannot exist by themselves in Runtime.

Like you would assume, objects can have members. For example, in the previous snippet of code, str had an unnamed member with the value of "Hello world".

You can access members using the accession operator -

	Object(str "Hello") # Commas are completely optional in Runtime. You can add them if you feel they help code readability
	Print(str-0)
	# This prints Hello
						

However, you can also think of objects as dictionaries, since you can also assign members via a string key.

	Object(str)
	Assign(str, "msg", "Greetings!")
	Print(str-"msg")
	# This prints Greetings!
	Print(str-0)
	# This also prints Greetings
						

Objects can be created simply by referring to them

	int # This creates an empty object called int
						

TODO: object doesnt evaluate, assign does Object() will simply assign new members by giving them incrementing unique int keys.
Assign() will assign a value to a specific member. This allows you to change existing values, as well as create new ones with specific keys, which don't have to abide to an incrementing schema.

Look at the following snippet of code

Object(i Input()) # Assign user input to the variable i
Print("Hello")
Print(i)
						

The answer is lazy-evaluation, or as I call it in Runtime, questionable-evaluation. Lazy-evaluation means that values are only evaluated when needed. For exaple, in Haskell you may assign the numbers 0-infinity to an array. While in most languages this would be impossible, Haskell allows this because it will only evaluate the numbers when you ask it to.

This is also how it works in Runtime. In the code snippet above, while i is assigned the value of Input() before "Hello" is printed, we only access it's value later in the line Print(i). The Print() function will evaluate it's arguments, in order to print them.

However if you're a Haskell aficionado, you may see a problem with this: Runtime is not purely functional, which means functions can have side effects. This is where the "questionable" part comes in. It is entirely possible, that the return value of a function has changed in the time it took between assigning it to a variable and actually evaluating it.

This is simply one of the things you will have to keep in mind when writing code in Runtime.

In order to understand evaluation fully, you will need to be aware of the specific mechanisms behind how it works.

In the last chapter we went over how an object with a single value is evaluated. However what if an object has multiple members? In that case the member which was lasted assigned to will be evaluated.

In the last chapters, we went over evaluation. However in order for Runtime to be langauge that can actually be used for anything, there needs to be a second mechanism for evaluating objects. That mechanism is calling .

Every object can be both evaluated and called, and in principle they are not so different from eachother. While evaluating an object will... evaluate it's last assigned to member, calling an object will evaluate all of an objects members in order of assignment, before returning the last one.

This, however, is where things start to get difficult. While the basic concept of functions is what was just described, there are quite a lot of quirks in the implementation which make things harder. For example, evaluating an object or its value will write the objects value to memory, whereas calling it will not. Heres an example to try to help you understand.

The last image should give you decent idea of how functions work. You create an object with a series of object calls, then you call that object, which results in all of its members being evaluated. Now we must move on to arguments/parameters.

Here is a simple function which takes a single number as an parameter and prints its following digit.

Objects are always passed by reference, and values are always passed by value.

Object(one, 1)
Object(value, one-0) # Passed the value of one
Object(reference, one) # Passed a reference to one
Assign(one, 0, 2)
Print(value) # Will print 1
Print(reference) # Will print 2
						

Congratulations! You've made it to the end of the documentation. In theory, you should now be able to write functional Runtime code, although in practice it will of course take some time before you're able to fully grasp the language.

This section will be a quick overview of some of the most useful functions that come with Runtime. A full reference of all Runtime objects can be found here.