接上文，我们定义了判断某行是否file copy,或者file overwrite的两个函数，事实上我们如果使用

startswith函数代替slice，会更稳定。从函数式编程角度，我们给出下面几个表达式：

      isRegDBRoot = lambda line: line[:11]=='RegDB Root:'

      isRegDBKey = lambda line: line[:10]=='RegDB Key:'

      isRegDBVal = lambda line: line[:10]=='RegDB Val:'

有了这三个更加紧凑的函数，我们给出之前方法的函数式编程写法;

      lines = open(r'd:\python22\install.log').readlines()

      regroot_lines = filter(isRegDBRoot, lines)

如果，你想通过多个选择标准来选择相应的行，那么函数式的写法就会显得笨拙。

我们可以根据相似的思路写出一个给定要求对应的过滤函数如下：

 #*--------------- Find the RegDB lines ------------------#

      def isAnyRegDB(line):

          if   line[:11]=='RegDB Root:': return 1

          elif line[:10]=='RegDB Key:':  return 1

          elif line[:10]=='RegDB Val:':  return 1

          else:                          return 0

但是，如果需求变成了其他的组合呢？显然依据这个思路，我们必须为另外的组合写更多的组合，这种组合是爆炸性的增长的。。。另外的思路是通过嵌套过滤函数来达到：

 #*------------- Filter on two line predicates -----------#

      shortline = lambda line: len(line) < 25

      short_regvals = filter(shortline, filter(isRegDBVal, lines))

这样的思路写出的程序比较容易排错，该函数使用了两个已有的函数来生成新的程序。但是一个显而易见的问题是：这样的程序很难阅读。同样的问题也出现在map函数上。通常解决这样问题的方法是多增加一些循环和中间变量。。

根据函授式编程的思路，我们可以在不增加代码量的情况下解决上面描述的问题。

这里的关键点是：选择的生成一些高级别的组合函数：这里的高级别函数是指：那些接受函数作为输入，返回函数作为输出的函数。一级函数接受数据，返回数据。相对应的一个高级函数的输入和输出都是函数对象。这些函数对象将在未来被其他地方使用：高级函数的一个例子是;函数工厂，它返回一个或者一组函数对象。下面是一个加法函数工厂;

>>> def adder_factory(n):

      ...    return lambda m, n=n: m+n

      ...

      >>> add10 = adder_factory(10)

      >>> add10

      <function <lambda> at 0x00FB0020>

      >>> add10(4)

      14

      >>> add10(20)

      30

      >>> add5 = adder_factory(5)

      >>> add5(4)

      9

回到正题，我们提到用高级组合函数来解决前面提到的问题，这些高级函数通过接受一些函数，对这些函数对象进行操作从而合成其他的函数。下面是一个组合高级函数库：

#------------------- combinatorial.py -------------------#

      from operator import mul, add, truth

      apply_each = lambda fns, args=[]: map(apply, fns, [args]*len(fns))

      bools = lambda lst: map(truth, lst)

      bool_each = lambda fns, args=[]: bools(apply_each(fns, args))

      conjoin = lambda fns, args=[]: reduce(mul, bool_each(fns, args))

      all = lambda fns: lambda arg, fns=fns: conjoin(fns, (arg,))

      both = lambda f,g: all((f,g))

      all3 = lambda f,g,h: all((f,g,h))

      and_ = lambda f,g: lambda x, f=f, g=g: f(x) and g(x)

      disjoin = lambda fns, args=[]: reduce(add, bool_each(fns, args))

      some = lambda fns: lambda arg, fns=fns: disjoin(fns, (arg,))

      either = lambda f,g: some((f,g))

      anyof3 = lambda f,g,h: some((f,g,h))

      compose = lambda f,g: lambda x, f=f, g=g: f(g(x))

      compose3 = lambda f,g,h: lambda x, f=f, g=g, h=h: f(g(h(x)))

      ident = lambda x: x

这样通过使用这些高级组合函数：我们可以这样解决之前遇到的问题：

 #----- Some examples using higher-order functions -----#

      # Don't nest filters, just produce func that does both

      short_regvals = filter(both(shortline, isRegVal), lines)

      # Don't multiply ad hoc functions, just describe need

      regroot_lines = \

          filter(some([isRegDBRoot, isRegDBKey, isRegDBVal]), lines)

      # Don't nest transformations, make one combined transform

      capFlipNorm = compose3(upper, flip, normalize)

      cap_flip_norms = map(capFlipNorm, lines)

可以看出通过函数式编程方法，我们可以不仅获得更加精炼的代码，以及更好的可读性.

任何嵌套的filter 和map函数都可以通过高级组合函数进行化简，总的来说，函数式编程方法得到的代码量应该在常规方法代码量的一半。

这种高级组合函数的另外一个好处是;他们可以提供一整套的函数的布尔表达式。

  #*---------- Simple Boolean algebra of values ----------#

      satisfied = (this or that) and (foo or bar)

在文本处理环境下，这样的操作经常是一些predic函数的结果。如下：

  #*---------- Boolean algebra of return values ----------#

      satisfied = (thisP(s) or thatP(s)) and (fooP(s) or barP(s))

通过之前的高级组合函数，我们可以得到如下代码：

 #*------ Boolean algebra of composed functions ------#

      satisfiedP = both(either(thisP,thatP), either(fooP,barP))

精简如斯啊。

一些问题下次再翻译，睡了。