necromancy 0.1.0

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2013 pasberth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rst

@@ -0,0 +1,141 @@
+Necromancy
+================================================================================
+
+Necromancy conjures up the functional code.
+
+.. code:: ruby
+
+  require 'necromancy'
+  N = Necromancy.new
+
+  # [:foo, :bar, :baz].map{|s| s.to_s }.map{|s| s.upcase }
+  [:foo, :bar, :baz].map &N.to_s . upcase
+
+  # [:foo, :hoge, :bar, :fuga].select{|s| s.to_s.length > 3} # => [:hoge, :fuga]
+  [:foo, :hoge, :bar, :fuga].select &N.to_s . length > 3
+
+Features
+--------------------------------------------------------------------------------
+
+Function composition
+________________________________________________________________________________
+
+Every messages to instance of `Necromancy` are function composition
+by default. that is left-to-right composition.
+
+.. code:: ruby
+
+  N.f.g == ->(o) { :g.to_proc(:f.to_proc(o)) } == ->(o) { o.f.g }
+
+
+Application with arguments
+________________________________________________________________________________
+
+If a message was called with some argument given,
+their arguments are given into that function each time.
+
+.. code:: ruby
+
+  N.f(x) == ->(o) { :f.to_proc(o, x) } == ->(o) { o.f(x) }
+
+
+Rich extensions.
+________________________________________________________________________________
+If you want, you can use extensions by clojuring up the evil spirit.
+
+.. code:: ruby
+
+  M = Necromancy.Alternative.new
+  M.x | M.y == ->(o) { o.x || o.y }
+
+Examples
+--------------------------------------------------------------------------------
+
+Simple Function composion
+________________________________________________________________________________
+
+First, your 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.
+
+.. code:: ruby
+
+  N = Necromancy.new
+
+After, you send some message to N when you need to write a simple block.
+
+.. code:: ruby
+
+  (1..5).map &N ** 2 # => [1, 4, 9, 16, 25]
+
+Function composion
+________________________________________________________________________________
+
+.. code:: ruby
+
+  N = Necromancy.Category.new
+  ary = ('A'..'Z').to_a
+  (0..4).map &N > ary.method(:[]) # => ["A", "B", "C", "D", "E"]
+
+Multiple accessing to attribtues
+________________________________________________________________________________
+
+.. code:: ruby
+
+  N = Necromancy.Arrow.new
+  str = "foo"
+  lambda(&N.upcase & :capitalize & :reverse).(str) # => ["FOO", "Foo", "oof"]
+
+
+Maybe evaluating
+________________________________________________________________________________
+
+.. code:: ruby
+
+  N = Necromancy.Alternative.new
+  n = N >> N.upcase!
+  "foo".tap &n # => "FOO"
+  nil.tap &n # => nil
+
+Alias importation
+________________________________________________________________________________
+
+.. code:: ruby
+
+  N = Necromancy.Alternative.using(:>> => :then).new
+  str_or_nil = ["foo", nil].sample
+  str_or_nil.tap &(N.then N.upcase!) # => nil or "FOO"
+
+Hiding importation
+________________________________________________________________________________
+
+.. code:: ruby
+
+  N = Necromancy.Alternative.hiding(:*, :**).new
+  (1..5).map &N ** 2 # => [1, 4, 9, 16, 25]
+
+Specifying importation
+________________________________________________________________________________
+
+.. code:: ruby
+
+  N = Necromancy.Alternative.(:>>).new
+  str_or_nil = ["foo", nil].sample
+  str_or_nil.tap &N >> N.upcase! # => nil or "FOO"
+  (1..5).map &N ** 2 # => [1, 4, 9, 16, 25]
+
+Multiple module importation
+________________________________________________________________________________
+
+.. code:: ruby
+
+  N = Necromancy.Arrow.Alternative.hiding(:*, :**).new
+  [nil, 42, "foo"].map &N.is_a?(Integer) >> (N * 2 & N ** 2) | N # => [nil, [84, 1764], "foo"]
+
+
+Installation
+--------------------------------------------------------------------------------
+
+.. code:: sh
+
+  gem install necromancy

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/fizzbuzz.rb

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

data/examples/pythonic-fizzbuzz.rb

@@ -0,0 +1,8 @@
+require 'necromancy'
+
+L = Necromancy.Alternative.using(:<< => :if,
+                                 :>> => :then,
+                                 :|  => :else).new
+puts (1..100).map &( (L%15).zero? .then(proc{"FizzBuzz"}) .else   \
+                     (L%3).zero?  .then(proc{"Fizz"})     .else   \
+                     (L%5).zero?  .then(proc{"Buzz"})     .else L )

data/examples/using-extensions.rb

@@ -0,0 +1,6 @@
+require 'necromancy'
+
+L = Necromancy.Alternative.hiding(:*, :**).new
+
+ary = [1, nil, 2, nil, 3]
+p ary.map &(L | proc{0}) * 10 # => [10, 0, 20, 0, 3]

data/lib/necromancy/control/alternative.rb

@@ -0,0 +1,47 @@
+require 'necromancy'
+require 'necromancy/control'
+require 'necromancy/control/applicative'
+
+module Necromancy
+
+  module Control::Alternative; extend Control
+
+    include Control::Applicative
+
+    def empty?(x, *xs)
+      not x
+    end
+
+    protected :empty?
+
+    def *(callable) 
+      str = make_evaluable_string(callable)
+      necromancy = "self.empty?(*(xs = (#{str}))) ? xs : (args.concat(xs); #{@necromancy})"
+      self.class.new(necromancy, @references.dup)
+    end
+
+    def |(callable)
+      str = make_evaluable_string(callable)
+
+      if @is_alternative_or
+        exprs = [str, *@exprs]
+      else
+        exprs = [str, @necromancy]
+      end
+
+      necromancy = exprs.inject do |else_expr, cond_expr|
+        "self.empty?(*(xs = (#{cond_expr}))) ? (#{else_expr}) : xs"
+      end
+
+      self.class.new(necromancy, @references.dup).instance_eval do
+        @is_alternative_or = true
+        @exprs = exprs
+        self
+      end
+    end
+
+
+    alias __Applicative_Astarisk *
+    protected :__Applicative_Astarisk
+  end
+end

data/lib/necromancy/control/applicative.rb

@@ -0,0 +1,30 @@
+require 'necromancy'
+require 'necromancy/control'
+
+module Necromancy
+
+  module Control::Applicative; extend Control
+
+    def *(callable)
+      str = make_evaluable_string(callable)
+      self.class.new("args.concat((#{str})); #{@necromancy}", @references.dup)
+    end
+
+    def **(callable)
+      str = make_evaluable_string(callable)
+      self.class.new(str, @references.dup).__Applicative_Astarisk(self)
+    end
+
+    def <<(callable)
+      self.class.new("args.pop; #{@necromancy}", @references.dup).__Applicative_Astarisk(callable)
+    end
+
+    def >>(callable)
+      str = make_evaluable_string(callable)
+      self.class.new("args.pop; #{str}", @references.dup).__Applicative_Astarisk(self)
+    end
+
+    alias __Applicative_Astarisk *
+    protected :__Applicative_Astarisk
+  end
+end

data/lib/necromancy/control/arrow.rb

@@ -0,0 +1,23 @@
+require 'necromancy'
+require 'necromancy/control'
+require 'necromancy/control/category'
+
+module Necromancy
+
+  module Control::Arrow; extend Control
+
+    include Control::Category
+
+    def &(callable)
+      str = make_evaluable_string(callable)
+      necromancy = "(#{@necromancy}) + (#{str})"
+      self.class.new(necromancy, @references.dup)
+    end
+
+    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"
+      self.class.new(necromancy, @references.dup)
+    end
+  end
+end

data/lib/necromancy/control/category.rb

@@ -0,0 +1,20 @@
+require 'necromancy'
+require 'necromancy/control'
+
+module Necromancy
+
+  module Control::Category; extend Control
+
+    def >(callable)
+      str = make_evaluable_string(callable)
+      necromancy = "args = (#{@necromancy}); #{str}"
+      self.class.new(necromancy, @references.dup)
+    end
+
+    def <(callable)
+      str = make_evaluable_string(callable)
+      necromancy = "args = (#{str}); #{@necromancy}"
+      self.class.new(necromancy, @references.dup)
+    end
+  end
+end

data/lib/necromancy/control.rb

@@ -0,0 +1,47 @@
+module Necromancy
+
+  module Control
+
+    def new
+      mod = self
+      Class.new(::Necromancy::Necromancy) { include mod }.new
+    end
+
+    def branch(&block)
+      mod = self
+      Module.new { include mod; extend Control; module_eval(&block) }
+    end
+
+    private :branch
+
+    def call(*targets)
+      branch { protected *instance_methods }.using(*targets)
+    end
+
+    def using(*targets)
+      names = targets.select { |t| t.is_a? Symbol }
+      aliases = targets.select { |t| t.is_a? Hash }.inject(:merge) || {}
+      branch do
+        public *names
+        aliases.each do |org, als|
+          alias_method(als, org)
+          protected org
+          public als
+        end
+      end
+    end
+
+    def hiding(*names)
+      branch { protected *names }
+    end
+
+    def method_missing(name, *args, &block)
+      super unless ('A'..'Z').include? name[0]
+      if ::Necromancy::Control.const_defined? name
+        branch { include ::Necromancy::Control.const_get(name) }
+      else
+        super
+      end
+    end
+  end
+end

data/lib/necromancy/necromancy.rb

@@ -0,0 +1,82 @@
+module Necromancy
+
+  class Necromancy < BasicObject
+
+    protected *instance_methods
+    protected
+
+    def initialize(necromancy = "args", references = [])
+      @necromancy = necromancy
+      @references = references
+    end
+
+    def method_missing(name, *args, &block)
+      getproc = ":#{name}.to_proc"
+
+      if args.size == 0
+        getargs = nil
+      elsif args.size == 1
+        getargs = ", (#{make_evaluable_literal(args[0])})"
+      else
+        getargs = ", *(#{make_evaluable_literal(args)})"
+      end
+
+      if block
+        getblock = ", &(#{make_evaluable_literal(block)})"
+      else
+        getblock = nil
+      end
+
+      necromancy = "[#{getproc}.(*(#{@necromancy})#{getargs}#{getblock})]"
+      self.class.new(necromancy, @references.dup)
+    end
+
+    def to_proc
+      instance_eval("->(*args) { i = 0; stack = []; xs = (#{@necromancy}); xs.size == 1 ? xs.first : xs }")
+    end
+
+    def class
+      @class ||= (class << self; self end).superclass
+    end
+
+    def get_ref(i)
+      @references[i]
+    end
+
+    def set_ref(i, v)
+      @references[i] = v
+    end
+
+    def add_val(v)
+      i = @references.size
+      @references[i] = v
+      i
+    end
+
+    def make_evaluable_literal(anyref)
+      case anyref
+      when nil, ::Integer, ::Float, ::Symbol
+        anyref.inspect
+      else
+        i = add_val(anyref)
+        "self.get_ref(i + #{i})"
+      end
+    end
+
+    def make_evaluable_string(anyref)
+      case anyref
+      when Necromancy
+        references = anyref.instance_eval {@references}
+        necromancy = anyref.instance_eval {@necromancy}
+        @references.concat(references)
+        "stack << i; i = #{references.size}; xs = (#{necromancy}); i = stack.pop; xs"
+      when ::Symbol
+        "[:#{anyref}.to_proc.(*args)]"
+      else
+        prc = anyref.to_proc
+        i = add_val(prc)
+        "[self.get_ref(i + #{i}).(*args)]"
+      end
+    end
+  end
+end

data/lib/necromancy/version.rb

@@ -0,0 +1,4 @@
+module Necromancy
+
+  VERSION = "0.1.0"
+end

data/lib/necromancy.rb

@@ -0,0 +1,12 @@
+module Necromancy
+
+  require 'necromancy/version'
+  require 'necromancy/necromancy'
+  require 'necromancy/control'
+  require 'necromancy/control/category'
+  require 'necromancy/control/arrow'
+  require 'necromancy/control/applicative'
+  require 'necromancy/control/alternative'
+
+  extend Control
+end

data/necromancy.gemspec

@@ -0,0 +1,16 @@
+version = File.read("VERSION").chomp
+`perl -i -pe 's/VERSION = "[\\d\\.]+"/VERSION = "#{version}"/' lib/necromancy/version.rb`
+Gem::Specification.new do |s|
+  s.name = "necromancy"
+  s.version = version
+  s.authors = ["pasberth"]
+  s.description = %{Necromancy conjures up the functional code.}
+  s.summary = %q{experimental release}
+  s.email = "pasberth@gmail.com"
+  s.homepage = "https://github.com/pasberth/necromancy"
+  s.license = 'MIT'
+  s.require_paths = ["lib"]
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- spec/*`.split("\n")
+  s.add_development_dependency "rspec"
+end

data/spec/alternative_spec.rb

@@ -0,0 +1,89 @@
+require 'necromancy'
+
+describe Necromancy::Control::Alternative do
+
+  let(:l) { described_class.new }
+  shared_examples_for "pure" do
+
+    example { proc(&f * l).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&f * l | l).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&f * l | g).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&l | g).(r).should == proc(&l).(r) }
+    example { proc(&l | f * l).(r).should == proc(&l).(r) }
+    example { proc(&l | l ** f).(r).should == proc(&l).(r) }
+    example { proc(&l ** f).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&l ** f | l).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&l ** f | g).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&l >> g).(r).should == proc(&g).(r) }
+    example { proc(&l >> f * l).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&g << l).(r).should == proc(&g).(r) }
+    example { proc(&f * l << l).(r).should == proc(&f).(r, proc(&l).(r)) }
+    pending { proc(&h * l * l).(r).should == proc(&f).(r, proc(&l).(r), proc(&l).(r)) }
+  end
+
+  shared_examples_for "empty" do
+
+    example { proc(&f * l).(r).should == proc(&l).(r) }
+    example { proc(&f * l | g).(r).should == proc(&g).(r) }
+    example { proc(&l | g).(r).should == proc(&g).(r) }
+    example { proc(&l | f * l).(r).should == proc(&l).(r) }
+    example { proc(&l | l ** f).(r).should == proc(&l).(r) }
+    example { proc(&l ** f).(r).should == proc(&l).(r) }
+    example { proc(&l ** f | l).(r).should == proc(&l).(r) }
+    example { proc(&l ** f | g).(r).should == proc(&g).(r) }
+    example { proc(&l >> g).(r).should == proc(&l).(r) }
+    example { proc(&l >> f * l).(r).should == proc(&l).(r) }
+    example { proc(&g << l).(r).should == proc(&l).(r) }
+    example { proc(&f * l << l).(r).should == proc(&l).(r) }
+  end
+
+  it_behaves_like "empty" do
+    let(:r) { nil }
+    let(:f) { described_class.new.inspect }
+    let(:g) { described_class.new.inspect }
+  end
+
+  it_behaves_like "empty" do
+    let(:r) { false }
+    let(:f) { described_class.new.& }
+    let(:g) { !described_class.new }
+  end
+
+  it_behaves_like "pure" do
+    let(:r) { true }
+    let(:f) { described_class.new.& }
+    let(:g) { !described_class.new }
+  end
+
+  it_behaves_like "pure" do
+    let(:r) { 0 }
+    let(:f) { described_class.new.^ }
+    let(:g) { !described_class.new }
+  end
+
+  it_behaves_like "pure" do
+    let(:r) { [] }
+    let(:f) { described_class.new.+ }
+    let(:g) { described_class.new.first }
+  end
+
+  it_behaves_like "pure" do
+    let(:r) { {} }
+    let(:f) { described_class.new.merge }
+    let(:g) { described_class.new[:x] }
+  end
+
+  it_behaves_like "empty" do
+    let(:r) { {} }
+    let(:l) { described_class.new[:x] }
+    let(:f) { described_class.new.== }
+    let(:g) { described_class.new.inspect }
+  end
+
+  it_behaves_like "pure" do
+    let(:r) { {x: 42} }
+    let(:l) { described_class.new[:x] }
+    let(:f) { described_class.new.!= }
+    let(:g) { described_class.new.inspect }
+  end
+end

data/spec/applicative_spec.rb

@@ -0,0 +1,48 @@
+require 'necromancy'
+
+describe Necromancy::Control::Applicative do
+
+  let(:l) { described_class.new }
+
+  shared_examples_for "an Applicative" do
+
+    example { proc(&f * l).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&l ** f).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&l >> g).(r).should == proc(&g).(r) }
+    example { proc(&l >> f * l).(r).should == proc(&f).(r, proc(&l).(r)) }
+    example { proc(&g << l).(r).should == proc(&g).(r) }
+    example { proc(&f * l << l).(r).should == proc(&f).(r, proc(&l).(r)) }
+    pending { proc(&h * l * l).(r).should == proc(&f).(r, proc(&l).(r), proc(&l).(r)) }
+  end
+
+  it_behaves_like "an Applicative" do
+    let(:r) { nil }
+    let(:f) { described_class.new.& }
+    let(:g) { !described_class.new }
+  end
+
+
+  it_behaves_like "an Applicative" do
+    let(:r) { false }
+    let(:f) { described_class.new.& }
+    let(:g) { !described_class.new }
+  end
+
+  it_behaves_like "an Applicative" do
+    let(:r) { true }
+    let(:f) { described_class.new.& }
+    let(:g) { !described_class.new }
+  end
+
+  it_behaves_like "an Applicative" do
+    let(:r) { 0 }
+    let(:f) { described_class.new.^ }
+    let(:g) { !described_class.new }
+  end
+
+  it_behaves_like "an Applicative" do
+    let(:r) { [] }
+    let(:f) { described_class.new.+ }
+    let(:g) { described_class.new.first }
+  end
+end

data/spec/arrow_spec.rb

@@ -0,0 +1,38 @@
+require 'necromancy'
+
+describe Necromancy::Control::Arrow do
+
+  let(:l) { described_class.new }
+
+  shared_examples_for "an Arrow" do
+    example { proc(&l & l).(r).should == [proc(&l).(r), proc(&l).(r)] }
+    example { proc(&l & l & l).(r).should == [proc(&l).(r), proc(&l).(r), proc(&l).(r)] }
+    example { proc(&l & l & l & l).(r).should == [proc(&l).(r), proc(&l).(r), proc(&l).(r), proc(&l).(r)] }
+    example { proc(&l & l > f).(r).should == proc(&f).(proc(&l).(r), proc(&l).(r)) }
+    example { proc(&l & l > ga * gb).(r).should == [proc(&ga).(proc(&l).(r)), proc(&gb).(proc(&l).(r))] }
+    example { proc(&l & l & l > ga * gb * ga).(r).should == [proc(&ga).(proc(&l).(r)), proc(&gb).(proc(&l).(r)), proc(&ga).(proc(&l).(r))] }
+    example { proc(&l & l & l & l > ga * gb * ga * gb).(r).should == [proc(&ga).(proc(&l).(r)), proc(&gb).(proc(&l).(r)), proc(&ga).(proc(&l).(r)), proc(&gb).(proc(&l).(r))] }
+  end
+
+  it_behaves_like "an Arrow" do
+    let(:r) { 0 }
+    let(:f) { :+ }
+    let(:ga) { +l }
+    let(:gb) { -l }
+  end
+
+  it_behaves_like "an Arrow" do
+    let(:r) { [] }
+    let(:f) { :+ }
+    let(:ga) { l.first }
+    let(:gb) { l.last }
+  end
+
+  it_behaves_like "an Arrow" do
+    let(:l) { described_class.new.keys }
+    let(:r) { { x: 42 } }
+    let(:f) { :+ }
+    let(:ga) { described_class.new.first }
+    let(:gb) { described_class.new.last }
+  end
+end

data/spec/category_spec.rb

@@ -0,0 +1,21 @@
+require 'necromancy'
+
+describe Necromancy::Control::Category do
+
+  let(:l) { described_class.new }
+
+  shared_examples_for 'a Category' do
+
+    example { proc(&l > f).(r).should == proc(&f).(proc(&l).(r)) }
+    example { proc(&f < l).(r).should == proc(&f).(proc(&l).(r)) }
+    example { proc(&l > f > g).(r).should == proc(&g).(proc(&f).(proc(&l).(r))) }
+    example { proc(&g < f < l).(r).should == proc(&g).(proc(&f).(proc(&l).(r))) }
+  end
+
+  it_behaves_like "a Category" do
+
+    let(:r) { '42' }
+    let(:f) { described_class.new.to_i }
+    let(:g) { described_class.new + 1 }
+  end
+end

data/spec/examples/alternative_spec.rb

@@ -0,0 +1,38 @@
+require 'necromancy'
+
+describe Necromancy::Control::Alternative do
+
+  let(:l) { described_class.new }
+
+  example do
+    [{ x: 42}, {}].map(&l[:x] | proc{0}).
+      should == [{ x: 42}, {}].map {|h| h[:x] || 0 }
+  end
+
+  example do
+    i = 1
+    (1..5).map(&l.+ * proc{1}).
+      should == (1..5).map {|x| x + i if i }
+  end
+
+  example do
+    i = nil
+    (1..5).map(&l.+ * proc{}).
+      should == (1..5).map {|x| x + i if i }
+  end
+
+  example do
+    (1..5).map(&l.odd? >> l.succ | l.pred).
+      should == (1..5).map {|x| x.odd? ? x.succ : x.pred }
+  end
+
+  example do
+    [{x: 1}, {y: 2}].inject(&l.merge << ->(x,y){x&&y}).
+      should == [{x: 1}, {y: 2}].inject {|x, y| x.merge(y) if x && y }
+  end
+
+  example do
+    [{x: 1}, nil, {y: 2}].inject(&l.merge << ->(x,y){x&&y}).
+      should == [{x: 1}, nil, {y: 2}].inject {|x, y| x.merge(y) if x && y }
+  end
+end

data/spec/examples/applicative_spec.rb

@@ -0,0 +1,18 @@
+require 'necromancy'
+
+describe Necromancy::Control::Applicative do
+
+  let(:l) { described_class.new }
+
+  example do
+
+    %w(foo bar baz).map(&l.+ * :reverse).
+      should == %w(foo bar baz).map {|s| s + s.reverse }
+  end
+
+  example do
+
+    %w(foo bar baz).map(&l.reverse ** :+).
+      should == %w(foo bar baz).map {|s| s + s.reverse }
+  end
+end

data/spec/examples/arrow_spec.rb

@@ -0,0 +1,26 @@
+require 'necromancy'
+
+describe Necromancy::Control::Arrow do
+
+  let(:l) { described_class.new }
+
+  example do
+    %w(foo bar baz).map(&l.upcase & :capitalize).
+      should == %w(foo bar baz).map {|s| [s.upcase, s.capitalize] }
+  end
+
+  example do
+    %w(foo bar baz).map(&l.upcase & :capitalize & :reverse).
+      should == %w(foo bar baz).map {|s| [s.upcase, s.capitalize, s.reverse] }
+  end
+
+  example do
+    %w(foo bar baz).map(&l.upcase & :capitalize > :+).
+      should == %w(foo bar baz).map {|s| s.upcase + s.capitalize }
+  end
+
+  example do
+    %w(foo bar baz).map(&l.upcase & :capitalize > l.chars.to_a * :to_sym).
+      should == %w(foo bar baz).map {|s| [s.upcase.chars.to_a, s.capitalize.to_sym] }
+  end
+end

data/spec/examples/category_spec.rb

@@ -0,0 +1,12 @@
+require 'necromancy'
+
+describe Necromancy::Control::Category do
+
+  let(:l) { described_class.new }
+
+  example do
+
+    %w(0 1 2).map(&l.to_i > "foo".method(:[])).
+      should == %w(0 1 2).map {|x| "foo"[x.to_i] }
+  end
+end

data/spec/examples/slam_spec.rb

@@ -0,0 +1,43 @@
+require 'necromancy'
+
+describe Necromancy do
+
+  let(:l) { described_class.new }
+
+  example do
+    [:foo, :bar, :baz].map(&l.to_s . upcase).
+      should == ["FOO", "BAR", "BAZ"]
+  end
+
+  example do
+    [:foo, :hoge, :bar, :fuga].select(&l.to_s . length > 3).
+      should == [:hoge, :fuga]
+  end
+
+  example do
+    qstr = "hoge=fuga&foo=bar"
+    Hash[qstr.split(?&).map &l.split(?=)].
+      should == {"hoge"=>"fuga", "foo"=>"bar"}
+  end
+
+  example do
+    (1..5).map(&l ** 2).
+      should == [1, 4, 9, 16, 25]
+  end
+
+  example do
+    %w[c++ lisp].map(&(l + "er").upcase).
+      should == ["C++ER", "LISPER"]
+  end
+
+  example do
+    %w[c++ lisp].map(&l.upcase + "er").
+      should == ["C++er", "LISPer"]
+  end
+
+  example do
+    procs = %w(succ pred odd?).map &l.to_sym . to_proc
+    procs.map(&l.call(1)).
+      should == [2, 0, true]
+  end
+end

data/spec/necromancy_spec.rb

@@ -0,0 +1,33 @@
+require 'necromancy'
+
+class TestStr < String
+
+  def f
+    TestStr.new upcase
+  end
+
+  def g(x)
+    TestStr.new self + x
+  end
+end
+
+describe Necromancy do
+
+  let(:l) { described_class.new }
+
+  shared_examples_for "a Necromancy" do
+
+    example { proc(&l.f).(r).should == r.f  }
+    example { proc(&l.g(x)).(r).should == r.g(x)  }
+    example { proc(&l.f . g(x)).(r).should == r.f.g(x)  }
+    example { proc(&l.g(x) . f).(r).should == r.g(x).f  }
+    example { proc(&l.f . f).(r).should == r.f.f  }
+    example { proc(&l.g(x) . g(x)).(r).should == r.g(x).g(x)  }
+  end
+
+  it_behaves_like "a Necromancy" do
+
+    let(:r) { TestStr.new 'hoge' }
+    let(:x) { 'fuga' }
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: necromancy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- pasberth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Necromancy conjures up the functional code.
+email: pasberth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.rst
+- Rakefile
+- VERSION
+- examples/fizzbuzz.rb
+- examples/pythonic-fizzbuzz.rb
+- examples/using-extensions.rb
+- lib/necromancy.rb
+- lib/necromancy/control.rb
+- lib/necromancy/control/alternative.rb
+- lib/necromancy/control/applicative.rb
+- lib/necromancy/control/arrow.rb
+- lib/necromancy/control/category.rb
+- lib/necromancy/necromancy.rb
+- lib/necromancy/version.rb
+- necromancy.gemspec
+- spec/alternative_spec.rb
+- spec/applicative_spec.rb
+- spec/arrow_spec.rb
+- spec/category_spec.rb
+- spec/examples/alternative_spec.rb
+- spec/examples/applicative_spec.rb
+- spec/examples/arrow_spec.rb
+- spec/examples/category_spec.rb
+- spec/examples/slam_spec.rb
+- spec/necromancy_spec.rb
+homepage: https://github.com/pasberth/necromancy
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: experimental release
+test_files:
+- spec/alternative_spec.rb
+- spec/applicative_spec.rb
+- spec/arrow_spec.rb
+- spec/category_spec.rb
+- spec/examples/alternative_spec.rb
+- spec/examples/applicative_spec.rb
+- spec/examples/arrow_spec.rb
+- spec/examples/category_spec.rb
+- spec/examples/slam_spec.rb
+- spec/necromancy_spec.rb
+has_rdoc: