(define null? (lambda (x) (eq? x '())))

> (null? '())
#t
> (null? '(1))
#f

(define not (lambda (x) (cond
	((eq? x #f) #t)
	(#t #f) )))
> (not #f)
#t
> (not 3)
#f

(define map (lambda (fn l) (cond
	((null? l) '())
	(#t (cons (fn (car l)) (map fn (cdr l)))))))

> (map (lambda (x) (* x 2)) '(1 2 3))
(2 4 6)

(define filter (lambda (fn l) (cond
	((null? l) '())
	((fn (car l)) (cons (car l) (filter fn (cdr l))))
	(#t (filter fn (cdr l))) )))

> (filter (lambda (x) (not(null? x))) '(1 () (2) () 3))
(1 (2) 3)

(define list-ref (lambda (l n) (cond
	((eq? n 0) (car l))
	(#t (list-ref (cdr l) (- n 1))) )))
> (list-ref '(11 22 33 44 55 66) 3)
33

(define replicate (lambda (x n) (cond
	((eq? n 0) '())
	(#t (cons x (replicate x (- n 1)))))))

> (replicate 0 7)
(0 0 0 0 0 0 0)

(define map-2d (lambda (fn ll)
	(map (lambda (l) (map fn l)) ll)))

(map-2d (lambda (x) (/ x 2))
'((1 2)
(3 4)))

> (define board (replicate (replicate 0 3) 3))
> board
((0 0 0) (0 0 0) (0 0 0))
> (define board (map-2d (lambda (x) (+ x 9)) board))
> board
((9 9 9) (9 9 9) (9 9 9))