Gegeben ist dieses Programm:
class C:
def f(self, a):
b = a
self.c = b
h(self.g)
return self.c
def g(self):
self.f()
Ich möchte self implizit machen. Ich muss dann lokale Variablen und Attribute unterscheiden können. Letztere kennzeichne ich mit einem @. Dann habe ich:
class C:
def f(a):
b = a
@c = b
h(g)
return @c
def g():
f()
Ich möchte () für Funktionsaufrufe weglassen. Will ich eine Funktion referenzieren und nicht aufrufen, muss ich ein & davor schreiben. Ich kann noch lokale Variablen und Funktionsaufrufe verwechseln. Hier soll gelten, lokale Variablen haben Vorrang.
class C:
def f a:
b = a
@c = b
h &g
return @c
def g:
f
Ich möchte, damit ich auf Attribute von außen zugreifen kann, auch getter und setter einführen. Setter kann ich nicht von lokalen Variablendefinition unterscheiden. Sie mir var zu kennzeichnen, ist hässlich. Also definiere ich, dass man, wenn man einen setter aufrufen will, explizit self benutzen muss. Setter haben ein = im Namen.
class C:
def c:
return @c
def c= v:
@c = v
def f a:
b = a
self.c = b
h &g
return c
def g:
f
Das explizite return ersetze ich durch die Konvention, dass der letzte Ausdruck automatisch zurück gegeben wird. Das ändert die Semantik, weil jetzt kein implizites None kommt, aber egal. Außerdem schreibe ich attr, um getter und setter zu definieren.
class C:
attr c
def f a:
b = a; @c = b; h &g; c
def g:
f
Hm, vielleicht sollte ich noch : weglassen und statt einzurücken ein explizites end schreiben:
class C
attr c
def f a
b = a; @c = b; h &g; c
end
def g
f
end
end
Oh, Ruby! (Fast jedenfalls, attr_acessor braucht ein :c und & gibt es so nicht)
Stefan