^ Can usually be read in compound glyphs as contains. For example "^&" is the contains all operator and "^@" is the contents at or dereference operator.
| Can usually be read in compound glyphs as any. For example "^|" is the contains any operator.
& Can usually be read in compound glyphs as all. For example "^&" is the contains all operator which looks for matches of all characters in a string. It also reads as each as in :@& reads control-at-each (also :for if you prefer English control statements).
* Can usually be read as mark. For example "*=" is the mark elements that are equal operator.
: Can usually be read as control. For example :for or :@& designates the for structured programming element (read control at each). :? (read control-if ) is used for the if structured programming element. Also used to denote system members of objects (e.g. 'abc' :typec gives English string name of object)
. Used to separate fields of a compound variable name. (e.g. Account.Address.Street)
` Can usually be read as index or index of. For example "`->>|" is the index of next any operator which finds the index of the next delimiter. The plural ( `` ) is read as indices of
@ Can usually be read as at. For example "@<-" positions the cursor at beginning of stream. Is also used to set context for subsequent operations as in "@==" which tells a following grade or sort to do exact matching.
< Can usually be taken to mean left, previous, or down. For example "``<" is the grade down operator and "@<<-|" is the at previous any operator.
> Can usually be taken to mean right, next, or up. For example ">>>" is the sort ascending operator and "`->>&" is the index of next all operator.
~ Can usually be read as without. For example "~<" is the without leading operator. Also read as not when used with booleans.
\ Can usually be read as reduce by. For example "\+" is the reduce by addition or sum operator.
/ Can usually be read as scan or running. For example "/*" is the running product operator.
% Can usually be read as convert. For example "%/" is convert to U/C; "%\" is convert to L/C; and "%*" is convert to string.
%* This is the convert to string operator. It is used throughout the examples to convert the output to a string for display in the example.
%** This is the convert to verbose string operator. It is principally a debugging aid and won't find much application in real programs. It is used extensively in the documentation to reveal details about result objects.
; This is Glee's statement separator just as the period "." is the sentence separator in English written text.
# A special Glee symbol used to begin natural language operators like #log, #ln, #cos, #sin, etc. Also means count.
$ A special Glee symbol used in its debugging and program annotation mechanism. It is not an operator ... it is a parser signaling device
$* ... *$
These are Glee's comment indicators. For example "$$" indicates the rest of a line of Glee code is taken as a comment (in 'C' and 'C++" this corresponds to the "//" used at the end of a line.) The "$*" starts a block comment and "*$" terminates it. This corresponds to the "/*" and "*/" in 'C' and 'C++'
' A Glee delimiter used to delimit literal strings (e.g. 'Hello World' )
" A Glee delimiter used to delimit literal strings (e.g. "Don't do that")
$R / $r Raw capture: Often you have text on the clipboard that you want to analyze with Glee. An easy way to introduce it is with the raw capture facility. $RdelimString$r **your text pasted here ** delimString => variable will capture its literal essence in a variable. Example: $Rxyxyxy$rContains "embedded" 'quotes' of both kinds.xyxyxy=>Var.
$V / $v Verbosity runtime switch: In many examples you will see $V (turn verbosity on) and $v (turn verbosity off). These are messages embedded in your code that tell the parser how to display results. The initial condition is set by the verbosity checkbox in the form. It is reset by that checkbox before each run. This display can also be accomplished with the %** verbose display operator. The %* produces a simple string display result.
anonymous reference In Glee, a reference to an unnamed object. The most common use is a reference to the local namespace returned by niladic use of the @ operator.
association A pairing of a symbolic name and the data to which it refers. In Glee, namespaces are sequences of associations.
arguments Inputs to an operation. If only one argument (monadic) it appears to the left of the operator. If two arguments (dyadic) they appear on each side of the operator.
#bag (bag object) In GLEE, a balanced skip list with non-unique key/value pairs. (see #set, #dict, and #idx)
bit A vector of logical elements having values of only 1 or 0 Also sometimes referred to as boolean.
block In Glee, a block is an object delimited by curly braces {...} . It contains code, a local namespace, an initial expression, a break expression, and an error expression. Blocks with no names are called anonymous blocks. You name a block in Glee using the #pgm operator or the #op operator. Once named, a block is essentially a Glee program that can be invoked and referenced by its name.
boolean Another word for bit.
case When referring to characters, the distinction of being capitalized (upper case) or not capitalized (lower case). Glee ignores but preserves case in its names and most of its operations. :case is also a target for the :select control structure.
character A single letter like 'a'. May be non-printable like the "bell" character (ASCII 8).
class Another word for type. This word is currently seldom used in Glee speak.
compound variable A special kind of Glee variable that is really a tree of namespaces. It allows for COBOL like structuring of names for objects (e.g. "3518 Indian Forest Dr." => Account.Address.Street; "Spring, TX" => Account.Address.TownState).
control structures Program flow structures which support structured programming. These are (:for); (:do / :while); (:if / :elseif / :else); (:select / :case / :default); (:try / :catch / :finally); (:while / :do).
delimiter A character or sequence of characters that separate groups of things. For example, in normal English writing, the ',' and '.' are delimiters for phrases and sentences respectively. In Glee the ';' delimits instructions; '{ }' delimits blocks of instructions; and ( ) delimits instructions to control their order of execution.
depth Depth relates to Glee's sequences. Glee's simple objects, like numerics and strings, are at depth 0. Sequences containing these objects and are at depth 1. If a sequence contains a sequence, it is at depth 2. If that sequence contains a sequence, it is at depth 3. The enclose (>) operator creates depth. The disclose (<) operator removes depth if the level is homogeneous. The depth (**) operator reports depth.
#dict (dictionary obj) In GLEE, a balanced binary tree with unique keys each of which has a value (see also #set, #idx, and #bag).
dyadic An operation taking two arguments. In   3+4  , the + is the dyadic addition operator.
element A constituent of a vector. In the vector "abc"; a, b,and c are character elements of a character vector. Character vectors are also called strings. All objects in Glee are vectors and thus contain elements.
extraneous For Glee's purposes, this means more than absolutely necessary. Leading and trailing blanks are not necessary. More than one interceeding blank (i.e. between words) is extraneous.
field In Glee, a field is a special object for use in symbolic addressing. Fields begin with the period (.) or colon (:) character and then follow rules for Glee's names. When used with base objects, fields interact with the objects methods and properties. When used with referenced objects, fields address the object's named elements. For example, if a namespace is referenced, fields address (i.e. locate) the objects in the namespace by name. For example, (@ =>ns;10=>ns.i; @.i ) does the same thing as (10=>i; i). Fields should not be confused with object members (addressed with :@ ). They should also not be confused with compound variables (e.g. The leading period is the key.
function Another word for program. In Glee I use the term function and program interchangably. A method is a function contained in an object.
It is the nature of interpretive languages to create garbage. This is in the form of dynamically created storage holding intermediate results. Glee deals with garbage continually. It keeps its nest clean. So you won't experience a pause in an operating Glee program as it goes off to do housekeeping.
Glee A remarkable new way to computers what you want them to do.
Glee compare In string contexts you usually want to cast a wide net. For example, when searching for matches you're not concerned with case or extraneous white space. Further, you're not usually interested in punctuation. In string contexts, Glee uses these looser (albeit computationally more expensive) rules for doing comparisons. It ignores case; treats punctuation as white space; and ignores extraneous white space.
homogeneous In the context of Glee this means that all elements at a given depth are of the same type. It means that therefore, one level of depth can be removed by catenation of elements and the result will also be homogeneous. For example, if a sequence contains all numeric elements it is homogeneous. However, if it contains a mix of numeric and string elements, it is not homogeneous. To reduce the depth of a homogeneous sequence, use the disclose (<) operator.
heterogeneous In the context of Glee this means that at least one element object type differs from at least one other element object type in a sequence.
#idx (index obj) In GLEE, a balanced binary tree having unique key/value pairs. (see #set, #dict, and #bag)
indexing Locating elements within a vector (e.g. (10 20 30 40)[2 1]yields 20 10). " [ ] " is Glee's indexing operator.
instruction A single request to the computer. 3+5=>result; is an instruction to add two numbers and save the result. The semicolon (;) is the delimiter for instructions.
item A word which in Glee is a synonymn for "element".
literal Data that is directly (or literally) supplied to the program. In the example: ("Hello"=>a; a=>b;), "Hello" describes a literal character string assigned to a variable (a). Then the variable (a) is assigned to the variable (b).
A manifest constant in computer terms is a number (like pi or e) that the computer just knows. Glee has no such constants. Howerver, it does have niladic operators which produce such constants. These can then be stored in variables and used as constants. For example #pi => pi; ^ => e; #true => true; #false => false; #nil => nil. They can then be used in expressions (e.g. pi*d => circum; or r^2 * pi => area;).Obviously, if this is all there is to having such constants, I could have just put them in the namespace. For now, let's just know this is how Glee is and not ask why it doesn't have manifest constants.
member Objects have members. These are their methodsand properties. For example, all system objects have a :typeC property member that returns an English name for the object. To query an object use the : compound variable field separator alone (e.g. "abc" : gives :, :b64, :csv, :hex, :num, :props , :r64, :size, :string, :stringV, :typeC, :typeN which are the members of the string object. Then "abc":typeC gives String, the English string name for the object type.
method A name for a function or program contained in an object or type.
monadic An operation taking one argument. In ( 10 - ) the '-' is the monadic negation operation which changes the sign of its numeric left argument.
name In Glee a name is a symbolic reference to an object, typically called a variable. Glee names begin with an alphabetic and then contain any number of alphabetic or number characters with no intervening whitespace. Glee preserves case but is not case sensitive.
namespace An environment in which instructions are performed that defines the names of variables and programs known to operations. In Glee, namespaces are implemented as sequences of associations. Namespaces are Glee objects.
nil Nil is a special Glee object which is substituted when an operation fails or an index is outside of a range. For example 10 20 30[0 1 2] yields Nil 10 20. There is no element 0 in the vector 10 20 30. Operation behavior for Nil is defined for each operation. For example (10 20 30)[0 1 2]*10 yields Nil 100 200 (i.e. operating on Nils by "*" yields Nil.) Glee is aware of Nil in operations like 4 2 (#nil) 3 7 /+% which yields the running average 4 3 3 3 4. Notice Nil only participates as a place holder.
niladic An operation taking no arguments. The niladic operation ( #pi ) returns the constant 3.14159 used in circular operations like #sin and #cos. The niladic operator (^) returns 2.71828, the value of e. The niladic operator (?) returns a random integer. Additionally, you can assign to this niladic operator to set the random seed (e.g. "10=> ?; ?" will always yield 30957)
object A Glee complex element which contains members called properties and methods.
operation A process performed on arguments yielding a result.
operator A symbol that Glee recognizes as a moniker for an operation. The symbol '+' denotes the operation "sum".
persistence  Ability to retain state between sessions. Glee objects typically live in memory and are discarded at the end of a session. Glee has special syntax to copy objects to external non-volatile media (e.g. disk) and use it in subsequent sessions.
pointer A reference to where data is stored in memory. In Glee, pointers are the data element of sequence vectors. Use of pointers allows for very powerful program constructs. It also allows for storage conservation. In Glee, all pointers are reference counted. All garbage collection is automatic.
program A sequence of instructions which tell the computer what you want done. I will also refer to these as functions.
property This is another word for data. Objects have function (program) and property (data) members. For example, you can query the alignment property of a numeric object with and expression like 10.1 :@ ?alignC and get " F " indicating floating point.
record set A combination field list / records sequence. The field list contains the field names corresponding to the elements of the records (sequences) making up the record set (sequence). It is an object with support for adding and deleting fields and records. It has methods for accessing and arranging information in the set. It is like a table in other languages.
reduction Collapsing a vector to a scalar (really a 1 element vector) by performing some operation on it. For example (1 2 3 \+) reduces the vector 1 2 3 by placing the + operator between the elements and performing the operation (in this case ... sums the vector yielding 6).
referent That to which a reference to an object or element of a sequence refers. In Glee, a referent is always an association.
reference In Glee, a reference is a pointer to an association. When you perform activity on the reference (e.g. assign to it), the effect is on the referent. Glee uses the @ symbol to create a reference from an object.
reference counting Reference counting is a technique for memory conservation and management. If an object in Glee is referred to more than once, it is only retained in memory once. The number of references to the object is maintained. When all references to the object go away (e.g. are deleted or assigned to other objects), the object is automatically removed from memory. Some interpreters do this in a process called garbage collection. Glee attends to garbage immediately. There is no occasional delay for periodic housekeeping common to other interpreters like Java.
scalar A single element like the number 1.2 or the letter 'a'. In Glee everything is a vector so a scalar is simply a one element vector.
scan Perform a reduction but retain all the intermediate results. For example (1 2 3 /+) places the "+" operator between the elements. It then records the first element and working from left to right records the subsequent progress of the operation. In this case the result is (1 3 6) sometimes referred to as the "running total".
scope Describes where named objects can be seen. Describes where named objects can be changed. Objects are considered in read scope if the can be seen and in write scope if they can be replaced.
sequence A vector of pointers to Glee objects. "abc" (1 2 3) (7 8 9 *= 8) is a sequence of three Glee objects ("abc" is a vector of characters called a string; 1 2 3 is a vector of integers; and the result of (7 8 9 *= 8) is a vector of bits. The resulting three element sequence is a vector of pointers to the storage of these objects.
#set (set object) In Glee, a form of Red/Black tree containing only unique keys ... no values (see also #dict, #idx, and #bag).
singleton Another word for scalar or 1 element vector (you can never have too many words with the same meaning when you're dealing with computers).
skip list A binary tree like structure allowing quick key lookups. Skip lists are used to implement the #set, #dict, #idx, and #bag objects giving them very fast access by key.
statement Another word for instruction. (see instruction)
stable sort A stable sort preserves original order in the case of matching elements. Glee uses stable sorting techniques because it is typically the behavior needed. It is particulary important when sorting multiple field records in multiple passes. Computationally it's not that much more expensive although most systems don't do it.
In strand notation, you can exhibit objects side by side with no intervening operator. For example, given "Hello "=>a; "World"=>b;then   a b=>c   is strand notation which Glee sees as a sequence containing referents to the variables named "a" and "b". Displaying "c" you would see Hello World. In Glee you can create strands using parenthesis as well (e.g. (1 2 3) (3 2 1) creates a two element sequence of 3 element numerics.
stream Files and strings can be viewed as streams. Stream operators serve the need to slew through files and strings looking for and reading information. They can be viewed as slewing tape in a tape recorder where the tape media is the stream.
string A vector of characters like "Hello world". A vector of characters.
structured programming A technique of programming that serves to eliminate most branching. It makes programs easier to understand and manage. In Glee, the :for(...){...}:else {...} is structured programming
symbol A character or string that represents a programming element. '+' is the symbol for "sum". '\+' is the symbol for summation.
type A type in Glee may be numeric, character, bit, pointer, sequence, file, etc. Further, numeric types have the subtype integer and float. All Glee types are vectors. Some types like blocks are limited to singletons. Glee types are also classes in the object oriented sense. They have methods and properties (together called fields). They incorporate encapsulation but don't (yet) exhibit polymorphism and inheritance capabilities required for object orientation. Glee doesn't allow user creation of types (yet).
variable A symbolic name (and associated memory) which stores results for later reference. In ( 2=>a; 4=>b; a+b=>c;), (a,b, and c) are variables. In Glee variable names begin with a letter and contain any number of letters and numbers. The only symbol they can contain is the underbar ("_") but cannot begin with it. Glee variable names are not case sensitive. "Var" is the same as "var", "VAR", and "VaR". Glee does retain the case information internally for display purposes. It helps readability. For example "BigNumber" is slightly more readable than "BIGNUMBER".
vector A sequence of like elements (i.e. integers, characters, floats, bits, or pointers) like the numbers 1 2 3 or the letters 'abc'.
vulturing A colloquial term referring to poking around in unfamiliar data to determine how to extract useful information from it and to then extract that information and make it useful.
whitespace Whitespace is made up of the space, linefeed, and carriage-return characters. In Glee whitespace is a key delimiter. It separates numbers and separates operators from each other. Glee retains the whitespace in the source code. You should use whitespace liberally for readability, especially between successive operators. In fact, Glee forces you to space between operators to avoid human ambiguity. The computer has no trouble understanding because its rule for finding an operator is to scan for the longest match in the operator table.