I have this book called TEXT PROCESSING IN PYTHON by David Mertz on hand, it is a good book and in the first chapter it is really a show room for higher-order functions which I may now cite to remind you of the FLEXIBILITY of this keyword.
I'm not exactly sure what you mean by "flexibility"; all of these examples can be written without lambdas:
apply_each = lambda funs, args = []: map(apply, fns, [args]*len(fns))
def apply_each(fns, args=[]): return [fn(*args) for fn in fns]
bools = lambda lst: mpa(truth, lst)
def bools(lst): return [bool(x) for x in lst]
bool_each = lambda fns, args = []: bools(apply_each(fns, args))
def bool_each(fns, args=[]): return bools(apply_each(fns, args))
conjoin = lambda fns, args = []: reduce(mul, bool_each(fns, args))
def conjoin(fns, args=[]): reduce(mul, bool_each(fns, args))
all = lambda fns: lambda arg, fns = fns: conjoin(fns, (arg,))
def all(fns): def _(arg): return conjoin(fns, (arg,)) return _
both = lambda f,g: all(f(f,g))
def both(f, g): return all(f(f,g))
all3 = lambda f,g,h: all((f,g,h))
def all3(f, g, h): return all((f,g,h))
and_ = lambda f,g: lambda x, f=f, g=g: f(x) and g(x)
def and_(f, g): def _(x): return f(x) and g(x) return _
disjoin = lambda fns, args = []: reduce(add, bool_each(fns, args))
def disjoin(fns, args=[]): return reduce(add, bool_each(fns, args))
some = lambda fns: lambda arg, fns = fns: disjoin(fns, (arg,))
def some(fns): def _(arg): return disjoin(fns, (arg,)) return _
either = lambda f,g: some((f,g))
def either(f, g): return some((f,g))
anyof3 = lambda f,g,h: some((f,g,h))
def anyof3(f, g, h): return some((f,g,h))
compose = lambda f,g: lambda x, f=f, g=g: f(g(x))
def compose(f, g): def _(x): return f(g(x)) return _
compose3 = lambda f,g,h: lambda x, f=f, g=g, h=j: f(g(h(x)))
def compose3(f, g, h): def _(x): return f(g(h(x))) return _
ident = lambda x:x
def ident(x): return x
Steve -- http://mail.python.org/mailman/listinfo/python-list
