Class: Lisp::TypeChecks

Inherits:
Object show all
Defined in:
lib/rubylisp/type_checks.rb

Class Method Summary collapse

Class Method Details

.floatp_impl(args, env) ⇒ Object 



32
33
34
35
36
 
# File 'lib/rubylisp/type_checks.rb', line 32

def self.floatp_impl(args, env)
  raise "float? needs 1 argument" unless args.length == 1
  val = args.car.evaluate(env)
  return Lisp::Boolean.with_value(val.type == :number && val.float?)
end

.functionp_impl(args, env) ⇒ Object 



39
40
41
42
43
 
# File 'lib/rubylisp/type_checks.rb', line 39

def self.functionp_impl(args, env)
  raise "function? needs 1 argument" unless args.length == 1
  val = args.car.evaluate(env)
  return Lisp::Boolean.with_value(val.type == :function || val.type == :primitive)
end

.integerp_impl(args, env) ⇒ Object 



25
26
27
28
29
 
# File 'lib/rubylisp/type_checks.rb', line 25

def self.integerp_impl(args, env)
  raise "integer? needs 1 argument" unless args.length == 1
  val = args.car.evaluate(env)
  return Lisp::Boolean.with_value(val.type == :number && val.integer?)
end

.nilp_impl(args, env) ⇒ Object 



46
47
48
49
 
# File 'lib/rubylisp/type_checks.rb', line 46

def self.nilp_impl(args, env)
  raise "nil? needs 1 argument" unless args.length == 1
  return Lisp::Boolean.with_value(args.car.evaluate(env).nil?)
end

.not_nilp_impl(args, env) ⇒ Object 



52
53
54
55
 
# File 'lib/rubylisp/type_checks.rb', line 52

def self.not_nilp_impl(args, env)
  raise "not-nil? needs 1 argument" unless args.length == 1
  return Lisp::Boolean.with_value(!args.car.evaluate(env).nil?)
end

.register ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
 
# File 'lib/rubylisp/type_checks.rb', line 5

def self.register
  Primitive.register("list?")     {|args, env| Lisp::TypeChecks::typep_impl("list?", :pair, args, env) }
  Primitive.register("pair?")     {|args, env| Lisp::TypeChecks::typep_impl("pair?", :pair, args, env) }
  Primitive.register("symbol?")   {|args, env| Lisp::TypeChecks::typep_impl("symbol?", :symbol, args, env) }
  Primitive.register("number?")   {|args, env| Lisp::TypeChecks::typep_impl("number?", :number, args, env) }
  Primitive.register("integer?")   {|args, env| Lisp::TypeChecks::integerp_impl(args, env) }
  Primitive.register("float?")   {|args, env| Lisp::TypeChecks::floatp_impl(args, env) }
  Primitive.register("function?") {|args, env| Lisp::TypeChecks::functionp_impl(args, env) }

  Primitive.register("nil?")      {|args, env| Lisp::TypeChecks::nilp_impl(args, env) }
  Primitive.register("not-nil?")  {|args, env| Lisp::TypeChecks::not_nilp_impl(args, env) }
end

.typep_impl(name, sym, args, env) ⇒ Object 



19
20
21
22
 
# File 'lib/rubylisp/type_checks.rb', line 19

def self.typep_impl(name, sym, args, env)
  raise "#{name} needs 1 argument" unless args.length == 1
  return Lisp::Boolean.with_value(args.car.evaluate(env).type == sym)
end