linq.py

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
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)

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

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

	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 select(selector):
	def inner(source):
		return source.select(selector)
	return inner

def where(pred=bool):
	def inner(source):
		return source.where(pred)
	return inner

def take(count):
	def inner(source):
		return source.take(count)
	return inner

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()

fixed: http://gist.github.com/527054