# conts

## stevan apter — 2003-06-02 12:13:20

    ----- Original Message -----

    From: <phimvt@...>

    To: <concatenative@yahoogroups.com>

    Sent: Monday, June 02, 2003 12:00 AM

    Subject: Re: [stack] Re: K for Joy Programmers (paper), continuations

    >

    > On Sat, 31 May 2003, stevan apter wrote:

    [..]

    > Apart from explicit continuations like that, Joy still has an

    > operator 'conts' which pushes the current implicit continuations

    > on the stack - but the manual currently warns about its use.

    > It is harmless, and perhaps instructive, to put

    >      conts  putln

    > inside a program to see what outstanding implicit continuations there are.

    > I had hoped that I would find a use for it that could not be achieved by

    > explicit continuations. I have not thought about the topic for quite a

    > while, and for the time being I'll remain openminded. Any ideas?

    >

    an explanation of the behavior of conts would be appreciated.

    if i understand correctly, 'conts' pushes the future of the

    current computation onto the stack.  so i understand

    2 3 conts putln + 4 5 * - .

    [[+ 4 5 * -]]

    -15

    (but why the extra level of quotation?)

    but what's going on here?

    [2 3 conts putln + 4 5 * -] i .

    [[+ 4 5 * -] []]

    -15

    how do you calculate "the future" here?  perhaps a wider range of

    examples will render it obvious.

## John Cowan — 2003-06-02 12:19:10

    stevan apter scripsit:

     > if i understand correctly, 'conts' pushes the future of the

    > current computation onto the stack.  so i understand

    >

    > 2 3 conts putln + 4 5 * - .

    > [[+ 4 5 * -]]

    > -15

    >

    > (but why the extra level of quotation?)

     Because not only the rest of the current quotation, but the rest of

    all quotations in which it is nested, is the value of conts, which is

    why it is conts, not cont.

    --

    Long-short-short, long-short-short / Dactyls in dimeter,

    Verse form with choriambs / (Masculine rhyme):  jcowan@...

    One sentence (two stanzas) / Hexasyllabically   http://www.reutershealth.com

    Challenges poets who / Don't have the time.     --robison who's at texas dot net

## stevan apter — 2003-06-03 00:05:23

    2 3 conts putln + .

    [[+]]

    5

    why isn't conts

        [[putln +]]

    is 'putln' filtered as an assist to debugging when programming

    with continuations?  i.e. as a convenience?

## John Cowan — 2003-06-03 18:44:03

    stevan apter scripsit:

     >     2 3 conts putln + .

    > [[+]]

    > 5

    >

    > why isn't conts

    >

    >     [[putln +]]

    >

    > is 'putln' filtered as an assist to debugging when programming

    > with continuations?  i.e. as a convenience?

     I think because when putln executes the continuation has been changed; i.e.

    conts does not really *save* the continuation.  My naive Scheme implementation

    had this bug.

    --

    Do NOT stray from the path!             John Cowan <jcowan@...>

            --Gandalf                       http://www.ccil.org/~cowan

## stevan apter — 2003-06-03 23:46:01

    ----- Original Message -----

    From: "John Cowan" <cowan@...>

    To: <concatenative@yahoogroups.com>

    Sent: Tuesday, June 03, 2003 2:44 PM

    Subject: Re: [stack] conts

    > stevan apter scripsit:

    > >     2 3 conts putln + .

    > > [[+]]

    > > 5

    > >

    > > why isn't conts

    > >

    > >     [[putln +]]

    > >

    > > is 'putln' filtered as an assist to debugging when programming

    > > with continuations?  i.e. as a convenience?

    >

    > I think because when putln executes the continuation has been changed; i.e.

    > conts does not really *save* the continuation.  My naive Scheme implementation

    > had this bug.

    ck works as i would expect:

      2 3 conts print +

    [[print +]]

    5

    in my implementation, 'eval' is called with two arguments:  x, the stack,

    and y, a list of things to evaluate.  before i enter the evaluation loop,

    i prepend y to the continuation stack C, and when i'm done evaluating, i

    drop that list (which should be empty) from C.  within the evaluation loop

    the logic is:

        drop first item of the current continuation (i.e. next item in y)

        evaluate next item in y

    so when the next item in y is 'conts', i drop 'conts' from the head of

    C[0], leaving (in our example) C[0] = [print +], then evaluate 'conts'

    (which pushes C onto the stack.

    now here's a very strange thing.  a few weeks ago, when we were discussing

    paul chapman's accumulator-generator problem, i was worried about the

    fact that the joy solution contained an explicit self-reference, and i

    thought that it would be possible to implement something like 'self', to

    get the context of the call.  i wrestled with this for an hour or so,

    inadvertently implementing the continuation logic i described above.

    i mean, it was inadvertent since i hadn't even thought about continuations

    at that point (i had to read up on them to remember what they were).

    continuations took care of the future context, but the *past* had

    already been eaten up in the evaluation.  billy saw where i was heading

    before i did, and said so, but i didn't understand his comment at the

    time.

    >

    > --

    > Do NOT stray from the path!             John Cowan <jcowan@...>

    >         --Gandalf                       http://www.ccil.org/~cowan

    >

    >

    > To unsubscribe from this group, send an email to:

    > concatenative-unsubscribe@egroups.com

    >

    >

    >

    > Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/

    >

    >

## Nick Forde — 2003-06-04 09:13:34

    John Cowan writes:

      > stevan apter scripsit:

     > >     2 3 conts putln + .

     > > [[+]]

     > > 5

     > >

     > > why isn't conts

     > >

     > >     [[putln +]]

     > >

     > > is 'putln' filtered as an assist to debugging when programming

     > > with continuations?  i.e. as a convenience?

     >

     > I think because when putln executes the continuation has been changed; i.e.

     > conts does not really *save* the continuation.  My naive Scheme implementation

     > had this bug.

     Looking at interp.c:198 the current implementation of conts_() is:

    PUSH(conts_,LIST_NEWNODE,LIST_NEWNODE(conts->u.lis->next,conts->next))

    Changing this to:

    PUSH(conts_,LIST_NEWNODE,LIST_NEWNODE(conts->u.lis,conts->next))

    Fixes the problem above:

      2 3 conts putln + .

    [[putln +]]

    5

    The variable conts is set in exeterm(). Manfred will have to comment

    on where the bugs are as I'm not sure of the desired behaviour and

    haven't studied this function in any detail. e.g. with the above

    code change:

      1 2 3 [conts 4 5] i 6 7 _.

    [1 2 3 [[4 5] []] 4 5 6 7]

    7

      [[conts [conts 1 2] 3] i] i _.

    [[[[conts 1 2] 3] [] []] [conts 1 2] 3]

    3

    I too have wondered about conts for some time. It seems like it could

    be pretty powerful but I've not yet found a good application. The

    explicit continuations mentioned by Manfred seem easier to use and

    more natural as conts forces an extra level of evaluation. I'm sure

    there must be some scenarios where this isn't the case. I've probably

    just not done enough Joy programming to see them.

    Regards,

    Nick.

## stevan apter — 2003-06-04 12:09:40

    >

    > I too have wondered about conts for some time. It seems like it could

    > be pretty powerful but I've not yet found a good application. The

    > explicit continuations mentioned by Manfred seem easier to use and

    > more natural as conts forces an extra level of evaluation. I'm sure

    > there must be some scenarios where this isn't the case. I've probably

    > just not done enough Joy programming to see them.

     coroutines?

    i've seen the following problem posed in this context.

    you've got a program which recurses through a tree and

    prints each leaf prefixed by depth-many spaces:

    [[[dup @:] dip swap]

     [swap $ ,: sysout]

     [1 + [pt] left]

    ifte] `pt def;

      [[1 2 3]4 5] 0 pt;

     1

     2

     3

    4

    5

    (@: is the leaf predicate, 3 5 $: yields "   5", and

    ,: sysout enlists a string and prints it with a new

    line.  left takes a b [p] and applies p to a[0] b,

    a[1] b, ...  so pt reads:  if atomic, print, else

    apply pt to each subtree with incremented depth.)

    the problem is:  you're given two isomorphic trees.

    write ??? which uses pt to print corresponding leaves:

    [[1 2 3]4 5] [[10 20 30]40 50] 0 ???

     1

     10

     2

     20

     3

     30

    4

    40

    5

    50

    i don't *know* that this can be done with conts, but

    it seems promising.

    any ideas?

     >

    > Regards,

    >

    > Nick.

    >

## phimvt@lurac.latrobe.edu.au — 2003-06-17 03:33:09

    Please ignore this post,

    unless you sent me a private email with the above subject.

    This is just a courtesy reply.

    I responded to your email only today, sorry. But it bounced with

       "illegal host/domain name"     (your spam protection ?)

    There is no point in repeating it here, since if you can read

    this, then you can obviously read the pages.

      - Manfred

## phimvt@lurac.latrobe.edu.au — 2003-06-17 03:57:52

    On Wed, 4 Jun 2003, Nick Forde wrote:

     > John Cowan writes:

     [..]

     > Looking at interp.c:198 the current implementation of conts_() is:

    >

    > PUSH(conts_,LIST_NEWNODE,LIST_NEWNODE(conts->u.lis->next,conts->next))

    >

    > Changing this to:

    >

    > PUSH(conts_,LIST_NEWNODE,LIST_NEWNODE(conts->u.lis,conts->next))

    >

    > Fixes the problem above:

     You are right, of course. I have a very vague recollection (5 years

    ago) that your proposal was actually my first solution, but that

    I changed it for some reason. It had something to do with actually

    executing the continuation, rather than printing it, as in

         ...  conts  execonts ....

    where 'execonts' was something like '[i] step' or so.

    After executing 'conts', the 'execonts' is part of the continuation, and

    what gets executed by the actual call to 'execonts' is the whole

    continuation, starting with 'execonts' (which does NOT find

    an appropriate structure on top of the stack. So it was a sort

    of chicken/egg problem in reverse. But my memory is very vague.

     > The variable conts is set in exeterm(). Manfred will have to comment

    > on where the bugs are as I'm not sure of the desired behaviour and

                                                    ^^^^^^^

    I can't give the sort of specific answer you need. The general

    answer "something useful" is far too vague.

    [..]

     > be pretty powerful but I've not yet found a good application. The

    > explicit continuations mentioned by Manfred seem easier to use and

    > more natural as conts forces an extra level of evaluation.

     It's not as bad as it might seem. It is not that we have an interpreter

    interpreting an interpreter. It is a top-level stepping through

    the conts.

    Thanks for the thoughts, Nick.

    For the time being I won't change the implementation of conts

    until someone finds an application using the old or the new version.

      - Manfred

## phimvt@lurac.latrobe.edu.au — 2003-06-17 04:12:13

    On Wed, 4 Jun 2003, stevan apter wrote:

     > i've seen the following problem posed in this context.

    >

    > you've got a program which recurses through a tree and

    > prints each leaf prefixed by depth-many spaces:

     [..]

     > the problem is:  you're given two isomorphic trees.

    > write ??? which uses pt to print corresponding leaves:

     [..]

     > i don't *know* that this can be done with conts, but

    > it seems promising.

     Yes, maybe. The kind of explicit continuation that I have used

    for backtracking would probably not be useful here.

    Another example, this time for trees that need not be isomorphic,

    the "Same-Fringe" problem (Henderson, the Lispkit book):

    given two trees, determine whether corresponding leaves

    are identical - jump out and return "false" when a different

    pair is encountered. Without the 'jump out' it is easy:

    flatten both trees to form two lists, determine whether

    the two lists are identical. Henderson gives a continuation

    solution.

      - Manfred

## stevan apter — 2003-06-17 13:10:36

    thinking about continuations gives me a headache.  the

    received wisdom seems to be that most of the time you

    don't need them, but every so often you do, and then you

    *really* need them  (your leaf-equality example seems

    to qualify.)

    in the simple case of coroutines, it seems like there

    is a more direct route in joy:  fork the stack.  e.g.

    you have p, which prints a tree by recursing through

    it, keeping track of depth.  you have ... u t [p] where

    u and t are isomorphic trees.  so you have a combinator

    'fork' which takes an int n and a program p and splits

    the stack, then runs each instruction in p sequentially

    across the stacks:

            ... u t 2 [p] fork

    ->

            ... u

            ... t

    when all forks terminate, return something that looks

    like this:

            ... x y

    where x and y are the results left on the forked stacks.

    ?

     ----- Original Message -----

    From: <phimvt@...>

    To: <concatenative@yahoogroups.com>

    Sent: Tuesday, June 17, 2003 12:12 AM

    Subject: Re: [stack] conts

    >

    > On Wed, 4 Jun 2003, stevan apter wrote:

    >

    > > i've seen the following problem posed in this context.

    > >

    > > you've got a program which recurses through a tree and

    > > prints each leaf prefixed by depth-many spaces:

    > [..]

    > > the problem is:  you're given two isomorphic trees.

    > > write ??? which uses pt to print corresponding leaves:

    > [..]

    > > i don't *know* that this can be done with conts, but

    > > it seems promising.

    >

    > Yes, maybe. The kind of explicit continuation that I have used

    > for backtracking would probably not be useful here.

    >

    > Another example, this time for trees that need not be isomorphic,

    > the "Same-Fringe" problem (Henderson, the Lispkit book):

    > given two trees, determine whether corresponding leaves

    > are identical - jump out and return "false" when a different

    > pair is encountered. Without the 'jump out' it is easy:

    > flatten both trees to form two lists, determine whether

    > the two lists are identical. Henderson gives a continuation

    > solution.

    >

    >   - Manfred

    >

    >

    >

    >

    >

    >

    > To unsubscribe from this group, send an email to:

    > concatenative-unsubscribe@egroups.com

    >

    >

    >

    > Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/

    >

    >