necromancy 0.1.1 → 0.1.2

data/README.rst

@@ -1,7 +1,7 @@
-Necromancy
+屍術/Necromancy
 ================================================================================
 
-Necromancy conjures up the functional code.
+*屍術/Necromancy* conjures up the functional code.
 
 .. code:: ruby
 
@@ -20,7 +20,7 @@ Features
 Function composition
 ________________________________________________________________________________
 
-Every messages to instance of `Necromancy` are function composition
+Every messages to instance of ``Necromancy`` are function composition
 by default. that is left-to-right composition.
 
 .. code:: ruby
@@ -53,16 +53,16 @@ No core extensions.
 ________________________________________________________________________________
 
 Open classes is evil unless that is need really!
-Necromancy isn't. All methods are defining at local modules,
-and you can call their methods by sending some messages to a Necromancy object.
+*屍術/Necromancy* isn't. All methods are defining at local modules,
+and you can call their methods by sending some messages to a ``Necromancy`` object.
 
 Examples
 --------------------------------------------------------------------------------
 
-Simple Function composion
+Simple function composition
 ________________________________________________________________________________
 
-First, you create a `Necromancy` object.
+First, you create a ``Necromancy`` object.
 it is immutable, you can save it to any variable you like.
 for example, that is constant, global varibale, instance variable, class variable, local variable, etc.
 
@@ -76,7 +76,7 @@ After, you send some message to N when you need to write a simple block.
 
   (1..5).map &N ** 2 # => [1, 4, 9, 16, 25]
 
-Function composion
+Function composition
 ________________________________________________________________________________
 
 .. code:: ruby

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/examples/fizzbuzz.rb

@@ -1,6 +1,6 @@
 require 'necromancy'
 
-N = Necromancy.Alternative.new
+N = Necromancy.Alternative(:>>, :|).new
 puts (1..100).map &(N%15).zero? >> proc{"FizzBuzz"} |
                    (N%3).zero?  >> proc{"Fizz"}     |
                    (N%5).zero?  >> proc{"Buzz"}     |

data/lib/necromancy/control/alternative.rb

@@ -8,18 +8,44 @@ module Necromancy
 
     include Control::Applicative
 
+    # Tests whether the result is empty or not.
+    # If it is empty, {#empty?} returns the true, otherwise that returns the false.
+    # By default, {#empty?} returns the true, if it is nil or false.
     def empty?(x, *xs)
       not x
     end
 
-    protected :empty?
+    :empty?.tap(&method(:protected))
+    # protected :empty?
 
-    def *(callable) 
+    # Applies the result of the callable into self unless that result is empty.
+    # @see #empty?
+    # @note self :: a -> b -> c
+    # @param [Object] callable a -> b
+    # @return [Necromancy] a -> c
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Alternative.new
+    #   f = lambda(&N.+ * N) # == ->(o) { :+.to_proc.(o,o) if o }
+    #   f.(nil) # => nil
+    #   f.("foo") # => "foofoo"
+    def *(callable)
       str = make_evaluable_string(callable)
       necromancy = "self.empty?(*(xs = (#{str}))) ? xs : (args.concat(xs); #{@necromancy})"
       self.class.new(necromancy, @references.dup)
     end
 
+    # Evaluates the callable, unless result of self is empty. otherwise that returns result of self.
+    # @see #empty?
+    # @note self :: a -> b
+    # @param [Object] callable a -> b
+    # @return [Necromancy] a -> b
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Alternative.new
+    #   f = lambda(&N | ->(o){"foo"}) # == ->(o){ o ? o : "foo" }
+    #   f.(nil) # => "foo"
+    #   f.("bar") # => "var"
     def |(callable)
       str = make_evaluable_string(callable)
 

data/lib/necromancy/control/applicative.rb

@@ -5,20 +5,55 @@ module Necromancy
 
   module Control::Applicative; extend Control
 
+    # @note self :: a -> b -> c
+    # @param [Object] callable a -> b
+    # @return [Necromancy] a -> c
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Applicative.new
+    #   f = lambda(&N.+ * N) # == ->(o) {o + o}
+    #   f.(42) # => 84
     def *(callable)
       str = make_evaluable_string(callable)
       self.class.new("args.concat((#{str})); #{@necromancy}", @references.dup)
     end
 
+    # A variant of {#*} with the arguments reversed. 
+    # @note self :: a -> b
+    # @param [Object] callable a -> b -> c
+    # @return [Necromancy] a -> c
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Applicative.new
+    #   f = lambda(&N ** :+) # == ->(o) {o + o}
+    #   f.(42) # => 84
     def **(callable)
       str = make_evaluable_string(callable)
       self.class.new(str, @references.dup).__Applicative_Astarisk(self)
     end
 
+    # Sequence actions, discarding the value of the callable.
+    # @note self :: a -> b
+    # @param [Object] callable a -> _
+    # @return [Necromancy] a -> b
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Applicative.new
+    #   f = lambda(&N.succ << N.pred) # == ->(o) {o.pred; o.succ}
+    #   f.(42) # => 43
     def <<(callable)
       self.class.new("args.pop; #{@necromancy}", @references.dup).__Applicative_Astarisk(callable)
     end
 
+    # Sequence actions, discarding the value of self.
+    # @note self :: a -> _
+    # @param [Object] callable a -> b
+    # @return [Necromancy] a -> b
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Applicative.new
+    #   f = lambda(&N.succ >> N.pred) # == ->(o) {o.succ; o.pred}
+    #   f.(42) # => 41
     def >>(callable)
       str = make_evaluable_string(callable)
       self.class.new("args.pop; #{str}", @references.dup).__Applicative_Astarisk(self)

data/lib/necromancy/control/arrow.rb

@@ -8,12 +8,28 @@ module Necromancy
 
     include Control::Category
 
+    # @note self :: a -> b
+    # @param [Object] callable a -> b'
+    # @return [Necromancy] a -> (b, b')
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Arrow.new
+    #   f = lambda(&N.upcase & :capitalize & :reverse) # == ->(o) { [o.upcase, o.capitalize, o.reverse] }
+    #   f.("foo") # => ["FOO", "Foo", "oof"]
     def &(callable)
       str = make_evaluable_string(callable)
       necromancy = "(#{@necromancy}) + (#{str})"
       self.class.new(necromancy, @references.dup)
     end
 
+    # @note self :: a -> b
+    # @param [Object] callable a' -> b'
+    # @return [Necromancy] (a, a') -> (b, b')
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Arrow.new
+    #   f = lambda(&N.to_sym * N.to_f) # == ->(a, b) { [a.to_sym, b.to_f] }
+    #   f.("x", 42) # => [:x, 42.0]
     def *(callable)
       str = make_evaluable_string(callable)
       necromancy = "stack << [] << args; args = stack[-1][0..-2]; stack[-2].concat((#{@necromancy})); args = [stack[-1][-1]]; stack[-2].concat((#{str})); args = stack.pop; stack.pop"

data/lib/necromancy/control/category.rb

@@ -5,12 +5,30 @@ module Necromancy
 
   module Control::Category; extend Control
 
+    # Left-to-right composition.
+    # @note self :: a -> b
+    # @param [Object] callable b -> c
+    # @return [Necromancy] a -> c
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Category.new
+    #   f = lambda(&N.to_i > N * 2) # == ->(o) { o.to_i * 2 }
+    #   f.('42') # => 84
     def >(callable)
       str = make_evaluable_string(callable)
       necromancy = "args = (#{@necromancy}); #{str}"
       self.class.new(necromancy, @references.dup)
     end
 
+    # Right-to-left composition
+    # @note self :: b -> c
+    # @param [Object] callable a -> b
+    # @return [Necromancy] a -> c
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Category.new
+    #   f = lambda(&N.to_i < N * 2) # == ->(o) { (o * 2).to_i }
+    #   f.('42') # => 4242
     def <(callable)
       str = make_evaluable_string(callable)
       necromancy = "args = (#{str}); #{@necromancy}"

data/lib/necromancy/control.rb

@@ -2,6 +2,8 @@ module Necromancy
 
   module Control
 
+    # Creates a {Necromancy::Necromancy} object including the {Necromancy::Control}.
+    # @return [Necromancy]
     def new
       mod = self
       Class.new(::Necromancy::Necromancy) { include mod }.new
@@ -14,6 +16,7 @@ module Necromancy
 
     private :branch
 
+    # @deprecated
     def call(*targets)
       warn <<EOF
 Necromancy.Hoge.() deprecated.
@@ -22,6 +25,7 @@ EOF
       branch { protected *instance_methods }[*targets]
     end
 
+    # @deprecated
     def using(*targets)
       warn <<EOF
 Necromancy.Hoge.using() deprecated.
@@ -30,7 +34,21 @@ EOF
       self[*targets]
     end
 
-    def [](*targets)
+    # Reveals some methods and Creates some aliases.
+    # @param [Symbol] target Reveals a method of the symbol.
+    # @param [Hash]   target Hides all methods of each key and creates aliases from each value to each key.
+    # @param [Array]  targets A list of Symbol or Hash that will be processing as target.
+    # @return [Control] Processed new {Necromancy::Control} object.
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Alternative[:<< => :if,
+    #                              :>> => :then,
+    #                              :|  => :else].new
+    #   puts (1..100).map &( (N%15).zero? .then(proc{"FizzBuzz"}) .else   \
+    #                        (N%3).zero?  .then(proc{"Fizz"})     .else   \
+    #                        (N%5).zero?  .then(proc{"Buzz"})     .else N )
+    def [](target, *targets)
+      targets.unshift(target)
       names = targets.select { |t| t.is_a? Symbol }
       aliases = targets.select { |t| t.is_a? Hash }.inject(:merge) || {}
       branch do
@@ -43,22 +61,29 @@ EOF
       end
     end
 
-    def hiding(*names)
+    # Hides some methods.
+    # @param [Symbol] name Hides a method of the name.
+    # @param [Array]  names A list of a Symbol that will be processing as name.
+    # @return [Control] Processed new {Necromancy::Control} object.
+    # @example
+    #   require 'necromancy'
+    #   N = Necromancy.Alternative.hiding(:*, :**).new
+    #   ary = [1, nil, 2, nil, 3]
+    #   ary.map &(N | proc{0}) * 10 # => [10, 0, 20, 0, 3]
+    def hiding(name, *names)
+      names.unshift(name)
       branch { protected *names }
     end
 
-    def method_missing(name, *args, &block)
-      super unless ('A'..'Z').include? name[0]
-      if ::Necromancy::Control.const_defined? name
-        mod = ::Necromancy::Control.const_get(name)
-
+    def self.extended(mod)
+      return unless mod.name and mod.name.start_with? self.name
+      mthname = mod.name.sub("#{self.name}::", '')
+      define_method mthname do |*args, &block|
         if args.empty?
           branch { include mod }
         else
           branch { include mod; protected *mod.instance_methods }[*args, &block]
         end
-      else
-        super
       end
     end
   end

data/lib/necromancy/version.rb

@@ -1,4 +1,4 @@
 module Necromancy
 
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/necromancy.rb

@@ -1,3 +1,10 @@
+# @example
+#   require 'necromancy'
+#   N = Necromancy.Alternative(:>>, :|).new
+#   puts (1..100).map &(N%15).zero? >> proc{"FizzBuzz"} |
+#                      (N%3).zero?  >> proc{"Fizz"}     |
+#                      (N%5).zero?  >> proc{"Buzz"}     |
+#                      N
 module Necromancy
 
   require 'necromancy/version'

data/spec/examples/category_spec.rb

@@ -9,4 +9,14 @@ describe Necromancy::Control::Category do
     %w(0 1 2).map(&l.to_i > "foo".method(:[])).
       should == %w(0 1 2).map {|x| "foo"[x.to_i] }
   end
+
+  example do
+    lambda(&l.to_i > l * 2).('42').
+      should == '42'.to_i * 2
+  end
+
+  example do
+    lambda(&l.to_i < l * 2).('42').
+      should == ('42' * 2).to_i
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: necromancy
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors: