Fix a couple of doc comment references - and many spelling mistakes

sdk/lib/async/stream.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.async;
 
 // -------------------------------------------------------------------
 // Core Stream types
 // -------------------------------------------------------------------
 
@@ skipping 253 matching lines @@
    *       void add(String data) {
    *         _outputSink.add(data);
    *         _outputSink.add(data);
    *       }
    *
    *       void addError(e, [st]) { _outputSink.addError(e, st); }
    *       void close() { _outputSink.close(); }
    *     }
    *
    *     class DuplicationTransformer implements StreamTransformer<String, String> {
-   *       // Some generic types ommitted for brevety.
+   *       // Some generic types omitted for brevity.
    *       Stream bind(Stream stream) => new Stream<String>.eventTransformed(
    *           stream,
    *           (EventSink sink) => new DuplicationSink(sink));
    *     }
    *
    *     stringStream.transform(new DuplicationTransformer());
    *
    * The resulting stream is a broadcast stream if [source] is.
    */
   factory Stream.eventTransformed(
@@ skipping 174 matching lines @@
   /**
    * Transforms each element into a sequence of asynchronous events.
    *
    * Returns a new stream and for each event of this stream, do the following:
    *
    * * If the event is an error event or a done event, it is emitted directly
    * by the returned stream.
    * * Otherwise it is an element. Then the [convert] function is called
    * with the element as argument to produce a convert-stream for the element.
    * * If that call throws, the error is emitted on the returned stream.
-   * * If the call returnes `null`, no further action is taken for the elements.
+   * * If the call returns `null`, no further action is taken for the elements.
    * * Otherwise, this stream is paused and convert-stream is listened to.
    * Every data and error event of the convert-stream is emitted on the returned
    * stream in the order it is produced.
    * When the convert-stream ends, this stream is resumed.
    *
    * The returned stream is a broadcast stream if this stream is.
    */
   Stream<E> asyncExpand<E>(Stream<E> convert(T event)) {
     StreamController<E> controller;
     StreamSubscription<T> subscription;
@@ skipping 295 matching lines @@
     return future;
   }
 
   /**
    * Executes [action] on each element of the stream.
    *
    * Completes the returned [Future] when all elements of the stream
    * have been processed.
    *
    * If the stream contains an error, or if the call to [action] throws,
-   * the returne future completes with that error, and processing stops.
+   * the returned future completes with that error, and processing stops.
    */
   Future forEach(void action(T element)) {
     _Future future = new _Future();
     StreamSubscription subscription;
     subscription = this.listen(
         (T element) {
           // TODO(floitsch): the type should be 'void' and inferred.
           _runUserCode<dynamic>(() => action(element), (_) {},
               _cancelAndErrorClosure(subscription, future));
         },
@@ skipping 747 matching lines @@
    * [Stream.listen], by calling [asFuture], or by a previous call to [onError].
    */
   void onError(Function handleError);
 
   /**
    * Replaces the done event handler of this subscription.
    *
    * The [handleDone] function is called when the stream closes.
    * The value may be `null`, in which case no function is called.
    *
-   * This method reaplces the current handler set by the invocation of
+   * This method replaces the current handler set by the invocation of
    * [Stream.listen], by calling [asFuture], or by a previous call to [onDone].
    */
   void onDone(void handleDone());
 
   /**
    * Request that the stream pauses events until further notice.
    *
    * While paused, the subscription will not fire any events.
    * If it receives events from its source, they will be buffered until
    * the subscription is resumed.
@@ skipping 426 matching lines @@
   }
 
   void addError(error, [StackTrace stackTrace]) {
     _sink.addError(error, stackTrace);
   }
 
   void close() {
     _sink.close();
   }
 }