top:
  00xxxxxx out in in: expression
  01xxxxxx in  in in: statement
  1xxxxxxx out in in: conditional
expression: up to 64, 1 out, 2 in
  00000000 out sub in: unary-expr
  00000001 out sub in: unary-float-expr
  00xxxxxx out in  in: binary-expr, x > 1
unary-expr: up to 255, 1 out, 1 in
  (set! out in)
  (set! out (car   in))
  (set! out (cdr   in))
  (set! out (unbox in))
  (set! out (not          in))  ; if in == #f then #t else #f
  (set! out (nil?         in))  ; value => bool
  (set! out (pair?        in))  ; value => bool
  (set! out (box?         in))  ; value => bool
  (set! out (vector?      in))  ; value => bool
  (set! out (byte-string? in))  ; value => bool
  (set! out (struct?      in))  ; value => bool
  (set! out (fixnum?      in))  ; value => bool
  (set! out (float?       in))  ; value => bool
  (set! out (make-box     in))  ; value => box
  (set! out (make-struct  in))  ; metastruct => struct
  (set! out (make-float   in))  ; fixnum => float
  (set! out (lambda       in))  ; template-or-lambda => lambda
  (set! out (fix-         in))  ; two's complement / arithmetic negation
  (set! out (bit-not      in))  ; one's complement / bitwise negation
unary-float-expr: up to 255, 1 out, 1 in
  (set! out (float- in))

  ; ISO C
  (set! out (acos   in))
  (set! out (asin   in))
  (set! out (atan   in))
  (set! out (cos    in))
  (set! out (sin    in))
  (set! out (tan    in))
  (set! out (cosh   in))
  (set! out (sinh   in))
  (set! out (tanh   in))
  (set! out (exp    in))
  (set! out (frexp  in))  ; float => (float . fixnum)
  (set! out (log    in))  ; base e
  (set! out (log10  in))
  (set! out (modf   in))  ; float => (float . float)
  (set! out (sqrt   in))
  (set! out (ceil   in))
  (set! out (fabs   in))
  (set! out (floor  in))

  ; SVID & X/Open
  (set! out (erf    in))
  (set! out (erfc   in))
  ;(set! out (gamma  in))  ; obsolete
  (set! out (j0     in))
  (set! out (j1     in))
  (set! out (lgamma in))  ; float => (float . fixnum), actually lgamma_r
  (set! out (y0     in))
  (set! out (y1     in))

  ; SVID & XPG 4.2/5
  (set! out (asinh  in))
  (set! out (acosh  in))
  (set! out (atanh  in))
  (set! out (cbrt   in))
  (set! out (logb   in))

  ; XPG 4.2/5
  (set! out (expm1  in))
  (set! out (ilogb  in))
  (set! out (log1p  in))
  ;(set! out (rint   in))  ; implies changing rounding mode; use floor or ceil
binary-expr: up to 64, 1 out, 2 in
  (set! out (cons             in1 in2))  ; car cdr
  (set! out (make-vector      in1 in2))  ; nelem iv, nelem >= 0
  (set! out (make-byte-string in1 in2))  ; nbytes iv, nbytes >= 0
  (set! out (vector-ref       in1 in2))  ; vector n, 0 <= n < nelem
  (set! out (byte-string-ref  in1 in2))  ; string n, 0 <= n < nbytes
  (set! out (struct-ref       in1 in2))  ; struct n, 0 <= n < nslots
  (set! out (eq?     in1 in2))  ; any values; superset of (fix= in2 in1)
  (set! out (fix+    in1 in2))
  (set! out (fix-    in1 in2))
  (set! out (fix*    in1 in2))
  (set! out (fix/    in1 in2))
  (set! out (fix%    in1 in2))
  (set! out (fix<    in1 in2))  ; == (fix>  in2 in1)
  (set! out (fix>=   in1 in2))  ; == (fix<= in2 in1)
  (set! out (bit-and in1 in2))
  (set! out (bit-or  in1 in2))
  (set! out (bit-xor in1 in2))
  (set! out (fix<<   in1 in2))  ; arithmetic left-shift (2*x) w/ overflow into sign
  (set! out (fix>>   in1 in2))  ; arithmetic right-shift (x/2)
  (set! out (fix>>>  in1 in2))  ; logical right-shift; sign becomes zero (+)
  (set! out (float+    in1 in2))
  (set! out (float-    in1 in2))
  (set! out (float*    in1 in2))
  (set! out (float/    in1 in2))
  (set! out (float<    in1 in2))  ; == (float>  in2 in1)
  (set! out (float>=   in1 in2))  ; == (float<= in2 in1)
  (set! out (atan2     in1 in2))  ; float float
  (set! out (pow       in1 in2))  ; float float
  (set! out (ldexp     in1 in2))  ; float fixnum
  (set! out (fmod      in1 in2))  ; float float
  (set! out (hypot     in1 in2))  ; float float
  (set! out (jn        in1 in2))  ; fixnum float
  (set! out (yn        in1 in2))  ; fixnum float
  (set! out (nextafter in1 in2))  ; float float
  (set! out (remainder in1 in2))  ; float float
  (set! out (scalb     in1 in2))  ; float float
conditional: 1AAAAAAA; 1 out, 2 in + fA
  (set! out (if fA in1 in2))     ; in2 if fA == #f, in1 otherwise
statement: up to 64, 3 in
  (set-box! in in)  ; box value
  (set-car! in in)  ; pair value
  (set-cdr! in in)  ; pair value
  (vector-set!      in in in)  ; vector n value, 0 <= n < nelem
  (byte-string-set! in in in)  ; string n value, 0 <= n < nbytes
  (struct-set!      in in in)  ; struct n value, 1 <= n < nslots

in:
  nil  (00000000) [g0, always NIL]
  gN   (00NNNNNN) [global, N < 64]
  iN   (01NNNNNN) [instance, N < 64]
  fN   (1NNNNNNN) [frame, N < 120]
  --   (11111NNN) [reserved, N < 5]
  argv (11111101) [argument list]
  ctx  (11111110) [dynamic context]
  k    (11111111) [continuation]

out:
  fN   (1NNNNNNN) [0 <= N < 120]

lambda:[
  global: vector of immutable values (g1..gN); shared between instances (lambdas)
  instance: vector of immutable values (i0..iN); shared between frames (calls)
  frame: number of frame variables; initially NIL
  code: byte-string containing sequence of 4-byte instruction words
  tail-call: in-ref of lambda to tail-call
  arguments: in-ref of argument list to pass to tail-call
  context: in-ref of dynamic context to pass to tail-call
  continuation: in-ref of continuation to pass to tail-call
]

template:[
  global: linked
  instance: byte-string of in-refs. to parent instance/frame slots
  frame: copied verbatim
  code: linked
  tail-call: copied verbatim
  arguments: copied verbatim
  context: copied verbatim
  continuation: copied verbatim
]

Protocol:

Normal function calls (return to caller, or caller's continuation if tail-call):
  Call: Tail-call function with valid 'k' and original 'ctx'.
  Return: Tail-call 'k' with 'nil' continuation and context (ignored).

Coroutines (cooperating, interleaved tail-call chains in CPS):
  Call: Tail-call function with valid 'k' and original 'ctx'.
  Return: Tail-call 'k' with valid 'k' and original 'ctx'.

call-with-current-continuation:
  Look up abort handler by prompt tag in incoming 'ctx'.
  call provided lambda with lambda parameter as follows:
    Tail-call abort handler with same parameters and 'k' & 'ctx' from call/cc.

call-with-composable-continuation:
  (define (call-with-composable-continuation proc [prompt-tag (current-prompt-tag)])
    (let [(meta-continuation (prompt-tag-meta-continuation prompt-tag))]
      (call-with-current-continuation
        (lambda (k)
          (let [(result (let [(var (lambda values
                                     (call-with-continuation-prompt
                                       (lambda () (apply k values))
                                       prompt-tag)))]
                          (proc var)))]
            ((meta-continuation) result))))]))

call-with-continuation-prompt:
  (define (call-with-continuation-prompt body-thunk
                                         [prompt-tag (current-prompt-tag)]
                                         [abort-proc (lambda (fn . args)
                                                       (apply fn args))])
    (let [(meta-continuation (prompt-tag-meta-continuation prompt-tag))
          (abort-handler (prompt-tag-abort-handler prompt-tag))]
      (call-with-current-continuation
        (lambda (k)
          (parameterize [(meta-continuation k)
                         (abort-handler abort-proc)]
            (let [(result (body-thunk))]
              ((meta-continuation) result))))))]))

parameterize:
  Call thunk with 'k' and updated context.
  New context includes (parameter => value) association.

# vim:set sw=2 expandtab tw=0: