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.
```radon
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!! 🥱