[Python] Ma Go non ha le classi

[enrico franchi]

2015-03-27 10:17 GMT+00:00 Luca Bacchi <bacchilu a gmail.com>:

> I linguaggi a oggetti possono essere Class Based (come Java) o Object
> Based (come JavaScript).
>

Peccato che la storia sia molto piu' complicata. Imprimo luogo OOP e' un
*paradigma* di programmazione. Cioe' scrivere codice ad oggetti e' un
*modo* di scrivere codice. Puoi ampiamente scrivere codice ad oggetti in C,
senza nessun tipo di supporto sintattico o semantico per la programmazione
ad oggetti. Eppure il codice risultante e' comunque ad oggetti.

Se poi parliamo di come un linguaggio offre supporto sintattico o semantico
per la programmazione ad oggetti, la cosa cambia un pochetto.
Per esempio in C non hai praticamente nessun tipo di supporto sintattico ne
semantico.

Ma puoi avere cose molto particolari. Per esempio in un linguaggio come
scheme, puoi avere supporto semantico per la programmazione ad oggetti
usando le chiusure come oggetti. E siccome puoi intervenire liberamente
sulla sintassi (tramite le macro), puoi aggiungere facilmente supporto
sintattico. Uno dei primi linguaggi ad oggetti e' nato proprio cosi' (su
Common Lisp, pero'... non che cambi troppo).

Oppure in Erlang non hai nessun tipo di supporto sintattico, ma ancora una
volta un attore si puo' comportare in modo affine ad un oggetto. E quindi
hai supporto semantico per la baracca.

Nei classici linguaggi considerati ad oggetti, hai vari livelli di supporto
sintattico e semantico. Poi certo... molti dei linguaggi piu' primitivi ti
forzano ad un singolo punto fra essere class-based o prototype-based
(incidentalmente anche se a volte si usa object-based per intendere
linguaggi prototype-based e' terribilmente ambiguo, visto che viene
generalmente usato anche per definire tutti quei linguaggi che hanno un
qualche tipo di concetto di oggetto ma non possono essere considerati a
tutti gli effetti OOP; da cui preferisco usare il termine piu' diffuso:
prototype-based).

Ma, ovviamente, tutto quello che supporta una qualche forma di meta-object
protocol ti consente facilmente di avere gerarchie di oggetti che sono
class o prototype based. Un esercizio interessante per passare un
pomeriggio e' quello di sviluppare un type-system prototype-based per
Python. Si impara *tanto* su Python facendolo.

Quello che voglio dire e' che prototype vs. class based e' una distinzione
rilevante, ma non necessariamente e' legata al linguaggio in se, sebbene la
maggior parte dei linguaggi prendano una posizione chiara e distinta da
questo punto di vista. E soprattutto e' un aspetto che interessa solo una
parte di essere OOP: ovvero come viene gestita l'ereditarieta'. Per esempio
e' molto complicato classificare Go in base alla tua definizione binaria:
e' chiaramente non class-based (visto che non hai ereditarieta'), ma e'
ancor meno prototype based. Certo, il modo in cui puoi comporre le
interfacce assomiglia piu' a qualcosa di class-based, ma le differenze sono
tutto fuorche' piccole.

Quando poi vuoi metterti a classificare affari come Erlang o il tuo type
system fatto in Scheme... beh, potrebbe essere ampiamente ne class-based ne
instance based. Per esempio perche' non hai ereditarieta', ma magari hai
solo delegazione. E tanti saluti. :)


-- 
.
..: -enrico-
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20150327/35e00ab7/attachment.html>