diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index 8146014..0000000
--- a/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-functional.gemspec
-pkg
diff --git a/README.md b/README.md
index 1478272..d625a86 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,3 @@
-Obsolete
-========
-
-Use `#lazy`.
-
 Install
 =======
 
@@ -13,88 +8,8 @@ Usage
 
 	require 'functional'
 	
-	# To demonstrate Functional, we create a Class with a infinite loop:
-	class Sequence
-		include Enumerable
-		def initialize first = 0, step = 1
-			@i, @step = first, step
-		end
-		def each
-			# Our infinite loop:
-			loop do
-				yield @i
-				@i += @step
-			end
-		end
-	end
-	
-	Functional.new( Sequence.new).
-		select {|i| i.even? }.
-		collect {|i| i/3 }.
-		select {|i| i.even?}.
-		collect {|i| [[[[[[i.even?, i.odd?]]], i, [[[[[[i.class]]]]]]]]] }.
-		flatten. # It flattens everything! Not like: collect {|i| i.flatten }.
-		p
-	
-	# Without Functional... Bye bye.
-	Sequence.new.
-		select {|i| i.even? }.
-		collect {|i| i/3 }.
-		select {|i| i.even?}.
-		collect {|i| [[[[[[i.even?, i.odd?]]], i, [[[[[[i.class]]]]]]]]] }.
-		flatten. # It flattens everything! Not like: collect {|i| i.flatten }.
-		p
-
-It will never realize, that #p doesn't exists, because the first select runs endless.
-Functional#p prints everything to stdout.
-
-	(0..100000).to_fun.
-		collect {|i| i*3 }.
-		select {|i| i%5 == 2 }.
-		to_a
-
-Thanks to `Symbol#to_proc`:
-
-	Sequence.new.to_fun.
-		select( &:even?).
-		collect {|i| i/3 }.
-		select( &:even?).
-		collect {|i| [[[[[[i.even?, i.odd?]]], i, [[[[[[i.class]]]]]]]]] }.
-		flatten. # It flattens everything! Not like: collect {|i| i.flatten }.
-		p
-
-If you know methodphitamine,  combine it:
-
-	require 'methodphitamine'
-	
-	Sequence.new.to_fun.
-		select( &it.even?).
-		collect( &it/3).
-		select( &it.even?).
-		collect {|i| [[[[[[i.even?, i.odd?]]], i, [[[[[[i.class]]]]]]]]] }.
-		flatten.
-		p
-
-	(0..100000).to_fun.
-		collect( &it*3).
-		select( &it%5 == 2).
-		to_a
-
-Makros
-======
-
-	seq = Sequence.new.to_fun
-	seq = seq.select &it.even?  if must_be_even
-	seq = seq.
-		collect( &it/3).
-		select( &it.even?).
-		collect {|i| [[[[[[i.even?, i.odd?]]], i, [[[[[[i.class]]]]]]]]] }
-	seq = seq.flatten  if please_flatten
-	if print_it
-		seq.p
-	else
-		seq_to_a
-	end
+	obj = 0 .. 10**12
+	Functional.new( obj).select {|i| i.even? }.collect {|i| i/3 }.select {|i| i.even? }.each &method( :puts)
 
 What's with _#map_?
 =================
diff --git a/VERSION b/VERSION
index 9faa1b7..8acdd82 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.1.5
+0.0.1
diff --git a/lib/functional.rb b/lib/functional.rb
index f129e3d..dce2126 100644
--- a/lib/functional.rb
+++ b/lib/functional.rb
@@ -1,465 +1,46 @@
-class ::Regexp
-	class NegRegexp
-		def initialize r
-			@rx = r
-		end
-		def match l
-			! @rx.match( l)
-		end
-		def =~ l
-			! @rx =~ l
-		end
-		def -@
-			@rx
-		end
-	end
-
-	def -@
-		NegRegexp.new self
-	end
-end
-
-class ::Object
-	def to_fun meth = nil
-		Functional.new self, meth
-	end
-end
-
-class Counter
-	include Enumerable
-	attr_reader :c
-
-	def initialize first = nil, step = nil
-		@c, @step = first || 0, step || 1
-	end
-
-	def next; @c += @step end
-	def to_i; c.to_i end 
-	def to_f; c.to_f end
-
-	def + i
-		@c += @step*i
-	end
-
-	def each &e
-		loop { e.call self; self.next }
-	end
-end
 
 class Functional
-	def self.__version__() '0.1.5' end
 	include Enumerable
 
-	class DEFAULT
+	def self.method_missing meth, *args, &exe
+		self.new.send meth, *args, &exe
 	end
 
-	class Base
-		attr_reader :exe
-		attr_accessor :next
-		attr_reader :caller
-
-		def initialize &e
-			@caller = Kernel.caller.first
-			@exe = e
-		end
-
-		def base_fun *a
-			@next.call *a
-		end
-		alias call base_fun
-
-		def end
-			@next.end
-		end
-
-		def clean
-			@next.clean
-		end
-
-		def to_proc
-			method( :call).to_proc
-		end
-	end
-
-	class Collect <Base
-		def collect_fun *a
-			@next.call *@exe.call( *a)
-		end
-		alias call collect_fun
-	end
-
-	class Tap <Base
-		def tap_fun *a
-			@exe.call *a
-			@next.call *a
-		end
-		alias call tap_fun
-	end
-
-	class Select <Base
-		def select_fun *a
-			@next.call *a  if @exe.call *a
-		end
-		alias call select_fun
-	end
-
-	class Filter <Base
-		def filter_fun *a
-			@next.call *a  unless @exe.call *a
-		end
-		alias call filter_fun
-	end
-
-	class Compact <Base
-		def compact_fun *a
-			@next.call *a  unless a.empty? || [nil] == a
-		end
-		alias call compact_fun
-	end
-
-	class BottomUp <Base
-		def initialize start, *a, &e
-			@next.call *a, &e
-			@buffer, @start = nil, start
-		end
-
-		def bottom_up_fun a
-			if @exe.call a
-				@next.call @buffer+a
-				@buffer = @start.dup
-			else
-				@buffer += a
-			end
-		end
-		alias call bottom_up_fun
-
-		def end
-			@next.call @buffer
-			@next.end
-		end
-	end
-
-	class TopDown <Base
-		def initialize start, *a, &e
-			@next.call *a, &e
-			@buffer, @start = nil, start
-		end
-
-		def top_down_fun a
-			if @exe.call a
-				@next.call @buffer
-				@buffer = @start.dup+a
-			else
-				@buffer += a
-			end
-		end
-		alias call top_down_fun
-
-		def end
-			@next.call @buffer
-			@next.end
-		end
-	end
-
-	class Each <Base
-		def each_fun *a
-			@exe.call *a
-		end
-		alias call each_fun
-
-		def end
-			nil
-		end
-		alias :clean :end
-	end
-
-	class P <Each
-		def initialize *a
-			super *a, &Kernel.method( :p)
-		end
-	end
-
-	class Inject <Base
-		attr_reader :it
-		alias :end :it
-
-		def initialize start, *a, &e
-			super *a, &e
-			@it = start
-		end
-
-		def inject_fun *a
-			@it = @exe.call @it, *a
-		end
-		alias call inject_fun
-	end
-
-	class To_a <Inject
-		def initialize *a, &e
-			super [], *a, &e
-		end
-	end
-
-	class Map <Collect
-		def map_fun *a
-			@exe.call *a, &@next
-		end
-		alias call map_fun
-	end
-
-	class Flatten <Base
-		def flatten_fun *a
-			a.each &@next.method( :call)
-		end
-		alias call flatten_fun
-	end
-
-	class Reduce <Base
-		def initialize iv = ::Functional::DEFAULT, *a, &exe
-			super *a, &exe
-			iv = Array.method :new  if ::Functional::DEFAULT == iv
-			@buf = if iv.kind_of?( ::Proc) || iv.kind_of?( ::Method)
-					Hash.new {|h,k| h[k] = iv.call }
-				else
-					{}.tap {|h| h.default = iv }
-				end
-		end
-
-		def reduce_fun k, *a
-			@buf[ k] = @exe.call k, @buf[ k], *a
-		end
-		alias call reduce_fun
-
-		def end
-			@buf.each &@next.method( :call)
-			@next.end
-		end
-	end
-
-	class ToHash <Base
-		def initialize
-			super
-			@buf = {}
-		end
-
-		def to_hash_fun k, *a
-			@buf[k] = a
-		end
-		alias call to_hash_fun
-
-		def end
-			@buf
-		end
-
-		def clean
-		end
-	end
-
-	class Slice <Base
-		def initialize n
-			@buf, @n = [], n
-		end
-
-		def slice_fun *a
-			@buf.push a
-			unless @n > @buf.size
-				@next.call @buf
-				@buf.clear
-			end
-		end
-		alias call slice_fun
-
-		def end
-			@next.call @buf
-			@next.end
-		end
-	end
-
-	class Cons <Base
-		def initialize n
-			@buf, @n = [], n
-		end
-
-		def cons_fun *a
-			@buf.push a
-		 	unless @n > @buf.size
-				class <<self
-					def call *a
-						@buf.push a
-						@next.call @buf
-						@buf.shift
-					end
-				end
-				@next.call @buf
-				@buf.shift
-			end
-		end
-		alias call cons_fun
-
-		def end
-			@next.call @buf  unless @n > @buf.size
-			@next.end
-		end
-	end
-
-	class Pager <Base
-		def initialize *opts
-			@pager = IO.popen ENV['PAGER'] || 'less', 'w'
-			opts.each do |opt|
-				case opt.to_s
-				when *%w[inspect i] then alias call call_inspect
-				else raise ArgumentError, "Unknown opt: #{opt}"
-				end
-			end
-		end
-
-		def call_inspect *a
-			@pager.puts a.inspect
-		end
-
-		def pager_fun *a
-			@pager.puts a
-		end
-		alias call pager_fun
-
-		def clean
-			@pager.close
-		end
-
-		def end
-			clean
-			nil
-		end
-	end
-
-	attr_accessor :next, :stack, :obj, :func, :args
-
-	def initialize obj = nil, func = nil, *args
-		@next, @stack, @obj, @func, @args = self, self, obj, func, args
-	end
-
-	def push a
-		@stack = @stack.next = a
+	def push_method code, *args, &exe
+		name = "__meth_#{exe.object_id}"
+		define_singleton_method name, &exe
+		@stack.push [code % name]+args
 		self
 	end
 
+	def initialize obj = nil, func = nil, *args
+		@stack, @obj, @func, @args = [], obj, func, args
+	end
+
 	def collect &exe
-		push Collect.new( &exe)
+		push_method "value=%s(value)", &exe
 	end
 
+	# map/reduce?
 	def map &exe
-		push Map.new( &exe)
+		raise "Reserved for MapReduce."
 	end
 
-	def reduce iv = ::Functional::DEFAULT, &exe
-		push Reduce.new( iv, &exe)
+	# map/reduce?
+	def reduce &exe
+		raise "Reserved for MapReduce."
 	end
 
 	def select &exe
-		push Select.new( &exe)
+		push_method "%s(value)||next", &exe
 	end
 
-	def grep re
-		push Select.new( &re.method( :match))
-	end
-
-	def filter &exe
-		push Filter.new( &exe)
-	end
-	alias reject filter
-
-	def compact
-		push Compact.new
-	end
-
-	def updown init, &exe
-		push UpDown.new( init, &exe)
-	end
-
-	def topdown init, &exe
-		push TopDown.new( init, &exe)
-	end
-
-	def flatten &exe
-		push Flatten.new
+	def delete_if &exe
+		push_method "%s(value)&&next", &exe
 	end
 
 	def each &exe
 		return self  unless exe
-		push Each.new( &exe)
-		run
-	end
-
-	def to_hash
-		push ToHash.new
-		run
-	end
-
-	def join deli
-		push Inject.new('') {|i,j|i+deli+j}
-		run
-	end
-
-	def run
-		@obj.send @func||:each, *@args, &@next #.method(:call)
-		@next.end
-	rescue Object
-		@next.clean
-		raise $!
-	end
-
-	def p
-		each &Kernel.method( :p)
-	end
-
-	def pager *opts
-		push Pager.new( *opts)
-		run
-	end
-
-	def sort &exe
-		to_a.sort &exe
-	end
-
-	def sort_by &exe
-		to_a.sort_by &exe
-	end
-
-	# [ _A, _B, ..., _C, ..., _D ] ==> [ [0, _A], [1, _B], ..., [_I, _C], ..., [_N, _D]]
-	# [ [_A|_As], [_B|_Bs], ..., [_C|_Cs], ..., [_D|_Ds] ] ==> [ [0,_A|_As], [1,_B|_Bs], ..., [_I,_C|_Cs], ..., [_N,_D|_Ds] ]
-	def with_index &exe
-		i = 0
-		exe ||= Array.method :[]
-		push Collect.new {|*a| exe.call i, *a; i += 1 }
-	end
-
-	def slice n, &exe
-		push Slice.new( n)
-		block_given? ? self.collect( &exe) : self
-	end
-
-	def cons n, &exe
-		push Cons.new( n)
-		block_given? ? self.collect( &exe) : self
-	end
-
-	def tap &exe
-		push Tap.new( &exe)
-	end
-
-	class Save < Base
-		attr_reader :db
-
-		def initialize db
-			@db = db
-		end
-
-		def call k, *v
-			@db[ k] = v.length == 1 ? v.first : v
-		end
-	end
-
-	def save db
-		push Save.new( db)
+		@obj.send @func || :each, *@args, &eval( "lambda{|value|#{@stack.join( ";")};exe.call(value)}")
 	end
 end
diff --git a/test/functional_test.rb b/test/functional_test.rb
deleted file mode 100644
index 9497c66..0000000
--- a/test/functional_test.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-require 'test/unit'
-require 'functional'
-
-class FunTest < Test::Unit::TestCase
-	M = 0..100
-
-	def doit_fun m, &exe
-		f = m.to_fun
-		yield f
-		f.to_a
-	end
-
-	def test_to_fun_exists
-		assert_respond_to Object, :to_fun
-	end
-
-	def test_to_a
-		assert_equal M.to_a, doit_fun( M) {|x| x }
-	end
-
-	def test_collect
-		l = lambda {|x| x*2}
-		assert_equal M.collect( &l), doit_fun( M) {|x| x.collect( &l) }
-	end
-
-	def test_inject
-		assert_equal M.inject( 0) {|i,j| i+j }, M.to_fun.inject( 0) {|i,j| i+j }
-	end
-end