3.5 streams pt 2

3/5/jord/lecture.org

@@ -0,0 +1,169 @@
+* Lecture 6B: Streams Pt. 2
+https://youtu.be/qp05AtXbOP0
+
+the key idea is that we decouple the apparent order of events in our
+programs from the actual order of events in the computer
+
+#+BEGIN_SRC scheme
+  (define (nth-stream n s)
+    (if (= n 0)
+	(head s)
+	(nth-stream (-1+ n) (tail s))))
+#+END_SRC
+
+elements aren't calculated until they are forced
+
+elements are calculated when they are forced
+
+#+BEGIN_SRC scheme
+  (define (integers-from n)
+    (cons-stream
+     n
+     (integers-from (+ n 1))))
+
+  (define integers (integers-from 1))
+
+  (define (no-seven x)
+    (not (= (remainder x 7)
+	    0)))
+  (define no-sevens (filter no-seven
+			    integers))
+#+END_SRC
+
+/the sieve of eratosthenes/
+  for finding all primes
+
+#+BEGIN_SRC scheme
+  (define (sieve s)
+    (cons-stream
+     (head s)
+     (sieve (filter
+	     (lambda (x)
+	       (not
+		(divisible? x (head s))))
+	     (tail s)))))
+  (define primes
+    (sieve (integers-from 2)))
+#+END_SRC
+
+--> break
+
+there's another way to think about stream programming
+  -- not operating on distinct elements, but streams as a whole
+
+#+BEGIN_SRC scheme
+  (define (add-streams s1 s2)
+    (cond ((empty-stream? s1) s2)
+	  ((empty-stream? s2) s1)
+	  (else
+	   (cons-stream
+	    (+ (head s1) (head s2))
+	    (add-streams (tail s1)
+			 (tail s2))))))
+  (define (scale-stream c s)
+    (map-stream (lambda (x) (* x c)) s))
+#+END_SRC
+
+#+BEGIN_SRC scheme
+  (define ones (cons-stream 1 ones)) ;; infinite stream of 1s
+  (define ints (cons-stream 1 (add-streams ints ones)))
+#+END_SRC
+
+harry: this is very sneaky
+
+#+BEGIN_SRC scheme
+  (define (integral s initial-value dt)
+    (define int
+      (cons-stream
+       initial-value
+       (add-streams (scale-stream dt s)
+		    int)))
+    int)
+#+END_SRC
+
+#+BEGIN_SRC scheme
+  (define fibs
+    (cons-stream 0
+		 (cons-stream 1
+			      (add-streams fibs (tail fibs)))))
+#+END_SRC
+
+"this is like learning recursion again, but instead of recursive
+procedures, we have recursive data"
+
+"this shouldn't be surprising to you" as there is no difference
+between data and procedures
+
+#+BEGIN_SRC scheme
+  (define y (integral dy 1 .001))
+  (define dy (map square y)) ;; this doesn't work
+  ;; recursively defined
+#+END_SRC
+
+delayed integral:
+#+BEGIN_SRC scheme
+  (define (integral delayed-s
+		    initial-value
+		    dt)
+    (define int
+      (cons-stream
+       initial-value
+       (let ((s (force delayed-s)))
+	 (add-streams (scale-stream dt s)
+		      int))))
+    int)
+#+END_SRC
+
+#+BEGIN_SRC scheme
+  (define y (integral (delay dy) 1 .001))
+  (define dy (map square y)) ;; this does work
+  ;; bc of delay
+#+END_SRC
+
+--> break
+
+"before the break, something nasty started to happen"
+
+the explicit use of delay is messy
+
+we could rewrite the language to attach a delay to every procedure
+
+it would be a "normal order" evaluation language
+
+vs what we've been using, "applicative order"
+
+instead of evaluating arguments, just provide promises, passing
+promises around until you reach a primitive
+
+applicative order carries a price:
+  we are trying to abstract away time, but if we go too far,
+  we lose expressiveness in favor of elegance
+
+we can no longer really express iterative procedures
+
+BUT there is another, more striking reason:
+  normal order and side effects don't mix
+
+"it's very confusing for a very deep reason":
+  we've thrown away time
+
+the debate over FUNCTIONAL PROGRAMMING
+
+a purely functional language has no side effects
+
+no assignment
+
+
+a bank acct w/o state:
+#+BEGIN_SRC scheme
+  (define (make-deposit-account
+	   balance deposit-stream)
+    (cons-stream
+     balance
+     (make-deposit-account
+      (+ balance (head deposit-stream))
+      (tail deposit-stream))))
+#+END_SRC
+
+"the poor ppl sitting at the bank account window have the misfortune
+to exist in time"