One more time!

Now we’re getting ugly. Hmmmmmm.

(define (onemoretime fails? lst func)
  
  ;; acc is usually the result of the
  ;; "reduce so far", here it is the
  ;; last pair in newlst. cur is
  ;; current item of consideration
  ;; in the original list. 
  (define (foo acc cur)
    ;; func should return a new
    ;; pair, which gets tacked
    ;; onto the end of newlst.
    (set-cdr! acc (func cur))
    ;; Have lfold push the new
    ;; pair into acc next
    ;; time it loops.
    (rest acc))

  (define (bar acc cur)
    ;; Here, func is allowed to 
    ;; return #f signalling to 
    ;; leave acc alone.
    (let ((tst (func cur)))
      (if tst
	  (begin (set-cdr! acc tst)
		 (rest acc))
	  acc)))

  ;; Grab pointer to first cons.
  ;; Contents of car will be dropped.
  ;; Contents of cdr will be clobbered. 
  (let ((newlst (list #f))) 
    (lfold (if fails? bar foo)
	   newlst ; Accumulator
	   lst) ; list we're deriving from
    (rest newlst))) ; car is trash, see above.

Examples so far:

(define (append hd tl)
  (onemoretime #f hd (lambda (nxt) 
                                   (cons nxt tl))))

(define (map func lst)
  (onemoretime #f lst (lambda (nxt) 
                                   (list (func nxt)))))

(define (filter pred? lst)
  (onemoretime #t lst (lambda (nxt)
			           (if (pred? nxt)
			               (list nxt)
			               #f))))

About these ads