dslisprb 0.0.2 → 0.0.3

data/CHANGELOG

@@ -1,3 +1,13 @@
+0.0.3   fixed interpretation of special nil and T symbols
+
+        implemented autocompletion of lisp variable names on dslisp console
+
+        fixed variable assignment stack to match lisp behavior (see spec/stack.rb)
+
+        fixed variable eval (before (if T x y) was evaluated as x symbol instead of the value associated to x)
+
+        fixed bug on boolean evaluation of empty list
+
 0.0.2   conditional structure if and cond   
 
         mapcar and mapcan

data/Rakefile

@@ -7,7 +7,7 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'dslisprb'
-  s.version = '0.0.2'
+  s.version = '0.0.3'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY

data/bin/dslisprb

@@ -29,6 +29,11 @@ else
   stty_save = `stty -g`.chomp
   trap('INT') { system('stty', stty_save); exit }
 
+  Readline.completion_append_character = " "
+  Readline.completion_proc = proc do |s|
+    dslisp.variables.grep( /^#{Regexp.escape(s)}/ )
+  end
+
   while cmd = Readline.readline('> ', true)
     if cmd == "quit"
       exit

data/lib/dslisprb.rb

@@ -1,6 +1,11 @@
 class DsLisp
   class ToRuby
     class << self
+
+      def convert_name(name)
+        {:lt => "<", :ht => :>, :plus => :+, :mult => "*", :divide => "/", :minus => "-" }[name] || name[1..-1]
+      end
+
       def name_convert(name)
         {:< => "lt", :> => "ht", :+ => "plus", :* => "mult" , :/ => "divide", :- => "minus" }[name] || "_" + name.to_s
       end
@@ -15,24 +20,19 @@ class DsLisp
             CommonLispOperators.send(function_name, code)
           else      
             strargs = code[1..-1].map{|x| 
-              if Symbol === x
-                "(local_variables.include?(:#{x}) ? #{x} : (#{to_ruby(x)}))"
-              else
-                "(#{to_ruby(x)})"
-              end
+              "(#{to_ruby(x)})"
             }.join(",")
 
-            if Symbol === function_name
-              "#{name_convert(function_name)}.call(#{strargs})"
-            else
-              "#{to_ruby(code.first)}.call(#{strargs})"
-            end
+            "#{to_ruby(code.first)}.call(#{strargs})"
           end    
         else
           if code == :nil
-            nil
+            "nil"
           elsif code == :T
-            true
+            "true"
+          elsif Symbol === code
+#            "(local_variables.include?(#{name_convert(code)}) ? #{name_convert(code)} : nil)"
+            name_convert(code).to_s 
           else
             code.inspect
           end  
@@ -50,12 +50,12 @@ class DsLisp
       def cond(code)
         "(nil.tap { 
         " + code[1..-1].map{ |condition_code|
-          "(break (#{ToRuby.to_ruby condition_code[1]}) if (#{ToRuby.to_ruby condition_code[0]}))"
+          "(break (#{ToRuby.to_ruby condition_code[1]}) if (aux = (#{ToRuby.to_ruby condition_code[0]}); aux != [] and aux != nil) )"
         }.join(";") + "})"
       end
 
       def if(code)
-        "(if (#{ToRuby.to_ruby code[1]})
+        "(if (aux = (#{ToRuby.to_ruby code[1]}); aux != [] and aux != nil)
             #{ToRuby.to_ruby code[2]}
           else
             #{ToRuby.to_ruby code[3]}
@@ -65,8 +65,17 @@ class DsLisp
       end
 
       def lambda(code)
-        arguments = code[1].map(&:to_s).join(",")
-        "lambda{|#{arguments}| #{ToRuby.to_ruby(code[2])}}.lisp_inner_code(#{code.lisp_inspect.inspect})"
+        arguments = code[1].map(&ToRuby.method(:name_convert)).map(&:to_s)
+        "(#{arguments.join(",")} = #{code[1].map{"nil"}.join(",")} ;lambda{|*x|
+            oldargs = [ #{arguments.join(",")} ] # save current bindings
+            #{(0..arguments.size-1).map{|i| "#{arguments[i]} = x[#{i}]" }.join(";")} 
+            begin
+              aux = #{ToRuby.to_ruby(code[2])}
+            ensure
+              #{arguments.join(",")} = oldargs # restore bindings
+            end
+            aux
+          }.lisp_inner_code(#{code.lisp_inspect.inspect}))"
       end
 
       def block(code)
@@ -156,8 +165,19 @@ class DsLisp
     eval(ruby_code, main_binding)
   end
 
+  def variables
+    eval("local_variables", main_binding).map(&ToRuby.method(:convert_name))
+  end
+
 private
-  
+  def null(element)
+    element == nil or element == []
+  end
+
+  def not_null(element)
+    element != nil and element != []
+  end
+
   def main_binding
     unless @binding
       @binding = binding
@@ -184,7 +204,7 @@ private
       _list = lambda{|*args| args}
 
       # recognizers
-      _null = lambda{|element| (element == nil or element == []) || nil}
+      _null = lambda{|element| null(element) ? true : nil}
       _atom = lambda{|element| (not Array === element) || nil}
       _numberp = lambda{|element| Numeric === element || nil}
       _symbolp = lambda{|element| Symbol === element || nil}
@@ -195,9 +215,15 @@ private
       _nil = lambda{nil}
 
       # boolean
-      _not = lambda{|a| (not a) || nil}
-      _and = lambda{|a,b| (a and b) || nil}
-      _or = lambda{|a,b| (a or b) || nil}
+      _not = lambda{|a| null(a) ? true : nil}
+      _and = lambda{|a,b| (not_null(a) and not_null(b)) ? b : nil}
+      _or = lambda{|a,b| 
+          if not_null(a)
+            a
+          else
+            b
+          end 
+      }
 
 
       as_function = lambda{|object|
@@ -234,6 +260,12 @@ class Symbol
   end
 end
 
+class TrueClass
+  def lisp_inspect
+    "T"
+  end
+end
+
 class Array
   def lisp_inspect
     "(" + map(&:lisp_inspect).join(" ") + ")"  

data/lib/dslisprb.rb~

@@ -1,6 +1,11 @@
 class DsLisp
   class ToRuby
     class << self
+
+      def convert_name(name)
+        {:lt => "<", :ht => :>, :plus => :+, :mult => "*", :divide => "/", :minus => "-" }[name] || name[1..-1]
+      end
+
       def name_convert(name)
         {:< => "lt", :> => "ht", :+ => "plus", :* => "mult" , :/ => "divide", :- => "minus" }[name] || "_" + name.to_s
       end
@@ -15,24 +20,19 @@ class DsLisp
             CommonLispOperators.send(function_name, code)
           else      
             strargs = code[1..-1].map{|x| 
-              if Symbol === x
-                "(local_variables.include?(:#{x}) ? #{x} : (#{to_ruby(x)}))"
-              else
-                "(#{to_ruby(x)})"
-              end
+              "(#{to_ruby(x)})"
             }.join(",")
 
-            if Symbol === function_name
-              "#{name_convert(function_name)}.call(#{strargs})"
-            else
-              "#{to_ruby(code.first)}.call(#{strargs})"
-            end
+            "#{to_ruby(code.first)}.call(#{strargs})"
           end    
         else
           if code == :nil
-            nil
+            "nil"
           elsif code == :T
-            true
+            "true"
+          elsif Symbol === code
+#            "(local_variables.include?(#{name_convert(code)}) ? #{name_convert(code)} : nil)"
+            name_convert(code).to_s 
           else
             code.inspect
           end  
@@ -50,13 +50,12 @@ class DsLisp
       def cond(code)
         "(nil.tap { 
         " + code[1..-1].map{ |condition_code|
-          "(break (#{ToRuby.to_ruby condition_code[1]}) if (#{ToRuby.to_ruby condition_code[0]}))"
-        }.join(";")
-        + "})"
+          "(break (#{ToRuby.to_ruby condition_code[1]}) if (aux = (#{ToRuby.to_ruby condition_code[0]}); aux != [] and aux != nil) )"
+        }.join(";") + "})"
       end
 
       def if(code)
-        "(if (#{ToRuby.to_ruby code[1]})
+        "(if (aux = (#{ToRuby.to_ruby code[1]}); aux != [] and aux != nil)
             #{ToRuby.to_ruby code[2]}
           else
             #{ToRuby.to_ruby code[3]}
@@ -66,8 +65,17 @@ class DsLisp
       end
 
       def lambda(code)
-        arguments = code[1].map(&:to_s).join(",")
-        "lambda{|#{arguments}| #{ToRuby.to_ruby(code[2])}}.lisp_inner_code(#{code.lisp_inspect.inspect})"
+        arguments = code[1].map(&ToRuby.method(:name_convert)).map(&:to_s)
+        "(#{arguments.join(",")} = #{code[1].map{"nil"}.join(",")} ;lambda{|*x|
+            oldargs = [ #{arguments.join(",")} ] # save current bindings
+            #{(0..arguments.size-1).map{|i| "#{arguments[i]} = x[#{i}]" }.join(";")} 
+            begin
+              aux = #{ToRuby.to_ruby(code[2])}
+            ensure
+              #{arguments.join(",")} = oldargs # restore bindings
+            end
+            aux
+          }.lisp_inner_code(#{code.lisp_inspect.inspect}))"
       end
 
       def block(code)
@@ -157,8 +165,19 @@ class DsLisp
     eval(ruby_code, main_binding)
   end
 
+  def variables
+    eval("local_variables", main_binding).map(&ToRuby.method(:convert_name))
+  end
+
 private
-  
+  def null(element)
+    element == nil or element == []
+  end
+
+  def not_null(element)
+    element != nil and element != []
+  end
+
   def main_binding
     unless @binding
       @binding = binding
@@ -185,7 +204,7 @@ private
       _list = lambda{|*args| args}
 
       # recognizers
-      _null = lambda{|element| (element == nil or element == []) || nil}
+      _null = lambda{|element| null(element) ? true : nil}
       _atom = lambda{|element| (not Array === element) || nil}
       _numberp = lambda{|element| Numeric === element || nil}
       _symbolp = lambda{|element| Symbol === element || nil}
@@ -196,9 +215,15 @@ private
       _nil = lambda{nil}
 
       # boolean
-      _not = lambda{|a| (not a) || nil}
-      _and = lambda{|a,b| (a and b) || nil}
-      _or = lambda{|a,b| (a or b) || nil}
+      _not = lambda{|a| null(a) ? true : nil}
+      _and = lambda{|a,b| (not_null(a) and not_null(b)) ? b : nil}
+      _or = lambda{|a,b| 
+          if not_null(a)
+            a
+          else
+            b
+          end 
+      }
 
 
       as_function = lambda{|object|

data/spec/ast.rb

@@ -50,6 +50,14 @@ describe DsLisp, "ds lisp"  do
 
   it "should parse quote with lists" do
     DsLisp.new.parse("'(1 2 3)").should be == [:quote, [1,2,3]]
-  end 
+  end
+
+  it "should parse nil" do
+    DsLisp.new.parse("nil").should be == :nil
+  end
+
+  it "should parse quoted empty list" do
+    DsLisp.new.parse("'()").should be == [:quote, []]
+  end
 end
 

data/spec/ast.rb~

@@ -49,7 +49,15 @@ describe DsLisp, "ds lisp"  do
   end 
 
   it "should parse quote with lists" do
-    DsLisp.new.parse("'(1,2,3)").should be == [:quote, [1,2,3]]
-  end 
+    DsLisp.new.parse("'(1 2 3)").should be == [:quote, [1,2,3]]
+  end
+
+  it "should parse nil" do
+    DsLisp.new.parse("nil").should be == :nil
+  end
+
+  it "should parse quoted empty list" do
+    DsLisp.new.parse("'[]").should be == [:quote, []]
+  end
 end
 

data/spec/execution.rb

@@ -8,9 +8,9 @@ describe DsLisp, "ds lisp execution"  do
     end 
   end
 
-  [:x,:y,:z].each do |symbol|
+  [:x,:y,:z].map{|x| [:quote,x]}.each do |symbol|
     it "should parse simple symbolic atom #{symbol}" do
-      DsLisp.new.evaluate(symbol).should be == symbol
+      DsLisp.new.evaluate(symbol).should be == symbol.last
     end 
   end
 
@@ -26,6 +26,18 @@ describe DsLisp, "ds lisp execution"  do
     dslisp = DsLisp.new
     dslisp.evaluate("(defun foo (x) (+ x 1))")
     dslisp.evaluate("(foo 3)").should be == 4
+  end
+
+  it "should return false for empty list" do
+    DsLisp.new.evaluate("(and '() 2)").should be == nil
   end 
+
+  it "should evaluate empty list as false on if" do
+    DsLisp.new.evaluate("(if '() (+ 1 1) (+ 2 2))").should be == 4
+  end
+
+  it "should evaluate empty list as false on cond" do
+    DsLisp.new.evaluate("(cond ('() (+ 2 3)) ((> 2 1) (+ 1 2)))").should be == 3
+  end
 end
 

data/spec/execution.rb~

@@ -8,7 +8,7 @@ describe DsLisp, "ds lisp execution"  do
     end 
   end
 
-  [:x,:y,:z].each do |symbol|
+  [:x,:y,:z].map{|x| [:quote,x]}.each do |symbol|
     it "should parse simple symbolic atom #{symbol}" do
       DsLisp.new.evaluate(symbol).should be == symbol
     end 
@@ -23,7 +23,21 @@ describe DsLisp, "ds lisp execution"  do
   end
 
   it "should preserve variables through multiple function calls" do
-    DsLisp.new.evaluate([:quote, [1, 2, 3]]).should be == [1, 2, 3]
+    dslisp = DsLisp.new
+    dslisp.evaluate("(defun foo (x) (+ x 1))")
+    dslisp.evaluate("(foo 3)").should be == 4
+  end
+
+  it "should return false for empty list" do
+    DsLisp.new.evaluate("(and '() 2)").should be == nil
   end 
+
+  it "should evaluate empty list as false on if" do
+    DsLisp.new.evaluate("(if '() (+ 1 1) (+ 2 2))").should be == 4
+  end
+
+  it "should evaluate empty list as false on cond" do
+    DsLisp.new.evaluate("(cond ('() (+ 2 3)) ((> 2 1) (+ 1 2)))").should be == 3
+  end
 end
 

data/spec/functions.rb

@@ -69,10 +69,6 @@ describe DsLisp, "ds lisp functions"  do
     end
   end
 
-  it "should return nil on nil function" do
-    DsLisp.new.evaluate([:nil]).should be == nil
-  end
-
   # arithmetic
   it "should call +" do
     DsLisp.new.evaluate([:+,1,2]).should be == 3
@@ -140,6 +136,14 @@ describe DsLisp, "ds lisp functions"  do
     dslisp.evaluate("(defun foo (x) (+ x 1))")
     dslisp.evaluate("(mapcar foo '(1 2 3 4))").should be == [2, 3, 4, 5]
   end
+
+  it "should interpret nil symbol as nil" do
+    DsLisp.new.evaluate(:nil).should be == nil
+  end
+
+  it "should interpret T symbol as true" do
+    DsLisp.new.evaluate(:T).should be == true
+  end
 end
 
 

data/spec/functions.rb~

@@ -69,10 +69,6 @@ describe DsLisp, "ds lisp functions"  do
     end
   end
 
-  it "should return nil on nil function" do
-    DsLisp.new.evaluate([:nil]).should be == nil
-  end
-
   # arithmetic
   it "should call +" do
     DsLisp.new.evaluate([:+,1,2]).should be == 3
@@ -134,6 +130,20 @@ describe DsLisp, "ds lisp functions"  do
   it "should execute mapcar" do
     DsLisp.new.evaluate("(mapcar (lambda (x) (+ x 1)) '(1 2 3 4))").should be == [2, 3, 4, 5]
   end
+
+  it "should execute mapcar with defined function" do
+    dslisp = DsLisp.new
+    dslisp.evaluate("(defun foo (x) (+ x 1))")
+    dslisp.evaluate("(mapcar foo '(1 2 3 4))").should be == [2, 3, 4, 5]
+  end
+
+  it "should interpret nil symbol as nil" do
+    DsLisp.new.evaluate(:nil).should be == nil
+  end
+
+  it "should interpret T symbol as true" do
+    DsLisp.new.evaluate(:T).should be == nil
+  end
 end
 
 

data/spec/stack.rb

@@ -0,0 +1,14 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp stack"  do
+  it "should change variable value on lambda call" do
+
+    dslisp = DsLisp.new
+
+    dslisp.evaluate("(set x 100)")
+    dslisp.evaluate("(set foo1 (lambda (z) (+ x z)))")
+    dslisp.evaluate("(set foo2 (lambda (x) (foo1 4)))")
+    dslisp.evaluate("(foo2 3)").should be == 7
+  end
+end
+

data/spec/stack.rb~

@@ -0,0 +1,14 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp stack"  do
+  it "should change variable value on lambda call" do
+
+    dslisp = DsLisp.new
+
+    dslisp.evaluate("(set x 100)")
+    dslisp.evaluate("(set foo1 (lambda (z) (+ x z)))")
+    dslisp.evaluate("(set foo2 (lambda (x) (foo1 4)))")
+    dslisp.evluaate("(foo2 3)").should be == 7
+  end
+end
+

data/spec/variable.rb

@@ -0,0 +1,8 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp variables"  do
+  it "should evaluate variables on if" do
+    DsLisp.new.evaluate("((lambda (x) (if (> x 2) x 2)) 3)").should be == 3
+  end
+end
+

data/spec/variable.rb~

@@ -0,0 +1,8 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp execution"  do
+  it "should evaluate variables on if" do
+    DsLisp.new.evaluate("((lambda (x) (if (> x 2) x 2)) 3)").should be == 3
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dslisprb
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-27 00:00:00.000000000Z
+date: 2012-05-30 00:00:00.000000000Z
 dependencies: []
 description: 
 email: robertodarioseminara@gmail.com
@@ -26,10 +26,14 @@ files:
 - spec/ast.rb
 - spec/defun.rb~
 - spec/execution.rb~
+- spec/variable.rb~
+- spec/variable.rb
+- spec/stack.rb
 - spec/execution.rb
 - spec/defun.rb
 - spec/functions.rb~
 - spec/macro.rb~
+- spec/stack.rb~
 - spec/functions.rb
 - spec/ast.rb~
 - README.rdoc