closure {prototypes...} Returns a closure which can be provided to tabcompleters or run manually,
which provides an easy to use syntax for simple to moderately complex tab completion scenarios. Note that
this cannot be used in all cases, particularly where there are variable length arguments. In these cases,
it's best to write the closure yourself.
----
In general, the prototypes can be one of five values - a string, a ClassType of an enum type, an array, a closure,
or an associative array.

In all cases, once the list of completions has been determined, it is compared against the existing input so far of the 
user, and only matches that start with the current input are returned.

'''Note:''' Calling <code>get_tabcomplete_prototype</code> with no arguments disables tab completion (always returns an 
empty array).

==== Strings ====

These represent "prebaked" classes, and are listed below:

* <code>Player</code> - Online players ({{function|all_players}} equivalent, but more efficient)
* <code>OfflinePlayer</code> - All known players ({{function|get_offline_players}} equivalent)
* <code>Boolean</code> - Equivalent to array("true", "false")
* <code>None</code> - Returns an empty array, disabling tab complete for this value. This is useful for open fields, such as \
random strings, or a number.

==== ClassTypes ====

Must be enum values, and will autocomplete with the list of values in that enum.
* e.g. <code>WorldEnvironment</code>, which at time of writing is an enum containing the values {NORMAL, NETHER, THE_END}

==== Arrays ====

Arrays are simply returned as is:
* e.g. <code>array(1, 2, 3)</code>

==== Closures ====

You can pass a closure the same parameters as the tabcompleter, and they are expected to return an array. This is useful when
the completion logic varies based on the arguments passed in, such as the current player executing the tabcompleter.
* e.g. <code>closure(@alias, @sender, @args) { return array(1, 2, 3); }</code>

==== Associative arrays ====

These are used when you need to provide dynamic functionality based on previous arguments.

The keys of the array:
* are used to determine which parameter to look at, and what selector value that parameter must have.
* follow the general format of <code>&lt;enumValue</code>, where <code>&lt;</code> means that we're comparing to parameter \
immediately before this one, and <code>enumValue</code> is the selector value that was entered by the user into that parameter.

The values of the array:
* are one of the above completion types (string, ClassType enum, array, closure).

Example:
* e.g. <code>array('<1': closure(...){...}, '<2': closure(...){...}, '<3': closure(...){...})</code>
** This will run a different closure, depending on whether the previous parameter's value was entered by the user as 1, 2 or 3.

Note that:
* The <code>&lt;</code> marker can also point to more just the previous value. For instance <code>&lt;&lt;</code> would \
also work (e.g. <code>&lt;&lt;enumValue</code>), meaning to compare with the argument provided two parameters prior.
* If you have multiple selectors that have the same handler they can be combined into one pipe separated string, for \
instance <code>&lt;enumValue1|&lt;enumValue2</code>.
* Given that you can mix multiple argument selector types, it's possible you have a conflict. In this case the behavior \
is undefined, so it's recommended that you don't mix argument depth indicators (don't use <code>&lt;</code> and \
<code>&lt;&lt;</code> in the same group).
* Using only <code>&lt;</code> as a key (with no <code>enumValue</code> following it) is used to represent the default \
value, which will be used if nothing else matches. If this does not exist, and no other keys match, then no completions \
will be provided.