List Commands Library for 50g

[DavidM]

(09-06-2017 04:55 PM)3298 Wrote:  DO ... LOOP doesn't use the return stack, so combining these may be a simple way to avoid that RSWAP hassle while keeping the benefits.

I'd love to avoid the RSWAPs if I could, but I thought they were still needed inside the DO...LOOP structure. I found where I originally saw the technique: STREAM. It was my first introduction to the concept. It's small enough to use as an example of this concept for any folks that wish to follow along here. I've included the code below, along with some comments to help others understand what we're talking about. Credit where due: this isn't my code, but rather the actual built-in code for STREAM. The comments were added to help understand what it is doing.

As a reminder, UserRPL STREAM puts the first two elements of a list on the stack, then executes the prog/function you give it, then does the same with the rest of the elements. Here's how it does this:

Code:

::
   CK2&Dispatch
   # 50  ( must be list in SL2, and any kind of object in SL1 )
   ::
      ( save the executable object into NULLLAM1 )
      1LAMBIND

      ( make a copy of the list, then... )
      DUP

      ( equivalent of HEAD SWAP TAIL )
      CARCOMP SWAP CDRCOMP

      ( get the list size of TAIL from above )
      DUP LENCOMP

      ( make a copy of the list size and place it above TAIL )
      DUPUNROT

      ( if TAIL is an empty list, raise "Invalid Dimension" error )
      #0=case DimError

      ( Here's where the "magic" happens... the TAIL portion of the list is pushed
        onto the RPL Return Stack. Note that the return stack normally contains the
        addresses of RPL objects that execution will jump to when the current stream
        of RPL objects ends -- in SysRPL parlance: when SEMI is encountered.

        In this case, it is being used in a non-standard [but very clever] way.
        The 'R command is used to POP the next list element, which then leaves
        the return stack pointing at the next list element [or SEMI if at the end].
        As you'll see below, the only "issue" to overcome is that once the loop
        has been initiated, the list is no longer on the top of the return stack,
        so the RSWAPs are needed to temporarily move it to the top and then put it
        back again )

      >R    ( places the list on the return stack )

      ( main loop -- the list size is already in place in SL1 )
      ZERO_DO (DO)

         ( has the user pressed the "ON" key to cancel the loop? exit if so )
         ?ATTNQUIT

         ( swap the list into place, pop the next element, swap it back into place )
         RSWAP 'R RSWAP

         ( execute the "user program or function" object )
         1GETLAM EVAL

      LOOP  ( bottom of DO loop )

      ( this is a necessary step to remove the final SEMI from the RPL return stack )
      RDROP

      ( abandon the NULLLAM containing the user program/function object )
      ABND
   ;
;

Stepping through the above code with the debugging tools shows that the RSWAPs are necessary.

Now, to follow my own advice from another post about learning from others, I'll attempt to convert the above code into an alternative form using 3298's ticR suggestion in place of 'R. I'll skip the loop structure optimization for now to avoid confusion, and this time without the comments to show how small this command really is:

Code:

::
   CK2&Dispatch
   # 50
   ::
      1LAMBIND
      DUP
      CARCOMP SWAP CDRCOMP
      DUPLENCOMP #0=case DimError
      >R
      BEGIN
         ?ATTNQUIT
         RSWAP ticR RSWAP
         ITE ::
            1GETLAM EVAL
            FALSE
         ;
            TRUE
      UNTIL
      ABND
   ;
;

(09-06-2017 04:55 PM)3298 Wrote:  I guess you read the text file that comes with Nosy? It contains some programming tricks in its last section. ...

Thanks for the reminder to go back and take a look at it. I did see that (a long time ago), but must confess that I didn't take the time to digest that section at the time. Your examples are good ones for the power of the optimizations you (and Werner) are using.