Perl with classes

Originally developed as a procedural language, Perl was later adapted to support modern Object-Oriented Programming (OOP) with features like inheritance, virtual methods, and static methods.

Consider the following example:

It looks like typical object-oriented code, but it's actually Perl. Here, classes are based on packages, so to write a class, you need to create a package and add a constructor.

Perl doesn't have complex data types like structures, so to create an object of a class, you need to "bless" a reference to one of the basic types with the package name.

The name of the constructor can be anything, but it's conventional to use new. This object stores a list of students and allows manipulation of that list.

There are several types of methods in classes: static and virtual. ClassRoom::new() is a static method, which can only access the global state of the class itself and receives the package name as the first parameter.

Virtual functions, on the other hand, accept the object as the first parameter and perform operations at the instance level. Let's adjust the class with a new virtual method:

Receiving the object as the first parameter should be familiar to Rust or Python developers.

And, of course, there is a destructor. When an object has no more references, it will be destroyed, and you can specify a function to handle this:

Now, let's add some more complexity. Consider that the classroom might have a professor inside, and we need a method to check for their presence.

It's time to create a child class, ClassRoomWithProfessor, which can be used like this:

ClassRoomWithProfessor is a child of ClassRoom with some methods overridden. First, use the use base 'ClassRoom' keyword to specify the base class. The new constructor simply forwards everything to the parent class:

Here, the SUPER keyword tells the interpreter to call the method from the parent class.

Now, let's implement a new version of add_person:

Objects in Perl are built on top of existing abstractions, making them relatively easy to learn and use. However, debugging such code can be tricky. For example, there's no limitation on how a virtual method is called, so ClassRoom::add_person might be invoked in different ways:

Of course, the developer of such a class can cover these calls, but doing so can make the code much harder to maintain and understand.