2.4 abstract data

2/4/jord/lecture.org

@@ -0,0 +1,162 @@
+* Lecture 4A: Pattern Matching and Rule-Based Substitution
+  https://youtu.be/_fXQ1SwKjDg
+
+last week we wrote a stylized language for elementary calculus rules
+
+it was very stylized; it followed a dispatch structure
+
+the calculus rules are like this:
+
+:             rule
+:  pattern ----------> skeleton
+:     |                   |
+:     | match             | instantiation
+:     |                   |
+:     v                   v
+: expression |----->  expression
+:  source              target
+
+  - pattern :: something that matches
+  - skeleton :: something you substitute into to get a new expression
+
+the pattern is matched against the expression (source) and it produces
+a new expression (target) by instantiation of a skeleton
+
+instead of stooping to the computers way of understanding these rules,
+we are going to bring the computer to us
+
+we will separate the structure from the rules themselves
+
+here are some rules:
+#+BEGIN_SRC scheme
+  (define deriv-rules
+    '(
+      ( (dd (?c c) (? v))		0 )
+      ( (dd (?v v) (? v))		1 )
+      ( (dd (?v u) (? v))		0 )
+
+      ( (dd (+ (? x1) (? x2)) (? v))
+	(+ (dd (: x1) (: v))
+	   (dd (: x2) (: v)))	  )
+
+      ;; ...
+      ))
+#+END_SRC
+
+we are making up a language here
+
+'?' we are calling pattern variables in the language we are inventing
+':' we are calling skeleton evaluation (substitution objects)
+
+heres some syntax:
+#+BEGIN_SRC scheme
+  ;; Pattern Match
+
+  ;; foo -- matches exactly foo
+  ;; (f a b) -- matches a list whose first element is f,
+  ;;					 second is a,
+  ;;					 third is b
+  ;; (? x) -- matches anything, call it x
+  ;; (?c x) -- matches a constant, call it x
+  ;; (?v x) -- matches a variable, call it x
+
+  ;; Skeletons
+
+  ;; foo -- instantiates to itself
+  ;; (f a b) -- instantiates to a 3-list,
+  ;;		results of instantiating each of f, a, b
+  ;; (: x) -- instantiates to the value of x as in the pattern matched
+#+END_SRC
+
+gjs: "it's so much fun to make up a language"
+
+what would we do with such a thing?
+
+we are going to write a program called Simplifier
+#+BEGIN_SRC scheme
+  (define dsimp
+    (simplifier deriv-rules))
+
+  ;; (dsimp '(dd (+ x y) x))
+  ;; -> (+ 1 0)
+#+END_SRC
+
+we have a "deck" of rules
+
+:         +----------+
+:       +----------+ |
+:     +----------+ | |
+:   +----------+ | |-+
+:   |   RULE   | |-+
+:   |  p -- s  |-+
+:   +----------+
+:
+:         "dictionary"
+:  +-------+       +--------------+
+:  | match | ----> | instantiator | ---+
+:  +-------+       +--------------+    |
+:     🡑                                |
+:     |      *expressions*             |
+:     |                                |
+:     +--------------------------------+
+
+--> break
+
+THE MATCHER
+
+:                 +--- PATTERN
+:                 |
+:                 v
+:                +---------+
+: expression --> | matcher | --> dict
+:                +---------+
+:                         |
+:                         v
+:                       dict
+
+the matcher is complicated. i dont think ill reproduce it here
+
+there is a string of case analyses. it ends with the general case,
+an important pattern:
+#+BEGIN_SRC scheme
+  (define (match pat exp dict)
+    (cond ((eq? dict 'failed) 'failed)
+	  ((atom? pat)
+	   ;;...atom patterns
+	   )
+	  ;; ...
+	  ((atom? exp) 'failed)
+	  (else
+	   (match (cdr pat)
+		  (cdr exp)
+		  (match (car pat)
+			 (car exp)
+			 dict)))))
+#+END_SRC
+
+gjs sez: "go do a startup, make a couple mega bucks"
+
+we see our first eval/apply! we wont learn about it today tho
+
+--> break
+
+"gigo"
+  --> garbage in garbage out
+
+the simplifier is a recursive traversal of an expression, in parts
+and in whole.
+
+another idiom:
+#+BEGIN_SRC scheme
+  (define (simplify-exp exp)
+    (try-rules
+     (if (compound? exp)
+	 (map simplify-exp exp)
+	 exp)))
+#+END_SRC
+
+the recursion here is _hard_
+we dont have to think about it
+if we did, we'd get confused
+
+gjs: "learn how to program with abandon

2/4/jord/notes.org

@@ -0,0 +1,102 @@
+* 2.4 Multiple Representations for Abstract Data
+
+how to isolate different design choices to coexist in a program?
+
+  - type tags :: data objects that include explicit information about
+                 how it should be processed
+  - data-directed :: style of programming by additively assembling
+                     systems with generic operations
+
+** 2.4.1 representations for complex numbers
+develop a system for complex number arithmetic with two underlying
+implementations:
+
+  - rectangular form
+  - polar form
+
+#+BEGIN_SRC scheme
+  (define (add-complex z1 z2)
+    (make-from-real-imag (+ (real-part z1) (real-part z2))
+			 (+ (imag-part z1) (real-part z2))))
+  (define (sub-complex z1 z2)
+    (make-from-real-imag (- (real-part z1) (real-part z2))
+			 (- (imag-part z1) (real-part z2))))
+  (define (mul-complex z1 z2)
+    (make-from-mag-ang (* (magnitude z1) (magnitude z2))
+		       (+ (angle z1) (angle z2))))
+  (define (div-complex z1 z2)
+    (make-from-mag-ang (/ (magnitude z1) (magnitude z2))
+		       (- (angle z1) (angle z2))))
+#+END_SRC
+
+two lispers take on the challenge...
+
+#+BEGIN_SRC scheme
+  ;; BEN BITDIDDLE
+  (define (real-part z) (car z))
+  (define (imag-part z) (cdr z))
+  (define (magnitude z)
+    (sqrt (+ (square (real-part z)) (square (imag-part z)))))
+  (define (angle z)
+    (atan (imag-part z) (real-part z)))
+  (define (make-from-real-imag x y) (cons x y))
+  (define (make-from-mag-ang r a)
+    (cons (* r (cos a)) (* r (sin a))))
+#+END_SRC
+
+#+BEGIN_SRC scheme
+  ;; ALYSSA P. HACKER
+  (define (real-part z)
+    (* (magnitude z) (cos (angle z))))
+  (define (imag-part z)
+    (* (magnitude z) (sin (angle z))))
+  (define (magnitude z) (car z))
+  (define (angle z) (cdr z))
+  (define (make-from-real-imag x y)
+    (cons (sqrt (+ (square x) (square y)))
+	  (atan y x)))
+  (define (make-from-mag-ang r a) (cons r a))
+#+END_SRC
+
+** 2.4.2 tagged data
+
+to keep this two systems and to keep them separate, you could make a
+tagging system for data
+
+#+BEGIN_SRC scheme
+  (define (attach-tag type-tag contents)
+    (cons type-tag contents))
+  (define (type-tag datum)
+    (if (pair? datum)
+	(car datum)
+	(error "Bad tagged datum -- TYPE-TAG" datum)))
+  (define (contents datum)
+    (if (pair? datum)
+	(cdr datum)
+	(error "Bad tagged datum -- CONTENTS" datum)))
+#+END_SRC
+
+and then it would be simple to identify the said type
+
+#+BEGIN_SRC scheme
+  (define (rectangular? z)
+    (eq? (type-tag z) 'rectangular))
+  (define (polar? z)
+    (eq? (type-tag z) 'polar))
+#+END_SRC
+
+and so alyssa and ben could use this in their procedures, then name
+their procedures to reflect the work they are doing
+
+#+BEGIN_SRC scheme
+  (define (magnitude z)
+    (cond ((rectangular? z)
+	   (magnitude-rectangular (contents z)))
+	  ((polar? z)
+	   (magnitude-polar (contents z)))
+	  (else (error "Unknown type -- MAGNITUDE" z))))
+#+END_SRC
+
+we will come back to this in §2.5
+
+** 2.4.3 data-directed programming and additivity