Synopsis:
   alias [[-]<alias name> [<argument-list>] [<code block>]]

Description:
   ALIAS is one of ircII-EPIC's most powerful user interfaces.  It allows
   the user to execute an arbitrary series of commands with one single
   command.

   It actually serves a dual purpose.  The primary usage is as described,
   a convenient mechanism for issuing multiple commands in succession.
   It may also be used to define custom functions that can be used in
   conditional or assignment statements.  The real power of aliases comes
   from the fact that the client allows aliases to overload built-in
   commands (but not built-in functions).

   Usage
      Aliases are used just like normal commands (and functions).  They
      may be called from the input line by prepending the command character
      (see CMDCHARS) to them, or may be used in a script.  Likewise,
      scripted functions may be called using the normal $name() notation.
      Aliases have no functional differences between built-in commands and
      functions.

   Syntax
      Alias definitions with multiple commands may delimit the commands
      with semicolons, or the commands may span multiple lines if
      surrounded with curly braces.  Users familiar with C/C++ or Perl
      programming will note numerous similarities in the command syntax.
      Like those languages, commands and functions are distinguished by
      whether the alias has a return value; functions do, commands don't.

      The argument list of any kind of alias call, be it a command or
      a function, is assigned to the special expando $*.  Positional
      arguments from within $* are available through the special numeric
      expandos; $0 is the first argument, $1 is the second, and so on.

      Because it is very common for an alias to assign the command line 
      arguments to local variables, the <argument-list> is a convenient 
      (and fast) way for you to have positional arguments pushed into 
      local variables automatically when your alias is invoked.  I need
      to write the help page that describes all this and to it from here.

   Current aliases may be displayed by only giving the alias name in the
   command; all aliases matching the name are returned (such that "foo"
   might return aliases "foo" and "foobar").  If no alias name is given,
   all aliases are displayed.  An alias may be removed by prepending its
   name with a hyphen (-).

   As mentioned previously, the client's built-in commands may be overloaded
   by aliases.  This naturally poses a problem when one needs to use the
   real command, and needs to be sure it isn't some alias.  The simple
   answer is to use the "//command" form.  That is, the client will skip
   alias expansion for any command when it is preceded by the any command
   character twice.  Other methods include STACK, or avoiding command
   overloading in the first place.

Examples:
   To create an alias that overloads a command, and calls it too:
      alias lasers {
         echo ======= User Information for ${[$*] ? [$*] : S}
         //lasers $*
         echo ======= End User Information
      }

   To create a function that returns the sum of two inputs:
      alias sum {
         @ function_return = [$0] + [$1]
      }

   To create an alias that uses the new function:
      alias shows um {
         echo *** The sum of $0 and $1 is $sum($0 $1)
      }

   An alternate way of definite the same alias:
      alias shows um echo The sum of $0 and $1 is $sum($0 $1)

   To use the new /shows um command to compute a sum:
      /shows um 4 5

   Using the alias as in the previous example will display the following:
      *** The sum of 4 and 5 is 9

See Also:
   assign(5); say(1); send(5); set(4) CMDCHARS; stack(5)

Restrictions:
   As mentioned above, aliases can overload commands, but not functions.
   Alias names can consist of any character that isn't already a meta
   character for EPIC (the @ symbol, square brackets, curly braces, semi-
   colons, parenthesis, etc.).  Note, however, that functions will not work
   when the name contains certain characters.  A good rule of thumb is to
   limit alias names to alphanumeric characters (and the underscore).

Bugs:
   The exact syntax rules for alias structures (see ASSIGN for information
   about structures) is somewhat ambiguous.  Structures can be represented
   as either name.sub or name[sub], but only the former notation is
   guaranteed to work in all instances, but it's more difficult to use 
   correctly.  Functions do not work at all with the latter syntax.
   This isn't really a bug, because "name[sub]" is just syntactic sugar
   and the macro expander converts it to "name.sub" before doing any 
   lookups.

Other Notes:
   Do not confuse the syntax of the ALIAS command with the oddness
   of the LOADer.  Command bodies in ALIASes must always be 
   separated by semicolons, and usually the LOADer does this kind of
   stuff for you.  But that does not mean the semicolons aren't there.
   A lot of the structure and layout that people are used to with ircII
   and epic scripts is a peculiarity of the LOAD command and does
   NOT have anything to do with how ALIAS_ works.

