(newRPL) List extension library - LstX

[Gilles]

LstX is a library for all devices supporting newRPL. It is oriented on the manipulation of lists, combinations, permutations, filter, grouping, insertion, deletion of elements in a list etc. It also integrates some commands for processing character strings and compensates for certain shortcomings of the newRPL. This library is largely inspired by ListExt for HP 49/50g by David Mutter although the commands or syntaxes are sometimes different. New commands have also been added as you can see in the documentation.

Version 1.01c contains 63 commands organized in 8 submenus. Each command has an integrated help (long press on the menu key) and is integrated into newRPL's autocompletion entry (which is really very practical).

Download here the documentation to install and use LstX
Download here the code to install (ATTACH) on the device

[Gilles]

Here is the code v1.0d, without google drive :

Code:


@================================================================
@  List Extension for newRPL  Août 2023
@----------------------------------------------------------------
DIRECTORY
@---------------------------------------------------------------
'$LIBID' 'LstX' 
@---------------------------------------------------------------
'$TITLE' 
"List extended lib v1.01d Nemo59
Thanks to Claudio L. (newRPL)
and to D. Mutter (ListExt)" 
@================================================================
'LSEQ'   
  « → a  
   « CASE 
       a 1  ≥ THEN  1 a FOR 'n' n NEXT a →LIST END
       a -1 ≤ THEN -1 a FOR 'n' n -1 STEP a NEG →LIST END
      {} 
     END   
   » 
  »
@----------------------------------------------------------------
'LSEQR'   
  « → a b  
   « IF a b ≤  THEN 
      a b FOR 'n' n NEXT 
     ELSE 
      a b FOR 'n' n -1 STEP 
     END 
     a b - ABS 1 + →LIST
   »
  »
@----------------------------------------------------------------
'LASEQ'
  « → dep diff nbr 
   « 
    CASE 
     nbr NOT  THEN {} END
     nbr 1 == THEN dep 1 →LIST END
     dep 
     2 nbr START DUP diff + NEXT
     nbr →LIST
    END
   »
  » 
@----------------------------------------------------------------
'LMSEQ'   
  « → a b c 
   « CASE
       c 0 ≤ THEN {} END
       c 2 < THEN a 1 →LIST END
       a DUP     
       2 c START b * DUP NEXT
       DROP c →LIST
     END
   »
  »
@----------------------------------------------------------------
'LDSEQ' « SWAP INV SWAP LMSEQ »
@----------------------------------------------------------------
'LMRPT'
  « → List a  
   « {}
     IF a 1 ≥ THEN 1 a START List ADD NEXT END    
   » 
  »
  
@----------------------------------------------------------------
'LWHL'
  « DEPTH 3 - → LWHL.Pa LWHL.Pc LWHL.d
    « DO  
       DUP LWHL.Pa EVAL
      UNTIL DUP LWHL.Pc EVAL NOT END
      DROP
      DEPTH LWHL.d - →LIST
    »
  »
@----------------------------------------------------------------
'LDDUP'
  « 
   IF DUP SIZE 1 >  THEN
     REVLIST LIST→ {}
     1 ROT START
       IF SWAP DUP2 POS THEN DROP ELSE
         IF DUP TYPE 62 == THEN 1 →LIST END ADD 
       END
     NEXT 
   END
  » 
@----------------------------------------------------------------
'LPOP' « DUP HEAD SWAP TAIL SWAP »
@----------------------------------------------------------------
'LPOPR' « DUPDUP SIZE 1 - LFRST SWAP 1 LLAST LIST→ DROP »
@----------------------------------------------------------------
'LPUSH' « 1 →LIST SWAP ADD »
@----------------------------------------------------------------
'LPSHR' « 1 →LIST ADD »
@----------------------------------------------------------------
'LPICK' « SWAP → List « « List SWAP GET » MAP » »
@----------------------------------------------------------------
'LREPL' « ROT → List « 2 « 'List' UNROT REPL » DOLIST DROP List » »
@----------------------------------------------------------------
'LRMOV'
  « → List r 
   « IF r TYPE 10 == THEN
      @.........................................................
      @ Working with the stack in not significantly faster
      @ and more complicated than using two SUB. 
      @ Very different versus stock RPL
      @.........................................................
      List 1 r 1 - SUB
      List r 1 + List SIZE SUB
      ADD 
     ELSE
      IF r SIZE THEN 
       @.........................................................
       @ See to ameliorate? Not obvious because of // process
       @ For exemple { a b c d e } { 2 2 4 } LRMOV => { a c e }
       @ <=>  { a b c d e } 2 LRMOV 3 LRMOV  that is a lot faster
       @.........................................................
       r LDDUP SORT REVLIST
       1
       « → ri 
        « List 1 ri 1 - SUB 
          List ri 1 + List SIZE SUB
          ADD 'List' STO
        » 
       » 
       DOSUBS DROP List    
      END   
     END 
   » 
  »
@----------------------------------------------------------------
'LINSR'
  « → List n o
   « List n 1 - LFRST o ADD List DUP SIZE n - 1 + LLAST ADD »
  »
@----------------------------------------------------------------
'LFRST'  « 1 SWAP SUB »
@----------------------------------------------------------------
'LLAST' « OVER SIZE DUP ROT - 1 + SWAP SUB »
@----------------------------------------------------------------
'LDWHL'
  « OVER SIZE → LDWHL.List LDWHL.p LDWHL.s
   « IF LDWHL.s NOT THEN {} ELSE 
       0 'LDWHL.n' LSTO
       WHILE 'LDWHL.List' 'LDWHL.n' INCR GET LDWHL.p REPEAT END 
       LDWHL.List LDWHL.n LDWHL.s SUB
     END
   »
  »
@----------------------------------------------------------------
'LTWHL'
  « OVER SIZE → LTWHL.List LTWHL.p LTWHL.s
   « IF LTWHL.s NOT THEN {} ELSE 
       0 'LTWHL.n' LSTO
       WHILE 'LTWHL.List' 'LTWHL.n' INCR GET LTWHL.p REPEAT END 
       LTWHL.List 1 LTWHL.n 1 - SUB
     END
   »
  »
@----------------------------------------------------------------
'LDROP'
  « 0 RND → n
   « CASE
       n 0 > THEN DUP SIZE n 1 + SWAP SUB END
       n 0 < THEN DUP SIZE n + 1 SWAP SUB END
     END
   »
  »
@---------------------------------------------------------------
'LFILT'  
  « → LFILT.Filter 
    « 1 « IF DUP LFILT.Filter NOT THEN DROP END » DOSUBS »
  » 
@----------------------------------------------------------------
'LROLL' « DUP SIZE → List s « List 1 LLAST List s 1 - LFRST ADD » »
@----------------------------------------------------------------
'LRLLD' « DUP TAIL SWAP HEAD ADD »
@----------------------------------------------------------------
'LROT'
   « OVER SIZE → List a s  
    « CASE 
        a 0 > THEN List a LLAST List s a - LFRST  ADD END
        a 0 < THEN 'a' SNEG List s a - LLAST List a LFRST ADD END 
       List
      END   
    »
   »
@----------------------------------------------------------------
'LSWAP'  
   « PICK3 TYPE  → a b t
    « CASE
        t 62 == THEN  @ it's a list { ... }
                  DUP a GET OVER b GET
                  UNROT b SWAP PUT SWAP a SWAP PUT
                END
        t 32 == THEN @ It's a variable containing a list 
                  DUPDUP a GET OVER b GET
                  UNROT b SWAP PUT a SWAP PUT
                END
      END
    »
   »
@---------------------------------------------------------------
'LSHUF'
   « IF DUP TYPE 10 == THEN LSEQ END 
     LIST→ → s  
    « 
      1 s FOR n
        s n - 1 + RAND * IP n + ROLL
      NEXT
      s →LIST
     »
   »
@----------------------------------------------------------------
'DOPERM' 
@................................................................
@ DOPERM.L : Liste
@ DOPERM.P : Programme a éxécuter pour chaque permutation
@ DOPERM.T : Taille de de liste à permuter
@ DOPERM.B : Gestion du BREAK
@ DOPERM.S : Mémorise taille de la pile pour générer liste retour 
@ DOPERM.G : S/Prog récursif pour générer les permut successives
@................................................................

 « OVER SIZE 0 DEPTH 4 - → DOPERM.L DOPERM.P DOPERM.T DOPERM.B DOPERM.S
    «
       « 1 'DOPERM.B' STO »
  
       «  → DOPERM.K
         «
           IF DOPERM.B THEN 1 'LstX.Break?' LIBSTO EXIT END
           IF 'DOPERM.K==1' THEN DOPERM.L DOPERM.P  
           ELSE
             DOPERM.K 1 - DOPERM.G  
             1 DOPERM.K 1 - FOR 'DOPERM.I'
                IF DOPERM.K 2 MOD THEN
                 'DOPERM.L' 1 GET 'DOPERM.L' DOPERM.K GET
                 'DOPERM.L' 1 ROT PUT 'DOPERM.L' DOPERM.K ROT PUT
                ELSE
                 'DOPERM.L' DOPERM.I GET 'DOPERM.L' DOPERM.K GET
                 'DOPERM.L' DOPERM.I ROT PUT 'DOPERM.L' DOPERM.K ROT PUT
                END
                DOPERM.K 1 - DOPERM.G  
             NEXT
           END
         » 

       » → BREAK DOPERM.G
         « 
           0 'LstX.Break?' LIBSTO
           DOPERM.T DOPERM.G EVAL
           DEPTH DOPERM.S - →LIST
         »
    » 
  »
@---------------------------------------------------------------
'DOCOMB'
@...............................................................
@ DOCOMB.L : Liste
@ DOCOMB.R : Nbr d'items à combiner
@ DOCOMB.P : Programme a éxécuter pour chaque combinaison
@ DOCOMB.E : Taille de de liste initiale
@ DOCOMB.B : Gestion du BREAK
@ DOCOMB.S : Mémorise taille de la pile pour générer liste retour 
@ DOCOMB.G : S/Prog récursif pour générer les combi successives
@................................................................

  « PICK3 SIZE PICK3 0 SWAP NDUPN →LIST 0 DEPTH 6 -
    → 'DOCOMB.L' 'DOCOMB.R' 'DOCOMB.P' 'DOCOMB.E' 'DOCOMB.D' 'DOCOMB.B' 'DOCOMB.S'
    « 
      « 1 'DOCOMB.B' STO » @ BREAK
  
      «  → DOCOMB.I DOCOMB.X 
        «
          IF DOCOMB.B 'LstX.Break?' LIBRCL OR THEN EXIT END
          IF  DOCOMB.X DOCOMB.R 1 + ==  THEN DOCOMB.D DOCOMB.P 
          ELSE
            IF DOCOMB.I DOCOMB.E ≤ THEN
              'DOCOMB.L' DOCOMB.I GET 'DOCOMB.D' DOCOMB.X ROT PUT
              DOCOMB.I 1 + DOCOMB.X 1 + DOCOMB.G
              DOCOMB.I 1 + DOCOMB.X DOCOMB.G
            END 
          END
        » 
      »
      → BREAK DOCOMB.G
      « 
        0 'LstX.Break?' LIBSTO
        1 1 DOCOMB.G EVAL
        DEPTH DOCOMB.S - →LIST
      »
   »
 »
@---------------------------------------------------------------
'DOCOPE'
 « → DOCOPE.P
   « « 'DOCOPE.P' RCL DOPERM IF DUP SIZE THEN LIST→ END DROP » DOCOMB »
 »
@----------------------------------------------------------------
'NL→I' 
  « DUP SIZE 0 → s t
    « CASE 
        s NOT  THEN DROP 0 't' STO END
        s 1 == THEN 1 GET 't' STO END
        LIST→  1 1 ROT  1 - START
          DUP UNROT * 't' STO+
          10 *
        NEXT
        * 't' STO+
      END
      t
    »
  »
@----------------------------------------------------------------
'I→NL'
  « ABS 0 RND DUP XPON → n s  
   « IF s 0 ≥ THEN s 0 FOR 'a' n a a DIGITS -1 STEP
     ELSE 0 0 's' STO END
     s 1 + →LIST     
   » 
  »  
@---------------------------------------------------------------
'LUNION' « ADD LDDUP »
@---------------------------------------------------------------
'LINTR'
  « → Lst2
    « 
      1 « IF Lst2 OVER POS NOT THEN DROP END » DOSUBS 
      LDDUP
    »
  »
@---------------------------------------------------------------
'LMAX' « IF DUP SIZE 1 > THEN « MAX » STREAM ELSE 1 GET END »
@---------------------------------------------------------------
'LMIN' « IF DUP SIZE 1 > THEN « MIN » STREAM ELSE 1 GET END »
@---------------------------------------------------------------
'LCLLT' 
 « 
  { } → ri 
   « LIST→ 
     « DEPTH →LIST 'ri' SWAP SADD » DOLIST
       DROP ri     
     »
   »
@---------------------------------------------------------------
'LDIST' 
  « OVER SIZE → List t s
   « IF t 0 < THEN s NEG 't' STO/ END
     IF s t IDIV2 THEN DROP List EXIT END
     'n' LSTO
     1 n FOR i
       0 s 1 - FOR j
         'List' i j + GET
         n STEP
         t →LIST
      NEXT
      n →LIST
   »
  »
@---------------------------------------------------------------
'LGRP' 
  «  DUP SIZE DEPTH 2 -  → List s d
    « IF s 2 < THEN List ELSE
        List 1 GET
        2 s FOR n
          IF List n GET DUP2 == THEN DROP END
        NEXT
        DEPTH d - →LIST
      END
    »
  »
@---------------------------------------------------------------
'LRPCT' 
  « DUP SIZE {} 1  → List s Count c
    « CASE 
        s NOT THEN { { } { } } END
        s 1 == THEN List { 1 } 2 →LIST END
        DEPTH 'd' LSTO
        List 1 GET
        2 s FOR n
          IF List n GET DUP2 == THEN DROP 1 'c' STO+ 
          ELSE 'Count' c SADD 1 'c' STO 
          END
        NEXT
        'Count' c SADD
        DEPTH d - →LIST Count 2 →LIST 
      END
    »
  »
@---------------------------------------------------------------
'LRPC→' « LIST→ « NDUPN DROP » DOLIST »
@---------------------------------------------------------------
'LSDIV'
  « OVER SIZE → List n s
    « IF s n IDIV2 s 0 == OR THEN DROP List EXIT ELSE ABS 't' LSTO END
      IF n 0 < THEN n ABS t 'n' STO 't' STO END
      1 s FOR 'i'
        List i i n + 1 - SUB
      n STEP
      t →LIST
    »
  »
@---------------------------------------------------------------
'SPLIT' « DUP2 1 SWAP SUB UNROT 1 + OVER SIZE SUB »
@---------------------------------------------------------------
'RSPLT' « OVER SIZE SWAP - SPLIT »
@---------------------------------------------------------------
'LSSR' « → List a b « List 1 a 1 - SUB List a b SUB REVLIST List b 1 + OVER SIZE SUB ADD ADD » »
@---------------------------------------------------------------
'LCNT' 
  « OVER SIZE 0 → List o s n 
    « IF s NOT THEN 0 ELSE
        1 s FOR 'i' 'List' i GET o SAME 'n' STO+ NEXT
        n
      END    
    » 
  »
@---------------------------------------------------------------
'LDUPL' 
  « DUP SIZE 0 → List s Exit
    « IF s 2 < THEN 0 'Exit' STO
      ELSE
        1 s 1 - FOR 'i'
          IF Exit THEN EXIT END
         'List' i GET 'o' LSTO
          i 1 + s FOR j
            IF 'List' j GET o SAME THEN 1 'Exit' STO EXIT END 
          NEXT
        NEXT
      END
      Exit
    » 
  »
@---------------------------------------------------------------
'MPOS' « → o « 1 « IF o SAME THEN NSUB END » DOSUBS » » 
@---------------------------------------------------------------
'LDIFF' 
  « → list2 
    « IF DUP SIZE THEN
        1 « IF list2 OVER POS THEN DROP END » 
        DOSUBS
      ELSE { } END
    » 
  » 
@---------------------------------------------------------------
'LXIL'  
  « 1
    « IF DUP TYPE 62 == THEN LIST→ DROP END » DOSUBS
  »
@---------------------------------------------------------------  
'LXILR' « DO DUP LXIL UNTIL DUP ROT SAME END  »
@---------------------------------------------------------------
'MDIST' « SWAP LXILR SWAP LDIST » 
@---------------------------------------------------------------
'LMAP' 
  « → Pgm 
    « 1 « IF DUP TYPE 62 ≠ THEN Pgm END » DOSUBS » 
  »
@---------------------------------------------------------------
'DOLLST' « → Pgm « LIST→ 'Pgm' DOLIST » »
@---------------------------------------------------------------
'LCPRD'
« 
  « OVER SIZE OVER SIZE → l1 l2 s1 s2
    «
      IF s1 s2 AND THEN
        1 s1 FOR i
          1 s2 FOR j
            l1 i GET l2 j GET ADD 
          NEXT
        NEXT
        s1 s2 * →LIST 
      ELSE
        { }
      END
    »
  »
  → List Recur
  «  
     IF List TYPE 62 == List SIZE AND THEN
       WHILE List SIZE 1 > REPEAT
         List 2 LFRST LIST→ DROP Recur EVAL
         List 2 LDROP
         SWAP LPUSH 'List' STO
       END
       List LXIL
     ELSE {} END
  »
»

@==============================================================
'DOSORT'

« 0 → List KSORT.Order Pivot
  « 
    « 'List' Pivot Dernier LSWAP
      Premier 'j' LSTO 
      Premier Dernier 1 - FOR 'i'
        IF 'List' i GET 'List' Dernier GET KSORT.Order THEN  
         'List' i j LSWAP
         1 'j' STO+ 
        END
      NEXT
      'List' Dernier j LSWAP
      j
    »
 
    « → Premier Dernier
      « IF Premier Dernier < THEN
          Dernier Premier - RAND * 0 RND Premier + 'Pivot' STO
          Part 'Pivot' STO
          Premier Pivot 1 - Tri
          Pivot 1 + Dernier Tri
        END
      »
    » 
     → Part Tri
    « 1 List SIZE Tri EVAL List »
  »
»

@================================================================
'SGE'
« OVER SIZE OVER SIZE → s1 s2 t1 t2
 « 1 @ True (great or equal)  by default
   IF s1 s2 SAME THEN EXIT DROP END
   IF t2 NOT THEN EXIT END
   IF t1 NOT THEN NOT EXIT END
   1 t1 FOR 'i'
     s1 i i SUB UTF8→ 1 GET 
     s2 i i SUB UTF8→ 1 GET - 'n' LSTO
     IF n 0 > THEN EXIT END
     IF n 0 < THEN NOT EXIT END
     IF i t2 == THEN EXIT END
     IF i t1 == THEN NOT EXIT END 
   NEXT
 »
»
@---------------------------------------------------------------
'SLT' « SGE NOT »
@---------------------------------------------------------------
'SLE' « DUP2 IF SAME THEN DROP2 1 ELSE SGE NOT END »
@---------------------------------------------------------------
'SGT' « DUP2 IF SAME THEN DROP2 0 ELSE SGE END »
@---------------------------------------------------------------
'LCASE' 
« IF DUP SIZE THEN 
    UTF8→ 
      « IF DUPDUP #41h ≥ SWAP #5Ah ≤ AND THEN #20h + END » MAP 
    →UTF8 
  END »
@---------------------------------------------------------------
'UCASE' 
« IF DUP SIZE THEN 
    UTF8→ 
      « IF DUPDUP #61h ≥ SWAP #7Ah ≤ AND THEN #20h - END » MAP 
    →UTF8 
  END »
@---------------------------------------------------------------
'S→SL' « IF DUP SIZE THEN UTF8→ « →UTF8 » MAP END »
@---------------------------------------------------------------
'ALL?' 
  « OVER SIZE → 'ALL?.L' 'ALL?.P' 'ALL?.S'
    « 
      IF ALL?.S NOT THEN 0 EXIT END
      1 @ True by default
      1 ALL?.S FOR 'i'
      IF 'ALL?.L' i GET ALL?.P EVAL NOT THEN 
        NOT EXIT  @ returns FALSE (0)
      END 
      NEXT
   »
 »
@---------------------------------------------------------------
'VL→I' « RCL NL→I »
@---------------------------------------------------------------
'ISEVEN?' « 2 MOD NOT »
@---------------------------------------------------------------
'ISODD?' « 2 MOD »
@---------------------------------------------------------------
'LINCL' 
  « → list2 
    « IF DUP SIZE THEN
        1 « IF list2 OVER POS DUP THEN list2 SWAP LRMOV 'list2' STO  ELSE DROP2 END » 
        DOSUBS
      ELSE { } END
    » 
  » 
@===============================================================
@ Library meta data
@---------------------------------------------------------------
'$VISIBLE' 
{
 { 'LSEQ'   1 0 "" }
 { 'LSEQR'  2 0 "" }
 { 'LASEQ'  2 0 "" }
 { 'LMSEQ'  3 0 "" }
 { 'LDSEQ'  3 0 "" }
 { 'LMRPT'  2 0 "" }
 { 'LWHL'   3 0 "" } 
 { 'LDDUP'  1 0 "" }
 { 'LPOP'   1 0 "" }
 { 'LPOPR'  1 0 "" }
 { 'LPUSH'  2 0 "" }
 { 'LPSHR'  2 0 "" } 
 { 'LPICK'  2 0 "" }
 { 'LREPL'  3 0 "" }
 { 'LRMOV'  2 0 "" }
 { 'LINSR'  2 0 "" }
 { 'LFRST'  2 0 "" }
 { 'LLAST'  2 0 "" }
 { 'LDROP'  1 0 "" }
 { 'LDWHL'  2 0 "" }
 { 'LTWHL'  2 0 "" }
 { 'LFILT'  1 0 "" }
 { 'LROLL'  1 0 "" }
 { 'LRLLD'  1 0 "" }
 { 'LROT'   2 0 "" }
 { 'LSWAP'  3 0 "" }
 { 'LSHUF'  1 0 "" }
 { 'LINTR'  2 0 "" }
 { 'DOPERM' 2 0 "" }
 { 'DOCOMB' 3 0 "" }
 { 'DOCOPE' 3 0 "" }
 { 'LMAX'   1 1 "" }
 { 'LMIN'   1 1 "" }
 { 'LUNION' 2 0 "" }
 { 'NL→I'   1 0 "" }
 { 'I→NL'   1 0 "" }
 { 'LCLLT'  1 0 "" }
 { 'LDIST'  2 0 "" }
 { 'LGRP'   2 0 "" }
 { 'LRPCT'  1 0 "" }
 { 'LRPC→'  1 0 "" }
 { 'LSDIV'  1 0 "" }
 { 'SPLIT'  2 0 "" }
 { 'RSPLT'  2 0 "" }
 { 'LSSR'   3 0 "" }
 { 'LCNT'   2 0 "" }
 { 'LDUPL'  1 0 "" }
 { 'MPOS'   2 0 "" } 
 { 'LDIFF'  2 0 "" } 
 { 'LXIL'   2 0 "" } 
 { 'LXILR'  2 0 "" }  
 { 'MDIST'  2 0 "" } 
 { 'LMAP'   2 0 "" } 
 { 'DOLLST' 2 0 "" }
 { 'LCPRD'  1 0 "" }
 { 'DOSORT' 1 0 "" }
 { 'SGE'    2 0 "" }
 { 'SLE'    2 0 "" }
 { 'SGT'    2 0 "" }
 { 'SLT'    2 0 "" }
 { 'LCASE'  1 0 "" }
 { 'UCASE'  1 0 "" }
 { 'S→SL'   1 0 "" }
 { 'ALL?'   2 0 "" }
 { 'VL→I'   1 0 "" }
 { 'ISEVEN?' 1 0 "" }
 { 'ISODD?' 1 0 "" }
 { 'LINCL'  1 0 "" }
}

@---------------------------------------------------------------
'$MENU'
@ ===============================================================
@  Menu, submenus and help definition
@ =============================================== Begin Main menu
{
@-------------- ---------------------------- Begin create submenu
{ { "Creat" 1 }  « {

{ "LSEQ" LSEQ
"Creates a list of int from
1 to n or from -1 to -n
I<a> → L<1..a>" }
 
{ "LSEQR" LSEQR 
"Creates a list of integer
from a to b
I<a> I<b> → L<a..b>" }

{ "LASEQ" LASEQ
"Integer sequence by repetitive
addition
I<start> I<inc> I<times> → L<i>" }
 
{ "LMSEQ" LMSEQ 
"Int multiplicative sequence
Ex: 2 2 4 → {2 4 8 16}
R<start> R<mult> I<times> → L" } 
 
{ "LDSEQ" LDSEQ 
"Int divide sequence
Ex: 2 2 4 → {2 1 0.5 0.25}
R<start> R<div> I<times> → L" } 

{ "LMRPT" LMRPT 
"Repeat a list or object 
n times
L<l> I<n> → L<n times l>" }

{ "LWHL" LWHL 
"Execute action repeatedly until
check condition is false
O P<action> P<condition> → L<o>" }

{ "LSHUF" LSHUF 
"Shuffles the content of a list
of create a random list of int
L<o> or I →  L<o> or L<i>" }

} TMENULST » "Commands to create new lists" } 
@ -------------------------------------------- End Create submenu

@ -------------------------------------------- Begin Edit submenu
{ { "Edit" 1 } « { 

{ "LDDUP" LDDUP 
"Deduplicate items of a list
Ex : {a b c b d} → {a b c d} 
L<o> → L<o>" }

{ "LPOP" LPOP
"Retrieves first elmt in a list
leaving the rest on the stack
L<o> → L<o> O" }

{ "LPOPR" LPOPR
"Retrieves last elmt in a list
leaving the rest on the stack
L<o> → L<o> O" }

{ "LPUSH" LPUSH
"Add object to front of list
Unlike ADD, list is add as list
L O → L" }

{ "LPSHR" LPSHR
"Add object to end of list
Unlike ADD, list is add as list
L O → L" }

{ "LPICK" LPICK 
"return list elmts in specific order
Ex:{a b c d} {2 4} → {b d}
L<o> L<i> → L<o>" }

{ "LREPL" LREPL 
"{a b c d} {2 4} {x y}
→ {a x c y}
L<o> L<i> L<o> → L<o>" }

{ "LRMOV" LRMOV
"Remove one or more elmts
from a list as indicated 
L<o> L<i> or I → L<o>" }

{ "LINSR" LINSR 
"Insert one or more elmts
in a list
L<o> I L<o> or I → L<o>" }

{ "LFRST" LFRST
"returns the first <n> elmts
of a list
L<o> I → L<o>" }

{ "LLAST" LLAST
"returns the last <n> elmts
of a list
L<o> I → L<o>" }

{ "RHEAD" RHEAD
"Returns the last elmt
of a list
L<o> → O" }

{ "LDROP" LDROP
"Drop the specified count of
obj from begin(+) or end(-) 
L<o> I<+-> → L<o>" }

{ "LDWHL" LDWHL
"Drops elmts from beginning 
while match the  condition
L<o> P<t/f> → L<o>" }

{ "LTWHL" LTWHL
"Takes elmts from beginning 
while match the  condition
L<o> P<t/f> → L<o>" }

{ "LFILT" LFILT 
"Returns a list for wich
the supplied prog is true
L<o> P → L<o> " }

} TMENULST » 
"Get, put, swap, insert,
delete etc objects in list" }


@ ---------------------------------------------- End Edit submenu

@ ------------------------------------- Begin Arrangement submenu
{ { "Arrng" 1 }  « {
 
{ "LROLL" LROLL 
"Roll the list. Equivalent
to 1 LROT
L<o> I → L<o>" }

{ "LRLLD" LRLLD 
"Roll down the list. 
Equivalent to -1 LROT
L<o> I → L<o>" } 

{ "LROT"  LROT
"Rotates list elements left or 
right as indicated by count
L<o> I → L<o>" }

{ "LSWAP" LSWAP 
"Swap the position of two
elements of the list
L<o> I I → L<o>" }

{ "LSHUF" LSHUF 
"Shuffles the content of 
a list
L<o> →  L<o>" }

{ "DOSORT" DOSORT 
"Sort a list with an order given
by a program
L<o> P →  L<o>" }

{ "LSSR" LSSR 
"Reverse a subsequence of
a list between a and b
L<o> I<a> I<b> → L<o>" }
 
} TMENULST » "Arrangement" } 
@ --------------------------------------- End Arrangement submenu

@ ------------------------------------------- Begin Group submenu
{ { "Group" 1 }  « {
 
{ "LCLLT" LCLLT 
"Collates a list of sublist

L<l<o>> → L<o>" }

{ "LDIST" LDIST 
"Distributes list in sublist
of size I
L<o> I → L<o>" }

{ "MDIST" MDIST 
"Distributes list in sublist
of size I after explode inner
L<o> I → L<o>" }

{ "LGRP" LGRP 
"Replaces repeated elmts with
a signle instance
L<o> → L<o>" }

{ "LRPCT" LRPCT 
"Like LGRP and count each elements

L<o> → L<l<o>l<o>>" }

{ "LRPC→" LRPC→ 
"Restores a list that was grouped
with LRCPT
L<l<o>l<o>> → L<o>" }

{ "LSDIV" LSDIV 
"Subdivides a list in list of
n elmts (or n list if n<0)
L<o> → L<l<o>...l<o>>" }

{ "SPLIT" SPLIT 
"Split a list in two parts
First part is I items
L<o> I → L<o> L<o>" }

{ "RSPLT" RSPLT 
"Split a list in two parts
Right part is I items
L<o> I → L<o> L<o>" }

{ "LXIL" LXIL 
"Return a list with first level
inner list exploded
L<o> → L<o>" }

{ "LXILR" LXILR
"Return a list with all the
inner list exploded
L<o> → L<o>" }

} TMENULST » "Gouping lists" } 
@ --------------------------------------------- End Group submenu

@ -------------------------------------------- Begin Test submenu
{ { "Test"  1 } « {

{ "LCNT" LCNT 
"Count occurences of an object
in a list
L<o> O → I" }

{ "MPOS" MPOS 
"Find all positions of an
object in a list
L<o> O → L<i>" }

{ "LDUPL" LDUPL 
"Test if there is duplicate 
objects in a list
L<o> → I<t/f>" }

{ "ALL?" ALL? 
"Test if all the objects
of the list checks prog P
L<o> P → I<t/f>" }

} TMENULST » "Tests on lists or items of list" } 
@ ---------------------------------------------- End Test submenu

@ ------------------------------------- Begin Combination submenu
{ { "Comb"  1 } « {

{ "DOCOMB" DOCOMB 
"Apply a pgm to all combinations
of n elmt of list. BREAK to exit
L<o> I P → L<o>" }

{ "DOPERM" DOPERM 
"Apply a pgm to all permutations
of a list. BREAK to exit
L<o> P → L<o>" }

{ "DOCOPE" DOCOPE 
"Apply a pgm to all combinations
and permutations. BREAK to exit
L<o> I P → L<o>" }

{ "DOLLST" DOLLST 
"Like DOLIST but with list of lists.
{{a b}{c d}} «+» → {'a+c' 'b+d'}
L<l<o>..l<o>> P → L<<lo>..l<o>>" }

{ "LMAP" LMAP 
"Apply a pgm to all elmt but
whithout explore inner list
L<o> P → L<o>" }

{ "LCPRD" LCPRD 
"Returns list of sublists with
cartesian product of s/lists input
L<l<o>l<o>...> → L<l<o>l<o>...>" }


} TMENULST » "Combinatorics on lists" } 
@ --------------------------------------- End Combination submenu

@ -------------------------------------------- Begin Math submenu
{ { "Math"  1 } « {

{ "I→NL" I→NL 
"Convert an integer to
a list of digits
I → L<I>" }

{ "NL→I" NL→I
"Convert a list of digits
to an integer
L<i> → I" }

{ "VL→I" VL→I
"Convert a list of variables
that store a digit to an integer
L<v> → I" }

{ "LMAX" LMAX "Max item in a list" }

{ "LMIN" LMIN "Min item in a list" }

{ "LINTR" LINTR 
"2 Lists intersection.
Deduplicate
L<o> L<o> → L<o> " }

{ "LUNION" LUNION 
"2 Lists union
Deduplicate
L<o> L<o> → L<o> " }
 
{ "LDIFF" LDIFF 
"List of objects in list lvl2 that
don't match objects list level 1
L<o> L<o> → L<o>" }

{ "LINCL" LINCL 
"List of objects in list level2 
includes in objects list level1
L<o> L<o> → L<o>" }

{ "ISEVEN?" ISEVEN? 
" is the number even ?

I → 0/1 " }

{ "ISODD?" ISODD? 
" is the number odd ?

I → 0/1 " }

} TMENULST » "Math on lists" } 
@ ---------------------------------------------- End Math submenu

@ ------------------------------------------ Begin String submenu
{ { "String"  1 } « {

{ "SGT" SGT 
"Test if a string is
strictly greater to another
S S → 0/1" }

{ "SLT" SLT 
"Test if a string is strictly 
less to another
S S → 0/1" }

{ "SGE" SGE 
"Test if a string is
greater or equal to another
S S → 0/1" }

{ "SLE" SLE 
"Test if a string is less
than or equal to another
S S → 0/1" }

{ "LCASE" LCASE 
"Upper to lower cases

S → S" }

{ "UCASE" UCASE 
"Lower to upper cases

S → S" }

{ "S→SL" S→SL 
"String to chars list

S → L<c>" }


} TMENULST » "String manupulation" } 
@ ---------------------------------------------- End String submenu

} 
@================================================================
ENDDIR