Shell-like Decorators

[Joel Bender]

I was inspired by shell-like processing mentioned here:

     <http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/276960>

and created a decorator version below.  I've been using it for parsing
a pile of C include files and building digraphs of the results.  For
example, given jdir('*.h') returns a sequence of file names:

     jdir("*.h") | jimap(file) | jchain \
       | jmatch(r"^#define\s+(\w+)\s+(\d+)") | jdict

builds a dictionary of the #define's in the files.  Comments?


Joel

---------- Code Bits ----------

import re
import sys

from itertools import imap, ifilter, chain

#

class _jcall:

     def __init__(self, f):
         self.fn = f

     def __ror__(self, input):
         return self.fn(input)

     def __call__(self, *args, **kwargs):
         return self.fn(*args, **kwargs)

def jcall(f):
     return _jcall(f)

jlist = jcall(list)
jtuple = jcall(tuple)
jdict = jcall(dict)
jchain = jcall(lambda input: chain(*input))

#

def jiter(iterfn):

     def iterwrap(f = None):

         class _jiter(_jcall):

             def __ror__(self, input):
                 return iterfn(self.fn, input)

         return _jiter(f)

     return iterwrap

jmap = jiter(map)
jfilter = jiter(filter)
jimap = jiter(imap)
jifilter = jiter(ifilter)
jreduce = jiter(reduce)

#

def japply(f):

     class _japply(_jcall):

         def __ror__(self, input):
             for item in input:
                 self.fn(item)

     return _japply(f)

def writelines(f):
     return japply(f.write)

printlines = writelines(sys.stdout)

#

import re

def jgrep(pat):
     return jifilter(re.compile(pat).search)

def jmatch(pat):
     expr = re.compile(pat)

     def matchfn(input):
         for item in input:
             m = expr.match(item)
             if m: yield m.groups()

     return jcall(matchfn)

def jsub(pat,repl):
     expr = re.compile(pat)
     return jimap(lambda x: expr.sub(repl, x))