anchor.diff:    }
   
     /// Gets the Optional value, or [null] if there is none.
  -  T get orNull => _value;
  +  T/*?*/ get orNull => _value;
   
     /// Transforms the Optional value.
     ///
     /// If the Optional is [absent()], returns [absent()] without applying the transformer.
     ///
     /// The transformer must not return [null]. If it does, an [ArgumentError] is thrown.
  -  Optional<S> transform<S>(S transformer(T value)) {
  +  Optional<S> transform<S>(S transformer(T/*!*/ value)) {
       return _value == null
           ? Optional<S>.absent()
  -        : Optional<S>.of(transformer(_value));
  +        : Optional<S>.of(transformer(_value/*!*/));
     }
   
     /// Transforms the Optional value.
  
positive.code:   /// Gets the Optional value.
    ///
    /// Throws [StateError] if [value] is null.
    T get value {
      if (_value == null) {
        throw StateError('value called on absent Optional.');
      }
      return _value;
    }
  
    /// Executes a function if the Optional value is present.
    void ifPresent(void ifPresent(T value)) {
      if (isPresent) {
        ifPresent(_value);
      }
    }
  
  
negative.code:   /// If the Optional is [absent()], returns [absent()] without applying the transformer.
    ///
    /// Returns [absent()] if the transformer returns [null].
    Optional<S> transformNullable<S>(S/*?*/ transformer(T/*!*/ value)) {
      return _value == null
          ? Optional<S>.absent()
          : Optional<S>.fromNullable(transformer(_value/*!*/));
    }
  
    @override
    Iterator<T/*!*/> get iterator =>
        isPresent ? <T/*!*/>[_value/*!*/].iterator : Iterable<T>.empty().iterator;
  
    /// Delegates to the underlying [value] hashCode.
    @override
  