dslisprb 0.0.1

data/README.rdoc

@@ -0,0 +1,63 @@
+dslisprb (dseminara 'lisp) 
+http://github.com/tario/dslisprb
+Dario Seminara (http://tario-project.blogspot.com.ar/)
+
+== DESCRIPTION:
+
+dseminara 'lisp is my own implementation of lisp on ruby, created as an excercise in preparation for finals
+
+dslisprb try to be minimalist (only 200 lines of ruby code including parser, default 
+functions and macros and about 30 lines for the repl) by using ruby code generation where possible
+
+For example, lisp lambdas are represented as ruby lambdas defined with the code translated from lisp to ruby
+and lisp variables (including those where default functions/lambda are stored) are translated as ruby variables
+allowing reuse of the ruby stack instead of reimplement it 
+
+== FEATURES:
+  
+* dslisprb executable with readline
+* Basic common lisp functions
+
+== TODO:
+
+* MAPCAR
+* Defined functions and variable persistent between multiple evaluate calls
+* caaaar, cdadar, cddra, etc...
+
+== SYNOPSIS:
+
+See 'dslisprb --help' for usage information.
+
+== REQUIREMENTS:
+
+* Ruby
+
+== INSTALL:
+
+* gem install dslisprb
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 Dario Seminara
+
+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/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rake/gempackagetask'
+require "rspec/core/rake_task"
+
+spec = Gem::Specification.new do |s|
+  s.name = 'dslisprb'
+  s.version = '0.0.1'
+  s.author = 'Dario Seminara'
+  s.email = 'robertodarioseminara@gmail.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Lisp interpreter written in ruby, using code generation'
+  s.homepage = "http://github.com/tario/dslisprb"
+  s.has_rdoc = true
+  s.executables = ["dslisprb"]
+  s.files = Dir.glob("{lib,spec}/**/*") + [ 'README.rdoc', 'Rakefile', 'TODO', 'CHANGELOG' ]
+end
+
+desc 'Run tests'
+
+RSpec::Core::RakeTask.new("test:units") do |t|
+  t.pattern= 'spec/**/*.rb'
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new :rdoc do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.add 'lib', 'README.rdoc'
+  rd.main = 'README.rdoc'
+end
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_rdoc, :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]
+

data/TODO

@@ -0,0 +1,3 @@
+* MAPCAR
+* Defined functions and variable persistent between multiple evaluate calls
+* caaaar, cdadar, cddra, etc...

data/bin/dslisprb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require "dslisprb"
+
+dslisp = DsLisp.new
+if ARGV[0]
+  if ARGV[0] == '--help'
+    print "
+  dslisprb --help
+    show this message
+  dslisprb <lisp expression>
+    evaluate lisp expression, shows the result on standard output and exit
+
+    Example:
+      dslisprb \"(car '(1 2 3))\"
+      (2 3)
+
+  dslisprb without arguments starts the repl
+"
+
+  else
+    # execute and exit
+    print dslisp.evaluate(ARGV[0]).lisp_inspect,"\n"
+  end
+else
+  # repl
+  require 'readline'
+  print "enter lisp commands or quit to exit\n"
+
+  stty_save = `stty -g`.chomp
+  trap('INT') { system('stty', stty_save); exit }
+
+  while cmd = Readline.readline('> ', true)
+    if cmd == "quit"
+      exit
+    end
+
+    begin
+      print dslisp.evaluate(cmd).lisp_inspect,"\n"
+    rescue Exception => e
+      p e
+      print e.backtrace.join("\n"),"\n"
+    end
+  end
+end

data/lib/dslisprb.rb

@@ -0,0 +1,201 @@
+class DsLisp
+  class ToRuby
+    class << self
+      def name_convert(name)
+        {:< => "lt", :> => "ht", :+ => "plus", :* => "mult" , :/ => "divide", :- => "minus" }[name] || "_" + name.to_s
+      end
+
+      def to_ruby(code)
+        if Array === code
+          # lisp call
+
+          function_name = code.first
+
+          if (CommonLispOperators.methods - Class.methods).include?(function_name)
+            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
+            }.join(",")
+
+            if Symbol === function_name
+              "#{name_convert(function_name)}.call(#{strargs})"
+            else
+              "#{to_ruby(code.first)}.call(#{strargs})"
+            end
+          end    
+        else
+          code.inspect  
+        end
+      end    
+    end
+  end
+
+  module CommonLispOperators
+    class << self
+      def quote(code)
+        code[1].inspect
+      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})"
+      end
+
+      def block(code)
+        code[1..-1].map(&ToRuby.method(:to_ruby)).join(";")
+      end
+
+      def set(code)
+        "#{ToRuby.name_convert(code[1])} = #{ToRuby.to_ruby(code[2])}"
+      end
+
+      def defun(code)
+        newcode = [:set, code[1], [:lambda, code[2], code[3]]] 
+        ToRuby.to_ruby(newcode)
+      end
+
+      def defmacro(code)
+        name = code[1]
+        arguments = code[2]
+        impl = code[3][1]
+
+        subsl = Kernel.lambda{|_code, rplmap|
+          _code.map{|subcode|
+            if Array === subcode
+              subsl.call(subcode, rplmap)
+            else
+              rplmap[subcode] || subcode
+            end
+          }
+        }
+
+        CommonLispOperators.define_singleton_method(name) do |_code|
+          rplmap = {}          
+          (0..arguments.size-1).each do |i|
+            rplmap[arguments[i]] = _code[i+1]
+          end
+
+          ToRuby.to_ruby subsl.call(impl, rplmap)
+        end
+
+        ""
+      end
+    end
+  end
+
+  def parse(str)
+    if str.count("(") != str.count(")")
+      raise "Parentheshis count does not match, try adding parenthesis at the end of string :P"
+    end
+
+    if matchdata = /^\s*\'(.*)\s*$/.match(str)
+      [:quote, parse(matchdata[1].sub("'",""))]
+    elsif matchdata = /^\s*\((.*)\)\s*$/.match(str)
+      inside_code = matchdata[1]
+      if inside_code =~ /^\s*$/
+        []
+      else
+        # split tokens preserving parenthesis count
+        tokens = []
+        newtoken = ""
+        inside_code.split.each do |str|
+          newtoken << " "
+          newtoken << str
+          if newtoken.count("(") == newtoken.count(")")
+            tokens << newtoken
+            newtoken = ""          
+          end
+        end
+
+        tokens.map(&method(:parse))
+      end
+    else
+      if str =~ /^\s*\d+\s*$/
+        str.to_i
+      else
+        str.strip.to_sym
+      end
+    end
+  end
+
+  def evaluate(code)
+    if String === code
+      return evaluate(parse code)
+    end
+    # arithmethic
+    plus = lambda{|x,y| x+y}
+    mult = lambda{|x,y| x*y}
+    divide = lambda{|x,y| x/y}
+    minus = lambda{|x,y| x-y}
+
+    lt = lambda{|x,y| x<y || nil}
+    ht = lambda{|x,y| x>y || nil}
+    _eq = lambda{|x,y| x==y || nil}
+
+      
+    # list selectors
+    _car = lambda{|x| x.first}
+    _cdr = lambda{|x| x[1..-1]}
+    _nth = lambda{|index,list| list[index-1]}
+
+    # list constructors
+    _cons = lambda{|element, list| [element]+list}
+    _append = plus
+    _list = lambda{|*args| args}
+
+    # recognizers
+    _null = lambda{|element| (element == nil or element == []) || nil}
+    _atom = lambda{|element| (not Array === element) || nil}
+    _numberp = lambda{|element| Numeric === element || nil}
+    _symbolp = lambda{|element| Symbol === element || nil}
+    _listp = lambda{|element| Array === element || nil}
+    _length = lambda{|list| list.size}
+
+    # nil
+    _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}
+
+    # generate ruby code for lisp ast
+    ruby_code = ToRuby.to_ruby(code)
+    eval(ruby_code)
+  end
+end
+
+class Object
+  def lisp_inspect
+    inspect
+  end
+end
+
+class Symbol
+  def lisp_inspect
+    to_s
+  end
+end
+
+class Array
+  def lisp_inspect
+    "(" + map(&:lisp_inspect).join(" ") + ")"  
+  end
+end
+
+class Proc
+  def lisp_inspect
+    @inner_code
+  end
+
+  def lisp_inner_code(code)
+    @inner_code = code
+    self
+  end
+end
+

data/lib/dslisprb.rb~

@@ -0,0 +1,201 @@
+class DsLisp
+  class ToRuby
+    class << self
+      def name_convert(name)
+        {:< => "lt", :> => "ht", :+ => "plus", :* => "mult" , :/ => "divide", :- => "minus" }[name] || "_" + name.to_s
+      end
+
+      def to_ruby(code)
+        if Array === code
+          # lisp call
+
+          function_name = code.first
+
+          if (CommonLispOperators.methods - Class.methods).include?(function_name)
+            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
+            }.join(",")
+
+            if Symbol === function_name
+              "#{name_convert(function_name)}.call(#{strargs})"
+            else
+              "#{to_ruby(code.first)}.call(#{strargs})"
+            end
+          end    
+        else
+          code.inspect  
+        end
+      end    
+    end
+  end
+
+  module CommonLispOperators
+    class << self
+      def quote(code)
+        code[1].inspect
+      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})"
+      end
+
+      def block(code)
+        code[1..-1].map(&ToRuby.method(:to_ruby)).join(";")
+      end
+
+      def set(code)
+        "#{ToRuby.name_convert(code[1])} = #{ToRuby.to_ruby(code[2])}"
+      end
+
+      def defun(code)
+        newcode = [:set, code[1], [:lambda, code[2], code[3]]] 
+        ToRuby.to_ruby(newcode)
+      end
+
+      def defmacro(code)
+        name = code[1]
+        arguments = code[2]
+        impl = code[3][1]
+
+        subsl = Kernel.lambda{|_code, rplmap|
+          _code.map{|subcode|
+            if Array === subcode
+              subsl.call(subcode, rplmap)
+            else
+              rplmap[subcode] || subcode
+            end
+          }
+        }
+
+        CommonLispOperators.define_singleton_method(name) do |_code|
+          rplmap = {}          
+          (0..arguments.size-1).each do |i|
+            rplmap[arguments[i]] = _code[i+1]
+          end
+
+          ToRuby.to_ruby subsl.call(impl, rplmap)
+        end
+
+        ""
+      end
+    end
+  end
+
+  def parse(str)
+    if str.count("(") != str.count(")")
+      raise "Parentheshis count does not match, try adding parenthesis to the end :P"
+    end
+
+    if matchdata = /^\s*\'(.*)\s*$/.match(str)
+      [:quote, parse(matchdata[1].sub("'",""))]
+    elsif matchdata = /^\s*\((.*)\)\s*$/.match(str)
+      inside_code = matchdata[1]
+      if inside_code =~ /^\s*$/
+        []
+      else
+        # split tokens preserving parenthesis count
+        tokens = []
+        newtoken = ""
+        inside_code.split.each do |str|
+          newtoken << " "
+          newtoken << str
+          if newtoken.count("(") == newtoken.count(")")
+            tokens << newtoken
+            newtoken = ""          
+          end
+        end
+
+        tokens.map(&method(:parse))
+      end
+    else
+      if str =~ /^\s*\d+\s*$/
+        str.to_i
+      else
+        str.strip.to_sym
+      end
+    end
+  end
+
+  def evaluate(code)
+    if String === code
+      return evaluate(parse code)
+    end
+    # arithmethic
+    plus = lambda{|x,y| x+y}
+    mult = lambda{|x,y| x*y}
+    divide = lambda{|x,y| x/y}
+    minus = lambda{|x,y| x-y}
+
+    lt = lambda{|x,y| x<y || nil}
+    ht = lambda{|x,y| x>y || nil}
+    _eq = lambda{|x,y| x==y || nil}
+
+      
+    # list selectors
+    _car = lambda{|x| x.first}
+    _cdr = lambda{|x| x[1..-1]}
+    _nth = lambda{|index,list| list[index-1]}
+
+    # list constructors
+    _cons = lambda{|element, list| [element]+list}
+    _append = plus
+    _list = lambda{|*args| args}
+
+    # recognizers
+    _null = lambda{|element| (element == nil or element == []) || nil}
+    _atom = lambda{|element| (not Array === element) || nil}
+    _numberp = lambda{|element| Numeric === element || nil}
+    _symbolp = lambda{|element| Symbol === element || nil}
+    _listp = lambda{|element| Array === element || nil}
+    _length = lambda{|list| list.size}
+
+    # nil
+    _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}
+
+    # generate ruby code for lisp ast
+    ruby_code = ToRuby.to_ruby(code)
+    eval(ruby_code)
+  end
+end
+
+class Object
+  def lisp_inspect
+    inspect
+  end
+end
+
+class Symbol
+  def lisp_inspect
+    to_s
+  end
+end
+
+class Array
+  def lisp_inspect
+    "(" + map(&:lisp_inspect).join(" ") + ")"  
+  end
+end
+
+class Proc
+  def lisp_inspect
+    @inner_code
+  end
+
+  def lisp_inner_code(code)
+    @inner_code = code
+    self
+  end
+end
+

data/spec/ast.rb

@@ -0,0 +1,55 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp"  do
+
+  (1..10).each do |i|
+    it "should parse simple numeric atom #{i}" do
+      DsLisp.new.parse(i.to_s).should be == i
+    end 
+  end
+
+  (1..10).each do |i|
+    it "should parse simple numeric atom #{i} with spaces around" do
+      DsLisp.new.parse("  " + i.to_s + "   ").should be == i
+    end 
+  end
+
+  [:x,:y,:z].each do |symbol|
+    it "should parse simple symbolic atom #{symbol}" do
+      DsLisp.new.parse(symbol.to_s).should be == symbol
+    end 
+  end
+
+  it "should parse empty list" do
+    DsLisp.new.parse('()').should be == []
+  end
+
+  it "should parse list with atom inside" do
+    DsLisp.new.parse('(1)').should be == [1]
+  end 
+
+  it "should parse list with two atoms inside" do
+    DsLisp.new.parse('(1 2)').should be == [1, 2]
+  end 
+
+  it "should parse list with a list with two atoms inside" do
+    DsLisp.new.parse('((1 2))').should be == [[1, 2]]
+  end 
+
+  it "should parse list with two list with two atoms inside" do
+    DsLisp.new.parse('((1 2) (3 4))').should be == [[1, 2],[3, 4]]
+  end 
+
+  it "should parse list with two list with two symbolic atoms inside" do
+    DsLisp.new.parse('((a b) (c d))').should be == [[:a, :b],[:c, :d]]
+  end
+
+  it "should parse quote with atoms" do
+    DsLisp.new.parse("'car").should be == [:quote, :car]
+  end 
+
+  it "should parse quote with lists" do
+    DsLisp.new.parse("'(1 2 3)").should be == [:quote, [1,2,3]]
+  end 
+end
+

data/spec/ast.rb~

@@ -0,0 +1,55 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp"  do
+
+  (1..10).each do |i|
+    it "should parse simple numeric atom #{i}" do
+      DsLisp.new.parse(i.to_s).should be == i
+    end 
+  end
+
+  (1..10).each do |i|
+    it "should parse simple numeric atom #{i} with spaces around" do
+      DsLisp.new.parse("  " + i.to_s + "   ").should be == i
+    end 
+  end
+
+  [:x,:y,:z].each do |symbol|
+    it "should parse simple symbolic atom #{symbol}" do
+      DsLisp.new.parse(symbol.to_s).should be == symbol
+    end 
+  end
+
+  it "should parse empty list" do
+    DsLisp.new.parse('()').should be == []
+  end
+
+  it "should parse list with atom inside" do
+    DsLisp.new.parse('(1)').should be == [1]
+  end 
+
+  it "should parse list with two atoms inside" do
+    DsLisp.new.parse('(1 2)').should be == [1, 2]
+  end 
+
+  it "should parse list with a list with two atoms inside" do
+    DsLisp.new.parse('((1 2))').should be == [[1, 2]]
+  end 
+
+  it "should parse list with two list with two atoms inside" do
+    DsLisp.new.parse('((1 2) (3 4))').should be == [[1, 2],[3, 4]]
+  end 
+
+  it "should parse list with two list with two symbolic atoms inside" do
+    DsLisp.new.parse('((a b) (c d))').should be == [[:a, :b],[:c, :d]]
+  end
+
+  it "should parse quote with atoms" do
+    DsLisp.new.parse("'car").should be == [:quote, :car]
+  end 
+
+  it "should parse quote with lists" do
+    DsLisp.new.parse("'(1,2,3)").should be == [:quote, [1,2,3]]
+  end 
+end
+

data/spec/defun.rb

@@ -0,0 +1,27 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp defun"  do
+  it "should allow lambda" do
+    DsLisp.new.evaluate([:lambda, [:x], [:+, :x, 1]]).call(1).should be == 2
+  end
+
+  it "should allow lambda assign and call" do
+    DsLisp.new.evaluate([:block, 
+            [:set, :lambda_test, [:lambda, [:x], [:+, :x, 1]]], 
+            [:lambda_test, 1]
+            ]).should be == 2
+  end
+
+  it "should allow lambda returning 3" do
+    DsLisp.new.evaluate([:lambda, [:x], [:+, :x, 2]]).call(1).should be == 3
+  end
+
+  it "should allow defun as brief for lambda assign" do
+    DsLisp.new.evaluate([:block,
+            [:defun, :lambda_test, [:x], [:+, :x, 1]], 
+            [:lambda_test, 1]
+            ]).should be == 2
+  end
+end
+
+

data/spec/defun.rb~

@@ -0,0 +1,27 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp defun"  do
+  it "should allow lambda" do
+    DsLisp.new.evaluate([:lambda, [:x], [:+, :x, 1]]).call(1).should be == 2
+  end
+
+  it "should allow lambda assign and call" do
+    DsLisp.new.evaluate([:block, 
+            [:set, :lambda_test, [:lambda, [:x], [:+, :x, 1]]], 
+            [:lambda_test, 1]
+            ]).should be == 2
+  end
+
+  it "should allow lambda returning 3" do
+    DsLisp.new.evaluate([:lambda, [:x], [:+, :x, 2]]).call(1).should be == 3
+  end
+
+  it "should allow defun as brief for lambda assign" do
+    DsLisp.new.evaluate([:block,
+            [:defun, :lambda_test, [:x], [:+, :x, 1]], 
+            [:lambda_test, 1]
+            ]).should be == 2
+  end
+end
+
+

data/spec/execution.rb

@@ -0,0 +1,25 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp execution"  do
+
+  (1..10).each do |i|
+    it "should evaluate simple numeric atom #{i}" do
+      DsLisp.new.evaluate(i).should be == i
+    end 
+  end
+
+  [:x,:y,:z].each do |symbol|
+    it "should parse simple symbolic atom #{symbol}" do
+      DsLisp.new.evaluate(symbol).should be == symbol
+    end 
+  end
+
+  it "should evaluate call to arithmetic method +" do
+    DsLisp.new.evaluate([:+, 1, 2]).should be == 3
+  end 
+
+  it "should evaluate quote call to define literals" do
+    DsLisp.new.evaluate([:quote, [1, 2, 3]]).should be == [1, 2, 3]
+  end 
+end
+

data/spec/execution.rb~

@@ -0,0 +1,25 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp execution"  do
+
+  (1..10).each do |i|
+    it "should evaluate simple numeric atom #{i}" do
+      DsLisp.new.evaluate(i).should be == i
+    end 
+  end
+
+  [:x,:y,:z].each do |symbol|
+    it "should parse simple symbolic atom #{symbol}" do
+      DsLisp.new.evaluate(symbol).should be == symbol
+    end 
+  end
+
+  it "should evaluate call to arithmetic method +" do
+    DsLisp.new.evaluate([:+, 1, 2]).should be == 3
+  end 
+
+  it "should evaluate quote call to define literals" do
+    DsLisp.new.evaluate([:quote, [1, 2, 3]).should be == [1, 2, 3]
+  end 
+end
+

data/spec/functions.rb

@@ -0,0 +1,132 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp functions"  do
+
+  # selectors
+  it "should return 1 for (car (quote (1 2)))" do
+    DsLisp.new.evaluate([:car, [:quote, [1, 2]]]).should be == 1
+  end
+
+  it "should return (2 3) for (cdr (quote (1 2 3)))" do
+    DsLisp.new.evaluate([:cdr, [:quote, [1, 2, 3]]]).should be == [2, 3]
+  end
+
+  it "should return 5 for (nth 2 (quote (4 5 6)))" do
+    DsLisp.new.evaluate([:nth, 2, [:quote, [4, 5, 6]]]).should be == 5
+  end
+
+  # constructors
+  it "should return (1 2 3 4) for (cons 1 (quote (2 3 4)))" do
+    DsLisp.new.evaluate([:cons, 1, [:quote, [2, 3, 4]]]).should be == [1,2,3,4]
+  end
+
+  it "should return (1 2 3 4 5) for (append (quote (1 2)) (quote (3 4 5)))" do
+    DsLisp.new.evaluate([:append, [:quote, [1,2]], [:quote, [3, 4, 5]]]).should be == [1,2,3,4,5]
+  end
+
+  it "should return (1 2) for (list 1 2)" do
+    DsLisp.new.evaluate([:list, 1, 2]).should be == [1,2]
+  end
+
+  it "should return (1 2 3) for (list 1 2 3)" do
+    DsLisp.new.evaluate([:list, 1, 2, 3]).should be == [1,2,3]
+  end
+
+  # type recognizers
+  [:a, 1, [1,2,3,4], [], nil].each do |obj|
+    result = (obj == nil or obj == []) ? true : nil
+    it "should return #{result} for (null #{obj})" do
+      DsLisp.new.evaluate([:null, [:quote, obj]]).should be == result
+    end
+  end
+
+  [:a, 1, [1,2,3,4]].each do |obj|
+    result = (not Array === obj) ? true : nil
+    it "should return #{result} for (atom #{obj})" do
+      DsLisp.new.evaluate([:atom, [:quote, obj]]).should be == result
+    end
+
+    numberp_result = (Numeric === obj) ? true : nil
+    it "should return #{result} for (numberp #{obj})" do
+      DsLisp.new.evaluate([:numberp, [:quote, obj]]).should be == numberp_result
+    end
+
+    symbolp_result = (Symbol === obj) ? true : nil
+    it "should return #{result} for (symbolp #{obj})" do
+      DsLisp.new.evaluate([:symbolp, [:quote, obj]]).should be == symbolp_result
+    end
+
+    listp_result = (Array === obj) ? true : nil
+    it "should return #{result} for (listp #{obj})" do
+      DsLisp.new.evaluate([:listp, [:quote, obj]]).should be == listp_result
+    end
+  end
+
+  [[1], [1,2], [1,2,3], [1,2,3,4]].each do |obj|
+    result = obj.size
+    it "should return #{result} for (length #{obj})" do
+      DsLisp.new.evaluate([:length, [:quote, obj]]).should be == result
+    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
+  end
+
+  it "should call -" do
+    DsLisp.new.evaluate([:-,7,4]).should be == 3
+  end
+
+  it "should call *" do
+    DsLisp.new.evaluate([:*,5,6]).should be == 30
+  end
+
+  it "should call /" do
+    DsLisp.new.evaluate([:/,10,2]).should be == 5
+  end
+
+  # relational
+  [[3,2],[3,3],[3,4]].each do |pair|
+    result = pair.first < pair.last || nil
+    it "should call <" do
+      DsLisp.new.evaluate([:<,pair.first,pair.last]).should be == result
+    end
+
+    resultht = pair.first > pair.last || nil
+    it "should call >" do
+      DsLisp.new.evaluate([:>,pair.first,pair.last]).should be == resultht
+    end
+
+    resulteq = pair.first == pair.last || nil
+    it "should call eq" do
+      DsLisp.new.evaluate([:eq,pair.first,pair.last]).should be == resulteq
+    end
+  end
+
+  # boolean
+  [[true,true],[true,nil],[nil,true],[nil,nil]].each do |pair|
+    resultor = (pair.first or pair.last) || nil
+    resultand = (pair.first and pair.last) || nil
+    resultnot = (not pair.first) || nil
+
+    it "should call or with #{pair} and return #{resultor}" do
+      DsLisp.new.evaluate([:or,pair.first,pair.last]).should be == resultor
+    end
+
+    it "should call and with #{pair} and return #{resultand}" do
+      DsLisp.new.evaluate([:and,pair.first,pair.last]).should be == resultand
+    end
+
+    it "should call not" do
+      DsLisp.new.evaluate([:not,pair.first]).should be == resultnot
+    end
+  end
+
+end
+
+

data/spec/functions.rb~

@@ -0,0 +1,132 @@
+require "dslisprb"
+
+describe DsLisp::CommonLispFunctions, "ds lisp functions"  do
+
+  # selectors
+  it "should return 1 for (car (quote (1 2)))" do
+    DsLisp.new.evaluate([:car, [:quote, [1, 2]]]).should be == 1
+  end
+
+  it "should return (2 3) for (cdr (quote (1 2 3)))" do
+    DsLisp.new.evaluate([:cdr, [:quote, [1, 2, 3]]]).should be == [2, 3]
+  end
+
+  it "should return 5 for (nth 2 (quote (4 5 6)))" do
+    DsLisp.new.evaluate([:nth, 2, [:quote, [4, 5, 6]]]).should be == 5
+  end
+
+  # constructors
+  it "should return (1 2 3 4) for (cons 1 (quote (2 3 4)))" do
+    DsLisp.new.evaluate([:cons, 1, [:quote, [2, 3, 4]]]).should be == [1,2,3,4]
+  end
+
+  it "should return (1 2 3 4 5) for (append (quote (1 2)) (quote (3 4 5)))" do
+    DsLisp.new.evaluate([:append, [:quote, [1,2]], [:quote, [3, 4, 5]]]).should be == [1,2,3,4,5]
+  end
+
+  it "should return (1 2) for (list 1 2)" do
+    DsLisp.new.evaluate([:list, 1, 2]).should be == [1,2]
+  end
+
+  it "should return (1 2 3) for (list 1 2 3)" do
+    DsLisp.new.evaluate([:list, 1, 2, 3]).should be == [1,2,3]
+  end
+
+  # type recognizers
+  [:a, 1, [1,2,3,4], [], nil].each do |obj|
+    result = (obj == nil or obj == []) ? true : nil
+    it "should return #{result} for (null #{obj})" do
+      DsLisp.new.evaluate([:null, [:quote, obj]]).should be == result
+    end
+  end
+
+  [:a, 1, [1,2,3,4]].each do |obj|
+    result = (not Array === obj) ? true : nil
+    it "should return #{result} for (atom #{obj})" do
+      DsLisp.new.evaluate([:atom, [:quote, obj]]).should be == result
+    end
+
+    numberp_result = (Numeric === obj) ? true : nil
+    it "should return #{result} for (numberp #{obj})" do
+      DsLisp.new.evaluate([:numberp, [:quote, obj]]).should be == numberp_result
+    end
+
+    symbolp_result = (Symbol === obj) ? true : nil
+    it "should return #{result} for (symbolp #{obj})" do
+      DsLisp.new.evaluate([:symbolp, [:quote, obj]]).should be == symbolp_result
+    end
+
+    listp_result = (Array === obj) ? true : nil
+    it "should return #{result} for (listp #{obj})" do
+      DsLisp.new.evaluate([:listp, [:quote, obj]]).should be == listp_result
+    end
+  end
+
+  [[1], [1,2], [1,2,3], [1,2,3,4]].each do |obj|
+    result = obj.size
+    it "should return #{result} for (length #{obj})" do
+      DsLisp.new.evaluate([:length, [:quote, obj]]).should be == result
+    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
+  end
+
+  it "should call -" do
+    DsLisp.new.evaluate([:-,7,4]).should be == 3
+  end
+
+  it "should call *" do
+    DsLisp.new.evaluate([:*,5,6]).should be == 30
+  end
+
+  it "should call /" do
+    DsLisp.new.evaluate([:/,10,2]).should be == 5
+  end
+
+  # relational
+  [[3,2],[3,3],[3,4]].each do |pair|
+    result = pair.first < pair.last || nil
+    it "should call <" do
+      DsLisp.new.evaluate([:<,pair.first,pair.last]).should be == result
+    end
+
+    resultht = pair.first > pair.last || nil
+    it "should call >" do
+      DsLisp.new.evaluate([:>,pair.first,pair.last]).should be == resultht
+    end
+
+    resulteq = pair.first == pair.last || nil
+    it "should call eq" do
+      DsLisp.new.evaluate([:eq,pair.first,pair.last]).should be == resulteq
+    end
+  end
+
+  # boolean
+  [[true,true],[true,nil],[nil,true],[nil,nil]].each do |pair|
+    resultor = (pair.first or pair.last) || nil
+    resultand = (pair.first and pair.last) || nil
+    resultnot = (not pair.first) || nil
+
+    it "should call or with #{pair} and return #{resultor}" do
+      DsLisp.new.evaluate([:or,pair.first,pair.last]).should be == resultor
+    end
+
+    it "should call and with #{pair} and return #{resultand}" do
+      DsLisp.new.evaluate([:and,pair.first,pair.last]).should be == resultand
+    end
+
+    it "should call not" do
+      DsLisp.new.evaluate([:not,pair.first]).should be == resultnot
+    end
+  end
+
+end
+
+

data/spec/macro.rb

@@ -0,0 +1,11 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp macro"  do
+  it "should allow defmacro and use on different call" do
+    dslisp = DsLisp.new
+    dslisp.evaluate([:defmacro, :square, [:x], [:quote, [:*, :x, :x]]])
+    dslisp.evaluate([:square, 5]).should be == 25
+  end
+end
+
+

data/spec/macro.rb~

@@ -0,0 +1,11 @@
+require "dslisprb"
+
+describe DsLisp, "ds lisp macro"  do
+  it "should allow defmacro and use on different call" do
+    dslisp = DsLisp.new
+    dslisp.evaluate([:defmacro, :square, [:z], [:quote, [:*, :x, :x]]])
+    dslisp.evaluate([:square, 5]).should be == 25
+  end
+end
+
+

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: dslisprb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dario Seminara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-25 00:00:00.000000000Z
+dependencies: []
+description: 
+email: robertodarioseminara@gmail.com
+executables:
+- dslisprb
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dslisprb.rb
+- lib/dslisprb.rb~
+- spec/macro.rb
+- spec/ast.rb
+- spec/defun.rb~
+- spec/execution.rb~
+- spec/execution.rb
+- spec/defun.rb
+- spec/functions.rb~
+- spec/macro.rb~
+- spec/functions.rb
+- spec/ast.rb~
+- README.rdoc
+- Rakefile
+- TODO
+- CHANGELOG
+- bin/dslisprb
+homepage: http://github.com/tario/dslisprb
+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.10
+signing_key: 
+specification_version: 3
+summary: Lisp interpreter written in ruby, using code generation
+test_files: []