I have no interest in becoming productive, just wanna have fun.

Among other shiny ornaments on the Common-Lisp tree, there are
"continuations", thanks to Paul Graham and his older book. (the entire
book is available free, online, name is "On Lisp")

THE FOLLOWING CODE WON'T WORK UNLESS PAUL GRAHAM'S MACROS ARE LOADED
FIRST - - -

Anyone interested in playing with this, let me know and I will post the
macros and a bit of other code along with them.

Anyhow -
   Assume we have a simple 'progn' form:

(progn
    (print 'first)
    (print 'second)
    (print 'third)
    (print 'fourth)
    (print 'fifth)
     nil)

...and we want to create a continuation in it.

(progn
    (print 'first)
    (print 'second)
                                  <== create a contin' here
    (print 'third)
    (print 'fourth)
    (print 'fifth)
     nil)

Now once our continuation is wedged in there, we are empowered to jump
out of our 'progn' form any time we want to.

If we want to come back to the progn form later and finish up what it
does, fine and dandy.

If we don't want to ever come back, that is also fine and dandy.

Okay, let's jam our continuation in:

(progn
    (print 'first)
    (print 'second)

(=bind () (=values)
   (setq k #'(lambda ()

    (print 'third)
    (print 'fourth)
    (print 'fifth)
     nil)  )))

Now when we run our simple progn form, it displays:
FIRST
SECOND
#<Anonymous Function #x1EC0ACBE>

Okay, the jump-out part works, now let's  *use*  the continuation we
created to  "continue"  the interupted progn-form.

(progn
    (print 'first)
    (print 'second)

(=bind () (=values)
   (setq k #'(lambda ()

    (print 'third)
    (print 'fourth)
    (print 'fifth)
     nil)  ))

(funcall k)  )

Running the above progn form displays:

FIRST
SECOND
THIRD
FOURTH
FIFTH
NIL

Okay, we have our simple progn form 'spiked' with a continuation, so
now we can jump in and out of the progn form at will, anytime we want
to do so.

Here we do just that.  Randomly, according to the "if" section of code,
we  *might*  jump out of the progn form after it prints FIRST, SECOND
and go to a function named "elsewhere".  It takes 'elsewhere' about two
seconds to finish running, and elsewhere's last act is to use our
continuation to kick control back to our humble 'progn' form whereupon
the 'progn' form "continues" from where it was interupted, printing
THIRD, FOURTH, FIFTH.

(progn
    (print 'first)
    (print 'second)

(=bind () (=values)
   (setq k #'(lambda ()

    (print 'third)
    (print 'fourth)
    (print 'fifth)
     nil)  ))

(if (= (random 2) 0)
     (elsewhere)
     (funcall k) ))

I was intrested in learning about A.I.
I learned about Lisp because most A.I. programs were
written in Lisp. I than came to love Lisp as a language
coming from Basic I picked it up rather quick.

When I stated learning C at my Community College I realized how
lucky I was for choosing Lisp.

Copy and paste  *everything*  from between the asterisk lines to your
own file.   This code is necessary to be loaded into Lisp  _before_
the examples in this thread will run.

;****************************************

(defun group (source n)
   (if (endp source)
        nil
        (let ((rest (nthcdr n source)))
           (cons (if (consp rest)
                         (subseq source 0 n) source)
                         (group rest n)) )))

(defmacro abbrev (short long)
    `(defmacro ,short (&rest args)
         `(,',long ,@args)))

(defmacro abbrevs (&rest names)
   `(progn
       ,@(mapcar #'(lambda (pair)
                                `(abbrev ,@pair))
                         (group names 2) )))

(abbrevs
     =setq
     define-symbol-macro)

;; Below are Paul Graham's six macros.  About the only changes
;; that I made were to change his "*cont*" to "%cont%", in order
;; to emphasize that %cont% is not a dynamically-scoped
;; variable.
;;
;; Another change I made was to use "=setq" to ensure that %cont%
;; does not act like a dynamically-scoped variable.
;;
;; =setq is just a convenient shorter abbreviation for CL's built-in
;; macro named "define-symbol-macro"

(=setq
    %cont%
    #'(lambda (&rest args)
            (if (cdr args)
                 args
                 (car args) )))

(defmacro  =lambda (parms &body body)
  `#'(lambda (%cont% ,@parms) ,@body))

(defmacro  =defun (name parms &body body)
  (let ((f (gensym)))
    `(progn
      (defmacro ,name ,parms
        `(,',f %cont% ,,@parms))
      (defun ,f (%cont% ,@parms) ,@body) )))

(defmacro  =bind (parms expr &body body)
  `(let ((%cont%  #'(lambda ,parms ,@body))) ,expr))

(defmacro  =values (&rest retvals)
  `(funcall %cont% ,@retvals))

(defmacro  =funcall (fn &rest args)
  `(funcall ,fn %cont% ,@args))

(defmacro  =apply (fn &rest args)
  `(apply ,fn %cont% ,@args))

;*******************************************
;; End of Paul Graham's six macros from his "On Lisp" book.

A lot of AI problems are very complex in nature.

With Lisp, a person has the freedom to to make a program in "layers".

The top-layer of a complex Lisp program can look almost trivial in
nature, making it very easy to "follow-the-flow" of logic in one's own
program.

One can't appreciate how important this is, until one has gotten "lost"
in one's own program code, as the complexity of the program builds up
and overwhelms the programmer.

That is one reason why tools like "continuations" have to be used with
extreme care, because they aggravate the perceived-complexity of Lisp
code, making it hard to follow-the-flow of cracking a problem.

It is inconvenient to have to run the progn form just to demonstrate
continuations.  It would be nice if we could put the progn form into a
function named "demo".

Unfortunately, when we are dealing with macros as we are doing now,
subtle 'bugs' can occur due tothe way that CL handles macros.

I tried throwing our simpleprogn-form into a regular function named
"demo", but the progn form 'broke' and ceased to produce random output
displays, as it was designed to do.

Below is the only way I know of (presently) to preserve correct way
that our progn form runs.

(defvar  demo)

(setq  demo
    (quote (progn
                  (print 'first)
                  (print 'second)

                  (=bind () (=values)
                      (setq k #'(lambda ()

                  (print 'third)
                  (print 'fourth)
                  (print 'fifth)
                  nil)  ))

                  (if (= (random 2) 0)
                       (elsewhere)
                      (funcall k) ))) )

Now we can run demo, and it will flip between the two types of output
displays in a random manner, as it should.

Typical runs of  (eval demo) below -

Whenever it prints the line WENT-ELSEWHERE-FOR-AWHILE
...a little two-second delay occurs to simulate the time spent
executing the function "elsewhere"

(eval demo)
FIRST
SECOND
WENT-ELSEWHERE-FOR-AWHILE
THIRD
FOURTH
FIFTH
NIL

(eval demo)
FIRST
SECOND
THIRD
FOURTH
FIFTH
NIL

(eval demo)
FIRST
SECOND
WENT-ELSEWHERE-FOR-AWHILE
THIRD
FOURTH
FIFTH
NIL

(eval demo)
FIRST
SECOND
WENT-ELSEWHERE-FOR-AWHILE
THIRD
FOURTH
FIFTH
NIL

We have not done anything really interesting with continuations yet,
but what-the-heck, we are just starting to learn this stuff.

Since what you want is a `top-level' value for %cont% in those cases
where it is not lexically bound, your best bet is to set the
symbol-value.

(eval-when (:load-toplevel :execute)
  (setf (symbol-value '%cont%)
        (lambda (&rest args)
          (if (cdr args)
              args
              (car args)))))

What I am primarily worried about is the fact that the HyperSpec does
not spell out how to handle top level variable-binding.
(am I correct in this assumption?)

If a CL implementor decides to make all his top level variables have
dynamic scope, the HyperSpec might not stop him. That would "break"
Paul Graham's six macros.

Wow! - I just skim-read the definition of eval-when in CLtL2.

They were not kidding about "Its uses are relatively esoteric".

I will have to re-read that definition at least ten times before it
even begins to make sense to me!

I think the best way I can appreciate what eval-when does is to create
a program where a continuation "relies" on the value of %cont% as being
the initial defined value of %cont%.

I assume my present initial-defined-value of %cont% might "break" in
such cases, whereas the eval-when version would be less likely to
break.

Your "eval-when" suggestion really came to my rescue.

Now code works as I want it to work, with eval-when in the act.

Here is the transcript as to how things stand now.

Welcome to the demo version of Macintosh Common Lisp Version 4.3!

? (define-symbol-macro %cont% 'foo)
%CONT%

? %cont%
FOO

? (eval-when (:load-toplevel :execute)
        (setf (symbol-value '%cont%)
            (lambda (&rest args)
                (if (cdr args)
                     args
                    (car args)) )))
#<Anonymous Function #x1EFB8686>

? (let () (defun test () (print %cont%)))
TEST

? (test)
FOO
FOO

? %cont%
FOO

? (unintern '%cont%)
T

? (test)
FOO
FOO
?

? %cont%

Thanks again for the   eval-when   suggestion.

  (define-symbol-macro *cont* #'identity)

instead of the global setq, Graham's continuation macros will
work just fine.

Regards,
--
Nils Gösche
Ask not for whom the <CONTROL-G> tolls.

Joe Marshall kindly pointed out that some of my added code would break
Paul's macros, and suggested that I use the CL "eval-when" here.

After some brief tests, the addition of eval-when does indeed appear to
eliminate difficulties experienced by me when a continuation tries to
go to toplevel

Copy and paste  *everything*  from between the asterisk lines to your
own file.   This code is necessary to be loaded into Lisp  _before_
the examples in this thread will run.

;; CORRECTED VERSION - REPLACE YOUR OLDER VERSION
;****************************************

(defun group (source n)
   (if (endp source)
        nil
        (let ((rest (nthcdr n source)))
           (cons (if (consp rest)
                         (subseq source 0 n) source)
                         (group rest n)) )))

(defmacro abbrev (short long)
    `(defmacro ,short (&rest args)
         `(,',long ,@args)))

(defmacro abbrevs (&rest names)
   `(progn
       ,@(mapcar #'(lambda (pair)
                                `(abbrev ,@pair))
                         (group names 2) )))

(abbrevs
     =setq
     define-symbol-macro)

;; Below are Paul Graham's six macros.  About the only changes
;; that I made were to change his "*cont*" to "%cont%", in order
;; to emphasize that %cont% is not a dynamically-scoped
;; variable.
;;
;; Another change I made was to use "=setq" to ensure that %cont%
;; does not act like a dynamically-scoped variable.
;;
;; =setq is just a convenient shorter abbreviation for CL's built-in
;; macro named "define-symbol-macro"
;;
;; Regarding the "=setq" form immediately below, it might not be
;; necessary however I think it should be left in because a few CL
;; implementors might try to turn toplevel variables like  %cont%  into
;; special variables, which would break Paul Graham's six macros.

(=setq
    %cont%
    #'(lambda (&rest args)
            (if (cdr args)
                 args
                 (car args) )))

(eval-when (:load-toplevel :execute)
        (setf (symbol-value '%cont%)
            (lambda (&rest args)
                (if (cdr args)
                     args
                    (car args)) )))

(defmacro  =lambda (parms &body body)
  `#'(lambda (%cont% ,@parms) ,@body))

(defmacro  =defun (name parms &body body)
  (let ((f (gensym)))
    `(progn
      (defmacro ,name ,parms
        `(,',f %cont% ,,@parms))
      (defun ,f (%cont% ,@parms) ,@body) )))

(defmacro  =bind (parms expr &body body)
  `(let ((%cont%  #'(lambda ,parms ,@body))) ,expr))

(defmacro  =values (&rest retvals)
  `(funcall %cont% ,@retvals))

(defmacro  =funcall (fn &rest args)
  `(funcall ,fn %cont% ,@args))

(defmacro  =apply (fn &rest args)
  `(apply ,fn %cont% ,@args))

;*******************************************
;; End of Paul Graham's six macros from his "On Lisp" book.

Joe Marshall and myself were thrashing out a situation that occurs when
a continuation tries to go all the way to toplevel and terminate the
entire program.

As you know, seldom are continuations used in that fashion, usually
they just hop around inside the program.

For that matter, a standard "throw" would get us to toplevel and
program-termination if that was really what we wanted to do.

Also, if I wanted to, I could setq  the initial global value of
"*cont*"  (or  %cont% ) to 'foo instead of  "#'identity" and Paul's
macros would still work as advertised, except in the case that I
refered to above. (a very unlikely special case)

There is also a nasty side issue here.  The HyperSpec does not "forbid"
a CL implementor from causing all his toplevel variables to be special
variables, which would definately break Paul's macros.

So far, no CL implementations do that nasty trick, but what is to stop
them - nothing in the HyperSpec that I am aware of would stop them.

BTW, the business of departing from #'identity is Paul's code at the
bottom of page 395 of his "On Lisp" book, very handy whenever one wants
to return multiple values to toplevel when terminating the program.

Hope this explains what is going on -

Give me a little time and I will find my notes about the specific
situation where it broke, and I will get back to you.

Example #1 with eval-when
*********************************************
Welcome to the demo version of Macintosh Common Lisp Version 4.3!

? (define-symbol-macro %cont%  #'identity)
%CONT%

? (eval-when (:load-toplevel :execute)
  (setf (symbol-value '%cont%)
        (lambda (&rest args)
          (if (cdr args)
              args
              (car args)))))
#<Anonymous Function #x1EFB84DE>

? (define-symbol-macro k 'meow)
K

? (let ((r  %cont%))
     (defun test () (print(funcall %cont%  'woof))  (setq r 'bow-wow) r
)  )
;Compiler warnings :
;   Undeclared free variable %CONT%, in an anonymous lambda form.
TEST

? (test)
WOOF
BOW-WOW

? (funcall %cont% k)
MEOW
?
*******************************************

Example #2  without eval-when
#################################
Welcome to the demo version of Macintosh Common Lisp Version 4.3!

? (define-symbol-macro %cont%  #'identity)
%CONT%

? (define-symbol-macro k 'meow)
K

? (let ((r  %cont%))
     (defun test () (print(funcall %cont%  'woof))  (setq r 'bow-wow) r
)  )

;Compiler warnings :
;   Undeclared free variable %CONT%, in an anonymous lambda form.

If what you write has no merit (IMO of course), I ignore it.

It appears that the combination of "define-symbol-macro" and
"eval-when" will allow my continuation code to run on all compliant
implementations of CL, so what is the big deal?

  'lexical scope of a toplevel variable in the toplevel environment'

...then things start getting a little hazy.

One interpretation could be that the variable in question in the
toplevel environment is "visible" to every part of your program, except
when shadowed by a variable with the same name.  If the variable in
question is not declared to have dynamic scope, then you have only one
other type of scope that the variable can have, namely lexical scope.

There are only two types of scope when writing about the "scope" of a
variable, dynamic scope or lexical scope.

Now whether the variable scope is "blessed" by the HyperSpec or whether
the scope of the variable is "undefined" is beside the point, because
the scope of a variable *still* has to be one or the other,
dynamically-scoped or lexically-scoped in so far as how it acts in your
program.

For example, in my MCL ver 4.3 all toplevel variables created by setq
act as if they are lexically-scoped throughout the program.

You say that CMUCL toplevel variables are different.  That means to me
that toplevel variables in CMUCL act as if they were
dynamically-scoped.

For example, a toplevel SETQed variable in my MCL acts like it is
lexically-scoped throughout my program.

The only reason I am using "define-symbol-macro" and "eval-when" is to
ensure that my code will run properly on other CL implementations like
CMUCL for example.

We have already told you several times, but you never listen: Paul Graham wrote
his book just before the ANSI standard was finalized.  His code therefore
reflects a slightly older style which IS NO LONGER COMPLETELY CORRECT.  The
book is correct enough to be useful.  But it is not the epitome of perfection.

What you are trying to do is very similar to trying to work with the result of
dividing 1 by 0.  Since you have demonstrated much ignorance, I will inform you
that the result of 1/0 is UNDEFINED.

For all you know, typing "(setq a 1)" into a freshly loaded Lisp could cause
demons to fly out of your nose!

Would you bet your life that any arbitrarily chosen CL-conforming
implementation chooses to scope said variables in a particular way, if at all?

Prove me wrong.  Or stop making broad statements about an issue which you are
clueless about, at least in a forum that better-informed people are reading.

Pascal

(let ((r %cont%))
  (defun test ()
    (print (funcall %cont% 'woof))
    (setq r 'bow-wow)
    r))

As a fix, you might try

(eval-when (:load-toplevel :compile-toplevel :execute)
  (define-symbol-macro %cont% #'identity))

Does it work then?

Regards,
--
Nils Gösche
"Don't ask for whom the <CTRL-G> tolls."

And re. undefined behaviour:

FWIW: I believe that the reason most implementations allow this is to let
you stuff things into toplevel variables during an interactive session
without first defining them.

Cheers,

If you really feel the need you could use the #+ #- macro's to
make sure it works under most implementations. Then you would have to tell
people what Lisp's it worked under ala Screamer.

You could also write Lisp code to add the features missing from ANSI but
even that might not be portable.

If you want it to run across all ANSL compliant Lisps it's going to take
some more work that copying code from "On Lisp." + If you want it to also
work with CLtL1 & CLtL2 Lisps it will take even more work.

One possible drawback I could see is that there might be a call for an
extension to the CL standard for a `tissue system' by which these objects may
be caught and dealt with, and perhaps a way to resume from a sniffle.

P.S. I am sure that nasal demons, or even RMS, could cause quite a bit of
damage to your keyboard and more, depending on how they landed upon emerging
from your nose, and with how much energy they were ejected.

**********************************************
Welcome to the demo version of Macintosh Common Lisp Version 4.3!

? (define-symbol-macro %cont%  #'identity)
%CONT%

? (eval-when (:load-toplevel :execute)
  (setf (symbol-value '%cont%)
        (lambda (&rest args)
          (if (cdr args)
              args
              (car args)))))
#<Anonymous Function #x1EFB84DE>

? (define-symbol-macro k 'meow)
K

? (let ((r  %cont%))
     (defun test ()
         (print (funcall %cont%  'woof))
         (setq r 'bow-wow) r ))
;Compiler warnings :
;   Undeclared free variable %CONT%, in an anonymous lambda form.
TEST

? (test)
WOOF
BOW-WOW

? (funcall %cont% k)
MEOW
?
************************************************

Actually, eval-when frightens me.  At the present time, I find it
extremely difficult to comprehend that built-in CL function.

None of my tutorials explain eval-when, so I am left with trying to
comprehend it by reading  CLtL2.

Not an ideal way to learn.

I have immense respect for whatever Paul Graham writes, with the
possible exception of some stray example code in his books.

From those replies, I can ignore the hate mongers, and sift out
knowledge that is understandable to me.

Why should I abandon such a good learning tool.

Other Lisp newbies won't be influenced by my remarks, because I have
stated up front that I am a Lisp newbie also, many times.

My "clueless" broad remarks merely reflect the present stage of my
understanding, which is subject to daily change and improvement.

That is why I get a kick out of those guys who dig up old erroneous
remarks of mine, that I have long since rejected as wrong, in their
vain efforts to discredit me.

I just ignore them, they obviously have some sort of ego thing where
they feel the need to look clever-by-comparison to a newbie.

If you can't stand the heat in the "clueless" kitchen, stay out.

Just curious if a hardcopy is available, and where.

My Mac, running OS 10.2.4  (so-called "OS X") - froze up when I was
using the downloadable version.  That is the first time in six months
that OS X froze on anything.

I usually leave my Mac powered up all the time.  I have plenty of RAM
in my "Pismo" powerbook, 1024 MBs, so that was probably not the cause
of the freeze.