COMEFROM (en.wikipedia.org)

IIRC, INTERCAL does implement it.

Some elements of Aspect Oriented Programming are comparable to the COMEFROM statement.

http://en.wikipedia.org/wiki/Aspect-oriented_programming#See...

  (define-syntax comefrom
    (syntax-rules ()
      ((comefrom function expr ...)
       (let ((old-function function))
         (set! function
               (lambda args
                 (begin expr ...)
                 (apply old-function args)))))))
  
  (define (square x)
    (* x x))
  
  (define (hypotenuse a b)
    (sqrt (+ (square a) (square b))))
  
  (comefrom square
            (display "I'm a square!\n"))
  
  (hypotenuse 3 4)

  (define-syntax comefrom
    (syntax-rules ()
      ((comefrom function)
       (call-with-current-continuation
        (lambda (here)
          (set! function here))))))
  
  (define (noop)
    ; Do nothing
    #t)
  
  (define (main)
    (let ((i 0))
      (comefrom noop)
      (if (< i 5)
          (begin
            (set! i (+ i 1))
            (display "Hello world!\n")
            (noop)))))
  
  (main)

To some extent any inversion of control style framework works like this. It can be more or less befuddling depending on the straightforwardness of the framework. Declarative style programming such as sql, xslt, or msbuild also tend to work this way, which can be maddening to debug.

There's a CPAN module for it in Perl 5 (with support for fork() on parallel comefroms):

http://search.cpan.org/dist/Acme-ComeFrom/lib/Acme/ComeFrom....

I don't know if it gets any more obscure than Scheme's call/cc, which is a building block for other control flow structures. You can use it for cool things like the Racket web server, where event-driven programming can be made to feel like sequential, procedural-style programming. You can also use it for sick mind twisters like ((call/cc call/cc) (call/cc call/cc))

Conditions maybe?

They're what lies beyond exceptions: exceptions will unwind the stack looking for a handler (`catch` or the likes), and when found will execute that handler in its (the handler's) context (scope).

Conditions walk the stack instead of unwinding it, and execute the handler in their own context. This gives the handler the possibility of logging an error and bailing out, of course, but also of fixing the local data and resuming running the code[0], as if nothing had happened. A condition system essentially allows callees to reach into callers and ask them what to do, without having to lose any state or data.

This also gives more power to tools: without any specific instrumentation, a Smalltalk environment or a Common Lisp IDE can drop you at the error site (where the condition was signaled) without needing more than registering a condition handler when starting your code (if conditions are already handled by a condition handler in your stack, this default behavior won't happen until your handlers let the condition propagate further).

[0] Actual flexibility depends on the runtime, I'm not completely up to snuff with everything, I know in Common Lisp there's a concept of "restart": the one who signaled the condition or any of its callers can provide "restarts", which are essentially possible choices for resuming work. A log-parsing API could provide restarts to skip a corrupted or unreadable entry, to display a user prompt to ask him to "manually" parse the value or to provide the API with a value to use instead (could be a default, a placeholder, or a value obtained by calling the older log-parser you're trying to replace) (note: it's an inclusive or, the API provides all three and the developer using the API picks the one he wants depending on the situation). Or a dict's `get` method could signal on an invalid key and provide a restart making it return a default value of some sort.

In the original COBOL specification there is the infamous "ALTER X TO PROCEED TO Y" statement which modify a GOTO X in a GOTO Y.

It's actually "An actual example in INTERCAL would be too difficult to read[citation needed]"

Some people have a wicked sense of humour

Reminds me of TWAIN

Toolkit Without An Interesting Name