=begin
= ((<Ruby>)) Glossary

# Original: by matz@zetabits.com (Yukihiro Matsumoto, aka matz)
# English Translation: by matz himself and web-i31s@clio.ne.jp (SugHimsi) et alii.
# First Release: 2000-12-25
# Last Retrieval: 2000-12-29 (Fixed some misspelling.)

== ((*A*))

: ((:Abstract Data Type:))

    A bunch of data structure and operation to the ((<data|Data>))
    is called an abstract data type.

    The abstract data should not be operated unless passing this operation.
    As a result, it is not referred directly from the outside,
    and the change in an internal structure does not color the outside.
    This is called ((<encapsulation|Encapsulation>)).

: ((:Associative Array:))

    Alias of ((<hash|Hash>)).

    It seems "Associative" is because
    the hash can take out the value of an arbitrary key,
    and "Array" is because you can assume it to be an array
    which the subscript is not number.
    Once upon a time,
    the associative array (called associative memory then)
    was thought to be realized with hardware,
    but improvement of hardware's calculation speed
    and discovery of an appropriate algorithm
    (it is called "((<Hash>)) table", derivation of the hash)
    brought us achievement only with software.

: ((:AWK:))

    A small ((<scripting language|Scripting Language>))
    by Alfred ((*A*))ho, Peter ((*W*))einberger, and Brian ((*K*))ernighan.

== ((*B*))

: ((:Big Endian:))

    The American Continent original inhabitants... are Indians.
    Here: ((*endian*)).
    The etymology is the people who eat the egg from a round edge,
    after Swift's "Gulliver's Travels."
    Naturally, the people who eat from a pointed edge are
    the ((<'Little' endian|Little Endian>)).

    In the computer industry,
    it is one of the forms when CPU etc. arrange ((<data|Data>)).
    The networkers are said that they will like Big endian.
    See also "((<byte order|Byte Order>))."

: ((:Block:))

    The one to compose loop with, to build house and wall with,
    or to hit person with.

: ((:Bug:))

: ((:Built-In Class:))

    ((<Ruby>)) interpreter built-in class which the structure of
    ((<instance|Instance>)) is different from usual ((<object|Object>)).
    To define the class which inherits these classes is not recommended.

    A built-in class of ((<Ruby>)) is as follows:

     * Array
     * Bignum
     * Class
     * ((<Data>))
     * FalseClass
     * File
     * Fixnum
     * Float
     * ((<Hash>))
     * IO
     * ((<MatchingData>))
     * Module
     * NilClass
     * Proc
     * Regexp
     * String
     * Struct
     * ((<Thread>))
     * TrueClass

: ((:Byte Order:))

    Do you arrange four byte ((<data|Data>)) 0x1234
    with 1, 2, 3, 4? or 4, 3, 2, 1?
    The former way is called ((<Big Endian>)),
    and the latter is called ((<Little Endian>)).
    The controversy which is good continues from the preliterate era
    and till now the conclusion has not been reached yet.

== ((*C*))

: ((:Class:))

: ((:Class Method:))

    ((<Method>)) of class.
    It is defined in class Class of all classes.
    Though there is a method which is common in all classes
    and a ((<singleton method|Singleton Method>))
    which is proper to each class,
    that's not much of a problem.
# of no consideration.
    Do not misunderstand that
    '((|((<self>))|))' in the class method is a class.

: ((:Coerce:))

    ((<Method>)) of converting type of numerical value.
    The numeric calculation method is set on, when
    the ((<instance|Instance>)) which it doesn't know is passed as an argument,
    which the coerce method is used to convert it.
    The coerce method returns a pair of
    given (, and converted) value and
    itself (a converted value, if necessary), as its arguments.

    The converting order of numerical types of the library of ((<Ruby>)) is
    as follows:
        Fixnum -> Bignum -> Rational -> Float -> Complex

: ((:Constant:))

    ((<Variable>)) which cannot change value once it is defined.
    ...Contradiction in terms?

== ((*D*))

: ((:Data:))

    Wrapper to show pointer at C level as ((<Ruby>)) ((<object|Object>)).
    It is made of C pointer, the mark function, and the free function.
    The person who tries to add the ((<function|Function>)) to ((<Ruby>)) by C
    should master the usage of this class, by all means.
    Contrary to that, it is a class that have no business with a person
    whose schedule has no chance to try it.

: ((:defined?:))

    Operator to examine whether the various expression is actually defined.
    It returns the string to show the type of the expression if defined,
    and returns nil if not defined.
    While defined? looks like the ((<method|Method>)),
    it is the built-in operator of ((<Ruby>)),
    and it doesn't evaluate arguments.
    Therefore, there'll be no output with:

        defined? print("abc\n")

: ((:Destructive:))

    ((<Method>)) such as String#chop and Array#concat
    is said "It has destructive action",
    since they change the state of the ((<receiver|Receiver>)),
    though the hardware is seldom put out of order.

: ((:Dictionary:))

    The one that can take the definition out of the item.
    Changed to the alias of "((<hash|Hash>))."
    In ((<Smalltalk>)) (which can be called the origin of
    ((<object-oriented|Object-Oriented>)) ((<paradigm|Paradigm>)))
    the ((<data|Data>)) structure which corresponds to the hash
    was called "Dictionary."
    So there are specks of the crowd who are familiar with that term.

: ((:document:))

    The one that ((<matz>)) is really bad at.
    He always says
    "the source itself should be the document.
    It even describes ((<bugs|Bug>)) perfectly."
    But no one agrees.
    This is the programmers' use and wont. Sigh.

: ((:Dynamic Binding:))

    To select an appropriate procedure (((<method|Method>))) on the operation
    according to the ((<data|Data>)) type of its ((<object|Object>)).
    The flexibility of the program is effected to be improved.
    One of the requirements
    for ((<object-oriented|Object-Oriented>)) ((<paradigm|Paradigm>)).
    Dynamic binding is inevitable in ((<Ruby>))
    because there is no type in the ((<variable|Variable>)).

== ((*E*))

: ((:Eiffel:))

    An ((<object-oriented programming|Object-Oriented Programming>)) language.
    Young ((<matz>)) has said to drop scales off his eyes by the book
    "Object-oriented Software Construction,"
    written by the author of this language.
    Even so, ((<Ruby>)) doesn't look like Eiffel at all, except
    the ((<block|Block>)) end (with '((|((<end>))|))') and a reserved word '((|rescue|)).'

: ((:Encapsulation:))

    To hide the algorithm of an internal structure and processing from outside,
    by the immediate operation to ((<data|Data>)) only from a specific procedure
    (called the ((<method|Method>))) which accompanies the type of data.
    See also "((<Abstract Data Type>))."

    In ((<Ruby>)) it can be said that encapsulation will be compelled
    since it is impossible to refer to the ((<instance variable|Instance Variable>)) from non-method.

: ((:end:))

    Reserved word to which ((<block|Block>)) structure is finished.
    According to a certain statistics, 33% of the person,
    who saw ((<Ruby>)) first sees this, associates Pascal. (...trust it?)
    However, this form which does not pair with '((|begin|))' is
    actually the neighbor of Ada or ((<Eiffel>)) rather than Pascal.

    ((<Ruby>)) do not to have offered to {}
    which had been accustomed and familiar with C and ((<Perl>)).
    It is from the following reasons:

     * Evasion of ambiguous simple / complex sentence problem

       For instance, in C, when you try to add a sentence on

           if (a==b)
              c();

       and do as follows

           if (a==b)
              c();
              d();

       leads a confusing ((<bug|Bug>)).
       This problem exists also in Pascal.

     * Evasion of dangling 'else' problem

       It is similar to the situation above-mentioned. If you write

           if (a==b)
              if (c==d) foo();
           else bar();

       it becomes annoying.
       To tell the truth, what you really meant is:

           if (a==b) {
              if (c==d) foo();
              else bar();
           }

     * Improvement of readability

       There is a person who thinks that
       closing the ((<block|Block>)) in the word named 'end' is
       legible to program, though it is a debatable opinion.

     * Problems in sentence structure of '((|begin|))' and '((|case|))'

       Frankly speaking, ((<matz>)) have tried to use
       the ((<variable|Variable>)) 'end' several time
       only to have had a terrible time.
       Then, he examined to change to the grammar with {} for a time,
       but every time he abandoned it for the part of grammar
       of '((|begin|))' and '((|case|))' with no beauty.
       To tell the truth, this might be the first reason.

: ((:ENV:))

    ((<Object>)) which operates same as ((<Hash>))
    to access ((<environment variable|Environment Variable>)).
    Actually it is an ((<instance|Instance>)) of the Object class
    which adds a ((<singleton method|Singleton Method>)).
    When the ((<environment variable|Environment Variable>)) is changed
    with this object, it is succeeded to the offspring process
    of ((<Ruby>)).

: ((:Environment Variable:))

    Value which is delivered from parent process to offspring process.
    It is accessed with ((|((<ENV>))|)).
    What is delivered to the offspring process is
    a copy of the environment ((<variable|Variable>)),
    so it is not possible to pass informations
    from the offspring process to the parent
    by using the environment variable.
    The parent will not listen to the child.

: ((:Exception:))

    The one occurs in exceptional situation.
    when it occurs,
    unless it is caught explicitly by '((|rescue|))' paragraph of '((|begin|))',
    the call hierarchy is traced back
    and the execution of program (((<Thread>))) is interrupted.
    The ((<Ruby>)) program should thank exception,
    because it is able to ((<end>)) without checking
    an exceptional situation one by one, in almost all of the case.
    The information on the place where the exception is generated
    is stored in ((|$@|)),
    and the information on the exception itself is stored in ((|$!|)).
#    The latter is enlarged, since version 1.6, to be able
#    to use ((|=>|))((<variable|Variable>))-name.

== ((*F*))

: ((:FAQ, Frequently Asked Questions:))

    ...And the compiled answers of them.
    ((<Ruby>)) FAQ is still developing now.
    Questions and answers are always welcome.

: ((:Function:))

    Strictly speaking, ((<Ruby>)) has no functions.
    But the appearance of a method call with ((<receivers|Receiver>)) left out
    is like a function, and furthermore, there is a ((<method|Method>)) which
    we can describe it as a virtual function, ((|((<self>))|)),
    ((<instance variable|Instance Variable>)),
    where no ((<receiver|Receiver>)) informations are referred.
    Such methods are sometimes, in a torelant situation, called functions.

    Mostly such function(al method)s' visibility is set to private, so that
    they could not be called in the form which ((<receiver|Receiver>)) is
    not omitted.
    The representative of that methods is ((<module function|Module Function>)).

== ((*G*))

: ((:Global Variable:))

    ((<Variable>)) which can be referred to anywhere in the program.
    ((*Danger!*)) Overuse deadlock.

: ((:goto:))

    One of which ((<Ruby>)) doesn't have.

    Why ((|goto|))'s absent is not for the policy "it should not be anywhere,"
    but for the fact "it's troublesome in implementation."
    In place of ((|goto|)), ((|catch|))/((|throw|))
    or the ((<exception|Exception>)) is used\ in ((<Ruby>)).

    See also "((<Non-Local Exit>))."

== ((*H*))

: ((:Hash:))

    Data structure in ((<Ruby>)) which expresses the mapping from key to value.
    It is also called "((<Associative Array>))" or "((<Dictionary>))."
    The derivation of hash is the algorithm
    which is called "Hash table" in the achievement of the structure.
    The word 'hash' means "cut in pieces", of "hashed beef."

== ((*I*))

: ((:Immediate Value:))

    The one in ((<variable|Variable>)) that not ((<reference|Reference>))
    but actual value is stored.
    Only '((|Fixnum|))' and ((|nil|))/((|true|))/((|false|)) are
    immediate values in present ((<Ruby>)).
    However, there's no law against another ((<Ruby>))
    which ((|Fixnum|)) is not immediate value, and also you can regard
    the all values on the model as a ((<reference|Reference>))
    to the ((<object|Object>)).

: ((:Inheritance:))

    Do minimum in itself, and fully rely on what succeeded
    from the ancestor or the relative to deal the rest matter.
    In the real world, It should be an unpleasant fellow.

    Turned to establish a new class
    which adds the ((<function|Function>)) to a certain class.
    Inheritance is effective to express the relation of is-a.
    For instance,
    "Student" class which describes the character of the general
    student can be succeeded to "Department of Engineering student
    (who is afflicted with the experiment)" class.
    When there is no is-a relation and the situation only shares
    the character and the function,
    it is assumed preferable to use ((<Mix-in>)).

: ((:Initialize:))

    Put the ((<object|Object>)) (or "something")
    into "ready-to-use-it" state.
    The '((|initialize|))' ((<method|Method>)) should be redefined
    to initialize the ((<instance|Instance>)).
    The default definition of the method '((|new|))' of the class is
    to execute Initialize to the newly generated instance.
    The argument to ((|new|)) is tossed to initialize as it is.
    Moreover, when ((|new|)) is called with the ((<block|Block>)),
    the block is given to initialize as it is.

    This surely means Class#new is not to have to be redefined.

: ((:Instance:))

    ((<Object>)).

    There seems to be a meaning to emphasize belonging to the class
    where the object exists.
    It is heard that there are a lot of people who have failed
    in ((<object-oriented|Object-Oriented>)) ((<paradigm|Paradigm>))
    by confusing whether the one s/he touches is an object or an instance.
     

: ((:Instance Variable:))

    Intrinsic ((<variable|Variable>)) to ((<object|Object>)).
    The ((<instance|Instance>)) variable of ((<Ruby>)) is the one
    that applies @ just before the identifier.
    It can be referred only from inside of the ((<method|Method>)).

: ((:Iterator:))

    Rehearser.
    The group of a certain code which can be passed to the ((<method|Method>))
    is called '((<block|Block>)).'
    Iterator is the method which the given block...this is surely the case.
    In general, the block is executed more than one time, so the method is
    called 'iterator' ("iterate" = repeat it); but there is a custom
    to call the case executing only once or not repeating, also iterator,
    insofar as the block is given to the method.
    Keep in mind, just the method have the 'repetition' as many as 0 or 1 time,
    do not call it liar, because it must be the 'repetition.'

    In the iterator, you can execute the block by '((|yield|)).'

    Ah, of course.
    Nothing happens to the method
    when the block is given of not evaluating the block internally.
    I wish you not to disappoint though the error does not occur either.

== ((*J*))

: ((:Japanese (language):))

    Native language of ((<matz>)), the author of ((<Ruby>)).

    The cause of the poor ((<documentation|document>)) of ((<Ruby>))
    (according to his excuse).

== ((*K*))

# no entry.

== ((*L*))

: ((:Little Endian:))

    At first there're ten children and decreases one by one.
    In the computer industry,
    it is one of the forms when CPU etc. arrange ((<data|Data>)).
    A certain CPU maker with very big share is said that
    they will like Little endian. See also "((<byte order|Byte Order>))."

: ((:Local Variable:))

    ((<Variable>)) which can be referred only within a certain range.
    The range is called 'Scope'. The scope of ((<Ruby>)) is among:

     * The entire program
     * Class and module definition
     * ((<Method>)) definition
     * ((<Block>))

    and only ((<block|Block>))
    can access the local variable in the outside scope.
    An effective range of the local variable is
    from the place where the first substitution in scope appeared
    to an end of the scope.
    The effective range is fixed statically, and is unrelated
    whether actually executed.

== ((*M*))

: ((:main:))

    '((|((<self>))|))' at top level.

    Since it can't be without self,
    it is a mere ((<instance|Instance>)) of an ((<Object>)) class,
    only for being there.
    Some ((<singleton methods|Singleton Method>)) are defined
    to operate the Object class.

    Defined ((<singleton method|Singleton Method>)):

     * private 
     * public 
     * include

: ((:MatchingData:))

    ((<Object>)) which shows state concerning match of regular expression.
    Value of ((<variable|Variable>)) ((|$~|)).
    When the value of this variable is changed,
    the value of variable group (((|$1|)),((|$2|))...,((|$&|)),etc)
    concerning the regular expression changes, too.

: ((:matz:))

    ((<Ruby>))'s author.

    His real name is 'Yukihiro Matsumoto.'
    If you say '((*You-Key-Hero Matz-motor*))' real quick,
    it sounds like his name.
    ('tz' as in 'waltz')

: ((:Method:))

    Operation to ((<object|Object>)).
    You can refer to the object (((<receiver|Receiver>)))
    to be operated with ((<self>)).
    In ((<Ruby>)), if you exclude the object
    of a ((<built-in class|Built-In Class>)),
    since the structure of the object is dynamically determined,
    the character of a certain object is determined
    by the method defined in the object.

: ((:Mix-in:))

    To make a new taste mixing various one with the ice cream.
    Changed into mix the module with the class,
    and add the ((<function|Function>)).
    See also "((<Inheritance>))." 

    Multiple ((<inheritance|Inheritance>)) is not adopted in ((<Ruby>)).
    Instead, the inheritance for the is-a relation,
    and Mix-in for sharing the ((<function|Function>)) is prepared.
    The purpose of this is the belief of ((<matz>))
    that the relations should be in chaos when multiple inheritance is abused.

: ((:Module Function:))

    In the ((<methods|Method>)) which is used like ((<function|Function>)),
    the one defined both as a method of the module
    and a ((<singleton method|Singleton Method>)) is called module function.
    For instance, most methods of the ((|Math|)) module are the module functions.
    These methods is convenient because it can be used
    both in the form(for example): 

        Math.sqrt(2)

    and

        include Math
        sqrt(2)

== ((*N*))

: ((:Non-Local Exit:))

    Non-local exit (or global exit) is
    not an escape within the ranges of the ((<methods|Method>))
    such as ((|break|)), ((|next|)), ((|redo|)), ((|retry|)), and ((|return|)),
    but the type which interrupts going back the hierarchy of the method call
    as long as it's not caught.
    In ((<Ruby>)) there are two way:
    by ((<exception|Exception>)), or ((|catch|))/((|throw|)).

    Almost all exceptions can be caught with '((|rescue|))'
    (including ((|SystemExit|)) generated by exit),
    but the exception not significant to catching
    (example: Fail in memory allocation/interpreter's ((<bug|Bug>)))
    does not become the ((<object|Object>)) to catch.

    ((|catch|))/((|throw|)) is the one which, when '((|throw|))' is done,
    jumps at a dash to catch with the same tag
    as the tag specified.

== ((*O*))

: ((:Object:))

    A thing. The matter.

    Love, perhaps, is not an object, but love letter is an object.
    Whether something is an object or not strongly depends on YOUR philosophy.
    Might the cause that
    ((<object-oriented|Object-Oriented>)) ((<paradigm|Paradigm>)) is difficult.
    Someone in the computer industry calls a specific space in computer memory
    as 'object.' ((<Awk|AWK>))ward guys...

    See also "((<Encapsulation>))," and "((<Abstract Data Type>))."

: ((:Object-Oriented:))

    ((<In Japanese|Japanese (language)>)),
    an adjective "Object-Oriented" has transcolored to an abstract noun,
    which means "the ((<object|Object>))-based ((<paradigm|Paradigm>))."

    Any kind of view looks OK at first
    as long as the object is the central concept,
    but in general, it seems that the ((<paradigm|Paradigm>)) needs
     * ((<Inheritance>)),
     * ((<Encapsulation>)),
     * and ((<Polymorphism>)) (or ((<Dynamic Binding>))).
    Someone deals it as a wild card or a kind of magic,
    but our life has a lot more.
    Twenty-odd years since the dawn, through all our fortunes,
    there comes to be a first stage of pragmatic use...perhaps...agreed?

: ((:Object-Oriented Design:))

    System design based on ((<object|Object>)). ((*OOD*)).

: ((:Object-Oriented Programming:))

    Programming based on ((<object|Object>)). ((*OOP*)).

: ((:Object-Oriented Analysis:))

    System analysis based on ((<object|Object>)). ((*OOA*)).

: ((:Override:))

    ((<Redefinition>)).

    Define a ((<method|Method>)) same name as the one
    defined on the super class or included method.

    In overridden method, '((|((<super>))|))' can invoke
    the superior method with same name.

== ((*P*))

: ((:Paradigm:))

    An affected expression of a 'view.'
    You tame could use the plain word instead.

: ((:Perl:))

    Hmm.. Sounds familiar.  What was that?
# Practical Extract and Report Language, or Pathologically Eclectic Rubbish Lister.

: ((:Polymorphism:))

    To define actual operation as to an ((<object|Object>)).

    ((<Ruby>)) carries it out to choose the ((<method|Method>))
    according to the object of the ((<receiver|Receiver>)). 

    : Example:                               
        obj = "abc"
        print obj.length, "\n"        # => 3
        obj = [1,2,3,4]
        print obj.length, "\n"        # => 4

: ((:Python:))

    An ((<object-oriented programming|Object-Oriented Programming>)) language.
    ((<Ruby>))'s rival. "An elapsed serpent."

    If ((<matz>)) was content with Python, ((<Ruby>)) wouldn't be born now.
    Anxious most is length of the name.
    (Up to 6 characters!) 

== ((*Q*))

# no entry.

== ((*R*))

: ((:Receiver:))

    Operational subject of the ((<method|Method>)).
    It is on the left of '((|.|))' or '((|::|))' of method call expression.

    In a method, it can be referred as '((|((<self>))|)).'
    The ((<instance variable|Instance Variable>)) of the receiver is
    accessible in the form '((|@|))((<variable|Variable>))_name.'

: ((:Redefinition:))

    ((<Override>)). Rewrite.
#     Treacherous ((<override|Override>)).

: ((:Reference:))

    See also foobar.
#     See also hogehoge.

: ((:Ruby:))

    The name of the
    ((<object-oriented|Object-Oriented>))
    ((<scripting language|Scripting Language>))
    and its interpreter.

    The name 'ruby' is not an acronym.
    It's named after the red precious stone, which is the birthsone of July.
    Notice pearl(((<Perl>))) is the birthstone of June.

== ((*S*))

: ((:Sather:))

    An ((<object-oriented programming|Object-Oriented Programming>)) language.

    ((<Matz|matz>)) likes Sather rather than ((<Eiffel>)).
    But Sather doesn't look like ((<Ruby>)) at all, either.

: ((:Script:))

    Scenario.
    Turned into a relatively short program where the interpreter works on.

    Of course there's a super-masterpiece.

: ((:Scripting Language:))

    Interpreter which handles batch operations after the ((<script|Script>)).

    Man is also a scripting language on the point which reads script.

: ((:self:))

    Expression which refers to ((<receiver|Receiver>)).

    Why it's called '((|self|))'?
    By one account, the ((<receiver|Receiver>)) is the subject of the sentence
    where ((<method|Method>)) is the verb, so from the method's standpoint
    it's itself, though it is strongly suspected that it's the mimic
    of ((<Smalltalk>)) without deep account.

: ((:Singleton Class:))

    Virtual class only for the particular ((<object|Object>)).

: ((:Singleton Method:))

    ((<Method>)) which is defined only for the particular ((<object|Object>)).

    Singleton method can be succeeded to other method(s) in the following case: 
     * Cloned.
     * Made subclass(es).
    When the singleton method ((<overrides|Override>)) the original method,
    the original method can be invoked to appear by '((|((<super>))|))'.

: ((:Smalltalk:))

    An ((<object-oriented programming|Object-Oriented Programming>)) language,
    which laid the groundwork of the ((<paradigm|Paradigm>)) to this day,
    '((<object-oriented|Object-Oriented>))' style.

: ((:Sort:))

    To arrange in order.
    ((<Ruby>)) can sort anything, not only array, however complex, if only
     * they're countable (((|Enumerable|)) is included),
     * and the order is (i.e. ((|<=>|)) is) defined in each element.

: ((:super:))

    Technique to call upper level ((<method|Method>))
    from ((<overridden|Override>)) method.
    When argument is omitted, super'ed slave can be called by
    the same argument as that of the master's method.

    : Question: 
      If you change the value of ((<variable|Variable>)) given as an argument,
      which 'super' gets, the original value, or the changed?

        def foo(a)
           print a
        end
        def self.foo(a)
           a=25
           super
        end
        foo(5)        # 5 or 25??

    : Answer:
      the original one(((%5%))).

== ((*T*))

: ((:Thread:))

    ((*Thread of control*)), in original; a chain of control processes.

    In ((<Ruby>)), more than one thread can exist in a program.

== ((*U*))

: ((:undef:))

    To set the ((<method|Method>)) undefined.

    '((|undef|))' means that the particular method can be obviated,
    while ((<inheritance|Inheritance>)) or ((<Mix-in>))
    just adds class on the method.
    However, you'll pay for the lack of prudence
    when you '((|undef|))' the method which is called from inside of
    the method, which is crucial to the implementation od the class.

== ((*V*))

: ((:Variable:))

    A tag attached to an ((<object|Object>)).

    ((<Ruby>)) has ((<global|Global Variable>)), ((<local|Local Variable>)),
    class, and ((<instance|Instance Variable>)) variables.
    ((<Constant>)) has the same implication of tag, though
    it's not variable, since its value cannot be changed.

== ((*W*))

# no entry.

== ((*X*))

# no entry.

== ((*Y*))

# no entry.

== ((*Z*))

# no entry.

=end