Class: ComaLisp

Inherits:
Object
  • Object
show all
Defined in:
lib/comalisp.rb

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ ComaLisp

Returns a new instance of ComaLisp.



2
3
4
5
6
 
# File 'lib/comalisp.rb', line 2

def initialize(opts={})
  # parent is used for scoping
  @parent = opts[:parent]
  @env = opts[:env] || {}
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object (private) 



87
88
89
90
91
92
93
 
# File 'lib/comalisp.rb', line 87

def method_missing(name,*args,&block)
  if args.empty?
    variable_lookup(name)
  else
    method_call(name,*args,&block)
  end
end

Instance Method Details

#apply(fn, args) ⇒ Object 



49
50
51
 
# File 'lib/comalisp.rb', line 49

def apply(fn,args)
  self.send(fn,*args)
end

#call(fn, *args) ⇒ Object 



45
46
47
 
# File 'lib/comalisp.rb', line 45

def call(fn,*args)
  self.apply(fn,args)
end

#car(lst) ⇒ Object 



23
24
25
26
 
# File 'lib/comalisp.rb', line 23

def car(lst)
  return null if lst.size < 1
  lst[0]
end

#cdr(lst) ⇒ Object 



36
37
38
39
 
# File 'lib/comalisp.rb', line 36

def cdr(lst)
  return [] if lst.size == 0
  lst[1..-1]
end

#cons(head, tail = nil) ⇒ Object

we use array to represent list and cons The implication is that all lists must be proper. That is (cons 1, 2) is invalid. [] is the empty list. Nothing else is the empty list. It is the fixpoint for cdr.



11
12
13
 
# File 'lib/comalisp.rb', line 11

def cons(head,tail=nil)
  [head,*tail]
end

#consp(o) ⇒ Object 



15
16
17
 
# File 'lib/comalisp.rb', line 15

def consp(o)
  o.is_a? Array
end

#defun(argslist, &body) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/comalisp.rb', line 66

def defun(argslist,&body)
  me = self
  name = argslist.shift
  eigenclass = class << self; self; end
  eigenclass.instance_eval do
    define_method(name) do |*vals|
      env = {}
      argslist.each_with_index do |arg,i|
        env[arg] = vals[i]
      end
      me.scope(env,&body)
    end
  end
end

#let(*vars, &body) ⇒ Object 



53
54
55
56
57
58
59
 
# File 'lib/comalisp.rb', line 53

def let(*vars,&body)
  env = vars.inject({}) {|acc,(k,v)|
    acc[k] = v
    acc
  }
  scope(env,&body)
end

#list(*args) ⇒ Object 



41
42
43
 
# File 'lib/comalisp.rb', line 41

def list(*args)
  args
end

#null ⇒ Object 



28
29
30
 
# File 'lib/comalisp.rb', line 28

def null
  []
end

#nullp(list) ⇒ Object 



32
33
34
 
# File 'lib/comalisp.rb', line 32

def nullp(list)
  list == null
end

#scope(env = {}, &body) ⇒ Object 



61
62
63
64
 
# File 'lib/comalisp.rb', line 61

def scope(env={},&body)
  scope = ComaLisp.new(:parent => self, :env => env)
  scope.instance_eval(&body)
end

#set(var, val) ⇒ Object 



81
82
83
 
# File 'lib/comalisp.rb', line 81

def set(var,val)
  @env[var.to_sym] = val
end

#tail(lst) ⇒ Object 



19
20
21
 
# File 'lib/comalisp.rb', line 19

def tail(lst)
  lst.last
end