rubylisp 0.2.1 → 1.0.2

data/lib/rubylisp/alist.rb

@@ -1,230 +0,0 @@
-module Lisp
-
-  class AList < Object
-    include Enumerable
-
-    def self.register
-      Primitive.register("acons")         {|args, env| Lisp::AList::acons_impl(args, env) }
-      Primitive.register("assoc")         {|args, env| Lisp::AList::assoc_impl(args, env) }
-      Primitive.register("rassoc")        {|args, env| Lisp::AList::rassoc_impl(args, env) }
-      Primitive.register("dissoc")        {|args, env| Lisp::AList::dissoc_impl(args, env) }
-      Primitive.register("zip")           {|args, env| Lisp::AList::zip_impl(args, env) }
-      Primitive.register("alist-to-list") {|args, env| Lisp::AList::alist_to_list_impl(args, env) }
-      Primitive.register("list-to-alist") {|args, env| Lisp::AList::list_to_alist_impl(args, env) }
-    end
-
-    def self.acons_impl(args, env)
-      return Lisp::Debug.process_error("acons require at least 2 or 3 arguments", env) unless args.length == 2 || args.length == 3
-      key = args.car.evaluate(env)
-      value = args.cadr.evaluate(env)
-      alist = args.length == 2 ? nil : args.caddr.evaluate(env)
-      alist = Lisp::AList.from_list(alist) if !alist.nil? && alist.list? && !alist.alist?
-      return Lisp::Debug.process_error("the last argument to acons has to be an association list", env) unless alist.nil? || alist.alist?
-
-      if alist.nil?
-        Lisp::AList.new({key => value})
-      else
-        alist.acons(key, value)
-      end
-    end
-
-    def self.assoc_impl(args, env)
-      return Lisp::Debug.process_error("assoc require 2 arguments", env) unless args.length == 2
-      key = args.car.evaluate(env)
-      alist = args.cadr.evaluate(env)
-      alist = Lisp::AList.from_list(alist) if alist.list? && !alist.alist?
-      return Lisp::Debug.process_error("the last argument to assoc has to be an association list", env) unless alist.alist?
-      alist.assoc(key)
-    end
-
-    def self.rassoc_impl(args, env)
-      return Lisp::Debug.process_error("assoc require 2 arguments", env) unless args.length == 2
-      value = args.car.evaluate(env)
-      alist = args.cadr.evaluate(env)
-      alist = Lisp::AList.from_list(alist) if alist.list? && !alist.alist?
-      return Lisp::Debug.process_error("the last argument to rassoc has to be an association list", env) unless alist.alist?
-      alist.rassoc(value)
-    end
-
-    def self.dissoc_impl(args, env)
-      return Lisp::Debug.process_error("assoc require 2 arguments", env) unless args.length == 2
-      key = args.car.evaluate(env)
-      alist = args.cadr.evaluate(env)
-      alist = Lisp::AList.from_list(alist) if alist.list? && !alist.alist?
-      return Lisp::Debug.process_error("the last argument to dissoc has to be an association list", env) unless alist.alist?
-      alist.dissoc(key)
-    end
-
-    def self.zip_impl(args, env)
-      return Lisp::Debug.process_error("assoc require 2 or 3arguments", env) unless args.length == 2 || args.length == 3
-      key_list = args.car.evaluate(env)
-      return Lisp::Debug.process_error("the keys supplied to zip has to be a list", env) unless key_list.list?
-      value_list = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("the values supplied to zip has to be a list", env) unless value_list.list?
-      return Lisp::Debug.process_error("zip requires the same number of keys and values", env) unless key_list.length == value_list.length
-
-      if args.length == 3
-        alist = args.caddr.evaluate(env)
-        alist = Lisp::AList.from_list(alist) if alist.list? && !alist.alist?
-        return Lisp::Debug.process_error("the third argument to zip has to be an association list", env) unless alist.alist?
-        alist.zip(key_list.to_a, value_list.to_a)
-      else
-        Lisp::AList.zip(key_list.to_a, value_list.to_a)
-      end
-    end
-
-    def self.alist_to_list_impl(args, env)
-      return Lisp::Debug.process_error("alist-to-list requires 1 arguments", env) unless args.length == 1
-      alist = args.car.evaluate(env)
-      return alist if alist.list? && !alist.alist?
-      return Lisp::Debug.process_error("the argument to alist-to-list has to be an association list", env) unless alist.alist?
-            
-      alist.to_list
-    end
-    
-    def self.list_to_alist_impl(args, env)
-      return Lisp::Debug.process_error("list-to-alist requires 1 arguments", env) unless args.length == 1
-      list = args.car.evaluate(env)
-      return Lisp::Debug.process_error("the argument to list-to-alist has to be a list", env) unless list.list?
-            
-      Lisp::AList.from_list(list)
-    end
-
-    
-    def initialize(h=nil)
-      @value = h || {}
-    end
-
-    def lisp_object?
-      true
-    end
-    
-    def eq?(sexpr)
-      return false unless sexpr.alist?
-      @value == sexpr.value
-    end
-    
-    def empty?
-      @value.empty?
-    end
-
-    def string?
-      false
-    end
-
-    def character?
-      false
-    end
-
-    def number?
-      false
-    end
-
-    def positive?
-      false
-    end
-
-    def zero?
-      false
-    end
-
-    def negative?
-      false
-    end
-
-    def symbol?
-      false
-    end
-
-    def primitive?
-      false
-    end
-
-    def function?
-      false
-    end
-
-    def macro?
-      false
-    end
-
-    def pair?
-      true
-    end
-
-    def list?
-      true
-    end
-
-    def alist?
-      true
-    end
-
-    def frame?
-      false
-    end
-    
-    def length
-      return @value.length
-    end
-
-    def car
-      @value.first
-    end
-
-    def cdr
-    end
-
-    def acons(k, v)
-      @value[k] = v
-      self
-    end
-
-    def assoc(k)
-      v = @value[k]
-      Lisp::ConsCell.cons(k, v)
-    end
-
-    def rassoc(value)
-      @value.each do |k, v|
-        return Lisp::ConsCell.cons(k, v) if value == v || value.eq?(v)
-      end
-    end
-
-    def dissoc(k)
-      @value.delete(k)
-      self
-    end
-
-    def zip(keys, values)
-      keys.zip(values).each {|k, v| @value[k] = v}
-      self
-    end
-    
-    def self.zip(keys, values)
-      self.new.zip(keys, values)
-    end
-
-    def self.from_list(list)
-      h = {}
-      list.each do |pair|
-        h[pair.car] = pair.cdr
-      end
-      self.new(h)
-    end
-
-    def to_list
-      Lisp::ConsCell.array_to_list(@value.map {|k, v| Lisp::ConsCell.cons(k, v)})
-    end
-
-    def to_s
-      to_list.to_s
-    end
-
-   def print_string
-      self.to_s
-    end
-
-  end
-
-end

data/lib/rubylisp/assignment.rb

@@ -1,65 +0,0 @@
-module Lisp
-
-  class Assignment
-
-    def self.register
-      Primitive.register("set!", "(set! _name_ _new-value_)\n\nThe way to assign (i.e. rebind) a symbol. `name` is the symbol to be rebound.
-The `new-value` sexpr is evaluated to arrive at the new value to be bound to. Use of `set!` is frowned upon, and should not be used without thought.") do |args, env|
-        Lisp::Assignment::setbang_impl(args, env)
-      end
-      
-      Primitive.register("set-car!", "(set-car! _cons-cell_ _new-value_)\n\nSet the `car` pointer of `cons-cell`.") do |args, env|
-        Lisp::Assignment::setcarbang_impl(args, env)
-      end
-      
-      Primitive.register("set-cdr!", "(set-cdr! _cons-cell_ _new-value_)\n\nSet the `cdr` pointer of `cons-cell`.") do |args, env|
-        Lisp::Assignment::setcdrbang_impl(args, env)
-      end
-      
-      Primitive.register("set-nth!", "(set-nth! _n_ _list-or-vector_ _new-value_)\n\nSets the `n`th element of `list-or-vector` to `new-value`.") do |args, env|
-        Lisp::Assignment::setnthbang_impl(args, env)
-      end
-      
-    end
-
-    
-    def self.setbang_impl(args, env)
-      sym = args.car
-      return Lisp::Debug.process_error("set! requires a raw (unevaluated) symbol as it's first argument.", env) unless sym.symbol?
-      value = args.cadr.evaluate(env)
-      env.set(sym, value)
-    end
-
-    
-    def self.setcarbang_impl(args, env)
-      pair = args.car.evaluate(env)
-      return Lisp::Debug.process_error("set-car! requires a pair as it's first argument.", env) unless pair.pair?
-      value = args.cadr.evaluate(env)
-      pair.set_car!(value)
-    end
-
-    
-    def self.setcdrbang_impl(args, env)
-      pair = args.car.evaluate(env)
-      return Lisp::Debug.process_error("set-cdr! requires a pair as it's first argument.", env) unless pair.pair?
-      value = args.cadr.evaluate(env)
-      pair.set_cdr!(value)
-    end
-
-
-    def self.setnthbang_impl(args, env)
-      return Lisp::Debug.process_error("set-nth! requires 3 arguments.", env) unless args.length == 3
-      n = args.car.evaluate(env)
-      return Lisp::Debug.process_error("The first argument of set-nth! has to be an number.", env) unless n.number?
-      return Lisp::Debug.process_error("The first argument of set-nth! has to be positive.", env) unless n.value > 0
-
-      l = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("set-nth! requires a list or vector as it's first argument.", env) unless l.list? || l.vector?
-      value = args.caddr.evaluate(env)
-      l.set_nth!(n.value, value)
-      l
-    end
-
-
-  end
-end

data/lib/rubylisp/equivalence.rb

@@ -1,118 +0,0 @@
-module Lisp
-
-  class Equivalence
-
-    def self.register
-      Primitive.register("=", "(= number number)\n\nReturns whether the first numeric argument is equal to the second numeric argument.") do |args, env|
-        Lisp::Equivalence::num_eq_impl(args, env)
-      end
-      
-      Primitive.register("==", "(== number number)\n\nReturns whether the first numeric argument is equal to the second numeric argument.") do |args, env|
-        Lisp::Equivalence::num_eq_impl(args, env)
-      end
-      
-      Primitive.register("!=", "(!= number number)\n\nReturns whether the first numeric argument is not equal to the second numeric argument.") do |args, env|
-        Lisp::Equivalence::num_neq_impl(args, env)
-      end
-      
-      Primitive.register("/=", "(/= number number)\n\nReturns whether the first numeric argument is not equal to the second numeric argument.") do |args, env|
-        Lisp::Equivalence::num_neq_impl(args, env)
-      end
-
-      Primitive.register("eq?", "(eq? sexpr sexpr)\n\nReturns whether the first argument is the same type as the second argument, and the same object, except in the case of numbers where the values are compared.") do |args, env|
-        Lisp::Equivalence::eq_impl(args, env)
-      end
-      
-      Primitive.register("eqv?", "(eqv? sexpr sexpr)\n\nReturns whether the first argument is the same type as the second argument, and the same object, except in the case of numbers where the values are compared.") do |args, env|
-        Lisp::Equivalence::eqv_impl(args, env)
-      end
-      
-      Primitive.register("equal?", "(equal? sexpr sexpr)\n\nReturns whether the first argument is the same type as the second argument, and are lists containing the same elements, are identical strings, are frames with matching slots, are numbers with the same value, or are the same object (if none of the above).") do |args, env|
-        Lisp::Equivalence::equal_impl(args, env)
-      end
-      
-    end
-
-    # == - Check two integers for equivalence
-    
-    def self.num_eq_impl(args, env)
-      raise "= and == need 2 arguments, received #{args.length}" if args.length != 2
-      c1 = args.car.evaluate(env)
-      c2 = args.cadr.evaluate(env)
-      return Lisp::FALSE unless c1.integer? && c2.integer?
-      Lisp::Boolean.with_value(c1.value == c2.value)
-    end
-
-    def self.num_neq_impl(args, env)
-      raise "!= and /= needs 2 arguments, received #{args.length}" if args.length != 2
-      c1 = args.car.evaluate(env)
-      c2 = args.cadr.evaluate(env)
-      return Lisp::TRUE unless c1.integer? && c2.integer?
-      Lisp::Boolean.with_value(c1.value != c2.value)
-    end
-
-
-    # eq? - identity, typically used for symbols
-    
-    def self.eq_check(o1, o2)
-      return Lisp::FALSE unless o1.type == o2.type
-      Lisp::Boolean.with_value(case o1.type
-                               when :number
-                                 (o1.integer? == o2.integer?) && (o1.value == o2.value)
-                               else
-                                 o1.equal?(o2)
-                               end)
-    end
-    
-
-    def self.eq_impl(args, env)
-      raise "eq? needs 2 arguments, received #{args.length}" if args.length != 2
-      o1 = args.car.evaluate(env)
-      o2 = args.cadr.evaluate(env)
-      eq_check(o1, o2)
-    end
-    
-
-    # eqv? - same as eq?
-
-    def self.eqv_check(o1, o2)
-      eq_check(o1, o2)
-    end
-    
-    
-    def self.eqv_impl(args, env)
-      raise "eq? needs 2 arguments, received #{args.length}" if args.length != 2
-      o1 = args.car.evaluate(env)
-      o2 = args.cadr.evaluate(env)
-      eqv_check(o1, o2)
-    end
-    
-
-    # equal? - object equality: same value
-
-    def self.equal_check(o1, o2)
-      return Lisp::FALSE unless o1.type == o2.type
-      Lisp::Boolean.with_value(case o1.type
-                               when :pair
-                                 o1.eq?(o2)
-                               when :string
-                                 o1.value.eql?(o2.value)
-                               when :frame
-                                 o1.eq?(o2)
-                               when :number
-                                 (o1.integer? == o2.integer?) && (o1.value == o2.value)
-                               else
-                                 o1.equal?(o2)
-                               end)
-    end
-
-    
-    def self.equal_impl(args, env)
-      raise "equal? needs 2 arguments, received #{args.length}" if args.length != 2
-      o1 = args.car.evaluate(env)
-      o2 = args.cadr.evaluate(env)
-      self.equal_check(o1, o2)
-    end
-  end
-
-end

data/lib/rubylisp/io.rb

@@ -1,74 +0,0 @@
-module Lisp
-
-  class IO
-
-    def self.register
-      Primitive.register("load")         {|args, env| Lisp::IO::load_impl(args, env) }
-      Primitive.register("load-library") {|args, env| Lisp::IO::load_library_impl(args, env) }
-      Primitive.register("load-project") {|args, env| Lisp::IO::load_project_impl(args, env) }
-      Primitive.register("trace")        {|args, env| puts "Trace: #{(args.to_a.map {|a| a.evaluate(env).value.to_s}).join(' ')}"; nil} 
-      Primitive.register("error")        {|args, env| App.alert((args.to_a.map {|a| a.evaluate(env).value.to_s}).join(' '))}
-      Primitive.register("alert")        {|args, env| App.alert((args.to_a.map {|a| a.evaluate(env).value.to_s}).join(' '))}
-   end
-
-
-    def self.load_impl(args, env)
-      return Lisp::Debug.process_error("'load' requires 1 argument.", env) if args.empty?
-      fname = args.car.evaluate(env)
-      return Lisp::Debug.process_error("'load' requires a string argument.", env) unless fname.string?
-      filename = fname.value.end_with?(".lsp") ? fname.value : "#{fname.value}.lsp"
-      File.open(filename) do |f|
-        contents = f.read()
-        Lisp::Parser.new.parse_and_eval_all(contents)
-      end
-      Lisp::String.with_value("OK")
-    end
-
-    
-    def self.load_library_impl(args, env)
-      return Lisp::Debug.process_error("'load-library' requires 1 argument.", env) if args.empty?
-      library_name = args.car.evaluate(env)
-      return Lisp::Debug.process_error("'load-library' requires a string or symbol argument.", env) unless library_name.string? || library_name.symbol?
-      Dir.chdir(File.join(App.documents_path, "libraries", "#{library_name}.lib")) do |d|
-        if File.exists?("load.lsp")
-          File.open("load.lsp") do |f|
-            contents = f.read()
-            Lisp::Parser.new.parse_and_eval_all(contents)
-          end
-        else
-          Dir.glob("*.lsp") do |filename|
-            File.open(filename) do |f|
-              contents = f.read()
-              Lisp::Parser.new.parse_and_eval_all(contents)
-            end
-          end
-        end
-      end
-      Lisp::String.with_value("OK")
-    end
-
-    
-    def self.load_project_impl(args, env)
-      return Lisp::Debug.process_error("'load-project' requires 1 argument.", env) if args.empty?
-      project_name = args.car.evaluate(env)
-      return Lisp::Debug.process_error("'load-project' requires a string or symbol argument.", env) unless project_name.string? || project_name.symbol?
-      Dir.chdir(File.join(App.documents_path, "projects", "#{project_name}.prj")) do |d|
-        if File.exists?("load.lsp")
-          File.open("load.lsp") do |f|
-            contents = f.read()
-            Lisp::Parser.new.parse_and_eval_all(contents)
-          end
-        else
-          Dir.glob("*.lsp") do |filename|
-            File.open(filename) do |f|
-              contents = f.read()
-              Lisp::Parser.new.parse_and_eval_all(contents)
-            end
-          end
-        end
-      end
-      Lisp::String.with_value("OK")
-    end
-    
-  end
-end