SICP/util.scm

(define (assert a b)
  (cond ((equal? a b) (display "[ok]"))
    (else
      (display "[error] ")
      (display a)
      (display " != ")
      (display b)))
  (newline))

; I have this here to avoid name-conflicts with the amb implementation in
; amb.scm.
(define (my-assert a b)
  (cond ((equal? a b) (display "[ok]"))
    (else
      (display "[error] ")
      (display a)
      (display " != ")
      (display b)))
  (newline))

(define (gcd a b)
  (if (= b 0) (abs a) (gcd b (remainder a b))))

(define (average a b) (/ (+ a b) 2.0))
(define (id n) n)
(define identity id)
(define (inc n) (+ n 1))
(define nil '())
(define (divides? a b) (= (remainder b a) 0))
(define (cube n) (* n n n))
(define (even? n) (= (remainder n 2) 0))
(define (odd? n) (= (remainder n 2) 1))

; copied prime? from 1.21
(define (find-divisor n test-divisor)
  (cond ((> (square test-divisor) n) n)
        ((divides? test-divisor n) test-divisor)
        (else (find-divisor n (+ test-divisor 1)))))
(define (smallest-divisor n)
  (find-divisor n 2))
(define (prime? n) (if (= n 1) #f (= n (smallest-divisor n))))

; https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-15.html
(define (enumerate-interval low high)
  (if (> low high)
      nil
      (cons low (enumerate-interval (+ low 1) high))))

; Returns #t if there is no #f in xs, otherwise returns #f.
(define (all? xs)
  (cond ((null? xs) #t)
        ((eq? (car xs) #f) #f)
        (else (all? (cdr xs)))))

(define (all-eq? xs)
  (cond ((null? xs) #t)
        ((null? (cdr xs)) #t)
        ((eq? (car xs) (cadr xs)) (all-eq? (cdr xs)))
        (else #f)))

(define (fold-right op initial sequence) ; same as accumulate
  (if (null? sequence)
      initial
      (op (car sequence)
          (fold-right op initial (cdr sequence)))))

; From exercise 3.5
(define (random-in-range low high)
  (let ((range (- high low)))
    (+ low (random range))))

(define (contains x xs)
  (cond
    ((null? xs) #f)
    ((eq? x (car xs)) #t)
    (else (contains x (cdr xs)))))

(define (display-line x)
  (display x)
  (newline))

(define (take n xs)
  (if (= n 0)
    '()
    (cons (stream-car xs)
          (take (- n 1) (stream-cdr xs)))))

(define (drop n xs)
  (if (= n 0)
    xs
    (drop (- n 1) (stream-cdr xs))))

(define (find item stream)
  (define (iter n stream)
    (if (equal? (stream-car stream) item)
      n
      (iter (+ n 1) (stream-cdr stream))))
  (iter 0 stream))

(define (display-stream s)
  (stream-for-each display-line s))

(define (show x)
  (display-line x)
  x)

(define (stream-ref s n)
  (if (= n 0)
      (stream-car s)
      (stream-ref (stream-cdr s) (- n 1))))

(define (partial-sums xs)
  (cons-stream (stream-car xs)
               (add-streams (partial-sums xs)
                            (stream-cdr xs))))

(define (scale-stream stream factor)
  (stream-map (lambda (x) (* x factor)) stream))

(define (add-streams s1 s2)
  (stream-map + s1 s2))

(define (list->stream xs)
  (if (null? xs)
    '()
    (cons-stream (car xs) (list->stream (cdr xs)))))

(define ones (cons-stream 1 ones))

(define integers (cons-stream 1 (add-streams ones integers)))

(define (compile-to-file code target linkage file-name)
  (set! label-counter 0)
  (define (write-list-to-port xs port)
    (if (null? xs)
      '()
      (begin
        (display (car xs) port)
        (display "\n" port)
        (write-list-to-port (cdr xs) port))))
  (if #f ; #t means write to file; #f means don't write to file
    (let* ((compile-result (compile code target linkage))
           (assembly-insts (statements compile-result))
           (port (open-output-file file-name)))
      (write-list-to-port assembly-insts port)
      (display "[")
      (display file-name)
      (display "]\n")
      (close-output-port port))
      (begin
        (display "[")
        (display file-name)
        (display "]\n"))))

'util-loaded