anchor.diff:     * corresponding parameter and was processed before the isolate starts
      * running.
      *
  +   * If [errorsAreFatal] is omitted, the platform may choose a default behavior
  +   * or inherit the current isolate's behavior.
  +   *
      * You can also call the [setErrorsFatal], [addOnExitListener] and
      * [addErrorListener] methods on the returned isolate, but unless the
      * isolate was started as [paused], it may already have terminated
      * before those methods can complete.
      *
  -   * Returns a future that will complete with an [Isolate] instance if the
  +   * Returns a future which will complete with an [Isolate] instance if the
      * spawning succeeded. It will complete with an error otherwise.
      */
     external static Future<Isolate> spawn(void entryPoint(message), var message,
  -                                        { bool paused: false,
  -                                          bool errorsAreFatal,
  -                                          SendPort onExit,
  -                                          SendPort onError });
  +                                        {bool paused: false,
  +                                         bool errorsAreFatal,
  +                                         SendPort onExit,
  +                                         SendPort onError});
   
     /**
      * Creates and spawns an isolate that runs the code from the library with
  
positive.code:    * Creates and spawns an isolate that shares the same code as the current
     * isolate.
     *
     * The argument [entryPoint] specifies the entry point of the spawned
     * isolate. It must be a top-level function or a static method that
     * takes one argument - that is, one-parameter functions that can be
     * compile-time constant function values.
     * It is not allowed to pass the value of function expressions or an instance
     * method extracted from an object.
     *
     * The entry-point function is invoked with the initial [message].
     * Usually the initial [message] contains a [SendPort] so
     * that the spawner and spawnee can communicate with each other.
     *
     * If the [paused] parameter is set to `true`,
     * the isolate will start up in a paused state,
     * as if by an initial call of `isolate.pause(isolate.pauseCapability)`.
     * To resume the isolate, call `isolate.resume(isolate.pauseCapability)`.
     *
  
negative.code:  * independent workers that are similar to threads
   * but don't share memory,
   * communicating only via messages.
   *
   * To use this library in your code:
   *
   *     import 'dart:isolate';
   */
  library dart.isolate;
  