#Dekoratoren
#-----------

# Dekoratoren sind Funktionen, die Funktionen verändern.

# Zuerst brauchen wir eine Funktion, die irgend etwas macht:
# Signatur: `f`: int -> int
def f(n):
    """Addiert etwas zum gegebenen Argument."""
    return n + 4 # garantiert zufällig gewählt
f(13)

    
# Nehmen wir an, wir wollen wissen, wann die Funktion aufgerufen wird, z.B. zum Debuggen.
# Wir könnten eine andere Funktion machen, die die Aufrufe protokolliert:
# Signatur: `fDebug`: int -> int
def fDebug(n):
    """Addiert etwas zum gegebenen Argument und protokolliert das."""
    print("  aufgerufen mit %d" % n)
    res = n + 4
    print("  Ergebnis ist: %d" % res)
    return res
fDebug(13)


# Das ist nicht so toll, weil wir dann jeden Aufruf der Funktion durch unsere Debug-Funktion
# austauschen müssen -- und wenn wir wieder fertig sind, dann müssen wir die Funktion wieder
# zurücktauschen.

fPrime = f
# Eine andere Variante wäre, die Funktion selbst zu modifizieren oder auszutauschen:
# Signatur: `f`: int -> int
def f(n):    # debug-variante
    """Addiert etwas zum gegebenen Argument und protokolliert das."""
    print("  aufgerufen mit %d" % n)
    res = n + 4
    print("  Ergebnis ist: %d" % res)
    return res
f(13)

# und wieder zurück für später:
f = fPrime



# Auch hier ist das Problem, dass wir unsere Funktion austauschen und hinterher wieder
# zurücktauschen müssen. Und diese Lösung ist auch nicht wiederbenutzbar.
# Besser wäre es also, wenn wir die Funktion (die das macht, was wir wollen), mit dem
# Verhalten, das wir zusätzlich/temporär haben wollen, zu modifizieren.
# Signatur: `fDebugProtocol`: int -> int
def fDebugProtocol(n):
    print("  aufgerufen mit %d" % n)
    res = f(n)
    print("  Ergebnis ist: %d" % res)
    return res
fDebugProtocol(13)


# Auch hier: die Funktion ist speziell für `f` gemacht, also nicht wiederverwendbar.
# Immerhin haben wir schon das Verhalten aus-faktoriert.
# Die Wiederverwendbarkeit erreichen wir jetzt, indem wir der `debugProtocol` die
# Funktion übergeben, die wir protokollieren wollen:
# Signatur: `debugProtocolForFunction`: (`f`: int -> int, int) -> int
def debugProtocolForFunction(someF, n):
    print("  aufgerufen mit %d" % n)
    res = someF(n)
    print("  Ergebnis ist: %d" % res)
    return res
debugProtocolForFunction(f, 13)

# Besser, aber immer noch nicht toll: Wir müssen jeden Aufruf von `f` durch
# das `debugProtocol` ersetzen.
# Besser wäre es doch, die Funktion direkt zu modifizieren. Das erreichen wir, indem
# wir eine Funktion machen, die `f` als Argument nimmt und wieder eine Funktion zurückgibt.
# Das heißt, die Signatur ist 
# debugF: (int -> int) -> (int -> int)
def debugF(someF):
    # wir müssen wieder eine Funktion zurückgeben, also müssen wir eine machen:
    def aux(n):
        print("  aufgerufen mit %d" % n)
        res = someF(n)   # warum können wir hier f benutzen? Weil hier eine "Closure" vorhanden ist.
        print("  Ergebnis ist: %d" % res)
        return res
    return aux

# direkter Aufruf:
debugF(f)(13)

# und für später:
f2 = debugF(f)
# beliebieger Code 
f2(13)

# Weil das sehr praktisch ist, gibt es dafür in Python eine spezielle Syntax: die @-Syntax.
# Dadurch wird `debugF` zum Dekorator.
@debugF
def f3(n):
    """Gleiche Funktion wie vorhin!"""
    return n + 4
    
def f7(n):
    return n ** 2
f7 = debugF(f7)

# Jede Funktion, die eine Funktion nimmt und eine Funktion zurückgibt, kann als Dekorator benutzt werden.
# (Auch, wenn sich die Signaturen verändern (was auch sehr nützlich sein kann).)

def needsPassword(f):
    def aux(password, n):
        if password != 'vErYsEcReT':
            raise ValueError('password unknown')
        return f(n)
    return aux

@needsPassword
def g(n):
    return n + 7

g(7)                 # Falsche Signatur!
g('meinPasswort', 7) # ValueError weil falsches Passwort
g('vErYsEcReT', 7)   # yay!



# Komplizierter wird es, wenn der Dekorator auch noch ein Argument haben soll.

def addTo(N):
    def addNTo(f):
        def aux(n):
            return f(n) + N
        return aux
    return addNTo


# addTo: int -> ((int -> int) -> (int -> int))
@addTo(7)  # (int -> int) -> (int -> int)
def f(n):
    return n * 2





# Dekorator, der zu jeder Ausgabe auch die Uhrzeit ausgibt.
# >>> output("hallo")   # output: * -> None
# 19:30   hallo

def timeOut(f):
    def aux(*ausgabe):
        print("the time is now!",)
        f(*ausgabe)
        # return None
    return aux



@timeOut
def output(*ausgabe):
    print(*ausgabe)
    



lambda x : (x + 1)

def no_name(x):
    return x + 1