master_forest 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@master_forest --create

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in master_forest.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Joe Nelson
+
+MIT License
+
+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.md

@@ -0,0 +1,28 @@
+# Master Forest
+
+This gem parses and reduces combinatory logic written in Lazy K syntax.
+
+## Usage
+
+<table>
+  <caption>MasterForest::Term methods</caption>
+  <tbody>
+  <tr><td>initialize(string)</td>  <td>argument is a Lazy K string</td></tr>
+  <tr><td>leaf?</td>               <td>Is it a single letter like `s`, `k`, or `i`?</td></tr>
+  <tr><td>valid?</td>              <td>Is it syntactically valid?</td></tr>
+  <tr><td>normal?</td>             <td>Is it in normal form? (i.e. not further reducible)</td></tr>
+  <tr><td>to_s</td>                <td>Serialize back to Lazy K</td></tr>
+  <tr><td>l</td>                   <td>Left applicand; nil if leaf</td></tr>
+  <tr><td>r</td>                   <td>Right applicand; nil if leaf</td></tr>
+  <tr><td>reduce</td>              <td>Return single β reduction of term or term itself</td></tr>
+  <tr><td>fully_reduce(depth)</td> <td>Reduce depth times or until normal, default depth is ∞</td></tr>
+  </tbody>
+</table>
+
+## Performance
+
+This gem includes two implementations of the same functionality,
+`MasterForest::Term` and `MasterForest::MemcacheTerm`. If you
+run memcache then the latter will use it to memoize previous
+reductions. This goes much faster. You can test the speed by running
+`benchmark/run.rb`.

data/Rakefile

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

data/benchmark/run.rb

@@ -0,0 +1,27 @@
+require_relative '../lib/master_forest'
+require 'benchmark'
+include MasterForest
+
+def show_performance &blk
+  print Benchmark.measure &blk
+end
+
+[Term, MemcacheTerm].each do |impl|
+  puts "*"*80
+  puts "Benchmarking #{impl} implementation"
+  [
+    "```````sss`ssisss", "`````s``ssii`ssss", "`````sii``ss`ssss",
+    "`````sii```ssssss", "```````s`ssssisss", "`````s`ss`ss`ssss",
+    "``````ssi``ssssss", "``````ssi`ss`ssss", "`````s`s`ssi`ssss"
+  ].each do |term|
+    puts "Reduce #{term}"
+    2.times do |i|
+      print "#{i+1})"
+      show_performance do
+        t = impl.new term
+        t.fully_reduce
+      end
+    end
+    puts
+  end
+end

data/lib/master_forest/memcache_term.rb

@@ -0,0 +1,41 @@
+require 'dalli'
+
+module MasterForest
+  class MemcacheTerm < Term
+    def initialize raw, left = nil, right = nil
+      @cache = Dalli::Client.new 'localhost:11211'
+      super raw, left, right
+    end
+
+    def fully_reduce depth = Float::INFINITY
+      cur = self
+      redices = [self]
+      1.upto(depth) do
+        reduced = @cache.get cur.to_s
+        if reduced
+          cache! redices, reduced
+          return reduced
+        end
+
+        reduced = cur.reduce
+        if reduced.normal?
+          cache! redices, reduced
+          return reduced
+        else
+          redices << reduced
+        end
+        cur = reduced
+      end
+      cur
+    end
+
+    private
+
+    def cache! redices, redux
+      redices.each { |redex|
+        @cache.set redex.to_s, redux.to_s
+      }
+    end
+
+  end
+end

data/lib/master_forest/term.rb

@@ -0,0 +1,98 @@
+module MasterForest
+  class Term
+    def initialize raw, left = nil, right = nil
+      @raw = raw
+      if raw.nil?
+        @l, @r  = left, right
+        @parsed = @l and @r
+        raise "Empty node" unless @parsed
+      end
+    end
+
+    def to_s
+      @raw ||= ['`', l.to_s, r.to_s].join
+    end
+
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    def valid?
+      /[^`ski]/.match(to_s).nil? and (subterm_length(0)+1 == to_s.length)
+    end
+
+    def normal?
+      return @normal ||= if leaf?
+                           true
+                         elsif /^`(i|`k|``s)/.match(to_s)
+                           false
+                         else
+                           l.normal? && r.normal?
+                         end
+    end
+
+    def leaf?
+      to_s[0] != '`'
+    end
+
+    def l
+      shallow_parse unless @parsed
+      @l
+    end
+
+    def r
+      shallow_parse unless @parsed
+      @r
+    end
+
+    def reduce
+      return self if leaf?
+
+      return r   if to_s.start_with? '`i'
+      return l.r if to_s.start_with? '``k'
+      if to_s.start_with? '```s'
+        return join(join(l.l.r, r), join(l.r, r))
+      end
+
+      reduced = l.reduce
+      return join(reduced, r) if reduced != l
+      reduced = r.reduce
+      return join(l, reduced) if reduced != r
+
+      return self
+    end
+
+    def fully_reduce depth = Float::INFINITY
+      cur = self
+      1.upto(depth) do
+        reduced = cur.reduce
+        return reduced if reduced.normal?
+        cur = reduced
+      end
+      cur
+    end
+
+    private
+
+    def subterm_length subterm_start
+      balance = 1
+      @raw[subterm_start..-1].chars.each_with_index do |symbol, offset|
+        balance += (symbol == '`') ? 1 : -1
+        return offset if balance == 0
+      end
+      raise "Unclosed application #{@raw}:#{subterm_start}"
+    end
+
+    def shallow_parse
+      @parsed = true
+      return if leaf?
+      len = subterm_length 1
+      @l  = Term.new @raw[1     .. 1+len]
+      @r  = Term.new @raw[2+len .. -1   ]
+    end
+
+    def join left, right
+      Term.new nil, left, right
+    end
+  end
+end

data/lib/master_forest/version.rb

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

data/lib/master_forest.rb

@@ -0,0 +1,3 @@
+require "master_forest/version"
+require "master_forest/term"
+require "master_forest/memcache_term"

data/master_forest.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'master_forest/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "master_forest"
+  gem.version       = MasterForest::VERSION
+  gem.authors       = ["Joe Nelson"]
+  gem.email         = ["cred+github@begriffs.com"]
+  gem.description   = %q{THE MASTER FOREST: ONLY THE ELITE ARE ALLOWED TO ENTER!}
+  gem.summary       = %q{Combinatory logic parsing and reduction}
+  gem.homepage      = "https://github.com/begriffs/master_forest"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'dalli'
+  gem.add_development_dependency 'rspec'
+end

data/spec/term_spec.rb

@@ -0,0 +1,170 @@
+require 'master_forest'
+include MasterForest
+
+require 'ruby-prof'
+
+describe MasterForest do
+  context 'parsing' do
+    let(:s)    { Term.new 's'     }
+    let(:k)    { Term.new 'k'     }
+    let(:sk)   { Term.new '`sk'   }
+    let(:skk)  { Term.new '``skk' }
+    let(:s_kk) { Term.new '`s`kk' }
+    let(:bad)  { Term.new '``s'   }
+
+    context 'leaf node' do
+      it 'parses' do
+        s.to_s.should == 's'
+      end
+
+      it 'is a leaf' do
+        s.leaf?.should be_true
+      end
+
+      it 'has no children' do
+        s.l.should be_nil
+        s.r.should be_nil
+      end
+    end
+
+    context 'application' do
+      it 'parses' do
+        sk.to_s.should == '`sk'
+        sk.l.to_s.should == 's'
+        sk.r.to_s.should == 'k'
+      end
+
+      it 'parses deeper as needed on left' do
+        skk.l.to_s.should == '`sk'
+        skk.r.to_s.should == 'k'
+        skk.l.l.to_s.should == 's'
+      end
+
+      it 'parses deeper as needed on right' do
+        s_kk.l.to_s.should == 's'
+        s_kk.r.to_s.should == '`kk'
+        s_kk.r.l.to_s.should == 'k'
+      end
+
+      it 'is not a leaf' do
+        sk.leaf?.should be_false
+      end
+    end
+
+    context 'invalid' do
+      it 'fails to parse' do
+        expect { bad.l }.to raise_error
+      end
+    end
+
+    describe '#==' do
+      it 'is reflexive' do
+        (Term.new '``skk').should == (Term.new '``skk')
+      end
+      it 'distinct normal terms are not equal' do
+        skk.should_not == s_kk
+      end
+    end
+
+    context 'explicit tree building' do
+      it 'generates to_s as needed' do
+        (Term.new nil, s, k).to_s.should == '`sk'
+      end
+      it 'string overrides explicit children' do
+        (Term.new 'i', s, k).to_s.should == 'i'
+      end
+      it 'refuses to create an entirely blank node' do
+        expect { Term.new nil }.to raise_error
+      end
+    end
+  end
+
+  describe '#valid?' do
+    let (:leaf) { Term.new 'k'       }
+    let (:good) { Term.new '``ii`ii' }
+    let (:bad)  { Term.new '`iX'     }
+    let (:long) { Term.new '`iii'    }
+
+    it 'says valid terms are valid' do
+      leaf.should be_valid
+      good.should be_valid
+    end
+    it 'does not allow symbols other than `,s,k,i' do
+      bad.should_not be_valid
+    end
+    it 'does not allow extraneous characters at end' do
+      long.should_not be_valid
+    end
+  end
+
+  describe '#reduce' do
+    let(:s)    { Term.new 's'       }
+    let(:ii)   { Term.new '`ii'     }
+    let(:ki)   { Term.new '`ki'     }
+    let(:si)   { Term.new '`si'     }
+    let(:kis)  { Term.new '``kis'   }
+    let(:siks) { Term.new '```siks' }
+
+    it 'does not alter a leaf' do
+      s.reduce.to_s.should == 's'
+    end
+
+    it 'does not alter k or s with too little depth' do
+      ki.reduce.should == ki
+      si.reduce.should == si
+    end
+
+    it 'drops i combinator' do
+      ii.reduce.to_s.should == 'i'
+    end
+
+    it 'applies k combinator' do
+      kis.reduce.to_s.should == 'i'
+    end
+
+    it 'applies s combinator' do
+      reduced = siks.reduce
+      reduced.to_s.should == '``is`ks'
+      reduced.l.to_s.should == '`is'
+      reduced.r.to_s.should == '`ks'
+    end
+  end
+
+  describe '#fully_reduce' do
+    let (:biggie) { Term.new '`````s`ss`ss`ssss' }
+
+    it 'runs through many reductions and succeeds' do
+      biggie.fully_reduce.to_s.should == '``s``s``s``ss``ss``ssss``s``s``ss``ss``ssss``s``s``ss``ss``ssss``ss``s``ss``ss``ssss``s``s``s``ss``ss``ssss``s``s``ss``ss``ssss``s``s``ss``ss``ssss``ss``s``ss``ss``ssss``s``s``s``ss``ss``ssss``s``s``ss``ss``ssss``s``s``ss``ss``ssss``ss``s``ss``ss``ssss``ss``s``s``ss``ss``ssss``s``s``ss``ss``ssss``s``s``ss``ss``ssss``ss``s``ss``ss``ssss'
+    end
+  end
+
+  describe '#normal' do
+    let (:leaf) { Term.new 'i'   }
+    let (:app)  { Term.new '`ki' }
+    let (:ii)   { Term.new '`ii' }
+    let (:active_l) { Term.new '``iik'}
+    let (:active_r) { Term.new '`k`ii'}
+    let (:big)      { Term.new '``````ssi``ssssss'}
+
+    context 'given a leaf' do
+      it 'always says normal' do
+        leaf.should be_normal
+      end
+    end
+    context 'given an application' do
+      it 'is sometimes normal' do
+        app.should be_normal
+      end
+      it 'i application is never normal' do
+        ii.should_not be_normal
+      end
+      it 'detects active subterms' do
+        active_l.should_not be_normal
+        active_r.should_not be_normal
+      end
+      it 'detects deeply nested active terms' do
+        big.should_not be_normal
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: master_forest
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joe Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dalli
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: ! 'THE MASTER FOREST: ONLY THE ELITE ARE ALLOWED TO ENTER!'
+email:
+- cred+github@begriffs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/run.rb
+- lib/master_forest.rb
+- lib/master_forest/memcache_term.rb
+- lib/master_forest/term.rb
+- lib/master_forest/version.rb
+- master_forest.gemspec
+- spec/term_spec.rb
+homepage: https://github.com/begriffs/master_forest
+licenses: []
+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: Combinatory logic parsing and reduction
+test_files:
+- spec/term_spec.rb