iolite 0.0.1

data/example/fizzbuzz.rb

@@ -0,0 +1,15 @@
+require "iolite"
+
+include Iolite::Placeholders
+include Iolite::Statement
+
+fizzbuzz = if_else(
+	arg1 % 15 == 0, "FizzBuzz", if_else(
+	arg1 %  5 == 0, "Buzz", if_else(
+	arg1 %  3 == 0, "Fizz",
+	arg1
+)))
+
+p (1..20).map &fizzbuzz
+
+

data/example/hash.rb

@@ -0,0 +1,14 @@
+require "iolite"
+
+# Use require
+# define Hash#to_proc
+require "iolite/adaptored/hash"
+
+include Iolite::Placeholders
+
+p ({arg1 => arg2}).to_proc.call(:name, "homu")
+# => {:name=>"homu"}
+
+p ["homu", "mami", "mado"]. map &({ name: arg1 })
+# => [{:name=>"homu"}, {:name=>"mami"}, {:name=>"mado"}]
+

data/example/minimal_implement.rb

@@ -0,0 +1,42 @@
+
+# invoke call function
+def invoke func, *args
+	func.respond_to?(:call) ? func.call(*args) : func
+end
+
+class Proc
+	# send method
+	def send symbol, *args_
+		Proc.new { |*args|
+			self.call(*args).send(symbol, *args_.map{ |it| invoke(it, *args) })
+		}
+	end
+
+	# call any method
+	def method_missing symbol, *args
+		send(symbol, *args)
+	end
+end
+
+
+# return args[N]
+arg1 = Proc.new { |*args| args[0] }
+arg2 = Proc.new { |*args| args[1] }
+
+
+# assemble expr
+f = arg1 + arg2
+
+# apply expr
+result = f.call(1, 2)
+# => 3
+
+# call
+# 1. (arg1 + arg2).call(1, 2)
+# 2. arg1.send(:+, arg2).call(1, 2)
+# 3. arg1.call(1, 2).send(invoke(:+, 1, 2), invoke(arg2, 1, 2))
+# 4. arg1.call(1, 2).send(:+, arg2.call(1, 2))
+# 5. [1, 2][0].send(:+, [1, 2][1])
+# 6. 1.send(:+, 2)
+# 7. 3
+

data/example/simple.rb

@@ -0,0 +1,46 @@
+require "iolite"
+
+
+#######################################
+# Using block
+#######################################
+
+p (1..5).map { |it| it + 3 }
+# => [4, 5, 6, 7, 8]
+
+p (1..5).inject { |memo, item| memo + item }
+# => 15
+
+p ["homu", "mami", "an"].inject(0) { |memo, item| memo + item.length }
+# => 10
+
+p [{name: :homu}, {name: :mami}].map { |it| it[:name] }
+# => [:homu, :mami]
+
+p [:homu, :mami, :mado].select { |it| it =~ /^m/ }
+# => [:mami, :mado]
+
+
+#######################################
+# Using iolite
+#######################################
+
+# using arg1, arg2...
+include Iolite::Placeholders
+
+p (1..5).map &arg1 + 3
+# => [4, 5, 6, 7, 8]
+
+p (1..5).inject &arg1 + arg2
+# => 15
+
+p ["homu", "mami", "an"].inject 0, &arg1 + arg2.length
+# => 10
+
+p [{name: :homu}, {name: :mami}].map &arg1[:name]
+# => [:homu, :mami]
+
+p [:homu, :mami, :mado].select &arg1 =~ /^m/
+# => [:mami, :mado]
+
+

data/example/to_lazy.rb

@@ -0,0 +1,37 @@
+require "iolite"
+
+require "iolite/refinements/object_with_to_lazy"
+using Iolite::Refinements::ObjectWithToLazy
+
+# Using 1.9.x
+# require "iolite/adaptored/object_with_to_lazy"
+
+
+include Iolite::Placeholders
+
+
+class X
+	def plus a, b
+		a + b
+	end
+end
+
+x = X.new
+
+# To to_lazy object
+# to_lazy return "Iolite.lazy { |*args| self }"
+to_lazy_x = x.to_lazy
+
+# To to_lazy function
+to_lazy_f = to_lazy_x.plus(arg1, arg2)
+
+puts to_lazy_f.call(1, 2)
+# => 3
+
+
+str = "saya."
+["homu", "mami", "mado"].each &str.to_lazy.concat(arg1 + ".")
+puts str
+# => saya.homu.mami.mado.
+
+

data/iolite.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iolite/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "iolite"
+  spec.version       = Iolite::VERSION
+  spec.authors       = ["manga_osyo"]
+  spec.email         = ["manga.osyo@gmail.com"]
+  spec.summary       = %q{unblockable library}
+  spec.description   = %q{unblockable library}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/iolite.rb

@@ -0,0 +1,14 @@
+require "iolite/version"
+require "iolite/adaptor"
+require "iolite/functinal"
+require "iolite/lazy"
+require "iolite/placeholders"
+require "iolite/statement"
+
+# Not support 1.9.x
+require "iolite/refinements" if RUBY_VERSION.to_f > 2.0
+
+module Iolite
+	include Functinal
+	include Statement
+end

data/lib/iolite/adaptor.rb

@@ -0,0 +1,2 @@
+require "iolite/adaptor/all"
+

data/lib/iolite/adaptor/all.rb

@@ -0,0 +1,22 @@
+require "iolite/adaptor/define_send_original_methods"
+require "iolite/adaptor/callable"
+require "iolite/adaptor/bind"
+require "iolite/adaptor/send"
+require "iolite/adaptor/to_proc"
+require "iolite/adaptor/apply"
+require "iolite/adaptor/operators"
+require "iolite/adaptor/method_missing"
+require "iolite/adaptor/to_lazy"
+
+module Iolite module Adaptor
+	module All
+		include Callable
+		include Bind
+		include Send
+		include MethodMissing
+		include ToProc
+		include Apply
+		include Operators
+		include ToLazy
+	end
+end end

data/lib/iolite/adaptor/apply.rb

@@ -0,0 +1,10 @@
+require "iolite/functinal/bind"
+
+module Iolite module Adaptor
+	module Apply
+		def apply *args, &block
+			Functinal.bind(self, *args, &block)
+		end
+		alias_method :iolite_apply, :apply
+	end
+end end

data/lib/iolite/adaptor/bind.rb

@@ -0,0 +1,9 @@
+require "iolite/functinal/bind"
+
+module Iolite module Adaptor
+	module Bind
+		def bind *args
+			Functinal.bind(Iolite.lazy { |*args| self }, *args)
+		end
+	end
+end end

data/lib/iolite/adaptor/callable.rb

@@ -0,0 +1,7 @@
+module Iolite module Adaptor
+	module Callable
+		def iolite_functinal_invoke_call(*args)
+			call(*args)
+		end
+	end
+end end

data/lib/iolite/adaptor/define_send_original_methods.rb

@@ -0,0 +1,12 @@
+require "iolite/functinal/send"
+
+class Module
+	def iolite_define_send_original_methods prefix = "_"
+		instance_methods.each{ |method|
+			next if method !~ /\w/
+			define_method("#{prefix + method.to_s}"){ |*args|
+				Iolite::Functinal.send(self, method, *args)
+			}
+		}
+	end
+end

data/lib/iolite/adaptor/method_missing.rb

@@ -0,0 +1,10 @@
+require "iolite/functinal/send"
+
+module Iolite module Adaptor
+	module MethodMissing
+		def method_missing name, *args, &block
+			Functinal.send(self, name, *args, &block)
+		end
+		module_function :method_missing
+	end
+end end

data/lib/iolite/adaptor/operators.rb

@@ -0,0 +1,26 @@
+require "iolite/functinal/define_iolite_functinal_send_method"
+
+module Iolite module Adaptor
+	module Operators
+		define_iolite_functinal_send_method :==
+		define_iolite_functinal_send_method :=~
+		define_iolite_functinal_send_method :!
+		define_iolite_functinal_send_method :!=
+		define_iolite_functinal_send_method :!~
+		define_iolite_functinal_send_method :===
+
+		# &&
+		def product rhs
+			Lazy.new { |*args|
+				Functinal.invoke(self, *args) && Functinal.invoke(rhs, *args)
+			}
+		end
+
+		# ||
+		def disjunction rhs
+			Lazy.new { |*args|
+				Functinal.invoke(self, *args) || Functinal.invoke(rhs, *args)
+			}
+		end
+	end
+end end

data/lib/iolite/adaptor/send.rb

@@ -0,0 +1,11 @@
+require "iolite/functinal/send"
+require "iolite/functinal/invoke"
+
+module Iolite module Adaptor
+	module Send
+		def send *args, &block
+			Functinal.send(self, *args, &block)
+		end
+		alias_method :iolite_send, :send
+	end
+end end

data/lib/iolite/adaptor/to_lazy.rb

@@ -0,0 +1,11 @@
+# require "iolite/lazy"
+
+module Iolite module Adaptor
+	module ToLazy
+		def to_lazy
+			Iolite.lazy { |*args| self }
+		end
+		alias_method :iolite_to_lazy, :to_lazy
+		alias_method :to_l, :to_lazy
+	end
+end end

data/lib/iolite/adaptor/to_proc.rb

@@ -0,0 +1,10 @@
+module Iolite module Adaptor
+	module ToProc
+		def to_proc
+			Proc.new { |*args|
+				self.call(*args)
+			}
+		end
+		alias_method :iolite_to_proc, :to_proc
+	end
+end end

data/lib/iolite/adaptored/array.rb

@@ -0,0 +1,12 @@
+require "iolite/adaptor/all"
+require "iolite/functinal/invoke"
+
+class Array
+	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

data/lib/iolite/adaptored/hash.rb

@@ -0,0 +1,14 @@
+require "iolite/adaptor/all"
+require "iolite/adaptored/iolite_lazy_with_hash"
+
+class Hash
+	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

data/lib/iolite/adaptored/iolite_lazy_with_hash.rb

@@ -0,0 +1,7 @@
+module Iolite
+	class Lazy
+		def hash
+			__id__
+		end
+	end
+end

data/lib/iolite/adaptored/object_with_to_lazy.rb

@@ -0,0 +1,5 @@
+require "iolite/adaptor/to_lazy"
+
+class Object
+	include Iolite::Adaptor::ToLazy
+end

data/lib/iolite/adaptored/proc.rb

@@ -0,0 +1,5 @@
+require "iolite/adaptor/all"
+
+class Proc
+	include Iolite::Adaptor::All
+end

data/lib/iolite/adaptored/string.rb

@@ -0,0 +1,21 @@
+require "iolite/placeholders"
+
+class String
+	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}")}", it.to_s
+		}
+		result
+	end
+
+	def to_call_by_eval binding = nil
+		Iolite.lazy { |*args|
+			gsub(/#{'#{(.*?)}'}/) {
+				eval($1, binding).call(*args)
+			}
+		}
+	end
+end

data/lib/iolite/functinal.rb

@@ -0,0 +1,4 @@
+require "iolite/functinal/invoke"
+require "iolite/functinal/send"
+require "iolite/functinal/bind"
+require "iolite/functinal/define_iolite_functinal_send_method"

data/lib/iolite/functinal/bind.rb

@@ -0,0 +1,12 @@
+require "iolite/functinal/invoke"
+
+module Iolite module Functinal
+	def bind func, *args_
+		Iolite.lazy { |*args|
+# 			func.call(*invoke_a(args_, *args))
+			invoke(func, *args).call(*invoke_a(args_, *args))
+# 			func.call(*args).call(*invoke_a(args_, *args))
+		}
+	end
+	module_function :bind
+end end