Rename the raiseMessage() method to raise()

The shorter form of raise should be the one that takes a message, so
raiseMessage() has been renamed to raise(). The existing raise method
has been renamed to raiseDefault.
Adjust variable lookup and method overriding

A full variable lookup will search all scopes and every self value in
scope if a definition cannot be found in the immediate scope or self
value, and an ambiguity error occurs if multiple definitions are found.

Variables are no longer permitted to override methods in a super-object.
This avoids tricky situations where code that relies on variables having
values can be broken by an overriding variable.
Tidy up builtin boolean and list definitions

The andAlso() orElse() method has been relegated to short circuiting
booleans only, and replaced by the ifTrue() ifFalse() method and
companions ifTrue() and ifFalse(). Due to the issue with infinite
recurion on assertions, both ifTrue() ifFalse() and orElse() are both
untyped.

The doForEach() method on lists has been renamed to just do(). A 'Do'
type has been added to the prelude and the method for() do() has been
implemented as an associated control structure.
Move the prelude into the runtime

The prelude module is now in the runtime directory, and is exported by
the runtime module rather than directly imported by the main module.
Convert primitive values for getters and setters

Grace objects were converted back and forth from primitive
representations when calling out to JavaScript code, but only in
functions. Now getters and setters on JavaScript objects will also
perform a conversion before setting a value and after getting a value.

This commit also includes a minor change to the types that renames the
erroneously named 'Any' type to 'Object'.
Add names to invalid type error details

When multiple methods with the same name appeared in the same type, the
error message did not include the name of the duplicate method or the
name of the type if it appeared in an alias. Now alias names are
included in error stack traces and the InvalidType error are raised with
the name of the method which appears more than once.
Uglify name when retrieving method for annotating

Multipart method names were not uglified before being retrieved when
processing annotations, causing an internal error. Now the correct
method is retrieved. Additionally, the searches through local self and
scope in this and several other cases were redundant, and only the
direct scope is searched instead.
Yield tasks every 10ms instead of every apply

In order to avoid potential stalls when processing large chunks of code
with no method requests, yielding to the event loop now occurs directly
inside of the task mechanism once 10ms has passed since the last yield.
This should produce more consistent yielding, though it's not yet clear
what the performance penalities are for constantly checking the time.

The Task API is now exported by the main hopper module.
Taskify portions of the parser, making it async

The larger parts of the parser are now asynchronous, using the Task API.
This means that the parser will also be non-blocking. It should also
ease a transition to a token stream rather than manually splitting
tokens synchronously. The token operations remain synchronous for now.

The callback method on tasks can now handle undefined and null values,
and the prelude will report its module name if an error occurs. The two
external interpret methods now also take an optional module path, which
will be used for reporting in case of errors.
Add a stop method to halt a chain of tasks

It is now possible to stop an executing task and its dependencies by
calling the stop method. This method has no effect on completed tasks,
but will cause currently pending tasks to be rejected with an
InterruptError. Use of stop propagates down a chain of tasks, stopping
all dependent tasks. There are no guarantees as to how quickly all tasks
will be stopped, and the method will not stop concurrent tasks that were
spawned by, but are not in, the dependency chain.

The external interpreter methods now each return a function that can be
used to stop the underlying task.
Modify outer semantics to search all of scope

The outer semantics have been changed to work like super, where outer
may only appear as the receiver of another request. Outers can no longer
be chained, and ambiguities must be resolved by naming outer objects.
Tidy up inheritance and super semantics

The use of self inside an inherits request is now banned, with the same
Incomplete Object error that occurs when referencing it in annotations,
as the 'object' property on the scope is maintained when the first node
of an object body is an inherits clause. The processing of the clause
tidies up the property instead. A few other superfluous properties have
also been removed.

The rules for processing super requests are now more liberal, and they
may now appear outside of the method they are requesting. In all cases
use of super will resolve to the first method defined above the current
inheritance level, or an error if no such method can be found. This is
achieved by storing the existing definitions on the object at the moment
the inherits clause is encountered. A number of tests have been
introduced or changed to test this comprehensively.
Add parameter and generics checks to type match

Running match (and assert) on a type will now also check that the
requisite number of standard and generics parameters are present. This
takes into account variadic arguments and that generic parameters may be
ignored, so all an object needs to do to fulfill a type is guarantee
that it will not raise an error about incorrect argument counts for
either parameter form. The built-in types have been updated to include
this information.

As a result of this change, the String type has been updated to include
both the Pattern and List types, and the implementation has been updated
accordingly. The implementaion of the do() method in the List
constructor has been updated to reflect the actual type of the method.
The Task.each method can now iterate through strings, as well as through
lists or over a number.
Add dialect checking mechanism with AST

Modules which define a method named checked will now be passed the AST
nodes of the modules which use them as a dialect. A checker method may
raise a Checker Failure exception with a node from the AST to indicate a
static error at that point. The AST has been adjusted to be make
processing a checker method a little more sensible.

Some bugs in the JavaScript to Grace method lookup have been identified
and resolved by this change. The lookup will now also pretend that
JavaScript arrays have the built-in List methods.
Correct outer search to include prelude

The definitions on the prelude were not included in the actual scope
object, so the searchScope method could not locate its definitions. This
meant that outer could not reference definitions in the prelude. Now all
the prelude definitions are copied into the scope object when the
interpreter is created.
Rename list to sequence, complete coercer

The list objects stringified to as a 'sequence', and have now been
renamed throughout to use that name instead of list. A sequence class
is now available in the prelude. The type 'Do' has been moved from the
Grace prelude into the runtime, as it is now used internally.

The lookup mechanism on JavaScript objects has been updated to handle
all primitive types, providing methods as though they were the built-in
Grace objects when no such property exists on the primitive value.

This change also tidies up a few misnames in the primitive definitions,
and the built-in Boolean type.
Add Not A Number and simple number parsing

Strings now have an 'asNumber' method which will perform a simple parse
of the string into a number. It will raise the new Not A Number error if
the string is not a valid number. This error now also occurs on division
by zero.
Add a check method to handle static failures

The parse method on the hopper module has been removed in favour of a
check method, which performs both a parse and runs the dialect checker
if it exists. The outcome is either an object with information on where
the error occurred (if such information has been provided by the
original error) or the parsed AST if no error occurs. The interpret and
module methods will now also accept a pre-parsed AST, allowing a
two-step process of checking a module and then running it later without
re-parsing and checking it again.

The internal checking logic has been simplified, and a spelling mistake
on the nodeOrIfAbsent method resolved. Parse Errors have been renamed to
Parse Failures, to match with the naming scheme of other errors.
Simplify and specialise default object stringify

Rendering the names of every method in an object by default ballooned
too easily. Now Grace objects simply stringify to "object", but the
interpreter will add more information to object's asString methods if
they do not update the default, including the class and constructor name
of the object or the surrounding module name if no such method can be
found. Stringifying classes now also includes their name.