functional 0.1.1 → 0.1.3

data/README.md

@@ -8,8 +8,88 @@ Usage
 
 	require 'functional'
 	
-	obj = 0 .. 10**12
-	Functional.new( obj).select {|i| i.even? }.collect {|i| i/3 }.select {|i| i.even? }.each &method( :puts)
+	# 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
 
 What's with _#map_?
 =================

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.3

data/lib/functional.rb

@@ -1,4 +1,3 @@
-
 class ::Regexp
 	class NegRegexp
 		def initialize r
@@ -21,57 +20,100 @@ class ::Regexp
 end
 
 class ::Object
-	def functional meth = nil
+	def to_fun meth = nil
 		Functional.new self, meth
 	end
-	alias to_fun functional
+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
 	include Enumerable
 
+	class DEFAULT
+	end
+
 	class Base
 		attr_reader :exe
 		attr_accessor :next
+		attr_reader :caller
+
 		def initialize &e
+			@caller = Kernel.caller.first
 			@exe = e
 		end
 
-		def call *a
+		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 call *a
+		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 call *a
+		def select_fun *a
 			@next.call *a  if @exe.call *a
 		end
+		alias call select_fun
 	end
 
-	class DeleteIf <Base
-		def call *a
+	class Filter <Base
+		def filter_fun *a
 			@next.call *a  unless @exe.call *a
 		end
+		alias call filter_fun
 	end
 
 	class Compact <Base
-		def call *a
+		def compact_fun *a
 			@next.call *a  unless a.empty? || [nil] == a
 		end
+		alias call compact_fun
 	end
 
 	class BottomUp <Base
@@ -80,7 +122,7 @@ class Functional
 			@buffer, @start = nil, start
 		end
 
-		def call a
+		def bottom_up_fun a
 			if @exe.call a
 				@next.call @buffer+a
 				@buffer = @start.dup
@@ -88,6 +130,7 @@ class Functional
 				@buffer += a
 			end
 		end
+		alias call bottom_up_fun
 
 		def end
 			@next.call @buffer
@@ -101,7 +144,7 @@ class Functional
 			@buffer, @start = nil, start
 		end
 
-		def call a
+		def top_down_fun a
 			if @exe.call a
 				@next.call @buffer
 				@buffer = @start.dup+a
@@ -109,6 +152,7 @@ class Functional
 				@buffer += a
 			end
 		end
+		alias call top_down_fun
 
 		def end
 			@next.call @buffer
@@ -120,6 +164,7 @@ class Functional
 		def end
 			nil
 		end
+		alias :clean :end
 	end
 
 	class P <Each
@@ -130,16 +175,17 @@ class Functional
 
 	class Inject <Base
 		attr_reader :it
+		alias :end :it
+
 		def initialize start, *a, &e
 			super *a, &e
 			@it = start
 		end
-		def call *a
+
+		def inject_fun *a
 			@it = @exe.call @it, *a
 		end
-		def end
-			@it
-		end
+		alias call inject_fun
 	end
 
 	class To_a <Inject
@@ -149,21 +195,36 @@ class Functional
 	end
 
 	class Map <Collect
-		def call *a
+		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, *a, &e
-			super *a, &e
-			@buf = {}
-			@buf.default = iv
+		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)
+					p default: :proc, iv: iv
+					Hash.new {|h,k| h[k] = iv.call }
+				else
+					p default: :value, iv: iv
+					{}.tap {|h| h.default = iv }
+				end
 		end
 
-		def call *a
+		def reduce_fun *a
 			@buf[ a[0]] = @exe.call @buf[ a[0]], *a[1..-1]
 		end
+		alias call reduce_fun
 
 		def end
 			@buf.each {|i| @next.call *i}
@@ -171,6 +232,83 @@ class Functional
 		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
@@ -190,7 +328,7 @@ class Functional
 		push Map.new( &exe)
 	end
 
-	def reduce iv, &exe
+	def reduce iv = ::Functional::DEFAULT, &exe
 		push Reduce.new( iv, &exe)
 	end
 
@@ -202,8 +340,8 @@ class Functional
 		push Select.new( &re.method( :match))
 	end
 
-	def delete_if &exe
-		push DeleteIf.new( &exe)
+	def filter &exe
+		push Filter.new( &exe)
 	end
 
 	def compact
@@ -218,6 +356,10 @@ class Functional
 		push TopDown.new( init, &exe)
 	end
 
+	def flatten &exe
+		push Flatten.new
+	end
+
 	def each &exe
 		return self  unless exe
 		push Each.new
@@ -233,37 +375,61 @@ class Functional
 	def run
 		@obj.send @func||:each, *@args, &@next #.method(:call)
 		@next.end
+	rescue Object
+		@next.clean
+		raise $!
 	end
 
 	def p
-		each {|*a|Kernel.p a}
+		each &Kernel.method( :p)
 	end
-end
 
-begin
-	require 'tokyocabinet'
+	def pager *opts
+		push Pager.new( *opts)
+		run
+	end
 
-	class Functional
-		class Map <Base
-			class Emit < TokyoCabinet::BDB
-				alias emit putdup
-				alias call emit
-			end
+	def sort &exe
+		to_a.sort &exe
+	end
 
-			def call *a
-				@exe.call( *a).each &@next
-			end
-		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 }
+	end
+
+	def slice n, &e
+		push Slice.new( n)
+		push Collect.new( &e)  if e
+		self
+	end
+
+	def cons n, &e
+		push Cons.new( n)
+		push Collect.new( &e)  if e
+		self
+	end
+
+	class Save < Base
+		attr_reader :db
 
-		def map name, &e
-			push Map.new( name, &e)
+		def initialize db
+			@db = db
 		end
 
-		def Reduce name, &e
-			push Reduce.new( name, &e)
+		def call k, *v
+			@db[ k] = v.length == 1 ? v.first : v
 		end
 	end
 
-rescue MissingSourceFile
-	# TokyoCabinet not installed?
-end  if false
+	def save db
+		push Save.new( db)
+	end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Denis Knauf
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-25 00:00:00 +02:00
+date: 2011-11-24 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -38,11 +38,12 @@ homepage: http://github.com/DenisKnauf/functional
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -50,6 +51,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -59,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Makes big functional operations possible