(define-library (csc ir2)
  (export
    atom-continuation
    atom-expression
    atom?
    ir2=?
    kargs-expression
    kargs-refs
    kargs?
    ktail?
    make-atom
    make-kargs
    make-ktail
    make-update
    update-atom
    update-continuation
    update-ref

    ; Re-exports from IR1.
    constant-expression
    constant?
    lexical-ref-gensym
    lexical-ref-name
    lexical-ref?
    library-ref-library
    library-ref-name
    library-ref?
    make-constant
    make-lexical-ref
    lexical-set-expression
    lexical-set-ref
    lexical-set?
    make-lexical-set
    make-library-ref)
  (import (scheme base)
          (only (csc ir1)
            constant?
            ir1=?
            lexical-ref-gensym
            lexical-ref-name
            lexical-ref?
            lexical-set-expression
            lexical-set-ref
            lexical-set?
            library-ref-library
            library-ref-name
            library-ref?
            make-constant
            make-lexical-ref
            make-lexical-set
            make-library-ref)
          (only (csc loop)
            loop
            return))
  (begin
    ; This library defines the intermediate representation IR2.
    ; It's CPS time bitch.

    ; CPS atom:
    ;   An atom is a value that can be computed immediately without
    ;   any subexpressions.
    ;   Atoms consist of
    ;     - constant,
    ;     - lexical-ref,
    ;     - or library-ref

    ; CPS expressions:
    ;   CPS expressions are similar to IR1 expressions,
    ;   but constrained not to have any subexpressions except atoms.
    ;   And they take a continuation.

    ; CPS continuations
    ;   There are a few continuations.
    ;   Continuations are identified by an integer ID into the
    ;   continuation map.
    ;   Guile calls this map the "continuation soup".


    ; CPS expressions.


    ; An atom consists of an atom and a continuation.
    (define-record-type <atom>
      (make-atom expression continuation)
      atom?
      (expression atom-expression)
      (continuation atom-continuation))


    ; Modifies a library or lexically bound variable to the given atom.
    (define-record-type <update>
      (make-update ref atom continuation)
      update?
      (ref update-ref)
      (atom update-atom)
      (continuation update-continuation))


    ; CPS continuations.


    ; The tail continuation.
    (define-record-type <ktail>
      (make-ktail)
      ktail?)


    ; Binds the incoming values to the given lexically-bound variables
    ; and then evaluates expression.
    (define-record-type <kargs>
      (make-kargs refs expression)
      kargs?
      (refs kargs-refs)
      (expression kargs-expression))


    (define (ir2=?-sametype x y)
      (cond
        ((and (atom? x) (atom? y))
          (and (ir1=? (atom-expression x) (atom-expression y))
               (= (atom-continuation x) (atom-continuation y))))
        ((and (update? x) (update? y))
          (and (ir1=? (update-ref x) (update-ref y))
               (ir1=? (update-atom x) (update-atom y))
               (= (update-continuation x) (update-continuation y))))
        ((and (ktail? x) (ktail? y)) #t)
        ((and (kargs? x) (kargs? y))
          (let ((x-refs (kargs-refs x))
                (y-refs (kargs-refs y)))
            (and (= (length x-refs) (length y-refs))
                 (loop for x-ref in x-refs
                       for y-ref in y-refs
                       unless (ir1=? x-ref y-ref)
                         return #f
                       finally (return #t))
                 (ir2=? (kargs-expression x) (kargs-expression y)))))
        (else #f)))


    (define (ir2=? x y)
      (cond
        ((ir2=?-sametype x y) #t)
        ((and (ir2=?-sametype x x) (ir2=?-sametype y y))
          #f)
        (else (error "One or more arguments has a type unknown to ir2=?" x y))))))