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.

• [x] class keyword support.
• [x] BuiltInClass functionality to add built in classes like we have BuiltInFunctions. We have mentioned this on #23
• [x] BuiltInInstance to handle classes objective behaviours.
• [x] 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
    }
}

• [x] At the place of __add__ we can set __sub__, __mul__, __div__, __len__ etc. more will be added as we move forward.
• [x] #120
• [x] Our current constructor is the class name, but want to set it to __constructor__.
• [x] #93
• [ ] Our current function declaration keyword is fun and it will be fixed untill any second thoughts arrives. Methods will be same like functions.
• [x] #88
• [x] #89
• [ ] #92
• [x] 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!! 🥱