Added my solutions so far

ex-2-30.rkt

@@ -0,0 +1,61 @@
+#lang racket
+
+(define (accumulate op initial sequence)
+  (if (null? sequence)
+      initial
+      (op (car sequence)
+          (accumulate op initial (cdr sequence)))))
+
+(define (square x) (* x x))
+
+;; 2.30 oooh, we getting cool now are we?
+(define (square-tree l)
+  (cond
+    ((null? l) l)
+    ((list? (car l)) (cons (square-tree (car l))
+                           (square-tree (cdr l))))
+    (#t (cons (square (car l))
+              (square-tree (cdr l))))))
+
+(define (square-tree-map l)
+  (map (λ (x)
+         (if (list? x)
+             (square-tree-map x)
+             (square x)))
+       l))
+
+;; 2.31 hohoohoho nice
+(define (tree-map f l)
+  (map (λ (x)
+         (if (list? x)
+             (tree-map f x)
+             (f x)))
+       l))
+(define (square-tree-final l) (tree-map square l))
+
+;; 2.32 hmm.. cool stuff.
+(define (subsets s)
+  (if (null? s)
+      (list '())
+      (let ((rest (subsets (cdr s))))
+        (append rest (map (λ (l) (cons (car s) l)) rest)))))
+;; The reason this works, is because the set of subsets of a set s
+;; can be defined as such:
+;;  - if s is the empty set, the result is a set containing the empty set
+;;  - otherwise, the result is a set containing:
+;;    1. the subsets of s without the first element of s
+;;    2. the subsets of s with the first element of s
+;;    2 can be defined as the first element of s added to every
+;;    subset of s that does not contain the first element of s.
+;; probably not a very rigorous or formal definition, but good
+;; enough for now.
+
+
+;; 2.33
+(define (map p sequence)
+  (accumulate (lambda (x y) ⟨??⟩) nil sequence))
+(define (append seq1 seq2)
+  (accumulate cons ⟨??⟩ ⟨??⟩))
+(define (length sequence)
+  (accumulate ⟨??⟩ 0 sequence))
+