Question: I have 2 vectors A, B. Using `A.angleTo(B)`, I know the mangitude of the angle between them. 

How do I find the sign of this angle? 
Maybe we need to use some reference vector for this?

Answer: 
One way to implement continuations in an interpreter is to make that interpreter use its own explicit stack for function calling/returning and parameter passing. If you use the stack of the host language, and that language doesn't have continuations, then things are difficult.

If you use your own explicit stack, you can turn it into a "spaghetti stack" for continuations. A "spaghetti stack" is very similar to common representations of lexical environments. It contains frames, which point to parent frames. Capturing a continuation amounts to retaining a pointer to such a frame, and some code. Resuming a continuation means, more or less, restoring the stack to that frame, and the execution to that point in the code. The interpreter for the language doesn't recurse. When the interpreted language nests or recurses, the interpreter iterates and just pushes and pops the explicit stack to keep track of state.

An alternative approach is to use a linear stack, but copy it when a continuation is made. To resume a continuation, you can restore the entire stack from the copied snapshot. This is useful for delimited continuations, which can avoid copying the entire stack, but only that part of it that is delimited (and restore it on top of the existing stack, rather than by replacement). I have implemented delimited continuations in a language that uses the underlying C stack. A segment of the C stack is `memcpy`-d out into an object that lives on the heap. When a continuation is restored, that saved stack segment is blasted on top of the current stack. Pointers have to be adjusted, of course, because the segment is now at a different address, and the "dangling cabling" has to be hooked up to integrate that stack segment into the stack properly.

If a language is treated by compilation to CPS (continuation passing style), then continuations pop out for free. Every function has an implicit hidden argument: the continuation it has received. Function returning is compiled into a call to this continuation. If a block of code in the function needs to compute the current continuation, it just has to compose a small local computational future (representable as a lambda) with that incoming continuation (the future computation that happens when the local part returns). Henry Baker wrote a paper based on the observation that under CPS, since no function ever returns (returns compile to tail calls to the continuation), old stack frames are never revisited. The stack can just be allowed to grow, and when it reaches a limit, it can be "rewound" back to the top. Chicken Scheme implements the concept; it's worth investigating if you're interested in continuations. Chicken Scheme compiles to C code that uses the regular C stack. However, the generated functions never return: they simulate returning by calling continuations, and so the stack grows. What is even more fascinating is that objects which we normally understand as dynamic material are allocated from the stack also. Since nothing returns, those objects are safe. Whenever a certain stack limit is reached, all of the objects on the stack which are still live are moved to the heap, and the stack pointer is rewound back to the top.
First off. All languages has continuations. When you do `7 + n * 5` JavaScript reorders that to `mul_k(n, 5, (_v) => (add _v 7 k)` where `k` is a function that does everything that happnes after that expression. 

Now the first argument to `mul_k` is a continuation. Nothing scary about it except for one little think. You never actually return anything any longer. Every "return" is just passed to it's continuation which always is a tail call. 

A recursive function that itself isn't tail recursive will produce a new closure at each step and nest the next. These are are stored on the heap so non tail recursive functions becomes tail calls with lots of nested closures created.

Here is a small example:

```scm
(define (get-c) (call/cc (lambda (cont) cont)))

(let ((example (get-c)))
  (displayln example)
  (if (procedure? example)
      (example 10)
      "done"))

```

Lets imagine this is the whole program. Lets just write this to JavaScript. 

```js
// simple CPS version of displayln
const displayln = (arg, k) k(console.log(arg));

// simple CPS version of procedure?
const isProcedure = (arg, k) k(arg instanceOf Function);

// Simple CPS version of call/cc
const callCC = (userFun, callCCK) 
  => userFun((result, actualK) => callCCK(result), callCCK);

// simple top level continutation. Not a CPS function.
const kTopLevel = console.log;

// the user function get-c transformed into CPS
const getC = getCK => callCC((cont, k) => k(cont), getCK);

// the let code transformed into CPS
getC((example) => // c1
  displayln(example, (_undefined) => // c2 
    isProcedure(example, (result) => // c3
      result ? example(10, kTopLevel) : kTopLevel("done"))

```

Here is what's happening:

* `getC` gets the whole continuation (`c1`) and it calls `callCC`
* `callCC` calls `c1` with gets `(result, _) => c1(result)` as `example`
* `display` prints `example`, the continuation, passes its undefinded return value to it's continuation `c2`
* `isPorcedure` on `example` and it being a continuation it passes `true` as `result` to continuation `c3`
* being `true` it calls `example(10, kTopLevel)` which becomes `c1(10)`, thus `10` as example
* `display` prints èxample`, the number`10`, passes its underfined return value to its continuation`c2`
* isProcedure on `example` passes `false` as `result` to continuation `c3`
* Being `false` it calls `TopLevel("dome")`
* TopLevel prints "done"

As you can see. `call/cc` is easy peasy as long as the code is transformed to CPS *before* execution. JavaScript supports CPS very well. 

To help with how to convert code to CPS Matt Might has done it [countless times](http://matt.might.net/articles/) in his essays. Look for continuations in that list. He has even done it [in JavaScript](http://matt.might.net/articles/by-example-continuation-passing-style/). 

Now if your implementation needs to beinterpreted you could do the same conversion in Scheme and interpret that instead of user code. If you have continuation barriers you just need CPS from `call/cc` until the barrier.