#lang racket

(define (tagged-tuple? tag len p)
  (and (list? p)
       (= (length p) len)
       (eq? (car p) tag)))

(define (tagged-list? tag p)
  (and (pair? p)
       (eq? (car p) tag)
       (list? (cdr p))))

;; tree

(define (node x y)
  (list 'node x y))

(define (node? n)
  (tagged-tuple? 'node 3 n))

(define (node-left n)
  (second n))

(define (node-right n)
  (third n))

(define (leaf? n)
  (or (symbol? n)
      (number? n)
      (null? n)))

;; results

(define (res v s)
  (cons v s))

(define (res-val r)
  (car r))

(define (res-state r)
  (cdr r))

;;

;(define (rename t)
;  (define (rename-st t i)
;    (cond [(leaf? t) (res i (+ i 1))]
;          [(node? t)
;           (let* ([rl (rename-st (node-left t) i)]
;                  [rr (rename-st (node-right t) (res-state rl))])
;             (res (node (res-val rl) (res-val rr))
;                  (res-state rr)))]))
;  (res-val (rename-st t 0)))


;; currying

(let ([p (lambda (x y) (+ x y))])
  (p 3 4))

(let ([p (lambda (x y) (+ x y))])
  ((curry p) 3))

(let ([p (lambda (x y) (+ x y))])
  (((curry p) 3) 4))

((let ([p (lambda (x y) (+ x y))])
   ((curry p) 3)) 4)


;;

(define (st-app f x y)
  (lambda (i)
    (let* ([rx (x i)]
           [ry (y (res-state rx))])
      (res (f (res-val rx) (res-val ry))
           (res-state ry)))))

(define get-st
  (lambda (i)
    (res i i)))

(define (modify-st f)
  (lambda (i)
    (res null (f i))))

(define (inc n)
  (+ n 1))

;;

(define (rename t)
  (define (rename-st t i)
    (cond ;[(leaf? t) (lambda (i) (res i (+ i 1)))]
          [(leaf? t)
           (st-app (lambda (x y) x)
                   get-st
                   (modify-st inc))]
          [(node? t)
           (st-app node
                   (rename-st (node-left t))
                   (rename-st (node-right t)))]))
  (res-val (rename-st t 0)))

; WHILE