def decorator(fn):
    def inner(n):
        return fn(n) + 1
    return inner

# the "@" statement is same as f = decorator(f)
@decorator
def f(n):
    return n + 1

def wrap_with_prints(fn):
    # This will only happen when a function decorated
    # with @wrap_with_prints is defined
    print('print this when you decorate a function')
    def wrapped():
        # This will happen each time just before
        # the decorated function is called
        print('prepare to run %s' % fn.__name__)
        # Here is where the wrapper calls the decorated function
        fn()
        # This will happen each time just after
        # the decorated function is called
        print('done running %s' % fn.__name__)

    return wrapped

@wrap_with_prints
def func_to_decorate():
    print('some be wrapped')

func_to_decorate()

def log_calls(fn):
    ''' Wraps fn in a function named "inner" that writes
    the arguments and return value to logfile.log '''
    def inner(*args, **kwargs):
        # Call the function with the received arguments and
        # keyword arguments, storing the return value

        out = fn(*args, **kwargs)

        # Write a line with the function name, its
        # arguments, and its return value to the log file
        print('{} called with args {} and kwargs {}, returning {}\n'.format(fn.__name__,  args, kwargs, out))

        # Return the return value
        return out
    return inner

@log_calls
def add(a,b):
    return a+b
add(1,2)

def b(fn):
    return lambda s: '<b>{}</b>'.format(fn(s))

def em(fn):
    return lambda s: '<em>{}</em>'.format(fn(s))

@b
@em
def greet(name):
    return('Hello, {}!'.format(name))

print(greet("zyt"))

def add_log_out(log_level):
    def wrapper(f):
        def return_f(*real_para):
            """inner doc
            """
            print("[{}]: {} with parameter {}".format(log_level, f.__name__, real_para))
            return f(*real_para)

        return return_f
    return wrapper

# same as "add = add_log_out("INFO")(add)"
@add_log_out("INFO")
def add(a,b):
    """return a + b
    """
    return a+b

print(add(1,2))
print(add.__name__)
print(add.__doc__)

from functools import wraps
def add_log_out(log_level):
    def wrapper(f):
        @wraps(f)
        def return_f(*real_para):
            """inner doc
            """
            print("[{}]: {} with parameter {}".format(log_level, f.__name__, real_para))
            return f(*real_para)

        return return_f
    return wrapper

# same as "add = add_log_out("INFO")(add)"
@add_log_out("INFO")
def add(a,b):
    """return a + b
    """
    return a+b

print(add(1,2))
print(add.__name__)
print(add.__doc__)

def function():
    # initial some environment
    # the environment can use global variable to save or just put it as function parameter

    # def deeper(path, (environment)):
        # return condition
        for all possible sub situation:
            # change environment

            # try to go deeper
            deeper(new_path, (environment))

            # recover the enviroment

    deeper(initial_path)
    return