sicp-compiler-project/test-compiler/types.scm at main · samirose/sicp-compiler-project · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
(define-library
  (types)

  (export
   is-number?
   is-zero?
   is-eq?
   numeric-exp-is-number?
   is-boolean?
   eq?-evaluates-to-boolean-value
   arithmetic-comparison-operators-evaluate-to-boolean-values
   is-procedure?
   lambda-is-procedure?
   defined-procedure-is-procedure?
   imported-procedure-is-procedure?
   procedure-argument-is-procedure?
   procedure-from-procedure-is-procedure?
   is-procedure-eq-to-same-procedure?
   is-procedure-eq-to-different-procedure?
   is-procedure-number?-eq-to
   symbol-is-symbol?
   is-symbol?
   procedure-is-symbol?
   string-is-symbol?
   string-is-string?
   is-string?
   procedure-is-string?
   symbol-is-string?)

  (import (scheme base))

  (begin
    (define (is-number? x)
      (number? x))

    (define (is-zero? x)
      (zero? x))

    (define (is-eq? x y)
      (eq? x y))

    (define (numeric-exp-is-number?)
      (number? (+ 1 2)))

    (define (is-boolean? x)
      (boolean? x))

    (define (eq?-evaluates-to-boolean-value)
      (and (boolean? (eq? 1 1))
           (boolean? (eq? 1 2))))

    (define (arithmetic-comparison-operators-evaluate-to-boolean-values)
      (and (boolean? (< 1 2))
           (boolean? (< 2 1))
           (boolean? (<= 1 2))
           (boolean? (<= 2 1))
           (boolean? (= 1 1))
           (boolean? (> 2 1))
           (boolean? (> 1 2))
           (boolean? (>= 2 1))
           (boolean? (>= 1 2))))

    (define (is-procedure? x)
      (procedure? x))

    (define (lambda-is-procedure?)
      (procedure? (lambda (x) (+ x x))))

    (define (defined-procedure-is-procedure?)
      (procedure? lambda-is-procedure?))

    (define (imported-procedure-is-procedure?)
      (procedure? number?))

    (define (procedure-argument-is-procedure?)
      (and (is-procedure? (lambda (x) (* x x)))
           (is-procedure? is-number?)
           (is-procedure? zero?)))

    (define (doubler)
      (lambda (x) (+ x x)))

    (define (procedure-from-procedure-is-procedure?)
      (procedure? (doubler)))

    (define (is-procedure-eq-to-same-procedure?)
      (eq? number? number?))

    (define (is-procedure-eq-to-different-procedure?)
      (or (eq? number? zero?) (eq? zero? number?)))

    (define (is-procedure-number?-eq-to x)
      (eq? number? x))

    (define (symbol-is-symbol?)
      (symbol? 'sym))

    (define (is-symbol? x)
      (symbol? x))

    (define (procedure-is-symbol?)
      (symbol? doubler))

    (define (string-is-symbol?)
      (symbol? "bar"))

    (define (string-is-string?)
      (string? "foo"))

    (define (is-string? x)
      (string? x))

    (define (procedure-is-string?)
      (string? doubler))

    (define (symbol-is-string?)
      (string? 'test))

))