Object Oriented System Enhancement Proposal. (REP-2)

[Almas-Ali]

We are making Radon a true object oriented language like Python. We are willing to add almost all natures a OOP language supports.

• class keyword support.
• BuiltInClass functionality to add built in classes like we have BuiltInFunctions. We have mentioned this on Need BuiltInClass or Object for defining internal classes. #23
• BuiltInInstance to handle classes objective behaviours.
• Operators overloading systems to handle classes operational behaviours.

A basic sudo implementation of OOP in Radon will be like this.

class MyClass {
    fun __constructor__(this, any, others, args=null) {
        this.any = any
        this.others = 16*others
    }

    fun __add__(this, other) {
        return MyClass(
            this.any + other.any,
            this.others + other.others,
            this.args + other.args
        )
    }

    fun __destructor__(this) {
        pass
    }
}

• At the place of __add__ we can set __sub__, __mul__, __div__, __len__ etc. more will be added as we move forward.
• We will use len(object) to get length from a class which will be come from __len__. And will support more methods so on... #120
• Our current constructor is the class name, but want to set it to __constructor__.
• We will add a __destructor__ method to delete the object. #93
• Our current function declaration keyword is fun and it will be fixed untill any second thoughts arrives. Methods will be same like functions.
• pass keyword support. #88
• ... or Ellipsis support. #89
• del to delete objects. #92
• static keyword support for static methods.

Realistic OOP behaviors.

• Abstraction support.
• abstract keyword support.

abstract class AbstractClass() {
    fun some_method1(args1, args2, ...) # No implementations
    fun some_method2(args1, args2, ...) # No implementations
}

class NewClass(AbstractClass) {
    fun some_method1(args1, args2, ...) # Have to complete anyway
    {
        # implementations
    }
    fun some_method2(args1, args2, ...) # Have to complete anyway
    {
        # implementations
    }
}

• Encapsulation support.
• public, private, protected keyword support.

class ExampleClass {
    fun __constructor__(something) {
        this.something = something
    }

    # All methods by default public. explicitly definitions allowed.
    fun some_method() {
        return 123
    }
    public fun public_method() -> 0

    private fun private_method() {
        return 123
    }

    protected fun protected_method() {
        return 123
    }
}

• Polymorphism support.
  Operator overloading is a part of polymorphism, which is already done.
  If anything missing, will be updated later.
• Inheritance support.
• Single Inheritance.
• Multiple Inheritance.
• Multilevel Inheritance.
• Hierarchical Inheritance.
• Hybrid Inheritance.

class ParentClass {
    fun __constructor__(something) {
        this.something = something
    }

    fun some_method() {
        return 123
    }
}

class ChildClass(ParentClass) {
    fun __constructor__(something_new) {
        this.something_new = something_new
        super().__constructor__(something)
    }
}

child = ChildClass()
child.some_method()  # will work!

We will update this issue as we change our plans.

[angelcaru]

Operator overloading added in #50

[Almas-Ali]

More OOP concepts has been updated as proposal. A huge list to complete!! 🥱