I just browsed on the assignment, but it's due Nov 12. In what way I could be of help.

BTW, does your textbook cover template well?
Maybe you need sth extra.

Unfortunately I cannot read postscript files,
otherwise I might be able to help.

I would like to recommend a book --
C++ Primer, 3rd Edition (Addison-Wesley)
by Stanley B. Lippman & Josee Lajoie

IMHO, this is by far the best C++ textbook on the market.
It covers the advanced features, such as templates,
classes, exception handling, inheritances thoroughly
and also provides a tremedous amount of examples.

You may bypass the Personal Bookshelf interface by entering the URL of a e-book directly, for example, the ISBN code for
"Teach Yourself JAVA 1.1 PROGRAMMING in 24 Hours"
is 1-57521-270-6 .

One can access the e-book or retrieve everything using some "mirroring" utility by this URL:
http://www.mcp.com/??7670400/
1-57521/1-57521-270-6/index.htm (in one line)

You may find your own ??7670400 by opening in New Window a chapter of any e-book and add 86400 (24*3600) to it for daily renewal.

I guess it would be easy IF we can do it in C or C++ or something...
I guess it would be easier IF you use a single language through the course, Scheme and MT(?) are two of the better choices.

also IF I'm familiar with the Scheme/Prolog syntax.
You don't need to know too much for the sake of the assignment.

For the sake of the assignment, you may consult any LISP book and the R4RS documnetation (available online, from the links on the MIT page, let me see... yeap, they are in WinHelp format come with the MIT Scheme program.) If you are really lost with Scheme, I guess I can help you work out the first few problems by providing you some dumb implemnetations and let you improve on them.

For Prolog, I suppose you need very minimal study material, there should be some Tutorial available online... try finding them.

Well, one possible soln for prob 4 is:

(define append

  (lambda ls (apply +

                   (map (lambda (l) (apply + l)) 

                        ls) )))

(let ((x1 e1)

      ...

      (xn en))

 e)

((lambda (x1 ... xn) e) e1 ... en)

For instance,

;;; ----------------------------------------

;;; subsets procedure

;;;

;;; parameter: l - a list, treated as a set

;;; return   : a list of the 'subsets' of l

;;;

;;; algorithm: reduction!!

;;;   base case: subsets[()] = (())

;;;   induction: subsets[(a ls)] = (a%ss[ls] ss[ls])

;;;     where ss[ls] = a bunch of elements in subsets[ls]

;;;     & a%[X] = (a x1) (a x2) ... (a xn), n = |X|

;;;

;;; ----------------------------------------

(define (subsets l)

 (if (null? l)

	 '(())  ; returns list of empty list

	 ((lambda (m ls)

              (append (map (lambda (x) (cons m x)) 

                           ls)

                      ls))

	  (first l)  ; i.e. arg m

      (subsets (rest l)))))  ; arg ls

Also, other higher-order procedures can be reduced to lower-order functions, for example

(define (map procedure list)

  (if (null? list)

      '()

      (cons (procedure (car list))

            (map procedure (cdr list)) )))

Could you please tell me your understanding on "unrestricted lambda"? (here lambda is a noun, what is a lambda???)