Stoppp using trippple consonants

docs/language/informal/covariant-from-class.md

 # Informal Specification: Parameters that are Covariant due to Class Type Parameters
 
 Owner: eernstg@.
 
 ## Summary
 
 This document is an informal specification which specifies how to determine the
 reified type of a tear-off where one or more parameters has a type annotation in
 which a formal type parameter of the enclosing class occurs in a covariant
 position. This feature has no effect in Dart 1, it only affects strong mode and
@@ skipping 258 matching lines @@
 The dynamic checks associated with invocation of such a function are still
 needed, and they are unchanged.
 
 _That is, a dynamic error occurs if a method with a covariant parameter p is
 invoked, and the actual argument value bound to p has a run-time type which is
 not a subtype of the type declared for p._
 
 ## Alternatives
 
 The "erasure" of the reified parameter type for each covariant parameter to
-`Object` may seem agressive.
+`Object` may seem aggressive.
 
 In particular, it ignores upper bounds on the formal type parameter which gives
 rise to the covariance due to class covariance, and it ignores the structure of
 the type where that formal type parameter is used. Here are two examples:
 
 ```dart
 class C<X extends num> {
   void foo(X x) {}
   void bar(List<X> xs) {}
 }
@@ skipping 89 matching lines @@
   void Function(Object) fb = zs.add; // Statically a same type, OK at runtime.
   void Function(String) fc = zs.add; // Finally we can go wrong silently!
 }
 ```
 
 In other words, the static typing helps programmers to maintain the same level
 of knowledge (say, "this is a list of `num`") consistently, even though it is
 consistently incomplete ("it's actually a list of `int`"), and this helps a lot
 in avoiding those crazy assignments (to `List<String>`) where almost all method
 invocations will go wrong.