«

[David M Cook]:
> I would call it *pragmatically* implemented OOP. It's not
> "proper" as some would see it.

[Ville Vainio]:
> Elaborate?

[John Roth]
> As I understand it, there are a number of issues.

> 1. Lack of method polymorphism

> 2. Use of built-in functions instead of "proper" methods.

> 3. ability to declare functions and variables at the
> module level.

Ad 2 and 3... well, practicality/pragmatism beats purity, once again.
Right now I'm struggling with the stupidity of Java (whether it's got
properly implemented OOP is another issue) in order to get certified
(since doing Python for a living is as yet a severely limited option
for me, despite evangelism). Guess I'm just spoiled.
Ad 1... I've yet to get involved in projects big/complicated enough
where I could conceivably benefit from that, so I don't miss it.

Christopher

"John Roth" <> writes:

> "Ville Vainio" <> wrote in message
> news:...
> > >>>>> "David" == David M Cook <> writes:
> >
> > David> I would call it *pragmatically* implemented OOP. It's not
> > David> "proper" as some would see it.
> >
> > Elaborate?
>
> As I understand it, there are a number of issues.
>
> 1. Lack of method polymorphism

[...]

> 1 would be nice at times, but there's no way it's
> going to happen in a language that doesn't have
> static typing.

Sigh ...

* (defmethod foo ((x integer))
(format t "~&~s is an integer" x))
#<Standard-Method FOO (INTEGER) {480054CD}>


* (defmethod foo ((x string))
(format t "~&~s is a string" x))
#<Standard-Method FOO (STRING) {4800ABED}>


* (foo 2)
2 is an integer


* (foo "hello")
"hello" is a string


The ANSI standard for the _dynamically typed_ language shown above,
which implements the behaviour you claim will "never happen in a
language that doesn't have static typing", is about a decade old. (The
capability itself is at least another decade older.)

Jacek Generowicz <> schreef:

> * (defmethod foo ((x integer))

> * (defmethod foo ((x string))

> The ANSI standard for the _dynamically typed_ language shown above,

Maybe someone can explain, but the above doesn't look like "dynamic typing"
to me...?

--
JanC

"Be strict when sending and tolerant when receiving."
RFC 1958 - Architectural Principles of the Internet - section 3.9