anchor.diff:    /// Constructs an Optional of the given [value].
     ///
     /// If [value] is null, returns [absent()].
  -  const Optional.fromNullable(T value) : _value = value;
  +  const Optional.fromNullable(T/*?*/ value) : _value = value;
   
  -  final T _value;
  +  final T/*?*/ _value;
   
     /// True when this optional contains a value.
     bool get isPresent => _value != null;
  
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:   }
  
    /// Gets the Optional value, or [null] if there is none.
    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)) {
      return _value == null
          ? Optional<S>.absent()
          : Optional<S>.of(transformer(_value/*!*/));
    }
  
    /// Transforms the Optional value.
  