(define (length xs)
        (if (null? xs)
            0
            (+ 1 (length (cdr xs)))))

; 補助関数 (x1, y1) (x2, y2)を向かい合った頂点とする直立した長方形を描く
(define (draw-rectangle g x1 y1 x2 y2)
        (graphics-operation g 'fill-polygon
            (vector x1 y1 x2 y1 x2 y2 x1 y2)))
; vectorは配列をつくる組み込み関数
;  
(define (graph g l x y w h)
        (if (null? l)
            #t
            (begin 
               (draw-rectangle g x y (+ x w) (+ y (* h (car l))))
               (graph g (cdr l) (+ x w) y w h))))


(define (append xs ys)
        (if (null? xs)
            ys
            (cons (car xs) (append (cdr xs) ys))))

(define (insert x xs)
    (if (or (null? xs) (< x (car xs)))
        (con x xs)
        (cons (car xs) (insert x (cdr xs)))))

(define (delete x xs)
    (if (or (null? xs) (< x (car xs)))
        xs
        (if (= x (car xs))
            (cdr xs)
            (cons (car xs) (delete x (cdr xs))))))

(define (draw-segs g ps)
        (if  (or (null? ps) (null? (cdr ps)))
             #t
             (let* ((p1 (car ps)) (p2 (cadr ps))
                    (x1 (car p1)) (y1 (cadr p1))
                    (x2 (car p2)) (y2 (cadr p2)))
               (graphics-draw-line g x1 y1 x2 y2)
               (draw-segs g (cdr ps)))))


(define (add-point p1 p2)
  (list (+ (car p1) (car p2))
        (+ (cadr p1) (cadr p2))))

(define (move p ps)
        (if (null? ps)
            '()
            (cons (add-point p (car ps))
                  (move p (cdr ps)))))

(define (mult-point p1 p2)
  (let ((x1 (car p1)) (y1 (cadr p1))
        (x2 (car p2)) (y2 (cadr p2)))
       (list (- (* x1 x2) (* y1 y2)) (+ (* x1 y2) (* y1 x2)))))


(define (rotate-and-scale p ps)
        (if (null? ps)
            '()
            (cons (mult-point p (car ps))
                  (rotate-and-scale p (cdr ps)))))

(define (trasform p1 p2 p)
        (add-point p1 (mult-point p (sub-point p2 p1))))

(define (transform-list p1 p2 ps)
        (if (null? ps)
            '()
            (cons (transform p1 p2 (car ps))
                  (transform-list p1 p2 (cdr ps)))))

(define (one-step ps segs)
        (if (or (null? segs) (null? (cdr segs)))
            segs
            (let ((p1 (car segs)) (p2 (cadr segs)))
                 (cons p1
                       (append (transform-list p1 p2 ps)
                               (one-step ps (cdr segs)))))))


(define koch-points
  (list (list (/ 1.0 3) 0)
        (list (/ 1.0 2) (/ (sqrt 3) 6))
        (list (/ 2.0 3) 0)))


(define step0 '((-1 0) (1 0)))
(define step1 (one-step koch-points step0))
(define step2 (one-step koch-points step1))
(define step3 (one-step koch-points step2))
(define step4 (one-step koch-points step3))


(define rule1
  (list (list 0.4 0.2)
        (list 0.6 -0.2)))

(define rule2
  (list (list 0.25 0) (list 0.25 0.25) (list 0.5 0.25) (list 0.5 0)
        (list 0.5 -0.25) (list 0.75 -0.25) (list 0.75 0)))


(define (add1! xs)
        (if (null? xs)
            '()                                 ; add1!の返り値は、適当で良い。
            (begin (set-car! xs (+ (car xs) 1))
                   (add1! (cdr xs)))))
            ; beginは Sec. 3.5 （p 15）参照 

(define (append! xs ys)
        (if (null? (cdr xs))
            (set-cdr! xs ys)
            (append! (cdr xs) ys)))