linq.py

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
def linqmethod(method):
	name = method.__name__
	def gfunc(*args, **kargs):
		def ginner(source):
			func = getattr(source, name)
			return func(*args, **kargs)
		return ginner
	globals().__setitem__(name, gfunc)

	def inner(self, *args, **kargs):
		return method(self, *args, **kargs)
	return inner

class Enumerable(object):
	def __init__(self, source, inext):
		self._source = source
		self._inext = inext
	
	def __iter__(self):
		return self

	def next(self):
		return self._inext(self._source)

	@linqmethod
	def select(self, selector):
		def inext(source):
			return selector(source.next())
		return Enumerable(self, inext)

	@linqmethod
	def where(self, pred=bool):
		def inext(source):
			while True:
				item = source.next()
				if pred(item):
					return item
		return Enumerable(self, inext)

	@linqmethod
	def take(self, count):
		class inner(object):
			def __init__(self):
				self.index = 0
			def inext(self, source):
				while True:
					item = source.next()
					if self.index < count:
						self.index += 1
						return item
					else:
						raise StopIteration
		return Enumerable(self, inner().inext)

def make(source, *methods):
	def iter(s):
		for v in s:
			yield v

	def inext(s):
		return s.next()

	e = Enumerable(iter(source), inext)
	for method in methods:
		e = method(e)
	return e

def main():
	import linq

	def put(q):
		for n in q:
			print n,
		print

	a = [{'key': i, 'value': i * 2} for i in range(100)]

	# メソッドチェイン
	q = linq.make(a).take(20).where(lambda x: x['key'] % 2).select(lambda x: x['value'])
	put(q)

	# メソッドチェイン風
	q = linq.make(a
		, linq.take(20)
		, linq.where(lambda x: x['key'] % 2)
		, linq.select(lambda x: x['value'])
		)
	put(q)

if __name__ == '__main__':
	main()