XPL pilgrim seeks audience

["Bruce Middleton" xywright@xxxxxxxx]

As a 10-year Xywriter new to the list, I am intrigued to know if any of my
own XPL epiphanies, accruing over the decade, are news to the community;
indeed, to know the context of the hours of black frustration and moments of
euphoria they summarize: was I boldly venturing where none had gone before,
or stumbling through thickets on a course pathetically parallel to a smooth
paved road? A survey of the archive accessible to GOPHER hasn't answered
this - so I'll offer two specimen observations, and invite anyone familiar
with the history of the Xy subculture to remark on their novelty - or their
vintage as common knowledge.

*XPL's missing insert function*
There are only three real storage functions performed on strings
(functioning as text and code, that is - excluding for present purposes the
evaluation of mathematical expressions): they can be stored, and on recall
they can be either inserted or executed. XPL divides these three functions
among four commands - and even so manages to leave a class of possible (and
frequently desirable) operations unaccounted for: there is no way to recall
(that is, insert) strings which have been loaded (using LDPM or SU). The
function is so basic that its absence would seem preposterous if peope were
not used to it. Impossible to recall, revise and reload a subroutine loaded
to a permanent save-get on startup, or a macro loaded to an @SG? Absurd.
This deficiency can be patched - and to understand how, one must be clear on
the nature of the system. Specifically, one must realize that strings are
stored with an invisible inflector which determines whether they will be
inserted or executed by GT (and has no other function), and that the two
storage functions differ only in the inflectors they add (SV adding a text
inflector, while SU adds a code inflector). The ability to manipulate
inflection comes from the observation that a concatenated string takes on
the inflection of its last component. Exploiting this fact, one can change
the inflection of a string by concatenating it with a null string of the
desired inflection (created by, for example,  and ). This
permits synthesis of the simple, unconditional insert function which XPL
lacks: effected by appending a neutral null to strings before recalling them
with GT .
The current system not only makes some operations impossible: it also makes
the effects of some commands unpredictable. There is no practical way to
determine the inflection of a given save-get; it is unmarked on SG viewing
screens, and ignored by string operators (such as comparison and the
inclusion query). [It is possible to test the inflection of a string by
using concatenation to prefix a harmless procedure (such as ) and then executing GT (this will generate a prompt if the
string is codized and insertion if it is neutral) - but this is hardly a
practical routine procedure.] Such opacity leaves users who have LDPMed (or
SUed) to some SGs and SVed to others at the mercy of their own memories in
predicting what will happen when they hit a key. The implementation of
unconditional recall functions eliminates this uncertainty: any stored
string can be either inserted or executed at will - and the outcome of
commands never depends on invisible variables.

*Instant Unrestricted XPL Access*
Xywrite's manuals do not explain how to issue XPL commands on the fly (one
is told to save the procedure as a file, LDPM it to a SG which has been
assigned to a key, then hit the key). Tyson goes one better by suggesting
that the command SuA be assigned to a keystroke - providing a means of
loading the defined block to @A. It is, however, very easy to provide a
general portal to XPL (one which permits any procedure - including, but not
limited to, any single command - to be issued): simply add a Type 1 frame
whose program is %*. (For convenience, the keystroke which accesses it
can also place a pair of chevrons in the entry field, and leave the cursor
in insert mode between them.) Using such a frame, you can (for example) save
or load the defined block to any (even 3-digit) save/get; heck, you can even
send yourself prompts.