; Hal summarizes the new problems.
;   * Why did we end here?
;   -> we wanted MODULARITY.
; 6A:(7m) Today we look from another angle.
; Leaving the realms of OBJECT-ORIENTED PROGRAMMING
;   and entering the perspective of "stream processing"
;   or OPERATIONS ON AGGREGATES 1A:(24m5s)
;
; => Thereby creating CONVENTIONAL INTERFACES.

; 6A:(14m25s) Naming the spells.
; (cons-stream x y)  --> stream
; (head s)  --> extract first
; (tail s)  --> extract last
; FOR ANY X, Y:
;   (HEAD (CONS-STREAM X Y)) -> X
;   (TAIL (CONS-STREAM X Y)) -> Y

; (define (map-stream proc s)
;   (if (empty-stream? s)
;       the-empty-stream
;       (cons-stream
;        (proc (head s))
;        (map-stream proc (tail s)))))
; (define (filter pred s)
;   (cond
;    ((empty-stream? s) the-empty-stream)
;    ((pred (head s))
;     (cons-stream (head s)
;                  (filter pred
;                          (tail s))))
;    (else (filter pred (tail s)))))
; (define (accumulate combiner init-val s)
;   (if (empty-stream? s)
;       init-val
;       (combiner (head s)
;                 (accumulate combiner
;                             init-val
;                             (tail s)))))
; (define (enumerate-tree tree)
;   (if (leaf-node? tree)
;       (cons-stream tree
;                    the-empty-stream)
;       (append-streams
;        (enumerate-tree
;         (left-branch tree))
;        (enumerate-tree
;         (right-branch tree)))))
; (define (append-streams s1 s2)
;   (if (empty-stream? s1)
;       s2
;       (cons-stream
;        (head s1)
;        (append-streams (tail s1)
;                        s2))))
; (define (enum-interval low high)
;   (if (> low high)
;       the-empty-stream
;       (cons-stream
;        low
;        (enum-interval (1+ low) high))))

; These operations can be used to express general means
; of combination.

; Instead of:

; Instead of:
;;; SUM-ODD-SQUARES
; (define (sum-odd-squares tree)
;   (if (leaf-node? tree)
;       (if (odd? tree)
;           (square tree)
;           0)
;       (+ (sum-odd-squares
;           (left-branch tree))
;          (sum-odd-squares
;           (right-branch tree)))))
;;; ODD-FIBONACCI
; (define (odd-fibs n)
;   (define (next k)
;     (if (> k n)
;         '()
;         (let ((f (fib k)))
;           (if (odd? f)
;               (cons f (next (1+ k)))
;               (next (1+ k))))))
;   (next 1))

; you write:
;;; SUM-ODD-SQUARES
; (define (sum-odd-squares tree)
;   (accumulate
;    +
;    0
;    (map
;     square
;     (filter odd
;             (enumerate-tree tree)))))
;;; ODD-FIBONACCI
; (define (odd-fibs n)
;   (accumulate
;    cons
;    '()
;    (filter
;     odd
;     (map fib (enum-interval 1 n)))))
; 6A:(21m40s)
; QUESTIONS 6A:(23m30s) BREAK "This is like APL."

; Case Analysis
; Flattening Streams of Streams:
; (define (flatten st-of-st)
;   (accumulate append-streams
;               the-empty-stream
;               st-of-st))
; GIVEN N: FIND ALL PAIRS O<J<I<=N
;  SUCH THAT I+J IS PRIME.
; (define (flatmap f s)
;   (flatten (map f s)))
; (define (prime-sum-pairs n)
;   (map
;    (lambda (p)
;      (list (car p)
;      (cadr p)
;      (+ (car p) (cadr p))))
;    (filter
;     (lambda (p)
;       (prime? (+ (car p) (cadr p))))
;     (flatmap
;      (lambda (i)
;        (map
;         (lambda (j) (list i j))
;         (enum-interval 1 (-1+ i))))
;      (enum-interval 1 n)))))
;
; Hal introduces syntactic sugar for FLATMAP and MAP.
; (define (prime-sum-pairs n)
;   (collect
;    (list i j (+i j))
;    ((i (enum-interval 1 n))
;     (j (enum-interval 1 (-1+ i))))
;    (prime? (+ i j))))
; 6A:(33m18s) Backtracking Search (Eight-Queens Problem)
; 6A:(37m3s) Too concerned with time... A recursive solution to the problem:
; (define (queens size)
;   (define (fill-cols k)
;     (if
;      (= k 0)
;      (singleton empty-board)
;      (collect
;       (adjoin-position try-row
;                       k
;                       rest-queens)
;       ((rest-queens (fill-cols (-1+ k)))
;        (try-row (enum-interval 1 size)))
;       (safe? try-row k rest-queens))))
;   (fill-cols size))
; Fundamental QUESTION 6A:(41m11s) BREAK
; "At this point, you should get suspicious." --Hal
;   We look at it from a simple viewpoint, but that gets more and more
;   impossible, the more possibilities there are. (Or in another sense,
;   the more we want to understand everything at once.)

; 6A:(43m26s) Hal explains the hidden magic in Lisp streams.
;   "We decouple the apparent order of events in our programs
;    from the actual order of events in the computer."
; 6A:(48m) BEGIN SHOWCASE.
; 6A:(50m23s) Implementing STREAM.
;  (CONS-STREAM x y) -> (CONS x (DELAY y))
;  (HEAD s) -> (CAR s)
;  (TAIL s) -> (FORCE (CDR s))
; 6A:(56m3s)
;  (DELAY <exp>) -> (MEMO-PROC (LAMBDA () <exp>))
;  (FORCE P) -> (P)

; (define (memo-proc proc)
;   (lambda (already-run? result)
;     (lambda ()
;       (if (not already-run?)
;           (sequence
;            (set! result (proc))
;            (set! already-run? (not nil))
;            result)
;           result)) (nil nil)))

; "Instead of a list, there sits a promise to compute the list." --Hal
; QUESTIONS 6A:(1h1m23s) (END)