2.2 hierarchical data and closure

2/2/jord/exercises.org

@@ -0,0 +1,193 @@
+* Exercise 2.17
+#+BEGIN_SRC scheme
+  (define (last-pair mylist)
+    (if (null? (cdr mylist))
+        mylist
+        (last-pair (cdr mylist))))
+  (last-pair (list 5 4 3 2))
+#+END_SRC
+
+#+RESULTS:
+| 2 |
+
+* Exercise 2.18
+#+BEGIN_SRC scheme
+  (define (reverse mylist)
+    (define (reverser backwards original)
+      (if (null? original)
+          backwards
+          (reverser (cons (car original) backwards) (cdr original))))
+    (reverser (list) mylist))
+  (reverse (list 1 2 3 4))
+#+END_SRC
+
+#+RESULTS:
+| 4 | 3 | 2 | 1 |
+
+* Exercise 2.19
+#+BEGIN_SRC scheme
+  (define us-coins (list 50 25 10 5 1))
+  (define uk-coins (list 100 50 20 10 5 2 1 0.5))
+
+  (define (cc amount coin-values)
+    (cond ((= amount 0) 1)
+          ((or (< amount 0) (no-more? coin-values)) 0)
+          (else
+           (+ (cc amount
+                  (except-first-denomination coin-values))
+              (cc (- amount
+                     (first-denomination coin-values))
+                  coin-values)))))
+
+  (define (first-denomination coins) (car coins))
+  (define (except-first-denomination coins) (cdr coins))
+  (define (no-more? coins) (null? coins))
+
+  (cc 100 uk-coins)
+#+END_SRC
+
+#+RESULTS:
+: 104561
+
+* Exercise 2.20
+my bday!!
+#+BEGIN_SRC scheme
+  (define (same-parity a . ns)
+    (define (pare a ns)
+      (cond ((null? ns)
+             (list))
+            ((= (remainder (car ns) 2) (remainder a 2))
+             (cons (car ns) (pare a (cdr ns))))
+            (else (pare a (cdr ns)))))
+    (pare a ns))
+  
+  (same-parity 1 2 3 4 5 6 7 8 9)
+#+END_SRC
+
+#+RESULTS:
+| 3 | 5 | 7 | 9 |
+* Exercise 2.21
+#+BEGIN_SRC scheme
+  (define (square-list1 items)
+    (if (null? items)
+	(list)
+	(cons (square (car items)) (square-list1 (cdr items)))))
+
+  (define (square-list2 items)
+    (map (lambda (x) (square x)) items))
+
+  (square-list1 (list 1 2 3 4 5))
+  (square-list2 (list 1 2 3 4 5))
+#+END_SRC
+* Exercise 2.24
+i think louis' problem comes from the fact that the recursion goes to
+the base case before any action is taken, giving reverse order bc the
+last element is processed first. i think.
+
+* Exercise 2.23
+#+BEGIN_SRC scheme
+  (define (my-for-each proc items)
+    (cond ((null? items)
+	   0)
+	  (else
+	   (proc (car items))
+	   (my-for-each proc (cdr items)))))
+
+  (my-for-each (lambda (x) (newline) (display x)) (list 398 24 344))
+#+END_SRC
+* Exercise 2.24
+
+: (list 1 (list 2 (list 3 4)))
+
+: -> (1 (2 (3 4)))
+
+: -> 1|-->2|-->3|-->4|\
+* Exercise 2.25
+
+#+BEGIN_SRC scheme
+  (define a (list 1 3 (list 7 5) 9))
+  (car (caddr a))
+
+  (define b (list (list 7)))
+  (caar b)
+
+  (define c (list 1 (list 2 (list 3 (list 4 (list 5 (list 6 7)))))))
+  (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr c))))))))))))
+  ;; cadadadadadadr? lol
+#+END_SRC
+
+* Exercise 2.26
+
+#+BEGIN_SRC scheme
+  (define x (list 1 2 3))
+  (define y (list 4 5 6))
+
+  (append x y)
+  ;; (1 2 3 4 5 6)
+
+  (cons x y)
+  ;; ((1 2 3) 4 5 6)
+
+  (list x y)
+  ;; ((1 2 3) (4 5 6))
+#+END_SRC
+
+* Exercise 2.27
+#+BEGIN_SRC scheme
+  (define x (list (list 1 2) (list 3 4)))
+
+  x
+  ;; ((1 2) (3 4))
+
+
+  (define (reverse mylist)
+    (define (reverser backwards original)
+      (if (null? original)
+	  backwards
+	  (reverser (cons (car original) backwards) (cdr original))))
+    (reverser (list) mylist))
+
+  (reverse x)
+  ;; ((3 4) (1 2))
+
+  (define (deep-reverse x)
+  )
+  ;; TODO ... idk
+  (deep-reverse x)
+	
+#+END_SRC
+
+* Exercise 2.28
+#+BEGIN_SRC scheme
+  (define x (list (list 1 2) (list 3 4)))
+
+  (define (fringe x)
+    (if (not (pair? (car (cdr x))))
+	(cons 
+	(cons (fringe (car x)) (fringe (cdr x)))))
+
+
+  (fringe x)
+
+  ;; TODO
+  ;; again, idk.. breaking my brain
+#+END_SRC
+
+* Exercise 2.42
+the 8 queens puzzle
+
+#+BEGIN_SRC scheme
+  (define (queens board-size)
+    (define (queen-cols k)
+      (if (= k 0)
+          (list empty-board)
+          (filter
+           (lambda (positions) (safe? k positions))
+           (flatmap
+            (lambda (rest-of-queens)
+              (map (lambda (new-row)
+                     (adjoin-position new-row k rest-of-squares))
+                   (enumerate-interval 1 board-size)))
+            (queen-cols (- k 1))))))
+    (queen-cols board-size))
+#+END_SRC

2/2/jord/lecture.org

@@ -0,0 +1,271 @@
+* Lecture 3A Henderson Escher Example
+https://youtu.be/PEwZL3H2oKg
+
+last time we talked about compound data
+
+data abstraction,, this strange character 'george'
+
+get used to the idea that procedures can be objects
+
+like representing line segments
+
+: (define make-segment cons)
+: (define seg-start car)
+: (define seg-start cdr)
+
+the notion of *closure*
+
+closure is the thing that allows us to build complexity
+
+if we'd like to glue together 1, 2, 3, 4
+there are lots of ways to do it
+
+((1 2) (3 4))
+((1 (2 3)) 4)
+
+lisp likes a list to represent a chain of items
+
+(1 (2 (3 (4 /))))
+
+#+BEGIN_SRC scheme
+  (cons 1
+	(cons 2
+	      (cons 3
+		    (cons 4 nil))))
+#+END_SRC
+
+list provides the convenience 'list'
+
+#+BEGIN_SRC scheme
+  (list 1 2 3 4)
+  (define 1-to-4 (list 1 2 3 4))
+#+END_SRC
+
+the car of the whole thing is the first item
+the second item is the car of the cdr
+the third item is the car of the cdr of the cdr
+etc
+
+we move thru a list by cdring down a list
+
+#+BEGIN_SRC scheme
+  (scale-list 10 1-to-4)
+  (define (scale-list s l)
+    (if (null? 1)
+	nil
+	(cons (* (car l) s)
+	      (scale-list s (cdr l)))))
+#+END_SRC
+
+we should generalize that with a higher order procedure
+
+#+BEGIN_SRC scheme
+  (define (map p l)
+    (if (null? l)
+	nil
+	(cons (p (car l))
+	      (map p (cdr l)))))
+#+END_SRC
+
+scale-list becomes:
+
+#+BEGIN_SRC scheme
+  (define (scale-list s l)
+    (map (lambda (item) (* item s))
+	 l))
+#+END_SRC
+
+we could have written map iteratively, or recursively, but once we
+start thinking in terms of map, we stop thinking about iter vs recurs,
+we think about the aggregate, forgetting the details (control
+structure and order)
+
+comes from APL
+
+there is also for-each, which is like map, but does an action to each
+item rather than returning a list
+
+#+BEGIN_SRC scheme
+  (define (for-each proc list)
+    (cond ((null? list) "done")
+	  (else (proc (car list))
+		(for-each proc
+			  (cdr list)))))
+#+END_SRC
+
+---> break
+
+we'll spend the rest of the time discussing one example
+
+sums everything up to now, including
+  - list structure
+  - abstraction
+  - representation
+  - commonality captured by higher order procedures
+
+will also introduce the 3rd big idea of the course:
+  - metalinguistic abstraction
+
+the very most important thing:
+  when thinking about a language,
+  - primitives
+  - means of combination
+  - means of abstraction
+
+this example was made up by a fella named Peter Henderson
+
+like escher (geb!!)
+
+a language describes these escherian figures
+
+also gets at that procedures vs data thing
+
+if not already, hopefully will be completely confused about that
+
+this language has one PRIMITIVE:
+  - picture
+
+it draws a picture scaled to fill a rectangle
+
+some means of COMBINATION or OPERATION:
+  - rotate
+  - flip
+  - beside
+  - above
+
+great complexity can be quickly built courtesy of closure
+
+how is this language implemented?
+
+the basic element is a rectangle, specified by
+  - an origin (vector)
+  - a horizontal part (vector)
+  - a vertical part (vector)
+
+we can assume we have
+  - make-rect
+  - horiz
+  - vert
+  - origin
+
+to map points to a rectangle
+#+BEGIN_SRC scheme
+  (define (coord-map rect)
+    (lambda (point)
+      (+vect
+       (+vect (scale (xcor point)
+		     (horiz rect))
+	      (scale (ycor point)
+		     (vert rect)))
+       (origin rect))))
+#+END_SRC
+
+how do we get an image to start with?
+
+#+BEGIN_SRC scheme
+  ;; Constructing Primitive Pictures
+  ;;    from Lists of Segments
+
+  (define (make-picture seglist)
+    (lambda (rect)
+      (for-each
+       (lambda (s)
+	 (drawline
+	  ((coord-map rect) (seg-start s))
+	  ((coord-map rect) (seg-end s))))
+       seglist)))
+#+END_SRC
+
+eg,
+#+BEGIN_SRC scheme
+  (define r (make-rect ...))
+  (define g (make-picture ...))
+  (g r) ;; draws g in r
+#+END_SRC
+
+---> break
+
+why's it nice?
+
+once the primitive elements have been defined, means of combination
+just fall out
+
+#+BEGIN_SRC scheme
+  (define (beside p1 p2 a)
+    (lambda (rect)
+      (p1 (make-rect
+	   (origin rect)
+	   (scale a (horiz rect))
+	   (vert rect)))
+      (p2 (make-rect
+	   (+vect (origin rect)
+		  (scale a (horiz rect)))
+	   (scale (- 1 a) (horiz rect))
+	   (vert rect)))))
+#+END_SRC
+
+#+BEGIN_SRC scheme
+  (define (rotate90 pict)
+    (lambda (rect)
+      (pict (make-rect
+	     (+vect (origin rect)
+		    (horiz rect))
+	     (vert rect)
+	     (scale -1 (horiz rect))))))
+#+END_SRC
+
+the real punch line comes with the means of abstraction in this
+language
+
+this language is not only /implemented/ in lisp but /embedded/
+
+all the power of lisp is available to us
+
+#+BEGIN_SRC scheme
+  (define (right-push p n a)
+    (if (= n 0)
+	p
+	(beside p (right-push p
+			      (- n 1)
+			      a)
+		a)))
+#+END_SRC
+
+for some convoluted higer order procedures,
+#+BEGIN_SRC scheme
+  (define (push comb)
+    (λ (pict n a)
+      ((repeated
+	(λ (p) (comb pict p a))
+	n)
+       pict)))
+
+  (define right-push (push beside))
+#+END_SRC
+
+we are trying to nicely embed this language in another (lisp)
+
+there is no difference between data and procedure
+
+is rect a procedure or data? both. neither.
+
+
+theres a more general point about the structure of a system as the
+creating of a language
+
+engineering is creating a language, a sequence of layers of language
+
+harry's wearing sandals!!
+
+
+          language of
+    schemes of combination
+--------------------------------
+          language of
+      geometric positions
+--------------------------------
+          language of 
+        primitive picts
+
+in traditional "engineering", each thing is defined to do one thing
+in lisp, things are designed to talk about entire realms of ideas

2/2/jord/notes.org

@@ -0,0 +1,438 @@
+* 2.2 Hierarchical Data and the Closure Property
+
+!! "it is better to have 100 functions operate on one data structure
+   than 10 functions operate on 10 data structures" -- alan perlis
+
+Box and pointer diagram of (cons 1 2)
+
+:  |    +-----+-----+
+:  +--->|     |     |    +---+
+:       |  *  |  *------>| 2 |
+:       +--|--+-----+    +---+
+:          |
+:          v
+:        +---+
+:        | 1 |
+:        +---+
+
+pairs provide a universal building block from which we can build all
+sorts of data structures
+
+  - closure property :: the ability for pairing pairs
+  - hierarchical structures :: structures made up of parts that are
+       made up of parts that are made up of parts...
+
+note: closure in this sense is not the same as the closure used to
+describe procedures with free variables. the authors do not like the
+use of the term to mean this other thing.
+
+: the sequence 1, 2, 3, 4 repr as a chain of pairs
+
+:     +---+---+   +---+---+   +---+---+   +---+---+
+: --->| * | *---->| * | *---->| * | *---->| * | X |
+:     +-|-+---+   +-|-+---+   +-|-+---+   +-|-+---+
+:       v           v           v           v
+:     +---+       +---+       +---+       +---+
+:     | 1 |       | 2 |       | 3 |       | 4 |
+:     +---+       +---+       +---+       +---+
+
+** 2.2.1 Representing Sequences
+
+one useful structure is the *sequence*, ie a list
+
+#+BEGIN_SRC scheme
+  (cons 1
+	(cons 2
+	      (cons 3
+		    (cons 4 nil))))
+#+END_SRC
+
+scheme provides a primitive for this action
+
+#+BEGIN_SRC scheme
+  (list 1 2 3 4)
+  (define one-thru-four (list 1 2 3 4))
+  (car one-thru-four)
+  (cdr one-thru-four)
+#+END_SRC
+
+#+RESULTS:
+| 2 | 3 | 4 |
+
+#+BEGIN_SRC scheme
+  (define one-thru-four (list 1 2 3 4))
+  (cons 10 one-thru-four)
+  (cadr one-thru-four)
+#+END_SRC
+
+#+RESULTS:
+: 2
+
+list processing (lisping!) is often achieved by "cdring down" lists
+
+#+BEGIN_SRC scheme
+  (define (list-ref items n)
+    (if (= n 0)
+	(car items)
+	(list-ref (cdr items) (- n 1))))
+  (define squares (list 1 4 9 16 25))
+  (list-ref squares 4)
+#+END_SRC
+
+#+RESULTS:
+: 25
+
+we often cdr down the entire list. scheme offeres the primitve ~null?~
+to help
+#+BEGIN_SRC scheme
+  (define (length items)
+    (if (null? items)
+	0
+	(+ 1 (length (cdr items)))))
+  (define odds (list 1 3 5 7 9))
+  (length odds)
+#+END_SRC
+
+if iteration is more to taste,
+#+BEGIN_SRC scheme
+  (define (length items)
+    (define (length-iter a count)
+      (if (null? a)
+	  count
+	  (length-iter (cdr a) (+ 1 count))))
+    (length-iter items 0))
+  (length (list 8 6 7 5 3 0 9))
+#+END_SRC
+
+another common technique is to "cons up" a list of answers while
+"cdring down" a list
+#+BEGIN_SRC scheme
+  (define (myappend list1 list2)
+    (if (null? list1)
+	list2
+	(cons (car list1) (myappend (cdr list1) list2))))
+  (myappend (list 1 2 3 4) (list 0 9 8 7))
+#+END_SRC
+
+#+RESULTS:
+| 1 | 2 | 3 | 4 | 0 | 9 | 8 | 7 |
+
+
+-- MAPPING OVER LISTS --
+
+a very useful operation is applying a transformation to each element
+in a list
+#+BEGIN_SRC scheme
+  (define (scale-list items factor)
+    (if (null? items)
+	(list)
+	(cons (* (car items) factor)
+	      (scale-list (cdr items) factor))))
+  (scale-list (list 1 2 3 4 5) 100)
+#+END_SRC
+
+#+RESULTS:
+| 100 | 200 | 300 | 400 | 500 |
+
+we can abstract this pattern
+#+BEGIN_SRC scheme
+  (define (mymap proc items)
+    (if (null? items)
+	(list)
+	(cons (proc (car items))
+	      (mymap proc (cdr items)))))
+  (mymap abs (list -10 2.5 -11.6 17))
+#+END_SRC
+
+#+RESULTS:
+| 10 | 2.5 | 11.6 | 17 |
+
+scheme provides a map primitive
+
+we can use map to redefine scale-list
+#+BEGIN_SRC scheme
+  (define (scale-list items factor)
+    (map (lambda (x) (* x factor))
+	 items))
+#+END_SRC
+
+the original definition of scale-list drew attention to the
+item-by-item processing. map establishes a higher level of
+abstraction.
+
+!! map abstracts the impl of procedures that operate on lists from the
+   details of how elements are extracted and combined
+
+we are going to look at how this use of sequences provides a framework
+for organizing programs ~~ cool
+
+** 2.2.2 Hierarchical Structures
+representing sequences as lists generalizes to representing sequences
+made of sequences
+
+for example,
+: ((1 2) 3 4) ;; made by
+: (cons (list 1 2) (list 3 4))
+is a list of three items, the first of which is a list
+
+: ((1 2) 3 4) --> |.|.|---------->|.|.|-->|.|\|
+:                  |               |       |
+:                  v               v       v
+:                 |.|.|-->|.|\|    3       4
+:                  |       |
+:                  v       v
+:                  1       2
+
+!! sequences of sequences are really /trees/
+
+to count the leaves in a tree:
+#+BEGIN_SRC scheme
+  (define x (cons (list 1 2) (list 3 4)))
+  (length x)		;; 3
+  (count-leaves x)	;; 4
+  (list x x) ;; (((1 2) 3 4) ((1 2) 3 4))
+  (length (list x x))	;; 2
+  (count-leaves (list x x)) ;; 8
+
+  (define (count-leaves x)
+    (cond ((null? x) 0)
+	  ((not (pair? x)) 1)
+	  (else (+ (count-leaves (car x))
+		   (count-leaves (cdr x))))))
+  (count-leaves x)
+#+END_SRC
+
+MAPPING OVER TREES
+
+#+BEGIN_SRC scheme
+  (define (scale-tree tree factor)
+    (cond ((null? tree) (list))
+	  ((not (pair? tree)) (* tree factor))
+	  (else (cons (scale-tree (car tree) factor)
+		      (scale-tree (cdr tree) factor)))))
+  (scale-tree (list 1 (list 2 (list 3 4) 5) (list 6 7)) 10)
+#+END_SRC
+
+#+RESULTS:
+| 10 | (20 (30 40) 50) | (60 70) |
+
+#+BEGIN_SRC scheme
+  (define (scale-tree tree factor)
+    (map (lambda (sub-tree)
+	   (if (pair? sub-tree)
+	       (scale-tree sub-tree factor)
+	       (* sub-tree factor)))
+	 tree))
+  (scale-tree (list 1 (list 2 (list 3 4) 5) (list 6 7)) 2)
+#+END_SRC
+
+#+RESULTS:
+| 2 | (4 (6 8) 10) | (12 14) |
+
+** 2.2.3 Sequences as Conventional Interfaces
+we have seen the power of data abstraction, we will now look at a new
+powerful design principle for working with data structures:
+  conventional interfaces
+
+consider this procedure, analagous to count-leaves
+#+BEGIN_SRC scheme
+  (define (sum-odd-squares tree)
+    (cond ((null? tree) 0)
+	  ((not (pair? tree))
+	   (if (odd? tree) (square tree) 0))
+	  (else (+ (sum-odd-squares (car tree))
+		   (sum-odd-squares (cdr tree))))))
+#+END_SRC
+
+on the surface, it's rather different than this one for finding even
+fibs
+#+BEGIN_SRC scheme
+  (define (even-fibs n)
+    (define (next k)
+      (if (> k n)
+	  (list)
+	  (let ((f (fib k)))
+	    (if (even? f)
+		(cons f (next (+ k 1)))
+		(next (+ x 1))))))
+    (next 0))
+#+END_SRC
+
+an abstract description shows a common nature
+
+program 1:
+  - enumerates the leaves of a tree
+  - filters, selecting odds
+  - squares selected ones
+  - accumulates the results with +, starting with 0
+
+program 2:
+  - enumerates integers from 0 to n
+  - computes fib for each int
+  - filters, selecting evens
+  - accumulates with cons, starting with empty list
+
+these follow a common pattern ging through the common stages (like a
+signal flow)
+  - enumerate
+  - filter
+  - map
+  - accumulate
+
+these programs could be more elegantly expressed by organizing them to
+follow a signal-flow idea
+
+SEQUENCE OPERATIONS
+
+concentrate on the "signals" that flow from one stage of the program
+to the next. representing these signals as lists allows us to perform
+list operations on them (LISt Processing ?!)
+
+to filter, accumulate, and enumerate
+#+BEGIN_SRC scheme :session signal
+  (define (filter predicate sequence)
+    (cond ((null? sequence) (list))
+	  ((predicate (car sequence))
+	   (cons (car sequence)
+		 (filter predicate (cdr sequence))))
+	  (else (filter predicate (cdr sequence)))))
+
+  (define (accumulate op initial sequence)
+    (if (null? sequence)
+	initial
+	(op (car sequence)
+	    (accumulate op initial (cdr sequence)))))
+
+  ;; to enumerate even-fibs
+  (define (enumerate-interval low high)
+    (if (> low high)
+	(list)
+	(cons low (enumerate-interval (+ low 1) high))))
+
+  ;; to enumerate tree leaves
+  (define (enumerate-tree tree)
+    (cond ((null? tree) (list))
+	  ((not (pair? tree)) (list tree))
+	  (else (append (enumerate-tree (car tree))
+			(enumerate-tree (cdr tree))))))
+
+  (filter odd? (list 1 2 3 4 5))
+  (accumulate + 0 (list 1 2 3 4 5))
+  (enumerate-interval 2 7)
+  (enumerate-tree (list 1 (list 2 (list 3 4)) 5))
+#+END_SRC
+
+#+RESULTS:
+| 1 | 2 | 3 | 4 | 5 |
+
+with that, we can express those funcs as signal flows
+#+BEGIN_SRC scheme :session signal
+  (define (sum-odd-squares tree)
+    (accumulate +
+		0
+		(map square
+		     (filter odd?
+			     (enumerate-tree tree)))))
+  (define (even-fibs n)
+    (accumulate cons
+		(list)
+		(filter even?
+			(map fib
+			     (enumerate-interval 0 n)))))
+#+END_SRC
+
+this style encorages MODULARITY ... cool
+
+we can use those units for any other task, like a list of the squares
+of the first so many fib nums
+#+BEGIN_SRC scheme :session signal
+  (define (fib n)
+      (cond ((= n 0) 0)
+	    ((= n 1) 1)
+	    (else (+
+		   (fib (- n 1))
+		   (fib (- n 2))))))
+  (define (square x) (* x x))
+  (define (list-fib-squares n)
+    (accumulate cons
+		(list)
+		(map square
+		     (map fib
+			  (enumerate-interval 0 n)))))
+  (list-fib-squares 10)
+#+END_SRC
+
+#+RESULTS:
+| 0 | 1 | 1 | 4 | 9 | 25 | 64 | 169 | 441 | 1156 | 3025 |
+
+we could rearrange them to compute odd ints in a sequence
+#+BEGIN_SRC scheme :session signal
+  (define (product-of-squares-of-odd-elements sequence)
+    (accumulate *
+		1
+		(map square
+		     (filter odd? sequence))))
+  (product-of-squares-of-odd-elements (list 1 2 3 4 5))
+#+END_SRC
+
+#+RESULTS:
+: 225
+
+here's another example to get the highest programmer salary
+#+BEGIN_SRC scheme
+  (define (salary-of-highest-paid-programmer records)
+    (accumulate max
+		0
+		(map salary
+		     (filter programmer? records))))
+#+END_SRC
+
+this is just a hint of the great power conferred by sequence ops
+
+we will use em to enable infinite sequences in 3.5 
+
+
+NESTED MAPPINGS
+
+the sequence paradigm can be used in the fashion of nested loops
+for this problem of pairs of numbers that add to primes
+#+BEGIN_SRC scheme
+  (accumulate append
+              (list)
+              (map (lambda (i)
+                     (map (lambda (j) (list i j))
+                          (enumerate-interval 1 (- i 1))))
+                   (enumerate-interval 1 n)))
+
+  ;; this is very common, we can express it like so
+  (define (flatmap proc seq)
+    (accumulate append (list) (map proc seq)))
+
+  (define (prime-sum? pair)
+    (prime? (+ (car pair) (cadr pair))))
+  (define (make-pair-sum pair)
+    (list (car pair) (cadr pair) (+ (car pair) (cadr pair))))
+
+  (define (prime-sum-pairs n)
+    (map make-pair-sum
+         (filter prime-sum?
+                 (flatmap
+                  (lambda (i)
+                    (map (lambda (j) (list i j))
+                         (enumerate-interval 1 (- i 1))))
+                  (enumerate-interval 1 n)))))
+#+END_SRC
+
+to generate unique permutations of a set, {1 2 3} {2 1 3} {3 1 2} etc
+#+BEGIN_SRC scheme
+  (define (permutations s)
+    (if (null? s)
+        (list (list))
+        (flatmap (lambda (x)
+                   (map (lambda (p) (cons x p))
+                        (permutations (remove x s))))
+                 s)))
+  (define (remove item sequence)
+    (filter (lambda (x) (not (= x item)))
+            sequence))
+#+END_SRC