anchor.diff:    /// Gets the Optional value.
     ///
     /// Throws [StateError] if [value] is null.
  -  T get value {
  +  T/*!*/ get value {
       if (_value == null) {
         throw StateError('value called on absent Optional.');
       }
  -    return _value;
  +    return _value/*!*/;
     }
   
     /// Executes a function if the Optional value is present.
  -  void ifPresent(void ifPresent(T value)) {
  +  void ifPresent(void ifPresent(T/*!*/ value)) {
       if (isPresent) {
  -      ifPresent(_value);
  +      ifPresent(_value/*!*/);
       }
     }
   
  
positive.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
  
negative.code: /// Use Optional as an alternative to allowing fields, parameters or return
  /// values to be null. It signals that a value is not required and provides
  /// convenience methods for dealing with the absent case.
  class Optional<T> extends IterableBase<T/*!*/> {
    /// Constructs an empty Optional.
    const Optional.absent() : _value = null;
  
  