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 



34
35
36
37
38
 
# File 'lib/rubylisp/type_checks.rb', line 34

def self.floatp_impl(args, env)
  return Lisp::Debug.process_error("float? needs 1 argument", env) 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 



41
42
43
44
45
 
# File 'lib/rubylisp/type_checks.rb', line 41

def self.functionp_impl(args, env)
  return Lisp::Debug.process_error("function? needs 1 argument", env) 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 



27
28
29
30
31
 
# File 'lib/rubylisp/type_checks.rb', line 27

def self.integerp_impl(args, env)
  return Lisp::Debug.process_error("integer? needs 1 argument", env) 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 



48
49
50
51
 
# File 'lib/rubylisp/type_checks.rb', line 48

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

.not_nilp_impl(args, env) ⇒ Object 



54
55
56
57
 
# File 'lib/rubylisp/type_checks.rb', line 54

def self.not_nilp_impl(args, env)
  return Lisp::Debug.process_error("not-nil? needs 1 argument", env) 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
17
18
 
# 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("null?")     {|args, env| Lisp::TypeChecks::nilp_impl(args, env) }
  Primitive.register("not-nil?")  {|args, env| Lisp::TypeChecks::not_nilp_impl(args, env) }
  Primitive.register("not-null?") {|args, env| Lisp::TypeChecks::not_nilp_impl(args, env) }
end

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



21
22
23
24
 
# File 'lib/rubylisp/type_checks.rb', line 21

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