ludy 0.0.9 → 0.1.0

data/lib/ludy/blackhole.rb

@@ -0,0 +1,17 @@
+
+require 'ludy/class/undef_all_methods'
+require 'singleton'
+
+module Ludy
+  # a blackhole would eat any message it received.
+  class Blackhole
+    undef_all_methods
+    include Singleton
+    def method_missing msg, *args, &block
+      self
+    end
+    def nil?
+      true
+    end
+  end
+end

data/lib/ludy/class/undef_all_methods.rb

@@ -0,0 +1,9 @@
+
+class Class
+  # undefine all instance methods, used for delegation class
+  def undef_all_methods
+    instance_methods.each{ |m|
+      undef_method m unless (m =~ /^__/ || m.to_sym == :object_id || m.to_sym == :public_send )
+    }
+  end
+end

data/lib/ludy/class.rb

@@ -0,0 +1,3 @@
+
+require 'ludy'
+Ludy.require_all_in 'class'

data/lib/ludy/deprecated/aspect.rb

@@ -0,0 +1,26 @@
+
+module Ludy
+
+
+end
+
+module Kernel
+  def cut target, &block
+    (class << target; self; end)
+  end
+end
+
+class Name
+  def name
+    'name'
+  end
+end
+
+cut Name do
+  def name
+    "<#{super}>"
+  end
+  def g
+    '??'
+  end
+end

data/lib/ludy/deprecated/callstack.rb

@@ -0,0 +1,24 @@
+
+module Ludy
+  # TRACE_EVENT   = 0
+  # TRACE_FILE    = 1
+  # TRACE_LINE    = 2
+  # TRACE_MSG     = 3
+  # TRACE_BINDING = 4
+  # TRACE_CLASS   = 5
+
+  def callstack levels = -1
+    st = Thread.current[:callstack]
+    if levels then st && st[levels - 2] else st end
+  end
+  module_function :callstack
+end # of Ludy
+
+set_trace_func lambda{ |*args|
+  case args[0]
+    when /call$/
+      (Thread.current[:callstack] ||= []).push args
+    when /return$/
+      (Thread.current[:callstack] ||= []).pop
+  end
+}

data/lib/ludy/deprecated/curry.rb

@@ -0,0 +1,29 @@
+
+require 'ludy/proc/curry'
+
+module Ludy
+
+  module Curry
+    def self.included target
+      target.module_eval{
+        instance_methods.each{ |m|
+          next unless m =~ /^\w/
+          module_eval <<-END
+            def c#{m} *args, &block
+              if args.size == method(:#{m}).arity
+                self.__send__ :#{m}, *args, &block
+              else
+                method(:c#{m}).to_proc.send :__curry__, *args
+              end
+            end
+          END
+        }
+      }
+    end
+  end
+
+end
+
+=begin
+              method(:#{m}).to_proc.curry.call *args, &block
+=end

data/lib/ludy/deprecated/rambda.rb

@@ -0,0 +1,23 @@
+
+require 'rubygems'
+raise LoadError.new('you need ruby2ruby gem to use this tool') unless require 'ruby2ruby'
+
+require 'ludy/symbol/to_proc'
+
+module Ludy
+
+  class Rambda
+    def initialize &block
+      @this = eval block.to_ruby
+      define_instance_method :call, &@this
+      alias_instance_method :[], :call
+    end
+    attr_reader :this
+    alias_method :to_proc, :this
+  end
+
+  def rambda &block
+    Rambda.new &block
+  end
+
+end # of Ludy

data/lib/ludy/deprecated/this.rb

@@ -0,0 +1,14 @@
+
+require 'ludy/callstack'
+
+module Ludy
+  def this
+    info = callstack(-2)
+    # lambda{ |*args|
+      # Thread.current[:temp_args] = args
+      # eval("send :#{info[3]}, *Thread.current[:temp_args]", info[4])
+    # }
+    eval('self', info[TRACE_BINDING]).method(info[TRACE_MSG])
+  end
+  module_function :this
+end # of Ludy

data/lib/ludy/deprecated/untranspose.rb

@@ -0,0 +1,12 @@
+
+class Array
+  def untranspose
+    result = ([nil]*self.first.size).map{[]}
+    self.each{ |zipped|
+      zipped = zipped.clone
+      result.each{ |r| r << zipped.shift }
+    }
+    result
+  end
+  def untranspose!; replace untranspose; end
+end

data/lib/ludy/deprecated/unzip.rb

@@ -0,0 +1,7 @@
+
+require 'ludy/array/untranspose'
+
+class Array
+  def unzip; untranspose.first; end
+  def unzip!; replace unzip; end
+end

data/lib/ludy/{dice.rb → dices.rb}

@@ -1,34 +1,25 @@
-#!/usr/bin/env ruby
-
-#    Copyright (c) 2007, Lin Jen-Shin（a.k.a. godfat 真常）
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
 
 module Ludy
 
-  class Dice
+  # dices, e.g., 4d6, 2d20, etc.
+  class Dices
     attr_reader :amounts, :faces
+    # the default dice is 1d20
     def initialize amounts = 1, faces = 20
       @amounts = amounts
       @faces = faces
     end
+    # roll the dices
     def roll
       @amounts.roll @faces
     end
+    # the possible min value these dices would roll out.
     def min; @amounts; end
+    # the possible max value these dices would roll out.
     def max; @amounts*@faces; end
   end
 
+  # a dice set could contain 4d6 + 2d20 and more dices.
   class DiceSet
     attr_reader :min, :max
     def initialize *args
@@ -39,15 +30,17 @@ module Ludy
         @max += i.max
       }
     end
+    # roll the dice set
     def roll
       result = 0
       @diceset.each { |i| result += i.roll }
       result
     end
-    def << dice
-      @diceset << dice
-      @min += dice.min
-      @max += dice.max
+    # put dices into this dice set
+    def << dices
+      @diceset << dices
+      @min += dices.min
+      @max += dices.max
       self
     end
   end
@@ -55,6 +48,7 @@ module Ludy
 end
 
 class Numeric
+  # roll dices (with amounts equal to self.to_i) with faces = ?
   def roll faces = 20
     return nil unless self > 0 &&  self.integer? &&
                      faces > 0 && faces.integer?
@@ -62,7 +56,9 @@ class Numeric
     1.step(self){ |i| result += rand(faces) + 1 }
     result
   end
-  def dice faces = 20
-    Ludy::Dice.new self, faces
+
+  # create dices with faces = ?
+  def dices faces = 20
+    Ludy::Dices.new self, faces
   end
 end

data/lib/ludy/kernel/defun.rb

@@ -0,0 +1,10 @@
+
+require 'ludy/message_dispatcher'
+
+module Kernel
+  # you can use defun for overloading(ad-hoc polymorphism),
+  # multi-method, pattern matching, and perhaps others?
+  def defun name, *args, &fun
+    Ludy::MessageDispatcher.create self, name, args, &fun
+  end
+end

data/lib/ludy/kernel/ergo.rb

@@ -0,0 +1,16 @@
+
+require 'ludy/blackhole'
+
+module Kernel
+  # it simply return self, see NilClass#ergo
+  def ergo
+    self
+  end
+end
+
+class NilClass
+  # return blackhole to eat any message, see Kernel#ergo
+  def ergo
+    Ludy::Blackhole.instance
+  end
+end

data/lib/ludy/kernel/id.rb

@@ -0,0 +1,6 @@
+
+module Kernel
+  undef_method :id if RUBY_VERSION < '1.9.0'
+  # id returns self
+  def id a = nil; a.nil? ? self : a; end
+end

data/lib/ludy/kernel/if_else.rb

@@ -0,0 +1,14 @@
+
+require 'ludy/blackhole'
+
+module Kernel
+  # another if variant...
+  def if
+    (yield if self).ergo
+  end
+  # another else variant...
+  def else
+    if self && !self.kind_of?(Blackhole) then self
+    else yield end
+  end
+end

data/lib/ludy/kernel/m.rb

@@ -0,0 +1,5 @@
+
+module Kernel
+  # for lazy people like me...
+  alias_method :m, :method
+end

data/lib/ludy/kernel/public_send.rb

@@ -0,0 +1,13 @@
+
+module Kernel
+  if RUBY_VERSION < '1.9.0'
+    # it would be defined if RUBY_VERSION < '1.9.0', see rdoc in ruby 1.9
+    def public_send msg, *args, &block
+      if self.respond_to? msg
+        self.__send__ msg, *args, &block
+      else
+        self.method_missing msg, *args, &block
+      end
+    end
+  end
+end

data/lib/ludy/kernel/singleton_method.rb

@@ -0,0 +1,13 @@
+
+module Kernel
+  if RUBY_VERSION < '1.9.0'
+    # it would be defined if RUBY_VERSION < '1.9.0', see rdoc in ruby 1.9
+    def define_singleton_method msg, &block
+      self.class.__send__ :define_method, msg, &block
+    end
+  end
+  # it simply alias singleton(instance) method
+  def alias_singleton_method new_msg, old_msg
+    self.class.__send__ :alias_method, new_msg, old_msg
+  end
+end

data/lib/ludy/kernel/tap.rb

@@ -0,0 +1,10 @@
+
+module Kernel
+  if RUBY_VERSION < '1.9.0'
+    # it would be defined if RUBY_VERSION < '1.9.0', see rdoc in ruby 1.9
+    def tap
+      yield self
+      self
+    end
+  end
+end

data/lib/ludy/kernel.rb

@@ -0,0 +1,3 @@
+
+require 'ludy'
+Ludy.require_all_in 'kernel'

data/lib/ludy/lazy.rb

@@ -1,24 +1,15 @@
-#!/usr/bin/env ruby
 
-#    Copyright (c) 2007, Lin Jen-Shin（a.k.a. godfat 真常）
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
+require 'ludy/kernel/public_send'
+require 'ludy/class/undef_all_methods'
 
 module Ludy
 
+  # a lazy object would be evaluated until the time it called,
+  # and save the result for futher use.
   class Lazy
-    instance_methods.each{|m| undef_method m unless m =~ /^__/}
+    undef_all_methods
 
+    # supply the evaluation function through first argument or block
     def initialize func = nil, &block
       if block_given? then @func = block
       else
@@ -27,11 +18,13 @@ module Ludy
       end
     end
 
+    # :nodoc:
     def method_missing msg, *arg, &block
-      (@obj ||= @func.call).__send__ msg, *arg, &block
+      (@obj ||= @func.call).public_send msg, *arg, &block
     end
   end
 
+  # provided for creating lazy object more convient
   def lazy arg = nil, &block
     Lazy.new arg, &block
   end

data/lib/ludy/message_dispatcher.rb

@@ -0,0 +1,58 @@
+
+require 'ludy/pattern_matcher'
+if RUBY_VERSION < '1.9.0'
+  require 'ludy/kernel/singleton_method'
+end
+
+module Ludy
+
+  class MessageDispatcher
+    # create a dispatcher or append arg_list to the existed dispatcher,
+    # see Kernel#defun
+    def self.create actor, msg, args, &fun
+      if (@patchers ||= {})[[actor, msg]].nil?
+        @patchers[[actor, msg]] = MessageDispatcher.new actor, msg, args, &fun
+      else
+        @patchers[[actor, msg]].listen args, &fun
+      end
+    end
+    # actor is the listener who listen to the message
+    def initialize actor, msg, args, &fun
+      @actor = actor
+      @msg = msg
+      @matcher = PatternMatcher.new args, &fun
+      define_method_in_actor
+    end
+    # open your ear and listen, and call me when you hear
+    def listen arg_list, &fun
+      @matcher << [arg_list, fun]
+    end
+
+    private
+    def define_method_in_actor
+      # if @actor.respond_to? @msg
+        # raise RuntimeError.new("#{@actor.inspect}'s method \"#{@msg}\" already defined.")
+      # else
+        matcher = @matcher
+        msg = @msg # make them close in the closure
+        define_method = @actor.kind_of?(Class) ? :define_method : :define_singleton_method
+
+        # comment off &block in lambda for ruby 1.8 compatibility
+        @actor.public_send define_method, msg do |*args|#, &block|
+          fun = matcher.first_match args
+          if fun.nil?
+            if self.respond_to? :method_missing
+              self.method_missing msg, *args#, &block
+            else
+              raise NoMethodError.new("#{self.inspect} doesn't respond to \"#{msg}\"")
+            end
+          else
+            fun.call(*args)#, &block)
+          end
+        end
+      # end
+    end
+  end
+
+end # of Ludy
+

data/lib/ludy/pattern_matcher.rb

@@ -0,0 +1,41 @@
+
+require 'ludy/kernel/public_send'
+
+module Ludy
+  # someone who does the pattern matching thing
+  # see Kernel#defun
+  class PatternMatcher
+    # init for the first parameter
+    def initialize args, &fun; @params = [[args, fun]]; end
+    # find the first match of this arguments. notice,
+    # this is not the best match. maybe someday i could
+    # implement the match policy accordingly or selectable policy.
+    def first_match args
+      @params.find{ |parameters, fun|
+        match? parameters, args
+      }.ergo.last
+    end
+    # delegate all the rest message to @params array
+    def method_missing msg, *args, &block
+      if @params.respond_to? msg
+        @params.public_send msg, *args, &block
+      else
+        raise NoMethodError.new("PatternMatcher doesn't respond to #{msg}")
+      end
+    end
+
+    private
+    def match? parameters, arguments
+      return false unless parameters.size == arguments.size
+      parameters.zip(arguments).each{ |param, arg|
+        if param.kind_of? Class
+          return false unless arg.kind_of?(param)
+        else
+          return false unless arg == param
+        end
+      }
+      return true
+    end
+  end
+
+end # of Ludy

data/lib/ludy/proc/bind.rb

@@ -0,0 +1,21 @@
+
+class Proc
+  # C++ TR1 style bind
+  # use _#{n} for placeholders
+  #  _1 => 1st arg
+  #  _2 => 2nd arg
+  #  ...and so on
+  def bind *args
+    lambda{ |*new_args|
+      self[*(args.map{ |arg|
+        if (arg.kind_of? Symbol) && arg.to_s =~ /^_(\d+)$/
+          # is placeholder
+          new_args[$1.to_i-1]
+        else
+          # is not placeholder
+          arg
+        end
+      } + new_args).first(self.arity)]
+    }
+  end
+end

data/lib/ludy/proc/chain.rb

@@ -0,0 +1,17 @@
+
+class Proc
+  #   TODO: missing traversal of chain
+  # create a chain of proc. whenever you call the chain,
+  # each proc would be called. the return value would be
+  # all the results saved orderly in a array.
+  def chain *procs, &block
+    procs << block if block
+    lambda{ |*args|
+      result = []
+      ([self] + procs).each{ |i|
+        result += [i[*args]].flatten
+      }
+      result
+    }
+  end
+end

data/lib/ludy/proc/compose.rb

@@ -0,0 +1,9 @@
+
+class Proc
+  # function coposition
+  # i.e., f compose g => f of g => f (g args)
+  def compose *procs, &block
+    procs << block if block
+    lambda{ |*args| ([self] + procs).reverse.inject(args){ |val, fun| fun[*val] } }
+  end
+end

data/lib/ludy/proc/curry.rb

@@ -0,0 +1,39 @@
+
+require 'ludy/kernel/public_send'
+
+class Proc
+  def __curry__ *pre # :nodoc:
+    lambda{ |*post| self[*(pre + post)] }
+  end
+
+  # make the caller be a curried function
+  #   lambda{|a,b,c| [a,b,c]}.curry[1][2][3]
+  #   => [1,2,3]
+  def curry
+    class << self
+      alias_method :__call__, :call
+      def call *args, &block
+        if self.arity == -1
+          begin # let's try if arguments are ready
+            # is there any better way to determine this?
+            # it's hard to detect correct arity value when
+            # Symbol#to_proc happened
+            # e.g., :message_that_you_never_know.to_proc.arity => ?
+            # i'd tried put hacks in Symbol#to_proc, but it's
+            # difficult to implement in correct way
+            # i would try it again in other day
+            self.public_send :__call__, *args, &block
+          rescue ArgumentError # oops, let's curry it
+            method(:call).to_proc.public_send :__curry__, *args
+          end
+        elsif args.size == self.arity
+          self.public_send :__call__, *args, &block
+        else
+          method(:call).to_proc.public_send :__curry__, *args
+        end
+      end
+      alias_method :[], :call
+    end
+    self
+  end
+end

data/lib/ludy/proc.rb

@@ -0,0 +1,3 @@
+
+require 'ludy'
+Ludy.require_all_in 'proc'

data/lib/ludy/symbol/curry.rb

@@ -0,0 +1,10 @@
+
+require 'ludy/symbol/to_proc'
+require 'ludy/proc/curry'
+
+class Symbol
+  # synonymy for to_proc.curry
+  def curry
+    to_proc.curry
+  end
+end

data/lib/ludy/symbol/to_msg.rb

@@ -0,0 +1,10 @@
+
+class Symbol
+  # it is like to_proc, but much more powerful
+  #   :'*2'.to_msg[5]
+  #   => 10
+  #
+  #   :'to_s(16)'.to_msg[15]
+  #   => "f"
+  def to_msg; lambda{ |*args| eval "args[0].#{self.to_s} #{args[1..-1].join ', '}" }; end
+end

data/lib/ludy/symbol/to_proc.rb

@@ -0,0 +1,7 @@
+
+class Symbol
+  if RUBY_VERSION < '1.9.0'
+    # it would be defined if RUBY_VERSION < '1.9.0', see rdoc in ruby 1.9
+    def to_proc; lambda{ |*args| args.shift.__send__ self, *args }; end
+  end
+end

data/lib/ludy/symbol.rb

@@ -0,0 +1,3 @@
+
+require 'ludy'
+Ludy.require_all_in 'symbol'