Kirit Sælensminde saidInheritance (if we consider it separate from subtypeing) is really just an implementation convenience for composition and forwarding. Take apart any Smalltalk
I do not meant inheritance without subtyping …
nheritance and you'll find that you can always move the class in the hierarchy and add an instance of the superclass as an attribute. You also need to forward all of the old super-classes methods that you don't override (and all of it's parents' ones too). This is what makes inheritance so useful, but I've never seen it as a defining quality of any OO system (although finding an OO system that doesn't have it is very rare). In the case of Erlang, there is absolutely nothing stopping you from implementing inheritance as composition and I suspect that the flexibility of Erlang's switch-like receive statement would make it much easier to do than it would in Smalltalk, Java or C++.
I still believe you miss the point. Of course you can do everything inheritance does using other techniques. OO is a paradigm not a catalog of features. A paradigm is a style of programming together with specific techniques, nothing else. When discussing functional languages with my colleages, I am amazed so many of them keep saying : “you can do the same in java”. That is not the point.
Take a look at http://en.wikipedia.org/wiki/Programming_paradigm
Subtype polymorphism can be seen as one of two things (and I'm not sure which you mean):
- Liskoff substitution
- Inclusional polymorphism (a form of structural subtyping in type theory)
subtype polymorphism also called inclusion polymorphism : http://en.wikipedia.org/wiki/Type_polymorphism#Subtyping_polymorphism
Erlang processes must allow this as it's impossible for any message based system not to. Any process implementation can be substituted for any other which responds properly to the same messages.
Liskoff substitution (and subtype polymorphism) is really tight to inheritance and subtypes. Take a look to the original paper written by Liskof.
As for the stronger type checking offered by inclusional polymorphism, as far as I know Erlang doesn't support this — you cannot formally specify within Erlang which messages a process must respond to (at least as far as I know, but I don't Erlang well at all). That you can't do this in Erlang doesn't stop the process and messages part of the language from being OO any more than Smalltalk's inability to the do the same thing stops it from being an OO language.
I would say it does. Again just a question of style … Smalltalk supports subtype polymorphism, doesn't it ? I am not sure what you mean by “inclusional”.
PDA (Procedural Data Abstraction) style : encapsulation of stateful data together with operations (method) in a same entity called object to build data abstraction ?
Isn't this exactly what an Erlang process is? Change the word “object” to “process”.
I don't think so if you think in term of style of programming (or paradigm or model).
Thanks for your reply. I believe Erlang is not an OO languages. You are right saying that Erlang is not just functional. According to WP (http://en.wikipedia.org/wiki/Multi-paradigm_programming_language) Erlang is a multi-paradigm language (functional, concurrent, distributed). There are more than two paradigms in the world of programming science. In the CTM book, Erlang is described as an example for the message-passing concurrency model.
That said. I am not by any mean an expert in Erlang. But I already like it ;-)
Edited — Removed an empty blockquote tag that was causing a render problem, KS
