Epic Scripting.  The Parsers.

The Parsing involved in ircII scripting is a very major difference between
ircII and more mainstream scripting languages.  The single most shocking
difference is that there are at least two parsers actively interpreting the
average script.  A demonstration follows.

  /eval echo $variable;echo $variable

It is not obvious from reading this command, but what is happening here is that
the "command parser" will break this line up into two commands, and then the
"expression parser" will translate $variable into values for each of the two
commands.  After this, the command is executed.  This is not a particularly
useful piece of code, but understanding it helps us understand the following.

  /eval $variable

The same thing is happening here, but since there is no echo command, the value
of the variable itself will be interpreted and executed as a command.  If the
value of $variable is a valid command, then this will work.

  /eval $shift(variable)

The same thing is happening here, but the variable is actually a call to the
shift function, the return value of which will be executed as a command.  This
is a much more useful thing to do because it means commands can be given at one
point in a script and executed later at a more appropriate time.

This is a good example of how the parsers can collide.  Fortunately, accidental
collisions can generally be avoided because the lines between the parsers are
so well defined that they appear to be a single language.  Making them collide
deliberately can be a good source of fun and profit, and it is a bit of an art
in itself.

Consider the following alias:

  alias getopts (var, pref, string, ...) {
     while (:option = getopt(:optopt :optarg "$string" $*)) {
        switch ($option) {
           (!) {echo * option "$optopt" is an invalid option}
           (-) {echo * option "$optopt" is missing an argument}
           (*) {
              push :optopts , push\($pref$optopt ${optarg?optarg:[ ]}\)
           }
        }
     }
     return @ $var = [$optarg]$optopts
  }

This alias will return a @ expression, and is useful as a single line version
of $getopt(), as in the following example.

  alias foo (args) {
     $getopts(:args :opt_ a:b $args)
     if (opt_b) {
        echo -b was used.
     } elsif (opt_a) {
        echo -a $opt_a was used.
     }
     echo Remaining arguments: $args
  }

Note that this method only seems to work well for single commands, such as @,
if, while, eval, etc.