Coffee Space

Constructors

The class Object itself is already an object and could be used as is, but the capital ‘O’ would indicate you are supposed to treat it like a class. This can be done with:

0016 print(Object.getB());
0017 obj = Object("10");
0018 print(obj.getB());

Firstly it would print {"20"}. We then clone Object, run the constructor and then store this data at obj. It then prints {"10"}. Note that it returns this data as a JSON representation, the default format for all objects ¹. All JSON in this language would always be a string, introducing non-string data was always a mistake.

A blank constructor is always a default clone of an object. Therefore:

0019 obj = Object();
0020 print(obj == Object()); // True

Implementation note: Variable don’t always have the JSON representation available until requested in the print or some other action that requires it, internally it would of course prefer to do math on integers.

Chaining

Unless a return statement is defined, by default functions return a reference to the object. For example, these are the same:

0021 print(Object.getB());
0022 print(Object.doNothing().getB());

Threading

All objects are atomic and locks are acquired to get and set values, including all deep objects in the structure. Each object is locked by both their own lock and all parents.

If one or more threads are editing the same object, it would be suggested to make a clone of it using the b = a() style. You could then edit and replace the original (but a race condition would still need to be handled).

Memory

If you access data that doesn’t exist, it doesn’t crash, it just returns a null placeholder. For example:

0023 array = [ "1", "2" ];
0024 print(array["0"]); // {"1"}
0025 print(array["1"]); // {"2"}
0026 print(array["2"]); // {}

null is always {}, and is also a valid object. As this type is blank, doesn’t store data and has no methods, no memory is required to store it.

Data Types

For now I think there would be int, float and string. Strings in the language would be UTF-8 encoded as this now appears to be the standard. The user can only access strings, but can perform additional operations if the strings are of the right type (a lot like how Python handles such things).

int and float would offer as much precision as the platform allows for. This could be queries somehow, but ultimately we can only aim for so much platform independence. It could be nice to be able to still run this on a microcontroller for example.

Functions vs Variables

In this language there is no difference, functions and variables must not share names.

Variables are of course scoped and there is still the idea of public, private and static types.

There would be some reserved keywords as you would have in other languages, such as:

0027 // if and else is reserved
0028 if(a == b){
0029   /* Something */
0030 }else{
0031   /* Something else */
0032 }
0033 /* for is reserved */
0034 for(i = 0; i < 10; i++){
0035   /* Loop something */
0036 }
0037 x = 0
0038 /*  While is reserved*/
0039 while(x++ < 10){
0040   /* Also loop something */
0041 }
0042 /* switch, case, break, continue, etc are reserved */
0043 switch(x){
0044   case "0" :
0045     print("wow");
0046     break;
0047   default :
0048     print("nice");
0049     break;
0050 }

Reserved would mean that neither an object or variable could have these names. We would also likely want to reserve all keywords commonly used in other languages encase we want them in the future.

Note: When checking the equality of two objects, we just check that their JSON representations are equal (deeply).