(define (rl) (load "ex1.ss"))

(define list-recur
  (lambda (f init)
    (letrec ([helper (lambda (l)
		       (cond [(null? l) init]
			     [else (f (car l) (helper (cdr l)))]))])
      helper)))

(define double-any (list-recur (lambda (x y) (cons x (cons x y))) '()))

;;; intended
(define double-list (list-recur (lambda (x y) (list (cons x (car y)) (cons x (cadr y)))) '(()())))

;;; to satisfy format of null case
(define double-list (lambda (ls)
		      (if (null? ls)
			  '()
			  ((list-recur (lambda (x y) (list (cons x (car y)) (cons x (cadr y)))) '(()())) ls))))

(define double-list (lambda (ls)
		      (cond [(null? ls) '()]
			    [else (list ((list-recur cons '()) ls) ((list-recur cons '()) ls))])))

(define double-list (list-recur (lambda (x y)
				  (if (null? y)
				      (list (list x) (list x))
				      (list (cons x (car y)) (cons x (cadr y))))) '()))


(define add1
  (lambda (ls)
    (map (lambda (x) (+ x 1)) ls)))


(define addSomething
  (lambda (ls sth)
    (map (lambda (x) (+ x sth)) ls)))

(define doSomething
  (lambda (ls sth)
    (map sth ls)))

(define returnSomething
  (lambda (sth)
    (lambda (x)
      (sth x))))

(define ls '((1 . "Hello") (2 . "Bye") (3 . "Good") (4 . "Bad")))

(define find
  (lambda (item ls)
    (cond [(null? ls) #f]
	  [(eq? (caar ls) item) (cdar ls)]
	  [else (find item (cdr ls))])))


(define ls1 '((1 "Hello" ()) (2 "Bye" ()) (3 "Good" ()) (4 "Bad" ())))

(define find1
  (lambda (item ls)
    (cond [(null? ls) #f]
	  [(eq? (caar ls) item) (cadar ls)]
	  [else (find1 item (cdr ls))])))


(define item1 '(1 "Hello" ()))
(define item2 '(2 "Bye" ()))
(define item3 '(3 "Good" ()))
(define item4 '(4 "Bad" ()))

(set-cdr! (cdr item1) item2)
(set-cdr! (cdr item2) item3)
(set-cdr! (cdr item3) item4)


(define make-stack
  (lambda ()
    (let ([stack ()])
      (lambda l
	(if (null? l)
	    #f
	    (cond [(eq? (car l) 'push) (set! stack (cons (cadr l) stack))]
		  [(eq? (car l) 'pop) (if (null? stack)
					  #f
					  (let ([item (car stack)])
					    (set! stack (cdr stack))
					    item))]
		  [(eq? (car l) 'empty?) (null? stack)]
		  [else #f]))))))


(define make-global-stack
  (lambda ()
    ()))

(define push
  (lambda (item)
    (set! s (cons item s))))

(define empty?
  (lambda ()
    (null? s)))

(define pop
  (lambda ()
    (if (null? s)
	#f
	(let ([item (car s)])
	  (set! s (cdr s))
	  item))))

(define s (make-stack))

(define nth-largest
  (lambda (n ls)
    (if (< n 1)
	#f
	(nth n (reverse ls)))))

(define nth
  (lambda (n ls)
    (cond [(null? ls) #f]
	  [(= n 1) (car ls)]
	  [else (nth (- n 1) (cdr ls))])))


(define find
  (lambda (item nls)
    (cond [(null? nls) #f]
	  [(list? (car nls)) (or (find item (car nls))
				 (find item (cdr nls)))]
	  [(eq? (car nls) item) #t]
	  [else (find item (cdr nls))])))