This is a user guide for the powerful second-generation anagramming program named WHAT, for Wolfberg's Helpful Anagramming Tool. WHAT is really a toolbox of powerful tools, with many facilities. You can make effective use of WHAT right away by using just a few of its key features, and you can learn what these are in an introductory document entitled "WHAT's First".
WHAT has been in use in the Boston-area Scrabble® clubs since the Spring of 2004. Mike announced and demonstrated it in public for the first time at the 2004 National Scrabble® Championship Tournament held in New Orleans, LA in early August, 2004.
Mike first wrote the ANA program in the early 1980's, and, with years of its use, he has come to want the program to be able to be more useful in answering queries which a competitive Scrabble® player tends to ask, either based on situations that arise in games or for the purpose of studying words in an organized manner. For the most common of queries, WHAT is used in much the same manner as ANA, but it has many new features that make it considerably more powerful.
A "Differences Between ANA and WHAT Programs" section near the end of this user guide lists the major differences between ANA and WHAT. This will be of interest only to the small number of folks who have used ANA.
Mike Wolfberg is a highly experienced programmer, with several decades of software development experience. Mike's computer use began in the early 1960's, when he was an undergraduate student at M.I.T. After completing his B.S. degree, Mike continued his formal education at the University of Pennsylvania, where he received one of the early Ph.D.'s in Computer Science. Mike has been an expert Scrabble® player since 1980, and he attributes his fast rise to a high level of play to his use of computers, before they were so prevalent in the game.
WHAT is a relatively large program, designed, developed, and documented by Mike in about 1 1/2 years of intense work. Mike plans to support and extend this program, hoping to be able to devote his full attention to this project for the foreseeable future, but this goal will likely be compromised by the need to earn a living.
This user guide is not a tutorial with introductory examples, but an extensive reference document with details about the program. Early reviewers have indicated a preference for introducing the many features of WHAT through examples. At this time, there is a separate document entitled "WHAT Examples", and it is based on the TWL98 lexicon. It will eventually be updated to correspond with the OWL2 lexicon, which is being adopted for use in North America starting in March, 2006.
It is our intention to write a series of introductory tutorials, and the first one of the series, entitled "WHAT's First", is a great place to begin to learn about the program. A couple of other tutorials have been written, to introduce the topics of flashcarding and the creation of study lists. Until more tutorials are available, please refer to this user guide to learn about all the features of WHAT. There is companion document to this guide, that is a reference for the WHAT command language; it is entitled "WHAT Command Language".
On-line help is also planned for the program, but it is not yet provided.
Although WHAT was produced especially for players of a popular word game played on a 15 x 15 board, it can be helpful for other word games and study. Some of the WHAT features are helpful for the 21 x 21 version of the 15 x 15 game, a 5 x 5 grid game, a 10 x 10 grid game in which letters can build upon other letters, and the game of Anagrams.
If you are a first-time user, you
may find it more comfortable using features of some
electronic word aid devices with which you are already familiar.
When WHAT first starts up,
the workspace includes a short paragraph
mentioning this, and you are instructed to look at the First Use
tab to the left. On that tab there is a graphical button labeled
If you are not familiar with such electronic devices, you may as well proceed to using WHAT the way it is intended to be used; therefore, we will not go through a detailed description of the use of these features. We will at least point out these differences between WHAT and word aid devices:
^25'followed by pressing the Enter key on the keyboard to see the first 25 words of the answer.
Once you are familiar with the use of WHAT for anagramming and pattern matching, you will likely no longer want to employ these electronic word aid features. You can update initial settings so that one of the other tabs on the left is initially showing when WHAT starts up. It is recommended that you will make this be the Query tab instead of the First Use tab. On the other hand, if you want to run WHAT on a screen with a small pixel density, such as 800 x 600, it will run without the left tabs showing.
When using these word aid features, you will be seeing
WHAT commands being constructed and performed for you.
For example, if you are seeking
words that end in AH
from the letters EKNJSUH
in your rack, the
constructed WHAT command is:
*ah,eknjsuh/Z/+B/<$$
In case you are curious, we will explain what this means. The comma separates the specified pattern from the specified rack. The pattern means that there can be any number of letters preceding AH in the sought words. These are the remaining command constituents:
| /Z | - | score 0 for blanks used from the rack |
| /+B | - | a 50-point bingo bonus should be used for words at least 7 letters |
| /<$ | - | sort the presentation by decreasing order of scores |
| $ | - | include scores in the presentation of the answer |
Here are a few examples to give you an idea of some of the kinds of word-game-oriented queries for which WHAT is applicable:
So these are typical of the kinds of queries you will make using WHAT. You will be able to formulate some complex queries and requests that were not utterable and answerable in ANA, such as the fourth example just given above. Here are some other examples:
The document "WHAT Examples" document includes the command sequences which can be used to answer the above sample questions.
We could continue for quite some time with the presentation of examples, but what is here should serve you with the idea of what WHAT is for. You can use it as a situation analyzer, as a quiz producer, and as a word study tool. You can use it to help you develop study lists. WHAT is also intended to find steals when playing the classic game of Anagrams, where already-found words can be stolen by adding letters from the pool (or possibly other words) and rearranging. You can use WHAT as a way to look for the spelling of words you mostly know. It can be used to solve hangman-type puzzles, that also show up in crossword puzzles, but for crossword puzzles, capitalized words are often permitted as answers, and such words are missing from WHAT's current lexicons.
Graphical user interfaces (or GUIs) are often used to support programs like WHAT, where there are many options and many states. GUIs are especially useful for occasional users of such programs, but they are not as easy and quick to use to answer simple little questions, such as those that are expected to be asked of WHAT. Therefore, WHAT is designed with a more historically traditional command line interface as the fundamental method of making queries. A GUI is then used along with that to indicate what the program understands the queries to be. The GUI part of WHAT exists as an optional aid. You are also permitted to use menu picks and some GUI pointing and clicking to make queries, but these are likely to be more tedious than typing a few characters of the WHAT command language. The cost of this is that there are many WHAT commands, and learning how to use the tool effectively will probably take you longer than learning a GUI-oriented program. We believe the current command line philosophy is better matched to the needs of a frequent WHAT user than the typical GUI style of use.
When you begin to type a command, the GUI presents the state of the program as indicated by the long-term state of WHAT and then possibly modified for that query. As soon as you begin to type characters for a new command, the GUI presents the current state as indicated by long-term settings and perhaps altered by the current command, even as you are typing it.
The WHAT command language was designed intentionally to be succinct. It is therefore not easy for a person to decipher a command. The intention is that you can compose commands effectively, but you may find it difficult to look at a command and decipher what it means. The main reason for this is some characters in the command language are used for several different purposes. A left angle bracket is such a character. Because of this, WHAT may someday include a command report feature, so you can see what a command means in English.
Having just said that WHAT is designed to be used via your typed commands, WHAT provides a GUI that you can use both for input and output communication with the program. Since the command repertoire of WHAT is so extensive, when you are still inexperienced, you will likely find it helpful to indicate your intentions via using some of the GUI, as well as by typing command characters.
While constructing a command, if you alter the state of WHAT using GUI actions, equivalent command characters are inserted into the command line. Likewise, as you type characters on the command line, the line is scanned after each change, and the GUI represents WHAT's best interpretation of the current command. Errors on the command line may cause WHAT to stop scanning the line; but in the absence of errors, you can see how your command may be changing WHAT's state. Error diagnosis is not done until the command is terminated with the Enter key, that indicates the command should be performed. You can instead ask that the line be checked for errors without any action taken by holding down the Ctrl key while pressing the Enter key.
There are several characters in the GUI that are underlined, and such characters are called "accelerator characters". You can get to that part of the GUI by pressing the Alt key along with that character.
If a button has focus (i.e. WHAT is accepting your input in this place), you can see it highlighted, and then you can press the Enter key to have the same effect as clicking the button.
In menus, pressing the up-arrow and down-arrow keys will move you up and down. Similarly, if you are in a box that has a list of items, you can move up or down the list using the arrow keys. If you are at a check box, the space key can be used to flip between the states of checked and unchecked.
You are welcome to alter the height and width of the
WHAT window, including
maximizing it on your computer screen. There is a minimum size that you
will be permitted to use for each of the dimensions. This minimum is still
large enough so that all GUI controls remain visible on the screen.
You may also adjust the font size of the workspace via the View
menu when WHAT is freshly started.
On the computer used to develop WHAT, the minimum
workspace size is 15 rows by 51 columns when using the default font of
The workspace window is main part of the WHAT window, where you type in commands and see results, primarily presentations of the slate. The workspace is arbitrarily long, and its width is settable.
You can clear the workspace either via a subcommand /CW or via clearing buttons available on the WHAT tab in the upper right of the WHAT window. You are likely to want to clear the workspace when you are preparing to print something. Printing in WHAT is done using the contents of the workspace.
The workspace window width has a particular value based on the size of the WHAT window. By default, the workspace width and the workspace window width are the same, since the width of the workspace is taken from the width of the workspace window.
You can see the width of the workspace on the Presentation tab on the left side of the WHAT window. Look for the box in the Layout section labelled Max Width. The default contents of this box is "workspace width". If you set the width to a particular number of characters, such as 80, it will show as "80 chars." in the box. To make such a change, you perform a command, usually a long-term one (see section "Short-term and Long-term States"), and the GUI can help you formulate the command via a dialog which comes up when you click on the ellipsis at the right end of that Max Width box.
When the workspace width is larger than the workspace window width, and when there are long lines, the workspace window will be scrollable. The only way this will happen is when you have chosen that long lines should not be wrapped. By default, lines longer than the workspace window width are wrapped to the next line (at spaces). You can control this via the View menu. If you have turned off wrapping, you can then get lines which are fully viewable only by scrolling.
Line wrapping is relevant only for lines which contain definitions, since otherwise, presentations are formatted such that they do not extend beyond the workspace width. There are two different widths which pertain: the workspace width and the workspace window width. Usually, these two quantities are the same, since by default the workspace width is set from the workspace window width. However, you may set to the workspace width to a specific number of characters or a specific number of columns.
The workspace window width is set indirectly based on the width of the WHAT window, and you are shown its dimensions at the lower right of the WHAT window. The wrapping of long lines is based upon the workspace window width. The formatting of slate presentations is based upon the workspace width. This distinction may be important for you to understand when you are preparing the workspace to be printed. Lines are printed according to how they are wrapped in the workspace. If a long line is not wrapped, or it is wrapped too far to the right, the printed form of that line cuts off near the right edge of the page.
On Mike Wolfberg's primary printer, using the default settings of 10 pitch Courier New font, and with the default left margin, a line is printed with 12 characters per inch, and so there is room for about 95 characters.
Although the design for WHAT features the use of a command language, the program also allows for your making menu picks in combination with typing keyboard keys to make up commands. If you are a new or occasional user, you may find this useful, but once you are a frequent user of WHAT, you are likely to formulate commands by typing commands on the keyboard only.
Words in the menus are underlined to show what accelerator keys you may type to select the menu items. These underlines do not show up in the menu until you press the Alt key.
We are aware that this user guide focuses on the command language, and it does not always mention how to use menu picks and other pointing and clicking to get WHAT to make up these commands. This deficiency may be rectified in the future.
You can use the mouse to move and click to control the WHAT graphical interface, but you also have the option to press various keys while holding down the Alt key in order to make choices. One area where this can be used is in the menus. You can press Alt+<letter>, where <letter> is the underlined letter of one of the menu choices, usually the first letter; for example, you can pull down the Tools menu by pressing Alt+T. You can then continue to make further submenu picks in the same way; for example, you can press Alt+T, Alt+W, and Alt+C to bring up a dialog to copy items among wordlists.
The WHAT screen includes some underlined characters, and these are indicators of other accelerator key choices you have. For example, notice on the Query tab on the left side of the screen, there is an underlined S to indicate you want to filter by score.The WHAT screen includes two regions where there are tabs on which you can click to see alternative graphical controls.
On the left side of the screen is a 3-tab control, where you have the choice of seeing either electronic words aid features, query construction info, or slate presentation info. You can click on the tab to move to the one you want, or you have this other option: You can switch between the 2 latter tabs by pressing either Ctrl+Q or Ctrl+P. To return to the First Use tab, you must click on the tab itself.
The larger tab control in the upper right of the WHAT screen has 8 tabs. You can click on a tab to bring it up, or you can press Ctrl+\ to advance to the next tab. This key was chosen since it is in the upper right area of the keyboard, to match where on the screen the tabs are.
If you would like to be shown pop-up hints as you move the mouse around
the WHAT screen, use the menu pick
As with other powerful programs with many features, such as Microsoft Word, you can begin to use WHAT employing only a small percentage of its available features. As time goes on, you can explore more features, such as when you have something new to do. Reading through this entire specification is probably not a good way to become familiar with WHAT if you have never used it or its predecessor before. Coming back to reading parts of this user guide from time-to-time may prove useful, but it is probably too overwhelming to take in all there is to offer in one reading.
Many commands are described with specs, such as "<number>^", to indicate some number is to be supplied at that place in the command. These category names, such as "number", are enclosed within non-bolded angle brackets. In this document, angle bracket characters you are meant to type are shown in bold and are slightly larger (e.g. < >). Most of these category names are self-explanatory, and a few special categories are defined explicitly.
There is a "Glossary" section late in this document.
In the workspace region, you interact with
WHAT by typing command
lines. WHAT prompts you to type a command line with:
WHAT?:
and the cursor remains on that line following one space as separator. You
type some characters and then complete the command line by pressing
the Enter key.
WHAT then does something. It may not always do something
you can see, according to what you have asked it to do in conjunction with
short-term and long-term settings. For example, if you start to use
WHAT and type the command line
nrtaeei
followed by pressing the Enter key, you will be shown the answer:
ARENITE RETINAE TRAINEE
WHAT
has shown you the words formable from the letters you typed by using
all the letters. This is a prototypical example of what you as a
user want to know, and making a short query of typing just those letters
is natural. There are many variations on this:
nrtaeei>you are shown the answer:
ARENITEs RETINAE TRAINEEswith the hook letters shown in lowercase. A hook is a letter that may be added to a word at one end or the other to form a new word. The term comes from how in the game played on a 15 x 15 board you must connect with words already on the board.
nrtaeei#and the result is:
Number of words = 3At this point, the words that constitute the answer to your query are "written on the slate", but it is your choice to not see what is on the slate in its entirety just yet. You could ask to see the first letter of the 2nd word on the slate by typing the command:
1/2and you would then be told:
Letter 1 of word 2 is: RHad you left off the 2 and typed only
1/you would be told:
Letter 1 of each word is: A,R,TIf the list is longer than 25 words, the commas would be dropped, and if the list is longer than 50, only the first 50 words are so described.
Rather than continuing to describe WHAT with examples in this document, we now describe the program in a more complete way to give you an understanding of what all the possibilities are for formulating commands. There is a comprehensive collection of examples is a separate document appropriately entitled "WHAT Examples".
If this is your first time reading this user guide, and if this is your first exposure to a description of the program, you are advised to set this aside now and read the "WHAT's First" document. That tutorial will provide you with enough knowledge to begin to make effective use of WHAT.
As you type a command line to WHAT, you have the ability to edit the line before submitting it for processing (i.e., getting performed). These editing characters are supported:
| Backspace | - | at the command start, do nothing; otherwise erase the character before the cursor and move the cursor to the left by one character. |
| Ctrl+Backspace | - | erase one or more previous characters in the current command back such that what looks like the previous word is eliminated. |
| Delete | - | at the command end, do nothing; otherwise erase the character at the cursor and leave the cursor where it is. |
| Ctrl+Delete | - | erase all the characters in the current command and move the cursor to the position of the command start. |
| Insert | - | toggle between two modes of character input - inserting and overlaying. |
| Ctrl+Enter | - | check the current command and report any errors in the middle part of the status bar at the lower border of the WHAT window. |
| Ctrl+T | - | at the command start or end, do nothing; otherwise interchange the character to the left of the cursor with the character to the right of the cursor and then move the cursor to the right by a character. |
| Home | - | move the cursor to the start of the command. |
| Ctrl+Home | - | scroll the workspace to its beginning. |
| End | - | move the cursor to the end of the command. |
| Ctrl+End | - | scroll the workspace to its end. |
| left-arrow | - | at the command start, do nothing; otherwise move the cursor one character to the left. |
| right-arrow | - | at the command end, do nothing; otherwise move the cursor one character to the right. |
| Ctrl+A | - | select all text in the workspace. |
| Ctrl+B | - | same as left-arrow, Backup one character. |
| Ctrl+C | - | copy selected text (see below). |
| Ctrl+E | - | same as End. |
| Ctrl+F | - | same as right-arrow, go Forward one character. |
| Ctrl+V | - | paste text from the clipboard (see below). |
| Ctrl+X | - | cut (or copy) selected text (see below). |
| Ctrl+Z | - | minimize the WHAT window - this works even from within the Challenge Dialog. |
| F1 through F12 | - | function keys are used to input user-chosen character sequences.
You can specify these assignments via a
dialog available via the Edit menu, and initial
values can be established in WHAT's initialization
file. F10 cannot be used, since it selects the menu.
Function keys represent text to be appended to the
command line, and there are two options, whether to:
|
WHAT deals with selecting, cutting, and pasting, in conjunction with the Windows system clipboard. You may insert text only on the command line to the right of the prompt. If the cursor is elsewhere when you attempt to paste, it is first moved to the end of the command line. Inserted text must be all on one line. If the clipboard includes more than one line of text, only the text on the first line is used in the paste operation, and then any text following the end of the pasted first line is lost. If you attempt to cut text that is not all within the current command (following the prompt), a copy is done instead. One exception to this is if you include part of the WHAT prompt in what you are cutting; in this case, a cut is done, but it does not include characters from the prompt.
If your mouse or your computer has a mouse wheel, WHAT will respond to the wheel by scrolling the workspace. You can also use the scroll bars on the right edge of the workspace to do this.
You may type double slash (//) on a line to cause WHAT to ignore the remainder of the line. In this way, you can type comments that have no effect on WHAT. This syntax is the same as introducing a comment in the C++ language.
Unless you intentionally clear it, WHAT retains a history of the commands you have typed in since starting up the program for its current session. Therefore, you can always go back and find a command you may want to resubmit to WHAT. There are facilities to see several of these commands at once, or you can bring back a specific command by its number. There are a few kinds of commands that are purposely not noted in the history. One example is the command to show you a random rack.
WHAT retains complete commands in its history, but the Command History area of the WHAT window, just above the workspace, shows beginnings of these commands, as much as can fit in the limited width area (which is not horizontally scrolled). If you select an old command from there via the pull-down menu, it will be placed into the workspace and it becomes the current command.
These command history keys and commands are not supported by menus and dialogs at the present time. This omission of low significance may be provided in the future. Please feedback any requests for this.
If you bring back a command, you are then able to edit it before pressing the Enter key to have it performed.
These are the keys and commands involving command history:
| up-arrow | - | If you started typing a new command that partial command is not
remembered, and then you are shown the previous command in the
history. Subsequent uses of
up-arrow continue to take you back
to earlier commands, one at a time. Once you are looking at the oldest command, another up-arrow has no effect. |
| down-arrow | - | Having pressed at least one up-arrow to see earlier commands in your command history, this character brings you back forward in the history list towards the present. Once you are looking at the most recent command, another down-arrow has no effect. |
| - | When you give this command by itself at the start of the command line, WHAT brings back the command indicated by the number, and it becomes the current command, ready for possible editing or execution. If you intend to suffix a number on the end of the previous command in the history, separate the carat and the number with a space so it is not interpreted as this kind of command. This cannot be used in a command file. | |
| ^-<number> | - | When you give this command by itself at the start of the command line, WHAT brings back the nth most recent command, and it becomes the current command, etc. This cannot be used in a command file. |
| /H | - | show recent command history so that it almost fills the workspace; command numbers are included. |
| /<number>H | - | show command history beginning with the command designated by the given number and show as many commands going forward as almost fills the output area (if that many exist). |
| ^ | - | use this character in a command to represent the text of the previous command, but this is not shown to you when you type the carat. However, if a command with a carat is performed, it is remembered with the carat replaced by the characters it represents. You can see that expanded executed command by looking at the Command History area above the workspace. If a command is brought back that had included a caret, the replacement will have been made. This cannot be used in a command file. |
There are more commands that involve command history described later in the "File Reading and Writing" section.
The state of WHAT consists of several criteria that affect how it carries out commands. Initially, there is a default state that applies, and you may indicate changes in various criteria both for the current command (i.e., the short-term) and also for the long-term. You may optionally follow parts of commands that affect the state of WHAT by an exclamation point to indicate the preceding command part not only affects the current or short-term situation, but it also applies to the long-term.
The GUI is helpful in showing the state of WHAT. At the beginning of a new command line, when WHAT has issued a prompt and you have not yet typed any part of a command, the GUI indicates the long-term state. As you begin to type a command, the GUI indicates the short-term state. Parts of the GUI are colored when changes are made. Yellow is used to show changes for the short-term (i.e., for the current command only), and green is used to show long-term changes.
A group of letters most commonly shows up in an order that forms a word,
but there are some circumstances when you will prefer to see a group of
letters in a canonical order. WHAT allows you to specify
canonical orderings
in a rather general way. You provide a string of characters that includes
exactly one of each of the letters of the alphabet (of either case)
and a blank denoted by
a question mark. Your string may also include individual spaces or other
separator characters. For example, our canonical ordering of choice is:
BCDEFGHJKLMNPQRSTVWXYZ? AEIOU
and this causes a word such as
ANISOLE
to be presented in canonical order as:
Use of uppercase letters is recommended, but not required, in canonical orderings. Especially since letter tiles in word games have the letters printed in uppercase, it will be a better visual match to use uppercase letters in canonical output. If you stick to uppercase letters in your chosen canonical orderings, WHAT also makes better presentations when canonical order output includes any letters that were specified as blanks. Specifically, letters based on blanks can be shown in green in the absence of any lowercase letters in your canonical order.
Here are some ideas for you in choosing your own order. You may wish to go in increasing or decreasing order by:
You may wish to separate some of these groups by spaces or a minus sign or some other character(s). If you intend to make and use flashcards, the best separators to use are spaces, since a canonically-ordered word is generally interpreted as a WHAT command when working with a flashcard.
Canonical orderings show up in two places in WHAT:
The special case of having no order is applicable only for the second situation, and in that case random order is used for the letters and blanks. The user-controlled orderings WHAT uses for these two situations can be set independently.
TBD: A while back, we realized there are two aspects of canonical ordering relating to what is on the slate and how the slate is presented. So slate output can have words or words canonically ordered. It is a separate matter how the slate is then presented. Canonical ordering can be used even if the slate has words on it. It would be redundant and of no meaning to have a slate with canonically ordered words and then ask to see the slate canonically ordered. At this point WHAT does not have commands to control each of these concepts.
The concept of a slate is specific to WHAT. It is virtual place within the program where query results are placed. You mainly interact with WHAT by issuing commands to it. A query is a specific kind of command that causes the program to output to the slate, typically replacing the slate contents by a new list of words. But some commands leave the slate alone and are either asking for some info about the slate or asking WHAT to do something else. WHAT includes the facility to save the slate to a wordlist for future use, but most often the slate keeps getting rewritten, as you continue to make query after query.
As a result of a making a query, the strings placed onto the slate are typically words in their correct (spelling) order. You can alter this so the words are placed onto the slate in the canonical order (of your choosing). These commands affect this:
| /QW | - | do not create "semi-words" but real words (the default) |
| /QS | - | allow for the creation of strings (without the requirement they be words) |
| /Q;W | - | create "semi-words" rather than words, namely output words to the slate in canonical order |
| /Q;S | - | create "semi-strings", namely output strings to the slate in canonical order |
When a semicolon (;) is included in a query the presentation of the slate contents is forced to be in canonical order, independently of what is on the slate at that time. That is, the slate may have words, canonically-ordered words, strings, or a mixture of these. The use of the semicolon to request the presentation be in canonical order affects each string on the slate, and so it is possible there will be duplicates within the presentation.
There are queries that can produce non-words when the [...] construct is involved, and then the /QS command may have to be used in order to retain all answers. Two-word anagram queries and two-word pattern queries necessarily result in strings.
Usually, the slate has words on it, but there is a way to get WHAT to have just letter strings on the slate. When the slate has words, it has zero or more words that are in alphabetical order. However, the presentation of the slate may reorder it for presentation purposes. This means that when you ask for the nth word of the slate, the answer is not dependent upon how you last saw the slate. Furthermore, a slate has at most one copy of any particular word.
Likewise, when the slate has strings on it, these are in alphabetical order, and there is at most one copy of any particular string on the slate at one time. These strings can include spaces, as is done for the output for two-word anagramming, two word patterns, and perhaps in canonical orderings.
There is a way to accumulate words on the slate, thus inhibiting WHAT from clearing the old slate when a new query is processed. This is specified with a command spec of /+S. Its opposite is /-S, that reverts to the default setting of slate clearing with each query.
The slate can be cleared by making a query (such as QQ) that results in nothing when query output replaces the slate (instead of augmenting it), and it can be cleared explicitly using the command /CS.
The WHAT slate usually holds words which were placed there as a result of performing a query, but in general the slate can have other forms of content. WHAT categorizes the slate as holding one of the following forms:
Usually the slate is cleared before a query is performed, but you have the option of augmenting the slate when you make a query. In this rare case, the most recent augmenting query is used to set the category, despite the fact the slate may have a mixture of categories of items.
There is a command to clear the slate, and when you perform this command, WHAT (somewhat arbitrarily) sets the category to "words".
You can see which category pertains when you issue the number sign command to ask for how many items are on the slate. The answer indicates one of the above categories.
The category of the slate affects how anagrams are shown when you have specified you want to see anagrams in slate presentation. If the slate contains words, then when anagrams are listed, the word is not repeated within the parentheses, but for any other category of slate contents, all anagrams of the letters of the item are shown in parentheses.
A query is a particular kind of command that causes some word list to be developed as a result of some specification of what letters are in the words. There are these kinds of queries:
Letters usually represent themselves in queries, and thus for the specification of commands other than for queries, prefix characters are used to indicate a command is being given. Specifically, to change the kind of query to be a pattern, type /P, and when this is performed, this affects the current query only (i.e. it is for the short-term). If the command /P!, is performed, not only is the current query affected, but the default kind of query is also changed. This means that in the absence of another current or long-term query kind spec, subsequent queries are of the pattern type. The following of the command by an exclamation point is the way to express long-term settings.
You may precede a letter in a query (or in a set specification) with a number to indicate a repetition count. A set, word reference, or subword reference in a query may also be preceded by a repetition count.
You are not required to designate the letters used as the basis of a query
sequentially. They may be interrupted by subcommands. For example,
n(V)(V)/pn
means you want to see those 4-letter words that start and end with an
N,
where the two inside letters are vowels. The
/p
command to request
a pattern match in the middle of the query letters is acceptable, but not
recommended.
Notice the mentioning of matching vowels with the (V) command constituent in the above example. This is one example of the designation of a set of letters in WHAT. Some of these sets are predefined, such as (V), and you are given the power to define your own sets. Some sets are defined based on letters and other sets involved in the query. Sets will be described later in the "Letter Sets" section of this guide.
To change the kind of query, type one of these commands:
| /A | - | for anagrams |
| /~A | - | for anagrams with blank circulation |
| /P | - | for pattern matching |
| /~P | - | for pattern matching with blank circulation |
| /+P | - | for pattern matching with inserted blank circulation |
| /S | - | for steals, as in the game of Anagrams |
| /~S | - | for steals requiring base word rearrangement |
| /I | - | for imbedded or included words |
| /B | - | for 5 x 5 grid game solving |
| /2A | - | for two-word anagrams |
| /2P | - | for two-word patterns |
The /2A and /2P commands automatically imply the /QS command to allow for strings on the slate.
While typing a query, you may employ certain characters or character sequences that imply the query should be a pattern, in which case, there is no need to type /P, but it doesn't hurt. These are some of those utterances:
| . | - | match any letter; this is a blank - the same as ?, except it implies the kind of query is pattern matching |
| * | - | match zero or more of any letters; this is a wild-card character, and it implies the kind of query is pattern matching |
| , | - | a comma separates a pattern spec and a rack spec; rack characters may follow the comma; typically you type the pattern, the comma, and the rack which is used to fill in blanks in the pattern. |
| [] | - | means a word from the current slate or given wordlist |
| [M] | - | means a word from the current slate or given wordlist mapped letter by letter |
| [<subword-spec>] | - | part of a word from the current slate or given wordlist |
| [M<subword-spec>] | - | part of a word from the current slate or given wordlist mapped letter by letter |
| <number> | - | the nth letter |
| <number>-<number> | - | the mth through nth letters |
| ~ | - | the reversed word |
| ~<number>-<number> | - | the mth through nth letters of the reversed word |
Although these query constituents imply a pattern query, that can be overridden by including /A on the line following any of these characters to indicate an anagram query is being made. It will often be the case that when you have a pattern query, you will use one of the above utterances, but there are exceptions; for example, you might ask for those words of length 8 whose letters alternate between consonants and vowels. The query would consist of built-in sets, and their inclusion in the query does not necessarily imply a pattern query. So, you would have to explicitly indicate this, such as by including /P in the query.
You may specify pattern queries by typing the pattern as the query string and then providing a rack of characters that can be used for blanks and sets within the pattern. Even if a singleton set is part of the pattern, the one character it can be must be found in the given rack. If you want a certain character at a certain position in the word, indicate it by itself, and don't repeat it in the rack. In other words, the rack is to provide those letters not already explicitly mentioned in the query string.
When processing an anagram query, WHAT ignores any rack characters that you have specified. This situation is somewhat unusual in that if you provide rack characters, the kind of query is set to pattern matching, and then you would have to provide an explicit override to set the query kind to "Anagrams", such as by including /A.
If you have a rack, such as
ACILMT?,
and want to know those words that have an
R
as the fourth letter, you could express a query as
...r....,acilmt?
The fact the
R
is in the pattern forces that fourth letter to be an
R.
The example just presented has a length of query that is known and a number of letters in the rack to match the number of blanks in the query. In such a case, it is clear that all letters of the rack must be used. However, when there are more letters provided than required, not all letters mentioned in the rack need be in a matched word. To force WHAT to include a letter from the rack in a word, it should be followed by an exclamation point. When the lengths imply the need for all letters to be used, the forcing of a letter is irrelevant; in a sense, WHAT assumes forced letters were used.
When a query includes an asterisk or any other wild card query constituent
(indicated by a repetition count of zero), any letters given in a rack may
be required or not (according to how they are specified), and the rack is
assumed to be filled out with as many blanks (or other wild card query
character) as are required to match the query. For example, you could ask
for those words that begin with a
Q
not immediately followed by a
U
that contains another
U,
using query:
Q(!U)*,u!*
The asterisk is a wild-card specifier, and you will often employ this one in queries, especially pattern matching queries. It represents any number of any letters. WHAT supports a more general form of wild-card specifier that can represent any number of specified letters; for example, any number of vowels. This is indicated by employing a repetition count of zero as a prefix to a letter or set in a query. So the zero means "zero or more of the following letter or set".
Most kinds of sets are permitted in a rack, but query-based sets are not.
Word references are allowed within a rack. The rack is an unordered set, so reversed words and subwords can be expressed, but the reversal has no effect.
Characters in a rack must immediately follow a comma and not include spaces. The first space you present within your specification of the rack terminates the rack, and further characters you type are taken to be query characters. You may provide further rack characters within the query by tying another comma.
If you not explicitly set the kind of query, but you include a word
reference, the query is kind is defaulted to be a pattern match, but if
you then include either a plus sign or minus sign, that changes the
query kind to "Anagrams". So, if you have a slate of
words resulting from a query other than an anagram query,
you could perform either of these commands
[]-
[]/A
to see those words along with their anagrams.
This section needs updating, now that the GUI is involved, etc. Thus we indicate it is To Be Determined (subsequently abbreviated as "TBD") in this guide.
When you end a command with Shift+Enter, WHAT will check that command, but not perform it. When you end a command with Enter, WHAT will first check the command, and either report detected errors, or it will perform the command in the absence of errors.
As you type a command, the WHAT GUI indicates the meaning of the command in the current context of the program, but the checking for errors and conditions worthy of warnings is delayed until you finish the command and press the Enter key. At this point, if anything is wrong, WHAT comes back with a line starting with " ERROR - " and followed by a short explanation of the first error it noticed. Some legal parts of the command already scanned may have led to the program's carrying out some work. Upon encountering a part of a command line in error, WHAT ignores the remainder of that line.
Two conflicting specifications in a command are generally accepted and not considered as an error. The most recent spec overrides an earlier one. For example, if a command includes both an apostrophe and a quotation mark, the last one in the command pertains.
The feature of letter mapping is a somewhat obscure facility provided for unusual, non-typical queries.
Word references that begin with the letter
M
(or m)
following the left
square bracket indicate the each letter coming from the word or string
is to be mapped to a letter based on a user-specifiable mapping.
For example, one form of word reference may involve the mapping of one
letter to another; this is for a word reference of the form
[M<number>]
This means to get the nth letter of a word from the slate (or whatever the
current source of word references is) and map that letter to another letter.
WHAT supports one map at a time, and these are the related commands:
| /M"<26 letters>" | - | set the letter mapping |
| /M? | - | show the current letter mapping |
When WHAT starts, it has a default mapping of "BCDEFGHIJKLMNOPQRSTUVWXYZA".
The first letter in the mapping indicates the letter
A
maps to, the
second letter in the mapping indicates the letter
B
maps to, etc.
It is not required that the 26 letters in the mapping are all different.
There is a menu pick
In general, one letter on a command line appears to be a query with only that one letter, and since there are no 1-character words in WHAT's lexicons, this is never going to lead to any results. Therefore, some individual letters are used for some of the most common commands:
| C | - | bring up the dialog to handle challenges. |
| D | - | delete the current flashcard. |
| F | - | present the most recent flashcard again. |
| G | - | bring up the 5 x 5 Grid Game Player Dialog. |
| M | - | bring up the dialog for deleting, copying, or moving wordlist items. |
| N | - | when doing randomized flashcarding, first put the current flashcard at the end of the group, assuming the toughness is zero. Then present the next flashcard; this is equivalent to a command of the number zero only when doing randomized flashcarding. When doing sequential flashcarding, the card is not moved using this command, but it is moved for the toughness of zero command. |
| R | - | produce a random rack as a command, but do not perform that command; the command of one period does the same thing, except it does then perform the command. |
| T | - | show the Timer tab and start the WHAT timer. |
| X | - | move the current flashcard to the next wordlist. |
| Y | - | move the current flashcard to the wordlist after the next one. |
| Z | - | move the current flashcard to two wordlists after the next one. |
The main part of a query consists of any of these query constituents:
For any of these, you may give a prefix repetition count. When the count is zero it means zero or more of that constituent, so it is a wildcard specification. A zero count for a word reference has no well-defined meaning; this detail of WHAT deserves some further investigation [TBD]; until this is better understood and described, you are encouraged to avoid this construct in queries. A suffix of an exclamation point may follow any of these to indicate the letter(s) represented by the constituent must appear in the result.
The above section introduced some of the character specs that you may include in a query. This section introduces more of such specs. The simplest and most common query character is a letter. This just means the letter is part of the sought word. When the query is an "Anagrams" kind of query, that letter may appear anywhere within the word.
You can specify a blank in either of two ways:
| ? | - | this is the usual blank, one used in anagramming, and if blank scoring is being done, it scores what the letter it represents scores, as long as the bag has enough of that letter. |
| . | - | this is the same as the ? blank, except that a pattern query is implied by its inclusion in the query, as described in the previous section. |
Another powerful character spec that is supported by WHAT is a set of characters. A blank is a special form of a set in that it can represent one of any of the 26 letters of the alphabet. Other sets may also be useful in formulating queries. The later "Letter Sets" section covers sets.
Characters represent themselves in queries, and the usual kind of query
WHAT supports is an "Anagrams" kind of query.
For anagram queries, you
may specify some letters and then specify letters that you want to be
eliminated. Type a minus sign to introduce letters you want to remove.
An example is the query:
unitedstatesofamerica-underestimates/|4
that requests the words of at least length 4 that can formed from the
letters left over when you eliminate letters in
"underestimates" from those
in "unitedstatesofamerica".
You may use a plus sign to introduce more query letters to be included following a list of removed letters.
It is permissible to subtract too many of a letter such that the count for that letter goes negative, in that case WHAT assumes it to be zero.
Subtraction of letters is permitted for pattern matching queries only in the rack.
This unusual and powerful kind of query can be done for either anagram queries or pattern queries. Furthermore, with pattern queries there are two cases:
Except for the second of these cases, WHAT replaces each of the unrequired letters in the query with a blank. It does not replace blanks or sets or required letters of the query. This is appealing to use with anagramming to yield study lists; such words have been coined as "blanagrams" by others.
Recall that you specify a required letter by following it with an exclamation point.
Circulating the blank with pattern matching can be interesting in that you
are shown closely related words. For example, if you make the query:
baboon/~P
these words result:
BABOOL BABOON BABOOS GABOON
As mentioned above,
the blank may be circulated for a pattern query such that it is
inserted to the left or right of each character, instead of in place of
the character. For example, this query:
senor/+P
yields these words:
SENHOR SENIOR SENORA SENORS SENSOR
The query kind known as "Steals" is provided especially for finding
word steals when playing the game of Anagrams. The letters you provide
in a steal query must all show up in the answer. A minimum number of
blanks are added to the query letters to yield the shortest word. If
blanks are part of the query they represent excess above the minimum.
Thus,
/~Sumiaq
yields an answer of MAQUIS, and
/~Sumiaq?
yields an answer of : MARQUIS, whereas
/~Smaqui?
yields an answer of 7 words including
AQUARIUM.
This might be a bit confusing. The base word of MAQUI has a 1-letter steal when requiring base word rearrangement, that is UMIAQS. If you then seek a steal with 2 letters requiring rearrangement it turns out that there are no 2-letter steals with a rearranged answer - the only 2-letter steal of MAQUI is MARQUIS, and there is no rearrangement. When requiring rearrangement for this case, a 2-letter steal request answer consists of those words with 3-letter steals.
Queries for steals are limited to letters, blanks, and whole word references; they may not include wild characters, sets, nor partial word references. This restriction could probably be lifted; please let us know if you have such a need.
The ability to perform 2-word anagramming is probably not of any use for most word games, but this feature is included in WHAT since this kind of question does arise on occasion. Especially when many letters are provided as the basis of the query, the number of answers can be extensive. For this reason, WHAT will not accept a two-word anagramming query that includes any blanks.
WHAT supports two-word anagramming only for explicitly provided letters. Blanks, sets, and wild-card characters are not supported in two-word anagramming at present.
In the answer to a two-word anagramming query, no duplicates are produced, but all anagram variations are included. So if CAT is part of one pair of words in the answer, there will be another answer with ACT in the same place.
Individual words which are part of the answer to a two-word anagram query are never marked with an indicator to show that the word is from a particular lexicon. This is also the case for two-word pattern queries.
The slate holds the answer to a two-word anagram request with one space separating the two words, and the words are in alphabetical order. When the slate is presented, WHAT is aware that it was created as a result of a two-word anagram query, and therefore is determines the longest first word, and then presents the slate with one word pair per line and so that the second words of each answer line up in the same column.
This section describes how you use each of the characters of the keyboard within WHAT commands. The order of this section is based on the order of ASCII numerical encoding.
Individual keyboard characters other than digits and letters are employed as common constituents of commands. Less-used command constituents are expressed using multi-character sequences.
| <tab> | - | The Tab key can be pressed to terminate a command line which has one or more words to be challenged. The Challenge Dialog is brought up, primed with any comma-separated words on the command line. |
| Esc | - | The Esc key can be pressed to terminate a query which is taking too long or a slate presentation which is more than you want to see. It is used other than during the processing of a command to alternate between the Challenge dialog and normal WHAT use. |
| <space> | - | Spaces terminate subcommands. They are usually optional. A space ends the specification of rack characters (introduced by a comma). |
| ! | - | The exclamation point is used in these ways:
|
| " | - | The quotation mark (or double-quote) is employed in commands to indicate words are to be presented one per line, each with its definition. When a word has more than one definition, a plus sign is used as as a separator instead of the usual minus sign; when the presntation layout is not set to one word per line, all definitions of the word are shown in the presentation on subsequent lines. This feature is available only when you supply WHAT with a suitable definitions file. Quotation marks are also used within commands to enclose labels and the print job title. |
| # | - | The number sign (also known as an octothorp) is employed in commands to mean "number of words". When it is used alone, it indicates the presentation of the slate is limited to indicating the number of items on the slate. It is also used within the specification of built-in sets, where it means letter frequency (i.e., "number of letters") in a game played on a 15 x 15 board. |
| $ | - | Dollar sign is used to specify something connected with the scoring of a letter or a word. |
| % | - | The percent (that anagrams to PRECENT) sign is used to specify something connected with word probabilities. |
| & | - | The ampersand is used in a couple of ways:
|
| ' | - | The apostrophe (or single-quote) is employed in commands to indicate words are to be presented in the order they are on the slate. This is typically in normal word order, but you can alter query results to yield other ordering. |
| ( | - | The left parenthesis (that anagrams to FELT INTERPHASES) is used as part of the specification of letter sets and to introduce a reference to a letter set. |
| ) | - | The right parenthesis
(that anagrams to
GIRTH/GRITH INTERPHASES)
is used:
|
| * | - | The asterisk (that anagrams to SARKIEST) is used in queries to mean zero or more blanks. Although when it is used a pattern match query is implied, you can change that so that an anagram query is done, in which case it means any number of blanks can be used. It is an error to include redundant asterisks in a query, such as consecutive ones. Consecutive periods and asterisks are permitted. |
| + | - | The plus (that anagrams to PULS) sign is used in some commands, such as the /+S command. It is also used in queries to terminate a list of subtracted letters and then revert to indicating letters included in the query. Another use of the plus sign is as part of the specification of a set indicating a letter already in the word. |
| , | - | The comma is used only as an optional character in the /OR command to indicate a comma is employed as a separator when slate output is in packed rows. It is also used to introduce the rack in a query. Typically you type the pattern, the comma, and the rack which is used to fill in blanks in the pattern. |
| - | - | The minus
(that anagrams to MUNIS)
sign is used for many different purposes:
|
| . | - | The period
(that anagrams to DOPIER)
is used in queries to mean a
blank, but also the query is implied to be a pattern match kind
of query. A period-specified blank, like a question mark one, normally
scores according to the letter for which it is used in a word; whether
it does is under your control using the
/Z and
/-Z commands.
A command consisting of just a period causes a random rack to be generated and it replaces the command line. |
| / | - | Slash is employed to introduce most of the WHAT commands and subcommands. It is also used when probing the slate as a separator between character number and item number, either of which you may omit. |
| <digits> | - | Digits are used to express numbers, and these are employed throughout the WHAT commands to provide values. A number can precede a letter in a query to indicate a repetition count. Also, /2A and /2P specify kinds of queries. |
| : | - | The colon is used to represent the presentation of the slate is to be based on what the blank can be. It is also used to specify sorting based on what the blank is. It is used as a separator when specifying an item of a wordlist in commands to delete, copy, and move items, and also to start up sequential flashcarding. |
| ; | - | The semicolon is used to refer to canonically-ordered words. You may create the slate with canonically-ordered words. As a separate step, you can have the slate presented with words in canonical order. Canonically-ordered words are in general non-words; you can think of these as "semi-words", hence the choice of using this character for this purpose. |
| < | - | The left angle bracket is used to specify something connected with front hooks. It is used to specify decreasing sorting order. It also shows up in relational operators, where it means "less than". It is used in ranges where the range is not inclusive of the upper extreme. |
| = | - | The equal sign is used in a few different ways:
|
| > | - | The right angle bracket is used to specify something connected with back hooks. It is used to specify increasing sorting order. It also shows up in relational operators, where it means "greater than". |
| ? | - | The question mark represents a blank in a query. Like a period-specified blank, it usually scores according to the letter for which it is used in a word, but you may indicate blanks are to be zero-scoring using the /Z and command. It is also part of commands for word presence in a lexicon or wordlist. |
| @ | - | The at-sign
(that anagrams to
GAINST/GIANTS/SATING)
is used:
|
| <ABC...> | - | Uppercase or lowercase letters represent themselves in queries; case of letters is of no significance. Letters of either case are also usable as part of many different WHAT commands. |
| [ | - | The left square bracket is employed in a query to introduce a reference to a word already on the slate or some list. The reference may be for the whole word or some part of it, namely a subword. |
| \ | - | Back-slash is employed in commands to mean nothing about the slate is presented as a result of making a query. |
| ] | - | The right square bracket is used:
|
| ^ | - | The carat is employed in commands to refer to commands already issued and thus exist in the command history. Its use is not supported in command files. |
| _ | - | The underscore is currently an unused character is WHAT. |
| ` | - | The back apostrophe (or unquote) is employed in commands to indicate words are to be shown with what letters can be unhooked, namely whether a leading or final letter (or both) of a word can be dropped to form other words. |
| <abc...> | - | Lowercase or uppercase letters represent themselves in queries; case of letters is of no significance. Letters of either case are also usable as part of many different WHAT commands. |
| { | - | The left curly brace (that anagrams to ACERB/CABER) is used in WHAT to introduce a set of letters whose probability is to be computed. |
| | | - | The vertical bar is used to specify something connected with word length. It is used as part of commands to affect sorting by word length and presentation of word length. It is also used within subword references (within square brackets) to indicate the number of letters in the referenced word and also some number of letters related to the referenced word's end. It is also used as the operator for set union for wordlists and letter sets. |
| } | - | The right curly brace (that anagrams to ACERB/CABER) is used in WHAT to terminate a set of letters whose probability is to be computed. |
| ~ | - | The tilde
(that anagrams to TILED)
is employed in various ways:
|
A letter set, which we will merely call a "set", consists of any number of each of the 26 letters of the alphabet, except an empty set is not allowed. Usually, each set, either built-in or user-defined, has at most one of any given letter, but this is not required; letter counts in a set may exceed one. This is useful in some uses of letter sets.
To include a set in a query, a set specification is used; these set specs always begin with a left parenthesis and end with a right parenthesis. Some of these enclose something as brief as one character.
You may use some kinds of set specifications only in queries.
There are several kinds of letter sets:
In the above several set specifications, you may use either lowercase or uppercase letters within the parentheses. It is easier to type uppercase letters, since parentheses are shifted keys.
= == ! != > < >= <=Either one or two equal signs means a test for equality (the double form may be preferred by C programmers), exclamation point means "not", and either ! or != means "not equal". For example, ($5) or ($>=5) means the set of letters whose scores are at least 5, namely: J, K, Q, X, Z.
= == ! != > < >= <=Either one or two equal signs means a test for equality (the double form may be preferred by C programmers), exclamation point means "not", and either ! or != means "not equal". For example, (#6) or (#>=6) means the set of letters whose counts are at least 6, namely: A, E, I, N, O, R, T.
A set of letters can be expressed by which letters a particular letter may
be in a word or what letters can be added to a set of letters to form a
word, given that word's other letters. For example, one might express a
word-based set as those letters that can be the second letter of 3-letter
words that begin with
T and end with
N.
These sets are specified by
enclosing within the parentheses at least 2 characters, such that exactly
one of them must be a period and others must be letters (of either case);
the example, just mentioned would be:
(t.n)
There is a second flavor of word-based sets that is a generalization of the use of a word with one period, and that is the use of a set of letters with one question mark. The set consists of those letters which that blank (denoted by the question mark) can represent such that there is at least one word with those letters. For example (ZOA?) represents the set with the letters E and N. It does not matter in what position the question mark is or where the letters are.
In these specifications, you may type letters in either case. You may precede a letter in a letter list by a number to indicate a repetition count greater than zero, but not in the final form above. There are many ways to specify the same set; for example, (#6) can also be denoted by (aeinort).
Single letters within parentheses have a special meaning, and therefore that is an unrecommended form in which to express a singleton set. In the instance where you want to be sure you are denoting a singleton set, precede the letter by a repetition count of one. However, WHAT will interpret (<letter>) as a singleton set if there is no other meaning for it.
When you plan to use a set more than once, or if you want to specify a set based on other sets using set operations (union, intersection, or set difference) you should declare a user-defined set. These user-defined sets are then referenced by a number less than 100. When you specify one of these sets you may optionally provide a label to help you to remember its purpose.
To declare a user-defined set, use one of the following forms of commands:
When the optional set number is omitted, the lowest number not currently in use for a user-defined set is employed.
When the optional set is specified as empty, the set is removed; sets may not be empty. When the optional set is present, it can be represented by one of several possibilities for "<set>" described in the previous section.
When all of the optional parts of the command are omitted, WHAT presents a listing of all the user-defined sets. If you provide only a label, nothing is done, but it is diagnosed. If you supply a label when you are removing a set, WHAT ignores the label, and it makes no error diagnosis.
For the final three command forms, "<set>" represents either:
Since letter sets may have more than one instance of any given letter, the meanings of these set operations are not traditional. When taking the union of two sets their counts are added. When taking the intersection each letter's count is the minimum of the two counts of that letter. Set difference is done by subtracting the counts of the second set from the counts of the first set, yielding counts that are no less than zero.
A user-defined set is referenced with its set number within parentheses, namely: (<number>)
Query-based sets are ones that can be used in the construction of pattern-matching queries, whose meanings are based on the current query. These sets are merely singletons (with one letter) since they refer to a specific letter already in the word being matched against the query. These are the possibilities:
For the two R- forms and three S- forms, the "<number> must be greater than 0.
Except for these last three forms, when you present the same set twice in a
query, each set is separately full. But for these same-set references, as
each letter is matched from the set, one of those letters is removed during
the query. An example, is the query
b(V)b(S2)
that produces answers
BABE,
BABU, and
BUBO, but not
BABA,
since the
A
was already used in the second position.
Query-based sets are usable only within the query part of a pattern-match query. They are not supported in a rack.
In a query, you may specify a set with a leading at-sign following the left
parenthesis. This denotes that all members of the set are to be included in
the query, as if they were supplied explicitly. This kind of set
specification makes little sense in a pattern-matching kind of query, so it
is not allowed there, except, perhaps, in the providing of a rack. For
example, in a query:
(@V)
specifies that all of the vowels are included (once) as query letters.
This is equivalent to having typed:
AEIOU
This kind of specification can be combined with set specs that begin with
a plus or minus sign. The at-sign must come first.
You can ask WHAT
to indicate the members of a presented set. You do this
by merely naming one set as a command. You may also ask to see all the
user-defined sets with the command:
/U
WHAT
presents these one per line using the format of: set number followed
by the label followed by the set contents. If a letter is repeated in a
set, a count is given before the letter.
The set denoted by (B) is a built-in set of the 98 letters in the bag. You may adjust the set's definition, but you must include at least one of each letter. This is the form of the subcommand to change the meaning of