Redesign of Paml Syntax/Semantics

Operator dataOf and "object instance" expression are removed, collections syntax/semantic is improved.

Operator dataOf is removed because object variables can now be accessed by both, data access "." and object access "->", operators. No need to take object data by special switcher like dataOf operator.

Collections now are declared by special syntax col ... of. This highlights that collections are neither objects nor values, but they are a language abstraction for item sequences. Items of a collection can be either objects or values depending on the items type.

Creation of new object instances is now completely an aspect and is implemented via transformations. As result, the type of object variable is a join point, which can be transformed into any initialization expression, and "constructor" is one of possible initialization expressions.

The syntax of message parameters is now unified with local variable declaration with obj/val keywords. The keywords can be omitted if the variable type can be inferred.

        value Point
    
        {
    
            X, Y : integer;
        
        }
    
        object Canvas
    
        {
    
            data Height, Width : integer;
        
            If the type of a parameter is unspecified, obj/val keyword is required to specify the parameter is object or value
        
            message Resize ( val height
            : integer, val width :
            integer )
        
{
            
                this.Height = height;
            
                this.Width = width;
            
            }
        
            message DrawPixel ( pixel :
            Point )
        
{
            
                TODO:
            
            }
        
            message Clear
        
{
            
                TODO:
            
            }
        
        }
    
        object Circle
    
        {
    
            data Radius : integer;
        
            data Center : Point;
        
            message MoveTo ( val x
            : integer, val y :
            integer )
        
{
            
                Object data (which are always values) can be changed in any way
            
                this . Center . X = x;
            
                this . Center . Y = y;
            
            }
        
            message MoveTo ( center :
            Point )
        
{
            
                this.Center = center;
            
            }
        
            If the type of a parameter is an object, the parameter is a join point, so a transformation can specify how the parameter is initialized
        
            message Draw ( canvas :
            Canvas )
        
{
            
                val pixel : Point;
            
                Local collection definition
            
                col pixels of Point;
            
                Calculate pixel coordinates
            
                Local values can be changed in any way
            
                pixel.X = ...;
            
                pixel.Y = ...;
            
                canvas->DrawPixel (pixel);
            
            }
        
        }
    
        subject Painter
    
        {
    
            Collection name is always a join point, to specify how the collection is translated to output code
        
            col Circles of Circle;
        
            message Render
        
{
            
                val height = 1080, width = 2048;
            
                The type of object variable is a join point and can be transformed to any initializing expression (like constructor call)
                    
Transformation can capture visible variables (locals "height" and "width" in the example) and use them in the initializing expression.
                    
                obj canvas : Canvas;
            
                canvas -> Clear ( ) ;
            
                Object state can be accessed by data access operator "." only for reading
            
                val h = canvas.Height;
            
                canvas->Resize ( height, width : 4096 );
            
                this.Circles (circle)
            
forEach{
                    
circle->Draw(canvas)};

            }
        
            The type of "circle" parameter is inferred as "Circle", it's an object so the parameter is also an join point
        
            message AddCircle (circle)
        
{
            
                add (this.Circles, circle); "add" is an operator in N-arity
                syntax
            
                or
            
                this.Circles add circle; "add" is an operator in binary syntax
            
            }
        
        }