Practising recursion with accumulate, filter and map for deeply nested lists

I'm practising recursion going through some of the exercises in David Evans book Introduction to Computing, Explorations in Language, Logic, and Machines.

These are the solutions to three of those exercises:

1. An accumulate (reduce) function for a list which can contain arbitrarily deeply nested lists.
   
   

   	#lang racket
   	(require rackunit)
   	(define (deep-list-accumulate comb base dls)
   	(if (null? dls)
   	base
   	(let [(first-dls (first dls))]
   	(comb (deep-list-accumulate comb base (rest dls))
   	(if (list? first-dls)
   	(deep-list-accumulate comb base first-dls)
   	first-dls)))))
   	(define (deep-list-sum dls)
   	(deep-list-accumulate + 0 dls))
   	(define (deep-list-prod dls)
   	(deep-list-accumulate * 1 dls))
   	(check-equal?
   	(deep-list-sum '()) 0)
   	(check-equal?
   	(deep-list-sum (list (list 1))) 1)
   	(check-equal?
   	(deep-list-sum (list (list 1) (list 1))) 2)
   	(check-equal?
   	(deep-list-sum (list 1 (list 1))) 2)
   	(check-equal?
   	(deep-list-prod (list 1 (list 2 (list 3 (list 4))))) 24)

   view raw deep-list-accumulate.rkt hosted with ❤ by GitHub
2. A map function for a list which can contain arbitrarily deeply nested lists.
   
   

   	#lang racket
   	(require rackunit)
   	(define (deep-list-map f dls)
   	(if (null? dls)
   	null
   	(let [(first-dls (first dls))]
   	(cons
   	(if (list? first-dls)
   	(deep-list-map f first-dls)
   	(f first-dls))
   	(deep-list-map f (rest dls))))))
   	(define (deep-list-square dls)
   	(deep-list-map (lambda (x) (* x x)) dls))
   	(define (deep-list-double dls)
   	(deep-list-map (lambda (x) (* 2 x)) dls))
   	(check-equal?
   	(deep-list-square (list 2))
   	(list 4))
   	(check-equal?
   	(deep-list-square (list 1 (list 2 (list 3))))
   	(list 1 (list 4 (list 9))))
   	(check-equal?
   	(deep-list-double (list 1 (list 2 (list (list 2 3 4) 3 (list 4)))))
   	(list 2 (list 4 (list (list 4 6 8) 6 (list 8)))))

   view raw deep-list-map.rkt hosted with ❤ by GitHub
3. A filter function for a list which can contain arbitrarily deeply nested lists.
   
   

   	#lang racket
   	(require rackunit)
   	(define (deep-list-filter pred dls)
   	(if (null? dls)
   	null
   	(let [(first-dls (first dls))
   	(rest-dls (rest dls))]
   	(if (list? first-dls)
   	(cons (deep-list-filter pred first-dls)
   	(deep-list-filter pred rest-dls))
   	(if (pred first-dls)
   	(cons first-dls
   	(deep-list-filter pred rest-dls))
   	(deep-list-filter pred rest-dls))))))
   	(define (even? x)
   	(zero? (modulo x 2)))
   	(define (evens-in dls)
   	(deep-list-filter even? dls))
   	(define (odds-in dls)
   	(deep-list-filter
   	(lambda (x) (not (even? x)))
   	dls))
   	(check-equal?
   	(evens-in (list 2 3 4))
   	(list 2 4))
   	(check-equal?
   	(odds-in (list 2 3 4))
   	(list 3))
   	(check-equal?
   	(odds-in (list 1 (list 2 (list 3))))
   	(list 1 (list (list 3))))
   	(check-equal?
   	(evens-in (list 1 (list 2 (list 3))))
   	(list (list 2 (list))))
   	(check-equal?
   	(evens-in (list 1 (list 2 (list (list 2 3 4) 3 (list 4)))))
   	(list (list 2 (list (list 2 4) (list 4)))))
   	(check-equal?
   	(odds-in (list 1 (list 2 (list (list 2 3 4) 3 (list 4)))))
   	(list 1 (list (list (list 3) 3 (list)))))

   view raw deep-list-filter.rkt hosted with ❤ by GitHub

You can find these and other exercises and examples from the book in this GitHub repository.

I'm loving the book.