(use-modules (ice-9 control))

(define kont)
(define tmp (lambda (k)
              (set! kont k)
              (k (+ 1 2))))


(define kont)
(* 2 (+ 1 5))
(+ 1 5)
(+ 1 [])

(* 2 (reset (+ 1 (shift k (set! kont k) (k 5)))))

(* 2 (reset (+ 1 (shift k (set! kont k) (k 5)))))

(kont 7)


(begin
  (let ((x 1))
    (reset
     (display "before\n")
     (+ 1 (shift k (set! kont k) 2))
     (display x)
     (display "after\n")
     4)))

(kont (kont 9))

(* 2 (reset (+ 1
               (dynamic-wind
                 (lambda () (display "entered\n")) ; pre-hook
                 (lambda () (shift k (set! kont k) 2)) ; body
                 (lambda () (display "exited\n")) ; post-hook
                 ))))

(with-continuation-barrier
 (lambda ()
   (define tmp #t)
   (display (+ 1 (call/cc (lambda (k) (set! kont k) 3))))
   (when tmp
     (set! tmp #f)
     (kont 6)))) ;; prints 4 7

(kont 3)

(define adder
  (reset (+ 1 (shift k k))))

(define adder
  (+ 1 (call/cc (lambda (k) k))))
(adder
 (adder 5))

(define my-real-lambda
  (my-lambda t (+ 3 t)))

(my-real-lambda (my-real-lambda 7))


(define-macro (my-lambda arg-name body)
  `(reset
    (let ((,arg-name (shift k k)))
           ,body)))

(define (loop res c)
  (if (= c 3)
      res
      (loop (cons c res) (+ 1 c))))
(loop '() 0)

(let loop ((res '())
           (c 0))
  (if (= c 3)
      res
      (loop (cons c res) (+ 1 c))))

(define (range)
  (define (get-elem return)
    (let loop ((i 0))
      (set! return (call/cc (lambda (k) (set! get-elem k) (return i))))
      (loop (+ 1 i))))

  (lambda ()
    (call/cc get-elem)))

(define rg (range))
(rg)

;; (define rg (range 0 3))
;; (rg)

;; (reset
;;  ((lambda (x)
;;     (display "entered")
;;     (let* ((return (lambda (t) (shift k (set! kont k) t)))
;;            (val (return x)))
;;       (display "exited")
;;       val
;;       "hi")) 5))

;; (kont 3)


(+ 1 (+ 3 4))
(+ 1 [])

;; (* 2 (reset (+ 2 (shift k k))))