function wrappers

[Ramon Crehuet]

Dear all,
I have a Fortran programming background and I have some difficulties in
understading how function wrappers work. I have delved into the subject
because of the new decorators, but I understand the decorator syntax. My
ignorance is more profound... Here is an example without decorators:

def require_int(func):
def wrapper(arg):
assert isinstance(arg, int)
return func(arg)
return wrapper
p1(a):
print a

p2=require_int(p1)

My question is: why do p2 arguments become wrapper arguments? What is
the flux of the arguments in the program when you pass functions as
arguments?
I have looked into some books and google but I cannot find a
satisfactory explanation. Could somebody please give me a hint or point
me to an appropriate source?
Thanks for your time,

Ramon

[Marc 'BlackJack' Rintsch]

On Wed, 10 Oct 2007 12:39:24 +0200, Ramon Crehuet wrote:

def require_int(func):
def wrapper(arg):
assert isinstance(arg, int)
return func(arg)
return wrapper
p1(a):
print a

p2=require_int(p1)

My question is: why do p2 arguments become wrapper arguments? What is
the flux of the arguments in the program when you pass functions as
arguments?

The function `p1` is passed into `require_int`. It is bound to the local
name `func` in `require_int`. Everytime `require_int` is called a new
function object is created and bound to the local name `wrapper`. The
name `func` in that new function object refers to the object bound to
`func` in the `require_int` namespace. Then the new function is returned
still carrying a reference to the `func` object that was passed into
`require_int`.

Ciao,
Marc 'Blackjack' Rintsch

[Paul Hankin]

On Oct 10, 11:39 am, Ramon Crehuet <[e-mail]:

Dear all,
I have a Fortran programming background and I have some difficulties in
understading how function wrappers work. I have delved into the subject
because of the new decorators, but I understand the decorator syntax. My
ignorance is more profound... Here is an example without decorators:

Functions are first-class values: this means they can be passed
around, used in expressions, and returned from other functions in just
the same way that ints, floats and other more obvious types.

All a decorator is a function that takes the function you give it, and
returns a new function. In your 'require_int' example, it returns the
nested function 'wrapper'. The clever bit is that 'wrapper' remembers
the argument to the decorator - func - (with value p1 in your
example), and can call it later.

Think of the 'def' statement as constructing an object which happens
to be a function. It has a dictionary which is used for variable
lookup so that it can remember 'func'. The def statement also binds
this function object to a name: the name of the function. You can see
some of the gory details if you go:

def f():
print 42

dir(f)

.... list of attributes of the function object.

--
Paul Hankin

[Scott David Daniels]

Ramon Crehuet wrote:

def require_int(func):
def wrapper(arg):
assert isinstance(arg, int)
return func(arg)
return wrapper
def p1(a):
print a
p2 = require_int(p1)

My question is: why do p2 arguments become wrapper arguments? What is
the flux of the arguments in the program when you pass functions as
arguments?

I suspect you don't understand that each time require_int is called
a _new_ function named wrapper is created (and then returned).

-Scott David Daniels
Scott David Da*****@Acm.Org