iolite 0.0.1

data/lib/iolite/functinal/define_iolite_functinal_send_method.rb

@@ -0,0 +1,9 @@
+require "iolite/functinal/send"
+
+class Module
+	def define_iolite_functinal_send_method send_name, define_name = send_name
+		define_method(define_name) { |*args|
+			Iolite::Functinal.send(self, send_name, *args)
+		}
+	end
+end

data/lib/iolite/functinal/invoke.rb

@@ -0,0 +1,11 @@
+module Iolite module Functinal
+	def invoke func, *args
+		func.respond_to?(:iolite_functinal_invoke_call) ? func.iolite_functinal_invoke_call(*args) : func
+	end
+	module_function :invoke
+
+	def invoke_a funcs, *args
+		funcs.map{ |it| invoke(it, *args) }
+	end
+	module_function :invoke_a
+end end

data/lib/iolite/functinal/send.rb

@@ -0,0 +1,13 @@
+require "iolite/functinal/invoke"
+
+module Iolite module Functinal
+	def send func, method, *args_, &block
+		Lazy.new { |*args|
+# 			block = invoke(block, *args) if block
+			invoke(func, *args).send(method, *invoke_a(args_, *args), &block)
+# 			invoke(func, *args).send(method, *invoke_a(args_, *args), &block)
+# 			func.call(*args).send(method, *invoke_a(args_, *args), &block)
+		}
+	end
+	module_function :send
+end end

data/lib/iolite/lazy.rb

@@ -0,0 +1,40 @@
+require "iolite/adaptor"
+
+module Iolite
+	class Lazy < BasicObject
+# 		include ::Iolite::Adaptor::All
+		include ::Iolite::Adaptor::Callable
+		include ::Iolite::Adaptor::Bind
+		include ::Iolite::Adaptor::Send
+		include ::Iolite::Adaptor::MethodMissing
+		include ::Iolite::Adaptor::ToProc
+		include ::Iolite::Adaptor::Apply
+		include ::Iolite::Adaptor::Operators
+		include ::Iolite::Adaptor::ToLazy
+
+		def initialize &block
+			@block = block
+		end
+
+		def call *args
+			@block.call(*args)
+		end
+
+# 		iolite_define_send_original_methods
+	end
+
+	def lazy &block
+		Iolite::Lazy.new &block
+	end
+	module_function :lazy
+
+# 	def wrap value
+# 		Iolite.lazy { |*args| value }
+# 	end
+# 	module_function :wrap
+#
+# 	def lazy_func func
+# 		Iolite.lazy { |*args| func.call(*args) }
+# 	end
+# 	module_function :wrap
+end

data/lib/iolite/placeholders.rb

@@ -0,0 +1,30 @@
+require "iolite/lazy"
+
+module Iolite module Placeholders
+	def args
+		Lazy.new { |*args|
+			args
+		}
+	end
+	module_function :args
+
+	def argument index
+		Lazy.new { |*args|
+			args[index-1]
+		}
+	end
+	module_function :argument
+
+	def prepare n
+		1.upto(n).each { |i|
+			const_set("ARG#{i}", argument(i))
+			define_method("arg#{i}") do
+				Placeholders.const_get("ARG#{i}")
+			end
+			module_function "arg#{i}"
+			alias_method "_#{i}", "arg#{i}"
+		}
+	end
+	module_function :prepare
+	prepare(10)
+end end

data/lib/iolite/refinements.rb

@@ -0,0 +1,6 @@
+require "iolite/refinements/object_with_to_lazy"
+# require "iolite/refinements/array"
+# require "iolite/refinements/hash"
+# require "iolite/refinements/proc"
+# require "iolite/refinements/string"
+

data/lib/iolite/refinements/array.rb

@@ -0,0 +1,16 @@
+require "iolite/adaptor/all"
+require "iolite/functinal/invoke"
+
+module Iolite module Refinements
+	module Array
+		refine ::Array do
+			include Iolite::Adaptor::ToProc
+			include Iolite::Adaptor::Bind
+			include Iolite::Adaptor::Apply
+			include Iolite::Adaptor::Callable
+			def call *args
+				Iolite::Functinal.invoke_a(self, *args)
+			end
+		end
+	end
+end end

data/lib/iolite/refinements/hash.rb

@@ -0,0 +1,18 @@
+require "iolite/adaptor/all"
+require "iolite/functinal/invoke"
+
+module Iolite module Refinements
+	module Hash
+		refine ::Hash do
+			include Iolite::Adaptor::ToProc
+			include Iolite::Adaptor::Bind
+			include Iolite::Adaptor::Apply
+			include Iolite::Adaptor::Callable
+			def call *args
+				Hash[ self.map { |key, value|
+					Iolite::Functinal.invoke_a([key, value], *args)
+				} ]
+			end
+		end
+	end
+end end

data/lib/iolite/refinements/object_with_to_lazy.rb

@@ -0,0 +1,9 @@
+require "iolite/adaptor/to_lazy"
+
+module Iolite module Refinements
+	module ObjectWithToLazy
+		refine Object do
+			include Iolite::Adaptor::ToLazy
+		end
+	end
+end end

data/lib/iolite/refinements/proc.rb

@@ -0,0 +1,9 @@
+require "iolite/adaptor/all"
+
+module Iolite module Refinements
+	module Proc
+		refine ::Proc do
+			include Iolite::Adaptor::All
+		end
+	end
+end end

data/lib/iolite/refinements/string.rb

@@ -0,0 +1,26 @@
+require "iolite/adaptor/all"
+require "iolite/functinal/invoke"
+
+module Iolite module Refinements
+	module String
+		refine ::String do
+			include Iolite::Adaptor::ToProc
+			include Iolite::Adaptor::Callable
+			def call *args
+				result = self.clone
+				args.each_with_index { |it, i|
+					result.gsub! Iolite::Placeholders.const_get("ARG#{i+1}").to_s, it.to_s
+				}
+				result
+			end
+
+			def to_call_by_eval binding = nil
+				Iolite.lambda { |*args|
+					gsub(/#{'#{(.*?)}'}/) {
+						eval($1, binding).call(*args)
+					}
+				}
+			end
+		end
+	end
+end end

data/lib/iolite/statement.rb

@@ -0,0 +1,3 @@
+require "iolite/statement/if"
+require "iolite/statement/if_else"
+

data/lib/iolite/statement/if.rb

@@ -0,0 +1,48 @@
+require "iolite/lazy"
+require "iolite/functinal"
+
+module Iolite module Statement
+
+	class IfThenElse
+		def initialize cond, then_
+			@cond = cond
+			@then_ = then_
+		end
+
+		def [](*else_)
+			Iolite.lazy { |*args|
+				if Iolite::Functinal.invoke(@cond, *args)
+					Iolite::Functinal.invoke_a(@then_, *args).last
+				else
+					Iolite::Functinal.invoke_a(else_, *args).last
+				end
+			}
+		end
+	end
+
+	class If
+		def initialize cond
+			@cond = cond
+		end
+
+		def [](*then_)
+			if_then = Iolite::Lazy.new { |*args|
+				if Iolite::Functinal.invoke(@cond, *args)
+					Iolite::Functinal.invoke_a(then_, *args).last
+				end
+			}
+			cond = @cond
+			(class << if_then; self; end).class_eval {
+				define_method(:else_) {
+					IfThenElse.new cond, then_
+				}
+			}
+			if_then
+		end
+	end
+
+	def if_ cond
+		If.new cond
+	end
+
+end end

data/lib/iolite/statement/if_else.rb

@@ -0,0 +1,11 @@
+module Iolite module Statement
+	def if_else cond, then_, else_
+		Lazy.new { |*args|
+			if Functinal.invoke(cond, *args)
+				Functinal.invoke(then_, *args)
+			else
+				Functinal.invoke(else_, *args)
+			end
+		}
+	end
+end end

data/lib/iolite/version.rb

@@ -0,0 +1,3 @@
+module Iolite
+  VERSION = "0.0.1"
+end

data/spec/iolite_adaptored_spec.rb

@@ -0,0 +1,101 @@
+load 'spec_helper.rb'
+require "iolite"
+require "iolite/adaptored/array"
+require "iolite/adaptored/hash"
+require "iolite/adaptored/proc"
+require "iolite/adaptored/string"
+require "iolite/adaptored/object_with_to_lazy"
+
+describe "Iolite Adaptored" do
+	include Iolite::Placeholders
+
+	describe "Array" do
+		it "call" do
+			expect([arg1, arg1, arg1].call(1)).to eq([1, 1, 1])
+		end
+		it "call with value" do
+			expect([arg1, 3, arg1].call(1)).to eq([1, 3, 1])
+		end
+		it "bind" do
+			expect([arg1, arg1, arg1].bind(arg2).call(1, 2)).to eq([2, 2, 2])
+		end
+		it "call invoke" do
+			expect(Iolite::Functinal.invoke([arg1, arg1, arg1], 1)).to eq([1, 1, 1])
+		end
+		it "nest" do
+			expect([arg1, [arg2, arg3]].call(1, 2, 3)).to eq([1, [2, 3]])
+		end
+		it "nest binding" do
+			expect([arg1, [arg1, arg2].bind(arg3, arg2)].call(1, 2, 3)).to eq([1, [3, 2]])
+		end
+	end
+
+	describe "Hash" do
+		it "call" do
+			expect({ arg1 => arg2 }.call(:name, :homu)).to eq({ name: :homu })
+		end
+		it "call key" do
+			expect({ arg1 => :mami }.call(:name, :homu)).to eq({ name: :mami })
+		end
+		it "call value" do
+			expect({ :mami => arg1 }.call(:name, :homu)).to eq({ mami: :name })
+		end
+		it "calls" do
+			expect({ arg1 => arg2, arg1 => arg3 }.call(:name, :homu, :mado)).to eq({ name: :homu, name: :mado })
+		end
+		it "bind" do
+			expect({ arg1 => arg3, arg2 => arg4 }.bind(arg1, arg1, arg2, arg3).call(:name, :homu, :mado)).to eq({ name: :homu, name: :mado })
+		end
+	end
+
+	describe "Proc" do
+		describe "operator" do
+			it "proc" do
+				expect((proc { 10 } + 20).call()).to eq(30)
+			end
+			it "lambda" do
+				expect((lambda { 10 } + 20).call()).to eq(30)
+			end
+		end
+		describe "bind" do
+			it "proc" do
+				expect(proc { |a, b| a + b }.bind(arg1, 2).call(1)).to eq(3)
+			end
+			it "lambda" do
+				expect(proc { |a, b| a - b }.bind(2, arg1).call(1)).to eq(1)
+			end
+		end
+	end
+
+	describe "String" do
+		include Iolite::Placeholders
+		it "call" do
+			expect("value:#{arg1}:#{arg2}".call(1, 2)).to eq("value:1:2")
+		end
+		it "#to_call_by_eval" do
+			expect('value:#{ Iolite::Placeholders.arg1 }:#{ Iolite::Placeholders.arg2 }'.to_call_by_eval.call(1, 2)).to eq("value:1:2")
+		end
+		it "#to_call_by_eval binding" do
+			var = 10
+			expect('value:#{ arg1 + arg2 * var }:#{ arg2 - arg1 }'.to_call_by_eval(binding).call(1, 2)).to eq("value:21:1")
+		end
+	end
+
+	describe "Object" do
+		describe "#to_lazy" do
+			it "lazy" do
+				expect(1.to_lazy.call()).to eq(1)
+			end
+			it "operator" do
+				expect((1.to_lazy + 2).call()).to eq(3)
+			end
+			it "operator with placeholder" do
+				expect((1.to_lazy + arg1).call(2)).to eq(3)
+			end
+			it "call method" do
+				expect(((1..10).to_lazy.first arg1).call(3)).to eq([1, 2, 3])
+			end
+		end
+	end
+end
+

data/spec/iolite_functinal_spec.rb

@@ -0,0 +1,87 @@
+load 'spec_helper.rb'
+require "iolite/functinal"
+
+
+describe "Iolite::Functinal" do
+	include Iolite::Functinal
+	class Callable
+		def iolite_functinal_invoke_call a, b
+			a + b
+		end
+	end
+	class Uncallable
+		def call x
+			x + x
+		end
+	end
+
+	class First
+		def iolite_functinal_invoke_call *args
+			args[0]
+		end
+		def call *args
+			args[0]
+		end
+	end
+	first = First.new
+
+	describe ".invoke" do
+		it "callable" do
+			expect(invoke(Callable.new, 1, 2)).to eq(3)
+		end
+		it "uncallable" do
+			expect(invoke(3, 1)).to eq(3)
+		end
+		it "uncallable call" do
+			expect(invoke(Uncallable.new, 1).class).to eq(Uncallable)
+		end
+		#it "uncallable proc" do
+		#	expect(invoke(proc { |a, b| a + b }, 1, 2).class).to eq(Proc)
+		#end
+	end
+
+	describe ".invoke_a" do
+		it "callable" do
+			expect(invoke_a([Callable.new, Callable.new], 1, 2)).to eq([3, 3])
+		end
+		it "uncallable" do
+			expect(invoke_a([1, 2], 1)).to eq([1, 2])
+		end
+	end
+
+	describe ".send" do
+		it "send callable" do
+			expect(send(4, :+, Callable.new).call(1, 2)).to eq(7)
+		end
+		it "send callable" do
+			expect(send(Callable.new, :+, Callable.new).call(1, 2)).to eq(6)
+		end
+		it "send with block" do
+			expect(send(first, :select){ |it| it > 1 }.call([1, 2, 3])).to eq([2, 3])
+		end
+	end
+
+	describe ".bind" do
+#		it "bind callable" do
+#			expect(bind(-> a, b { a + b }, 1, First.new).call(1, 2)).to eq(2)
+#		end
+#		it "bind method" do
+#			expect(bind(:+.to_proc, 1, First.new).call(2)).to eq(3)
+#		end
+#		it "bind next" do
+#			expect(bind(-> a, b { a + b }, bind(-> a, b { a + b }, First.new, First.new), First.new).call(3)).to eq(9)
+#		end
+		it "apply first" do
+			expect(bind(First.new, 1, 2).call(-> a, b { a + b })).to eq(3)
+		end
+	end
+
+#	describe ".apply" do
+#		it "call first" do
+#			expect(apply(-> a { -> b { a + b} }, 1).call(2)).to eq(3)
+#		end
+#		it "NoMethodError" do
+#			expect{ apply(-> a { 10 }, 1).call(2) }.to raise_error(NoMethodError)
+#		end
+#	end
+end