rubymotionlisp 0.2.2 → 1.0.0

data/lib/rubylisp/frame.rb

@@ -2,172 +2,13 @@ module Lisp
 
   class Frame < Atom
 
-    def self.register
-      Primitive.register("make-frame", "(make-frame slot-name slot-value ... )\n\nFrames can be created using the make-frame function, passing it an alternating sequence of slot names and values:\n\n        (make-frame a: 1 b: 2)\n\nThis results in a frame with two slots, named a: and b: with values 1 and 2, respectively.") do |args, env|
-        Lisp::Frame::make_frame_impl(args, env)
-      end
-      
-      Primitive.register("has-slot?", "(has-slot? frame slot-name)\n\nThe has-slot? function is used to query whether a frame contains (directly or in an ancestor) the particular slot.") do |args, env|
-        Lisp::Frame::has_slot_impl(args, env)
-      end
-      
-      Primitive.register("get-slot", "(get-slot _frame_ _slot-name_)\n\nThe get-slot function is used to retrieve values from frame slots") do |args, env|
-        Lisp::Frame::get_slot_impl(args, env)
-      end
-      
-      Primitive.register("get-slot-if", "(get-slot-if frame slot-name)\n\nThe same as above, except that if a matching slot is not found, nil is returned instead of raising an error.") do |args, env|
-        Lisp::Frame::get_slot_if_impl(args, env)
-      end
-      
-      Primitive.register("remove-slot!", "(remove-slot! frame slot-name)\n\nThe remove-slot! function is used to function is used to remove a slot from a frame. It only removes slots from the frame itself. not any of it's parents. remove-slot! return #t if the slot was removed, #f otherwise.") do |args, env|
-        Lisp::Frame::remove_slot_impl(args, env)
-      end
-      
-      Primitive.register("set-slot!", "(set-slot! frame slot-name new-value)\n\nThe set-slot! function is used to change values in frame slots") do |args, env|
-        Lisp::Frame::set_slot_impl(args, env)
-      end
-      
-      Primitive.register("send", "(send frame slot-name arg...)\n\nSend the message slot-name to frame, passing along the arg collection. The result is what is returned by the code in that slot.") do |args, env|
-        Lisp::Frame::send_impl(args, env)
-      end
-      
-      Primitive.register("send-super", "**(send-super slot-name arg...)\n\nLike send, but sends to the first parent that has the named slot. send-super can only be used from within a frame.") do |args, env|
-        Lisp::Frame::send_super_impl(args, env)
-      end
-      
-      Primitive.register("clone", "(clone frame)\n\nFrames represent things. For example, you could use a frame that looks like {x: 1 y: 10} to represent a point. A system that would use point frames will typically need many independant points. The approach to this is to create a prototypical point data frame, and use the clone function to create individual, independant frames.") do |args, env|
-        Lisp::Frame::clone_impl(args, env)
-      end
-      
-      Primitive.register("keys", "(keys frame)\n\nReturn a list of the keys in the frame.") do |args, env|
-        Lisp::Frame::keys_impl(args, env)
-      end
-      
-    end
-
-
-    def self.make_frame_impl(args, env)
-      c = args
-      m = {}
-      while !c.nil?
-        k = c.car
-        return Lisp::Debug.process_error("Slot names must be a symbol, found a {k.type}.", env) unless k.symbol?
-        return Lisp::Debug.process_error("Slot names must end in a colon, found '#{k}'.", env) unless k.naked?
-        v = c.cadr.evaluate(env)
-        m[k] = v
-        c = c.cddr
-      end
-
-      Lisp::Frame.with_map(m)
-    end
-
-
-    def self.has_slot_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key must be a symbol but was #{key.type}.", env) unless key.symbol?
-      return Lisp::TRUE if frame.has_slot?(key)
-      Lisp::FALSE
-    end
-
-    
-    def self.get_slot_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must be a symbol but was #{key.type}.", env) unless key.symbol?
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must name an existing slot.", env) unless frame.has_slot?(key)
-      frame.get(key)
-    end
-
-    
-    def self.get_slot_if_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must be a symbol but was #{key.type}.", env) unless key.symbol?
-      frame.get(key)
-    end
-
-    
-    def self.remove_slot_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must be a symbol but was #{key.type}.", env) unless key.symbol?
-      return Lisp::TRUE if frame.remove(key)
-      Lisp::FALSE
-    end
-
-    
-    def self.set_slot_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      key = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Frame key (#{key.to_s}) must be a symbol but was #{key.type}.", env) unless key.symbol?
-      value = args.caddr.evaluate(env)
-      frame.at_put(key, value)
-    end
-    
-
-    def self.send_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      selector = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("Selector must be a symbol but was #{selector.type}.", env) unless selector.symbol?
-      return Lisp::Debug.process_error("Message sent must name an existing slot in the receiver.", env) unless frame.has_slot?(selector)
-      func = frame.get(selector)
-      return Lisp::Debug.process_error("Message sent must select a function slot but was #{func.type}.", env) unless func.function?
-      params = args.cddr
-      frame_env = Lisp::EnvironmentFrame.extending(env, frame)
-      frame_env.bind_locally(Symbol.named("self"), frame)
-      func.apply_to(params, frame_env)
-    end
-
-    def self.get_super_function(selector, env)
-      f = env.frame
-      return nil if f.nil?
-      f.parents.each do |p|
-        func = p.get(selector)
-        return func unless func.nil?
-      end
-      nil
-    end
-    
-    def self.send_super_impl(args, env)
-      return Lisp::Debug.process_error("super can only be used within the context of a frame.", env) unless env.frame
-      selector = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Selector must be a symbol but was #{selector.type}.", env) unless selector.symbol?
-      func = get_super_function(selector, env)
-      return Lisp::Debug.process_error("Message sent must select a function slot but was #{func.type}.", env) unless func && func.function?
-      params = args.cdr
-      frame_env = Lisp::EnvironmentFrame.extending(env, env.frame)
-      frame_env.bind_locally(Symbol.named("self"), env.frame)
-      func.apply_to(params, frame_env)
-    end
-
-    
-    def self.clone_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      frame.clone
-    end
-
-
-    def self.keys_impl(args, env)
-      frame = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Frame data must be a frame but was #{frame.type}.", env) unless frame.frame?
-      ConsCell.array_to_list(frame.value.keys)
-    end
-
-
     def self.with_map(m)
       self.new(m)
     end
 
-    def initialize(m=nil)
-      @value = m || {}
+    def initialize(m = {})
+      @value = m
+      self
     end
 
 
@@ -285,11 +126,11 @@ module Lisp
       nil
     end
 
-    def eq?(other)
+    def equal?(other)
       return false unless other.frame?
       return false unless @value.length == other.value.length
       @value.each do |k, v|
-        return false unless Lisp::Equivalence.equal_check(other.value[k], v).value
+        return false unless other.value[k].equal?(v)
       end
       true
     end

data/lib/rubylisp/function.rb

@@ -2,7 +2,7 @@ module Lisp
 
   class Function < Atom
 
-    attr_reader :doc, :arity, :name
+    attr_reader :doc, :arity, :name, :env, :body
     
     def compute_required_argument_count(args)
       a = args
@@ -37,10 +37,11 @@ module Lisp
       if @var_args
         return Lisp::Debug.process_error("#{@name} expected at least #{@arity} parameters, received #{parameters.length}.", env) if parameters.length < @arity
       else
+        puts "#{@name} #{@arguments.print_string} #{@body.print_string}" unless parameters.length == @arity
+        puts caller unless parameters.length == @arity
         return Lisp::Debug.process_error("#{@name} expected #{@arity} parameters, received #{parameters.length}.", env) unless parameters.length == @arity        
       end
-      
-      local_env = EnvironmentFrame.extending(@env, env.frame)
+      local_env = EnvironmentFrame.extending(@env, @name, env.frame)
       local_env.previous = env
       self_sym = Symbol.named("self")
       if env.frame

data/lib/rubylisp/macro.rb

@@ -2,7 +2,7 @@ module Lisp
 
   class Macro < Atom
 
-    attr_reader :doc
+    attr_reader :name, :doc, :body
     
     def compute_required_argument_count(args)
       a = args
@@ -20,6 +20,7 @@ module Lisp
     end
     
     def initialize(name, arguments, doc, body, env)
+      #puts "Macro#initialize #{name} #{arguments.to_a}"
       sig = ([name] << arguments.to_a).flatten
       @doc = "(#{(sig.collect {|e| e.to_s}).join(" ")})"
       @name = name
@@ -33,14 +34,12 @@ module Lisp
 
     def expand(parameters, env, should_eval)
       if @var_args
-        return Lisp::Debug.process_error("#{@name} expected at least
-                                ##{@required_argument_count} parameters, received #{parameters.length}.", env) if parameters.length < @required_argument_count
+        return Lisp::Debug.process_error("#{@name} expected at least #{@required_argument_count} parameters, received #{parameters.length}.", env) if parameters.length < @required_argument_count
       else
-        return Lisp::Debug.process_error("#{@name} expected
-                                ##{@required_argument_count} parameters, received #{parameters.length}.", env) unless parameters.length == @required_argument_count        
+        return Lisp::Debug.process_error("#{@name} expected #{@required_argument_count} parameters, received #{parameters.length}.", env) unless parameters.length == @required_argument_count        
       end
       
-      local_env = EnvironmentFrame.extending(@env, env.frame)
+      local_env = EnvironmentFrame.extending(@env, @name, env.frame)
       self_sym = Symbol.named("self")
       if env.frame
         local_env.bind_locally(self_sym, env.frame)
@@ -63,8 +62,14 @@ module Lisp
         accumulating_arg = arg if arg.symbol?
       end
       local_env.bind_locally(accumulating_arg, Lisp::ConsCell.array_to_list(accumulated_params)) if accumulating_arg
+
+      #puts "expanding #{@name}"
+      #puts "     #{@body.print_string}"
       
-      @body.evaluate(local_env)
+      result = @body.evaluate(local_env)
+
+      #puts "     #{result.print_string}"
+      result
     end
     
     def internal_apply_to(parameters, env, should_eval)
@@ -91,7 +96,7 @@ module Lisp
     def type
       :macro
     end
-
+    
   end
 
 end

data/lib/rubylisp/{object.rb → native_object.rb}

@@ -1,21 +1,6 @@
 module Lisp
 
   class NativeObject < Atom
-
-    def self.register
-      Primitive.register("wrap-object")  {|args, env| Lisp::NativeObject::wrap_impl(args, env) }
-    end
-
-    def self.wrap_impl(args, env)
-      return Lisp::Debug.process_error("wrap-object requires 1 argument", env) unless args.length == 1
-      raw_val = args.car.evaluate(env)
-      val = if raw_val.list?
-              raw_val.to_a
-            else
-              raw_val
-            end
-      NativeObject.with_value(val)
-    end
     
     def self.new_instance_of(c)
       self.new(c.alloc.init)

data/lib/rubylisp/number.rb

@@ -42,6 +42,11 @@ module Lisp
       @value < 0
     end
 
+    def eqv?(sexpr)
+      return false unless sexpr.number?
+      @value == sexpr.value
+    end
+
     def type
       :number
     end

data/lib/rubylisp/parser.rb

@@ -10,7 +10,7 @@ module Lisp
     end
 
     def make_hex_number(str)
-      Lisp::Number.with_value(str.gsub("#x", "0x").to_i(0))
+      Lisp::Number.with_value(["0x", str].join.to_i(0))
     end
 
     def make_float(str)
@@ -18,7 +18,7 @@ module Lisp
     end
 
     def make_string(str)
-      Lisp::String.with_value(str[1...-1])
+      Lisp::String.with_value(str)
     end
 
     def make_symbol(str)
@@ -33,7 +33,7 @@ module Lisp
       tok, lit = tokens.next_token
       if tok == :RPAREN
         tokens.consume_token
-        return nil
+        return Lisp::ConsCell.cons()
       end
 
       car = nil
@@ -45,67 +45,85 @@ module Lisp
           cdr = self.parse_sexpr(tokens)
           return nil if tokens.next_token[0] == :EOF
           tok, lit = tokens.next_token
-          return Lisp::Debug.process_error("Expected ')' to follow a dotted tail on line #{tokens.line_number}", env) if tok != :RPAREN
+          return Lisp::Debug.process_error("Expected ')' to follow a dotted tail on line #{tokens.line_number}", Lisp::EnvironmentFrame.global) if tok != :RPAREN
           tokens.consume_token
           return Lisp::ConsCell.array_to_list(cells, cdr)
         else
           car = self.parse_sexpr(tokens)
-          return Lisp::Debug.process_error("Unexpected EOF (expected ')') on line #{tokens.line_number}", env) if tokens.next_token[0] == :EOF
+          return Lisp::Debug.process_error("Unexpected EOF (expected ')') on line #{tokens.line_number}", Lisp::EnvironmentFrame.global) if tokens.next_token[0] == :EOF
           cells << car
         end
         tok, lit = tokens.next_token
       end
 
       tokens.consume_token
-      return Lisp::ConsCell.array_to_list(cells)
+      Lisp::ConsCell.array_to_list(cells)
     end
 
-    def parse_map(tokens)
+    def parse_frame(tokens, literal)
       m = {}
       tok, lit = tokens.next_token
       if tok == :RBRACE
         tokens.consume_token
-        return ConsCell.cons(Symbol.named("make-frame"), nil)
-      end
-
-      cells = []
-      while tok != :RBRACE
-        item = self.parse_sexpr(tokens)
-        return Lisp::Debug.process_error("Unexpected EOF (expected '}') on line #{tokens.line_number}", env) if tokens.next_token[0] == :EOF
-        cells << item
-        tok, lit = tokens.next_token
+        if literal
+          Lisp::Frame.new
+        else
+          Lisp::ConsCell.cons(Lisp::Symbol.named("make-frame"), nil)
+        end
+      else
+        cells = []
+        while tok != :RBRACE
+          item = self.parse_sexpr(tokens)
+          return Lisp::Debug.process_error("Unexpected EOF (expected '}') on line #{tokens.line_number}", env) if tokens.next_token[0] == :EOF
+          cells << item
+          tok, lit = tokens.next_token
+        end
+        
+        tokens.consume_token
+        keys_and_values = Lisp::ConsCell.array_to_list(cells)
+        if literal
+          Lisp::PrimFrame.make_frame_impl(keys_and_values, Lisp::EnvironmentFrame.global)
+        else
+          Lisp::ConsCell.cons(Lisp::Symbol.named("make-frame"), keys_and_values)
+        end
       end
-
-      tokens.consume_token
-      return ConsCell.cons(Symbol.named("make-frame"), ConsCell.array_to_list(cells))
     end
 
 
-    def parse_vector(tokens)
+    def parse_vector(tokens, literal)
       v = []
       tok, lit = tokens.next_token
-      if tok == :RBRACKET
+      if tok == :RPAREN
         tokens.consume_token
-        return ConsCell.cons(Symbol.named("make-vector"), nil)
-      end
-
-      cells = []
-      while tok != :RBRACKET
-        item = self.parse_sexpr(tokens)
-        return Lisp::Debug.process_error("Unexpected EOF (expected ']') on line #{tokens.line_number}", env) if tokens.next_token[0] == :EOF
-        cells << item
-        tok, lit = tokens.next_token
+        if literal
+          Lisp::Vector.new
+        else
+          Lisp::ConsCell.cons(Lis::Symbol.named("vector"), nil)
+        end
+      else
+        cells = []
+        while tok != :RPAREN
+          item = self.parse_sexpr(tokens)
+          return Lisp::Debug.process_error("Unexpected EOF (expected ')') on line #{tokens.line_number}", env) if tokens.next_token[0] == :EOF
+          cells << item
+          tok, lit = tokens.next_token
+        end
+        
+        tokens.consume_token
+        
+        if literal
+          Lisp::Vector.with_array(cells)
+        else
+          Lisp::ConsCell.cons(Lisp::Symbol.named("vector"), Lisp::ConsCell.array_to_list(cells))
+        end
       end
-
-      tokens.consume_token
-      return ConsCell.cons(Symbol.named("make-vector"), ConsCell.array_to_list(cells))
     end
 
     
     def parse_sexpr(tokens)
       while true
         tok, lit = tokens.next_token
-        #puts "token: <#{tok}, #{lit}>"
+        # puts "token: <#{tok}, #{lit}>"
         return nil if tok == :EOF
         tokens.consume_token
         case tok
@@ -124,33 +142,37 @@ module Lisp
         when :LPAREN
           return parse_cons_cell(tokens)
         when :LBRACE
-          return parse_map(tokens)
-        when :LBRACKET
-          return parse_vector(tokens)
+          return parse_frame(tokens, false)
+        when :QUOTE_LBRACE
+          return parse_frame(tokens, true)
+        when :HASH_LPAREN
+          return parse_vector(tokens, false)
+        when :QUOTE_HASH_LPAREN
+          return parse_vector(tokens, true)
         when :SYMBOL
           return make_symbol(lit)
         when :FFI_NEW_SYMBOL
-          return FfiNew.new(lit)
+          return Lisp::FfiNew.new(lit)
         when :FFI_SEND_SYMBOL
-          return FfiSend.new(lit)
+          return Lisp::FfiSend.new(lit)
         when :FFI_STATIC_SYMBOL
-          return FfiStatic.new(lit)
+          return Lisp::FfiStatic.new(lit)
         when :FALSE
           return Lisp::FALSE
         when :TRUE
           return Lisp::TRUE
         when :QUOTE
           expr = parse_sexpr(tokens)
-          return ConsCell.array_to_list([Symbol.named('quote'), expr])
+          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('quote'), expr])
         when :BACKQUOTE
           expr = parse_sexpr(tokens)
-          return ConsCell.array_to_list([Symbol.named('quasiquote'), expr])
+          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('quasiquote'), expr])
         when :COMMA
           expr = parse_sexpr(tokens)
-          return ConsCell.array_to_list([Symbol.named('unquote'), expr])
+          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('unquote'), expr])
         when :COMMAAT
           expr = parse_sexpr(tokens)
-          return ConsCell.array_to_list([Symbol.named('unquote-splicing'), expr])
+          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('unquote-splicing'), expr])
         when :ILLEGAL
           return Lisp::Debug.process_error("Illegal token: #{lit} on line #{tokens.line_number}", Lisp::EnvironmentFrame.global)
         else
@@ -160,21 +182,23 @@ module Lisp
     end
 
     def parse(src)
-      tokenizer = Tokenizer.new(src)
-      tokenizer.init
-
-      sexpr = self.parse_sexpr(tokenizer)
-      return sexpr
+      tokenizer = Tokenizer.from_string(src)
+      self.parse_sexpr(tokenizer)
     end
 
+    def parse_object_from_file(port, env=Lisp::EnvironmentFrame.global)
+      tokenizer = Tokenizer.from_file(port)
+      result = self.parse_sexpr(tokenizer)
+      result.nil? ? Lisp::EofObject.instance : result
+    end
+    
     def parse_and_eval(src, env=Lisp::EnvironmentFrame.global)
       sexpr = self.parse(src)
       return sexpr.evaluate(env)
     end
 
     def parse_and_eval_all(src, env=Lisp::EnvironmentFrame.global)
-      tokenizer = Tokenizer.new(src)
-      tokenizer.init
+      tokenizer = Tokenizer.from_string(src)
       result = nil
       until tokenizer.eof?
         sexpr = self.parse_sexpr(tokenizer)
@@ -183,7 +207,12 @@ module Lisp
       result
     end
     
-
+    def process_file(fname)
+      File.open(fname) do |f|
+        parse_and_eval_all(f.read)
+      end
+    end
+    
   end
 
 end

data/lib/rubylisp/port.rb

@@ -0,0 +1,27 @@
+module Lisp
+
+  class Port < Atom
+
+    def self.with_value(p)
+      self.new(p)
+    end
+
+    def initialize(p)
+      @value = p
+    end
+
+    def type
+      :port
+    end
+
+    def port?
+      true
+    end
+
+    def to_s
+      "<port: #{@value}>"
+    end
+
+  end
+
+end

data/lib/rubylisp/prim_alist.rb

@@ -0,0 +1,115 @@
+module Lisp
+
+  class PrimAlist
+
+    
+    def self.register
+      Primitive.register("acons", "2|3")      {|args, env| Lisp::PrimAlist::acons_impl(args, env) }
+      Primitive.register("assq", "2")         {|args, env| Lisp::PrimAlist::assoc_impl(args, env) {|a, b| a.eq?(b) } }
+      Primitive.register("assv", "2")         {|args, env| Lisp::PrimAlist::assoc_impl(args, env) {|a, b| a.eqv?(b) } }
+      Primitive.register("assoc", "2")        {|args, env| Lisp::PrimAlist::assoc_impl(args, env) {|a, b| a.equal?(b) } }
+      Primitive.register("rassq", "2")        {|args, env| Lisp::PrimAlist::rassoc_impl(args, env) {|a, b| a.eq?(b) } }
+      Primitive.register("rassv", "2")        {|args, env| Lisp::PrimAlist::rassoc_impl(args, env) {|a, b| a.eqv?(b) } }
+      Primitive.register("rassoc", "2")       {|args, env| Lisp::PrimAlist::rassoc_impl(args, env) {|a, b| a.equal?(b) } }
+      Primitive.register("del-assq", "2")     {|args, env| Lisp::PrimAlist::dissoc_impl(args, env) {|a, b| a.eq?(b) } }
+      Primitive.register("dissq", "2")        {|args, env| Lisp::PrimAlist::dissoc_impl(args, env) {|a, b| a.eq?(b) } }
+      Primitive.register("del-assv", "2")     {|args, env| Lisp::PrimAlist::dissoc_impl(args, env) {|a, b| a.eqv?(b) } }
+      Primitive.register("dissv", "2")        {|args, env| Lisp::PrimAlist::dissoc_impl(args, env) {|a, b| a.eqv?(b) } }
+      Primitive.register("del-assoc", "2")    {|args, env| Lisp::PrimAlist::dissoc_impl(args, env) {|a, b| a.equal?(b) } }
+      Primitive.register("dissoc", "2")       {|args, env| Lisp::PrimAlist::dissoc_impl(args, env) {|a, b| a.equal?(b) } }
+      Primitive.register("zip", "2|3")        {|args, env| Lisp::PrimAlist::zip_impl(args, env) }
+      Primitive.register("pairlis", "2|3")    {|args, env| Lisp::PrimAlist::zip_impl(args, env) }
+    end
+
+    
+    def self.acons_impl(args, env)
+      key = args.car
+      value = args.cadr
+      alist = args.length == 2 ? nil : args.caddr
+      return Lisp::Debug.process_error("the last argument to acons has to be a list", env) unless alist.list?
+
+      pair = ConsCell.cons(key, value)
+      if alist.nil?
+        ConsCell.cons(pair)
+      else
+        ConsCell.cons(pair, alist)
+      end
+    end
+
+    
+    def self.assoc_impl(args, env, &equivalence_block)
+      key = args.car
+      alist = args.cadr
+      return Lisp::Debug.process_error("the last argument to assoc has to be a list", env) unless alist.list?
+
+      alist.each do |pair|
+        if equivalence_block.call(pair.car, key)
+          return pair
+        end
+      end
+    end
+
+    
+    def self.rassoc_impl(args, env, &equivalence_block)
+      value = args.car
+      alist = args.cadr
+      return Lisp::Debug.process_error("the last argument to rassoc has to be a list", env) unless alist.list?
+      alist.each do |pair|
+        if equivalence_block.call(pair.cdr, value)
+          return pair
+        end
+      end
+    end
+
+    
+    def self.dissoc_impl(args, env, &equivalence_block)
+      key = args.car
+      alist = args.cadr
+      return Lisp::Debug.process_error("the last argument to dissoc has to be a list", env) unless alist.list?
+
+      new_prefix = nil
+      trailing_end = nil
+      crawler = alist
+      while !crawler.nil? 
+        if equivalence_block.call(crawler.caar, key)
+          if new_prefix.nil?
+            new_prefix = crawler.cdr
+          else
+            trailing_end.set_cdr!(crawler.cdr)
+          end
+          return new_prefix
+        else
+          new_cell = ConsCell.cons(ConsCell.cons(crawler.caar, crawler.cdar))
+          if new_prefix.nil?
+            new_prefix = new_cell
+            trailing_end = new_prefix
+          else
+            trailing_end.set_cdr!(new_cell)
+          end
+        end
+        crawler = crawler.cdr
+      end
+    end
+    
+
+    def self.zip_impl(args, env)
+      key_list = args.car
+      return Lisp::Debug.process_error("the keys supplied to zip has to be a list", env) unless key_list.list?
+      value_list = args.cadr
+      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
+
+      old_list = if args.length == 3
+                   alist = args.caddr
+                   return Lisp::Debug.process_error("the third argument to zip has to be a list", env) unless alist.list?
+                   alist
+                 else
+                   nil
+                 end
+      pairs = key_list.to_a.zip(value_list.to_a)
+      pairs.inject(old_list) {|alist, pair| ConsCell.cons(ConsCell.cons(*pair), alist)}
+    end
+    
+  end
+
+end