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))
--
http://mail.python.org/mailman/listinfo/python-list
