lambda-calculus 0.1.0 → 0.1.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGZmYzJlZTA5MjY5ZGViOTEzY2VhZGI4NGE0OWMxNTRlM2U1NTc5YQ==
+    Y2FlZmU1ZmMwMDMwOWUyYmYyOWYyN2M5YzQ4NzM3MTliMDA4NjExZg==
   data.tar.gz: !binary |-
-    ZTlmMzZiNzk1MDk4YjNmZWY5NjhkYTRmMGM3OWJmMzJjNDY2ZGI3YQ==
+    YjQwZTU5MWFhZWU4NzM1ZmZjODI2YmJiYWY5Nzg0MmMyZGRmNjY2Zg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MWI5MzM2MGYwNjRkMWI3Zjc1ODNmNjFhNGM1Zjc0YmQwZmE3ZDRjY2EwMGQ4
-    MmNhZWVhM2MzYTQzNGQxNDdjMjVlOTc5OTI2ZmJhYjcwZWU2MGU5MDgwNDg2
-    ZTdjOGI1NTNlNzU0MzNkOGVlZjRjZjAwN2I0ZDcxMGNkMDExZjg=
+    OWRhYTFiYzBmODg5YWFlYTYyYTM1MTM3ZTViYjAwNjBmNDUwNGYwYTM4NmJl
+    NmE4YTE0NTUzNzc2MTRhMzdmOTk0YjY2ZDhlNDZhYmJlOTk2OWEyZDI1MDYw
+    YWJkNGQzMTFhODU1NWVmYzU1OThmNDE5MDE5OWJlMGU4YjM1ODI=
   data.tar.gz: !binary |-
-    MGZiY2U3MjEyYzRmZWRmMjA4NWUxMDY4NDhjYjlmYWE0YTMzYzNiOGY4MWEy
-    ODI2MDNiOGI5M2JjZDljNDk1NGM2YjU0ODU0NWYwMDRjMzNkNmJlOTE4ZmQ3
-    MzkxN2JlNmU1ZmM3MDM0NTYzYWUyZTU2OWY3NDI3ZDRjNWFkMmY=
+    NDRlODAwM2NhYTA0ZjNlYTgyOTkwODg0NWRiODg2Nzk0ZTY2ODI3ZDlhNzk5
+    NzY3YjIxNmQyOGIxZTIxZWM1ZjdkMWZkZTY0MzAxYmY4NjJiYmYyNzNhNTkx
+    ZTIyNWIxODFhN2QwMzA5YWY4ZGU2NTQ3MDk3MGYwMjQ1Yjc1NGQ=

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Alex Altair
+
+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,68 @@
+Lambda calculus engine [![Gem Version](https://badge.fury.io/rb/lambda-calculus.png)](http://badge.fury.io/rb/lambda-calculus)
+======================
+
+Ever wanted to evaluate lambda expressions from the command line? Well now you can!  
+1. Download this gem; `gem install lambda-calculus`.  
+2. Open up pry or irb and type `require 'lambda-calculus'`.  
+3. Declare a lambda expression; `my_exp = LambdaExpression.new('(\x.xy)(\a.a)')`  
+4. Evaluate or beta reduce!  
+```
+> my_exp.beta_reduce
+=> (\a.a)y
+> my_exp.evaluate
+=> y
+```
+Lambda expressions are a class. Their attributes depend on which kind they are, as defined by the following code snippet from lambda-calculus.rb;
+
+```ruby
+case args.length
+when 1
+  @kind = :variable
+  @value = node_value
+when 2
+  @kind = :abstraction
+  @bound_var = node_value
+  @body = child1
+when 3
+  @kind = :application
+  @function = child1
+  @argument = child2
+```
+Arguments
+---------
+`LambdaExpression.new()` has two modes for taking arguments; natively or naturally. I tried to make it as flexible as possible while matching expectations.
+
+Natively it can take one, two or three arguments where one makes it a variable, two makes it an abstraction, and three makes it an application. In each case the first argument must be a symbol or string of the correct form; anything but * for variables and abstractions, and only * for applications. The other arguments can be LambdaExpressions, strings of the natural form, or symbols.
+
+Naturally, one can just give the lambda expression written as a string, the way you might write an expression to someone over text.
+
+Some valid examples are shown below;
+
+This will become a variable;
+```ruby
+LambdaExpression.new(:x)
+LambdaExpression.new('x')
+```
+These will become abstractions;
+```ruby
+LambdaExpression.new(:x, :x)
+LambdaExpression.new('x', 'x')
+LambdaExpression.new(:x, 'xy')
+```
+These will become applications;
+```ruby
+LambdaExpression.new(:*, :x, :y)
+LambdaExpression.new('*', 'x', 'y')
+LambdaExpression.new(:*, :x, '\a.bb')
+```
+These will be parsed as strings
+```ruby
+LambdaExpression.new('x')
+LambdaExpression.new('xy')
+LambdaExpression.new('(\x.xy)(\a.bb)')
+LambdaExpression.new('\x.xy')
+```
+
+Being able to accept arbitrary strings means that a string parser is included.
+The method `beta_reduce` will perform beta reduction, but only on the top-level application.
+Methods for printing facts about lambda expressions are also included; `lambda_string_tester` for strings, and `lambda_tester` for native LambdaExpression objects.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rspec'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+
+desc "Run specs as default activity."
+task :default => :spec
+# Check the RDoc for RakeTask for various options that you can optionally pass into the task definition.
+# https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/rake_task.rb

data/lambda-calculus.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |spec|
+  spec.name        = 'lambda-calculus'
+  spec.version     = '0.1.4'
+  spec.date        = Time.now.strftime("%Y-%m-%d")
+  spec.summary     = "A class with methods for creating and evaluating lambda expressions."
+  spec.description = "This gem allows users to create and evaluate lambda expression objects from natural string input like '(\\x.xy)(\\a.aba)'."
+  spec.authors     = ["Alex Altair"]
+  spec.email       = 'alexanderaltair@gmail.com'
+  spec.files       = `git ls-files`.split("\n") - %w(.rvmrc .gitignore)
+  spec.homepage    = 'https://github.com/alexaltair/lambda-calculus'
+  spec.license     = 'MIT'
+  spec.test_files  = `git ls-files -- spec/*`.split("\n")
+  spec.post_install_message = "* Check out the documentation at #{spec.homepage} *"
+  spec.add_development_dependency "rspec"
+end

data/lib/lambda-calculus.rb

@@ -1,9 +1,8 @@
-# Takes a string and find the index of the matching close paren to the open paren specified. Default open paren index is the beginning of the string.
+# Takes a string and finds the index of the matching close paren to the open paren specified.
 def close_paren_index(string, open_paren_index = 0)
   if open_paren_index == 0
     raise ArgumentError "First character not an open paren." unless string[open_paren_index] == '('
-  else
-    raise ArgumentError "Given index not an open paren." unless string[open_paren_index] == '('
+  else raise ArgumentError "Given index not an open paren." unless string[open_paren_index] == '('
   end
   array = string.split('')
   depth = 1
@@ -22,16 +21,37 @@ end
 
 class LambdaExpression
 
-  # Change the setters so that attributes cannot be changed to make a meaningless lambda expression.
+  # ----- Change the setters so that attributes cannot be changed to make a meaningless lambda expression.
   attr_accessor :kind, :value, :bound_var, :body, :function, :argument
+  # ----- Make a class variable or something, which stores all the strategies; LambdaExpression.strategies = [:eager, :lazy, :depth_first ... ]
 
   def initialize(*args)
+    # This deals with all possible types of arguments that could be given.
+    args = sanitize_args(*args)
+    node_value, child1, child2 = args
 
-    # The first half of this deals with all possible types of arguments that could be given.
+    # At this point the first argument should be a symbol, and the rest LambdaExpressions.
+    case args.length
+    when 1
+      @kind = :variable
+      @value = node_value
+    when 2
+      @kind = :abstraction
+      @bound_var = node_value
+      @body = child1
+    when 3
+      @kind = :application
+      @function = child1
+      @argument = child2
+    else raise ArgumentError, "Wrong number of arguments. (Should be caught earlier.)"
+    end
+
+  end
 
+  def sanitize_args(*args)
     args.compact!
 
-    # If the expression is initialized in natural mode, as a written-out string, the initializer passes that string to .string_to_lambda_args to turn it into the native arguments.
+    # If the expression is initialized in natural mode, as a written-out string, the sanitizer passes that string to .string_to_lambda_args to turn it into the native arguments.
     if args.length == 1 && args[0].is_a?(String)
       args = LambdaExpression.string_to_lambda_args(args[0])
     end
@@ -42,7 +62,7 @@ class LambdaExpression
     end
 
     if node_value.is_a?(String)
-      node_value.to_sym
+      node_value = node_value.to_sym
     end
 
     if node_value.is_a?(Symbol)
@@ -58,40 +78,24 @@ class LambdaExpression
     else raise ArgumentError, "First argument is not a symbol."
     end
 
-    # At this point the first argument should be a symbol, and the rest LambdaExpressions.
-
-    case args.length
-    when 1
-      @kind = :variable
-      @value = node_value
-    when 2
-      @kind = :abstraction
-      @bound_var = node_value
-      @body = child1
-    when 3
-      @kind = :application
-      @function = child1
-      @argument = child2
-    else raise ArgumentError, "Wrong number of arguments. (Should be caught earlier.)"
-    end
-
+    return *[node_value, child1, child2].compact
   end
 
-
-  def to_s
-    case self.kind
-    when :variable then self.value.to_s
-    when :abstraction then "\\#{self.bound_var}.#{self.body}"
-    when :application
-      function_string = "#{self.function}"
-      argument_string = "#{self.argument}"
-      if self.function.kind == :abstraction
-        function_string = "(" + function_string + ")"
+  def self.string_to_lambda_args(string)
+    array = group_by_parens(string)
+    if array.length == 1
+      string = array[0]
+      if string[0] == '\\'
+        return string[1].to_sym, string[3..-1]
+      else return string.to_sym # Symbols are required to be only one character; this is enforced later in the initializer.
       end
-      unless self.argument.kind == :variable
-        argument_string = "(" + argument_string + ")"
+    else
+      last = array.pop
+      array.map! { |element| LambdaExpression.new(element) }
+      penultimate = array.inject do |function, next_arg|
+        LambdaExpression.new(:*, function, next_arg)
       end
-      return function_string + argument_string
+      return :*, penultimate, last
     end
   end
 
@@ -115,25 +119,26 @@ class LambdaExpression
     array
   end
 
-  def self.string_to_lambda_args(string)
-    array = group_by_parens(string)
-    if array.length == 1
-      string = array[0]
-      if string[0] == '\\'
-        return string[1].to_sym, string[3..-1]
-      else return string.to_sym # Symbols are required to be only one character; this is enforced later in the initializer.
+  def to_s
+    case self.instance_variable_get(:@kind)
+    when :variable then self.value.to_s
+    when :abstraction then "\\#{self.bound_var}.#{self.body}"
+    when :application
+      function_string = "#{self.function}"
+      argument_string = "#{self.argument}"
+      if self.function.kind == :abstraction
+        function_string = "(" + function_string + ")"
       end
-    else
-      last = array.pop
-      array.map! { |element| LambdaExpression.new(element) }
-      penultimate = array.inject do |function, next_arg|
-        LambdaExpression.new(:*, function, next_arg)
+      unless self.argument.kind == :variable
+        argument_string = "(" + argument_string + ")"
       end
-      return :*, penultimate, last
+      return function_string + argument_string
+    else raise "Lambda expression has no kind."
     end
   end
 
   # I stole this from the iternet, but understand how it works and tested it.
+  # ----- Change this so that it doesn't have any new instance variables.
   def deep_clone
     return @deep_cloning_obj if @deep_cloning
     @deep_cloning_obj = clone
@@ -154,12 +159,34 @@ class LambdaExpression
     deep_cloning_obj
   end
 
-  # This method does beta reduction only at the top level. Fuller lambda experession evaluation is done by evaluate.
+  # Deep equality; tests whether LambdaExpressions are the same down to the value of the instance variables.
+  def ===(other)
+    return true if self == other
+    if self.kind == other.kind
+      case self.kind
+      when :variable
+        return self.value == other.value
+      when :abstraction
+        return (self.bound_var == other.bound_var &&
+                self.body     === other.body)
+      when :application
+        return (self.function === other.function &&
+                self.argument === other.argument)
+      end
+    end
+    return false
+  end
+
+  # After de Bruijn indices are implemented, this will be the same as deep equality.
+  def alpha_equal?(other)
+  end
+
+  # This method does beta reduction only at the top level. Fuller lambda expression evaluation is done by #evaluate.
   def beta_reduce
-    copy = self.deep_clone
-    unless (copy.kind == :application) && (copy.function.kind == :abstraction)
-      return copy
+    unless (self.kind == :application) && (self.function.kind == :abstraction)
+      return self
     end
+    copy = self.deep_clone
     replacement = copy.argument
     bound_variable = copy.function.bound_var
 
@@ -178,30 +205,51 @@ class LambdaExpression
         self.function = self.function.substitute(bound_variable, replacement)
         self.argument = self.argument.substitute(bound_variable, replacement)
         return self
-      else raise ArgumentError, "First argument is not a LambdaExpression or has no .kind."
+      else raise ArgumentError, "First argument is not a LambdaExpression or has no kind."
       end
     end
 
     copy.function.body.substitute(bound_variable, replacement)
   end
 
-  def evaluate(strategy=:lazy)
-    raise "Method not yet written."
+  def evaluate(strategy=:depth_first)
+    case strategy
+    when :depth_first then self.evaluate_depth_first
+    else raise ArgumentError, "Argument #{strategy} is not an evaluation strategy."
+    end
+    # Eager/strict, pre-order, in-order, post-order/applicative-order, breadth-first, unstoppable hybrid
+  end
+
+  def evaluate_depth_first
+    expression = self.deep_clone
+    case expression.kind
+    when :variable then return expression
+    when :abstraction then return LambdaExpression.new( expression.bound_var, expression.body.evaluate_depth_first )
+    when :application
+      expression.function = expression.function.evaluate_depth_first
+      if expression.function.kind == :abstraction
+        return expression.beta_reduce.evaluate_depth_first
+      else
+        expression.argument = expression.argument.evaluate_depth_first
+        return expression
+      end
+    else raise ArgumentError, "This lambda expression has a wrong kind."
+    end
   end
 
   # This method helps me test LambdaExpression objects.
   def lambda_tester
-    puts   "To string: #{self}"
-    puts   "kind:      #{self.kind}"
+    puts   "To string:  #{self}"
+    puts   "kind:       #{self.kind}"
     case self.kind
     when :variable
-      puts "value:     #{self.value}"
+      puts "value:      #{self.value}"
     when :abstraction
-      puts "bound_var: #{self.bound_var}"
-      puts "body:      #{self.body}"
+      puts "bound_var:  #{self.bound_var}"
+      puts "body:       #{self.body}"
     when :application
-      puts "function:  #{self.function}"
-      puts "argument:  #{self.argument}"
+      puts "function:   #{self.function}"
+      puts "argument:   #{self.argument}"
     end
   end
 
@@ -210,28 +258,27 @@ class LambdaExpression
     puts "Test string:      #{string}"
     puts "Paren grouping:   #{LambdaExpression.group_by_parens(string)}"
     args = LambdaExpression.string_to_lambda_args(string)
-    arg0, arg1, arg2 = args
     puts "Lambda arguments: #{args}"
-    thing = LambdaExpression.new(arg0, arg1, arg2)
+    thing = LambdaExpression.new(*args)
     thing.lambda_tester
   end
 
   # Runs a block on every leaf in the tree.
   def each_leaf!
-    raise 'Method not yet written.'
+    raise "Method not yet written."
 
     self.each do |leaf|
       yield(leaf)
     end
   end
 
+  def evaluates_to?(other, strategy=:depth_first)
+    self.evaluate(strategy) === other
+  end
+
   # Returns a random LambdaExpression
   def self.random
     raise "Method not yet written."
   end
 
 end
-
-# LambdaExpression.lambda_string_tester('(\x.yx)\a.bb')
-# p test.beta_reduce
-# p test

data/spec/lambda_calculus_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe LambdaExpression do
+
+  describe 'new' do
+
+    it "should fail to initizlie the empty string" do
+      expect { LambdaExpression.new('') }.to raise_error
+    end
+
+    it "should initialize single characters as variables" do
+      test_cases = ['x', :a, 'g', :l, 'y', 'z']
+      test_cases.each do |expression|
+        LambdaExpression.new(expression).kind.should == :variable
+      end
+    end
+
+    it "should initialize abstractions" do
+      test_cases = [[:x, :x] , [:a, 'xa'], ['g', 'ga'], ['x', :x], ['\x.x'], ['\x.\y.xy']]
+      test_cases.each do |expression|
+        LambdaExpression.new(*expression).kind.should == :abstraction
+      end
+    end
+
+    it "should initialize applications" do
+      test_cases = [[:*, :x, :x], ['*', :a, 'x'], ['*', 'g', 'a'], ['xx'], ['a\x.\y.xy']]
+      test_cases.each do |expression|
+        LambdaExpression.new(*expression).kind.should == :application
+      end
+    end
+
+    it "should reject * as an argument in all other cases" do
+      test_cases = [[:*], [:*, :*], [:*, '*'], ['*', '*'], ['*', :*], ['x', :*], [:x, :*], [:x, '*'], ['x', '*'], ['*', '*', 'x'], ['*', 'x', '*'], [:*, :*, :x], ['a', '*', '*']]
+      test_cases.each do |expression|
+        expect { LambdaExpression.new(*expression) }.to raise_error
+      end
+    end
+
+  end
+
+  describe 'beta_reduce' do
+
+    it "should return the same object if it can't reduce" do
+      example = LambdaExpression.new('x')
+      example.beta_reduce.should == example
+      example.beta_reduce.value.should == example.value # Dubious meaning.
+
+      test_cases = ['\x.x', 'xy', 'x\y.y', 'xyz', '(\a.aab)xy']
+      test_cases.each do |expression|
+        example = LambdaExpression.new(expression)
+        example.beta_reduce.should == example
+      end
+    end
+
+    it "should return a different object if it can perform beta reduction" do
+      test_cases = ['(\x.xx)(\y.yy)', '(\x.xx)(\x.xx)', '(\x.yx)a', '(\a.aab)(xy)']
+      test_cases.each do |expression|
+        example = LambdaExpression.new(expression)
+        example.beta_reduce.should_not == example
+      end
+    end
+
+  end
+
+  describe 'evaluate' do
+    it "should return the same object for expressions that can't be evaluated"
+
+    # I have no idea how to correctly implement this.
+    # it "should return with any strategy for expressions with finite reduction steps" do
+    #   test_cases = ['x', 'xy'] # Come up with complicated examples.
+    #   test_cases.each do |string|
+    #     expression = LambdaExpression.new(string)
+    #     LambdaExpression.strategies.each do |strategy|
+    #       expression.evaluate(strategy).should # ... should what?
+    #     end
+    #   end
+    # end
+  end
+
+  describe '===' do
+
+    it "should return true when same up to same variable names, false otherwise" do
+      test_cases = { 'x'=>'x', :x=>'x', 'xy'=>'xy', '\a.ba'=>'\a.ba', '(\x.yx)a'=>'(\x.yx)a' }
+      test_cases.each do |expression|
+        example_self, example_other = LambdaExpression.new(expression[0]), LambdaExpression.new(expression[1])
+        example_self.should === example_other
+      end
+
+      test_cases = { 'x'=>'y', :x=>'y', 'xy'=>'yx', '\b.ba'=>'\a.ab', '(\x.yx)b'=>'(\x.yx)a' }
+      test_cases.each do |expression|
+        example_self, example_other = LambdaExpression.new(expression[0]), LambdaExpression.new(expression[1])
+        example_self.should_not === example_other
+      end
+    end
+
+    it "should be reflexive" do
+      test_cases = ['x', :x, 'xy', '\a.ba', '(\x.yx)a']
+      test_cases.each do |expression|
+        example = LambdaExpression.new(expression)
+        example.should === example
+      end
+    end
+
+    it "should be symmetrical" do
+      test_cases = { 'x'=>'x', :x=>'x', 'xy'=>'xy', '\a.ba'=>'\a.ba', '(\x.yx)a'=>'(\x.yx)a', 'x'=>'y', :x=>'y', 'xy'=>'yx', '\b.ba'=>'\a.ab', '(\x.yx)b'=>'(\x.yx)a' }
+      test_cases.each do |expression|
+        example_self, example_other = LambdaExpression.new(expression[0]), LambdaExpression.new(expression[1])
+        (example_self === example_other).should == (example_other === example_self)
+      end
+    end
+
+    # Later, too hard.
+    # it "should be transitive" do
+    # end
+
+    # pending "write a pending message"
+
+  end
+
+  describe 'deep_clone' do
+    it "should copy complex expressions which are alpha_equal and === but not =="
+    it "should leave the self untouched"
+  end
+
+  describe 'alpha_equal?' do
+    it "should return true for expressions with the same structure but different variable names"
+  end
+
+
+
+  # Can I write a function, has_lambda_properties?, to use in this file?
+  # Edge cases
+  #   The base cases create objects with correct properties
+  # Make complex specific LambdaExpressions and make sure they were initialized correctly
+  # Beta reduce leaves self untouched
+  # RSpec with random lambdas
+
+end
+
+  # test_cases = [blah]
+  # test_cases.each do |expression|
+  #   # code
+  # end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require './lib/lambda-calculus.rb'
+
+# RSpec.configure do |config|
+#   config.color_enabled = true
+#   config.formatter     = 'documentation'
+# end

metadata

@@ -1,27 +1,51 @@
 --- !ruby/object:Gem::Specification
 name: lambda-calculus
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Alex Altair
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-21 00:00:00.000000000 Z
-dependencies: []
-description: This gem allows users to create lambda expression objects in Ruby from
-  natural string input like '(\x.xy)(\a.aba)'.
+date: 2013-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem allows users to create and evaluate lambda expression objects
+  from natural string input like '(\x.xy)(\a.aba)'.
 email: alexanderaltair@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lambda-calculus.gemspec
 - lib/lambda-calculus.rb
+- spec/lambda_calculus_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/alexaltair/lambda-calculus
-licenses: []
+licenses:
+- MIT
 metadata: {}
-post_install_message: 
+post_install_message: ! '* Check out the documentation at https://github.com/alexaltair/lambda-calculus
+  *'
 rdoc_options: []
 require_paths:
 - lib
@@ -41,4 +65,6 @@ rubygems_version: 2.0.5
 signing_key: 
 specification_version: 4
 summary: A class with methods for creating and evaluating lambda expressions.
-test_files: []
+test_files:
+- spec/lambda_calculus_spec.rb
+- spec/spec_helper.rb