diff --git a/reactor-core/src/main/java/reactor/adapter/JdkFlowAdapter.java b/reactor-core/src/main/java/reactor/adapter/JdkFlowAdapter.java
index 6d076250e1..522f1b5657 100644
--- a/reactor-core/src/main/java/reactor/adapter/JdkFlowAdapter.java
+++ b/reactor-core/src/main/java/reactor/adapter/JdkFlowAdapter.java
@@ -23,7 +23,6 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.publisher.Flux;
-import reactor.util.annotation.NonNull;
 
 /**
  * Convert a Java 9+ {@literal Flow.Publisher} to/from a Reactive Streams {@link Publisher}.
@@ -40,7 +39,7 @@ public abstract class JdkFlowAdapter {
 	 * @param <T> the type of the publisher
 	 * @return a java {@code Flow.Publisher} from the given {@link Publisher}
 	 */
-	public static <T> Flow.Publisher<@NonNull T> publisherToFlowPublisher(final Publisher<@NonNull T>
+	public static <T> Flow.Publisher<T> publisherToFlowPublisher(final Publisher<T>
 			publisher) {
 		return new PublisherAsFlowPublisher<>(publisher);
 	}
@@ -52,19 +51,19 @@ public abstract class JdkFlowAdapter {
 	 * @param <T> the type of the publisher
 	 * @return a {@link Flux} from a java {@code Flow.Publisher}
 	 */
-	public static <T> Flux<@NonNull T> flowPublisherToFlux(Flow.Publisher<@NonNull T> publisher) {
+	public static <T> Flux<T> flowPublisherToFlux(Flow.Publisher<T> publisher) {
 		return new FlowPublisherAsFlux<>(publisher);
 	}
 
 	private static class FlowPublisherAsFlux<T> extends Flux<T> {
         private final java.util.concurrent.Flow.Publisher<T> pub;
 
-        private FlowPublisherAsFlux(java.util.concurrent.Flow.Publisher<@NonNull T> pub) {
+        private FlowPublisherAsFlux(java.util.concurrent.Flow.Publisher<T> pub) {
             this.pub = pub;
         }
 
         @Override
-        public void subscribe(final CoreSubscriber<? super @NonNull T> actual) {
+        public void subscribe(final CoreSubscriber<? super T> actual) {
         	pub.subscribe(new SubscriberToRS<>(actual));
         }
     }
@@ -72,12 +71,12 @@ public void subscribe(final CoreSubscriber<? super @NonNull T> actual) {
     private static class PublisherAsFlowPublisher<T> implements Flow.Publisher<T> {
         private final Publisher<T> pub;
 
-        private PublisherAsFlowPublisher(Publisher<@NonNull T> pub) {
+        private PublisherAsFlowPublisher(Publisher<T> pub) {
             this.pub = pub;
         }
 
         @Override
-        public void subscribe(Flow.Subscriber<? super @NonNull T> subscriber) {
+        public void subscribe(Flow.Subscriber<? super T> subscriber) {
         	pub.subscribe(new FlowSubscriber<>(subscriber));
         }
     }
@@ -88,7 +87,7 @@ private static class FlowSubscriber<T> implements CoreSubscriber<T>, Flow.Subscr
 
 		Subscription subscription;
 
-		public FlowSubscriber(Flow.Subscriber<? super @NonNull T> subscriber) {
+		public FlowSubscriber(Flow.Subscriber<? super T> subscriber) {
 			this.subscriber = subscriber;
 		}
 
@@ -130,7 +129,7 @@ private static class SubscriberToRS<T> implements Flow.Subscriber<T>, Subscripti
 
 		Flow.Subscription subscription;
 
-		public SubscriberToRS(Subscriber<? super @NonNull T> s) {
+		public SubscriberToRS(Subscriber<? super T> s) {
 			this.s = s;
 		}
 
diff --git a/reactor-core/src/main/java/reactor/core/Disposables.java b/reactor-core/src/main/java/reactor/core/Disposables.java
index 0ffe296737..ca256166e7 100644
--- a/reactor-core/src/main/java/reactor/core/Disposables.java
+++ b/reactor-core/src/main/java/reactor/core/Disposables.java
@@ -24,9 +24,8 @@
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import java.util.stream.Stream;
 
-import reactor.util.concurrent.Queues;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
+import reactor.util.concurrent.Queues;
 
 /**
  * A support class that offers factory methods for implementations of the specialized
@@ -56,7 +55,7 @@ public static Disposable.Composite composite() {
 	 *
 	 * @return a pre-filled atomic {@link Disposable.Composite}
 	 */
-	public static Disposable.Composite composite(Disposable @NonNull ... disposables) {
+	public static Disposable.Composite composite(Disposable... disposables) {
 		return new CompositeDisposable(disposables);
 	}
 
@@ -67,7 +66,7 @@ public static Disposable.Composite composite(Disposable @NonNull ... disposables
 	 * @return a pre-filled atomic {@link Disposable.Composite}
 	 */
 	public static Disposable.Composite composite(
-			Iterable<? extends @NonNull Disposable> disposables) {
+			Iterable<? extends Disposable> disposables) {
 		return new CompositeDisposable(disposables);
 	}
 
@@ -147,7 +146,7 @@ static final class CompositeDisposable implements Disposable.Composite, Scannabl
 		 * Creates a {@link CompositeDisposable} with the given array of initial elements.
 		 * @param disposables the array of {@link Disposable} to start with
 		 */
-		CompositeDisposable(Disposable @NonNull ... disposables) {
+		CompositeDisposable(Disposable... disposables) {
 			Objects.requireNonNull(disposables, "disposables is null");
 
 			int capacity = disposables.length + 1;
@@ -168,7 +167,7 @@ static final class CompositeDisposable implements Disposable.Composite, Scannabl
 		 * initial elements.
 		 * @param disposables the Iterable sequence of {@link Disposable} to start with
 		 */
-		CompositeDisposable(Iterable<? extends @NonNull Disposable> disposables) {
+		CompositeDisposable(Iterable<? extends Disposable> disposables) {
 			Objects.requireNonNull(disposables, "disposables is null");
 			this.loadFactor = DEFAULT_LOAD_FACTOR;
 			int c = DEFAULT_CAPACITY;
@@ -240,7 +239,7 @@ public boolean add(Disposable d) {
 		}
 
 		@Override
-		public boolean addAll(Collection<? extends @NonNull Disposable> ds) {
+		public boolean addAll(Collection<? extends Disposable> ds) {
 			Objects.requireNonNull(ds, "ds is null");
 			if (!disposed) {
 				synchronized (this) {
@@ -358,7 +357,7 @@ boolean removeEntry(Disposable value) {
 			}
 		}
 
-		boolean removeEntry(int pos, Disposable @Nullable [] a, int m) {
+		boolean removeEntry(int pos, Disposable[] a, int m) {
 			size--;
 
 			int last;
diff --git a/reactor-core/src/main/java/reactor/core/Exceptions.java b/reactor-core/src/main/java/reactor/core/Exceptions.java
index c3baea4340..c410c52ed3 100644
--- a/reactor-core/src/main/java/reactor/core/Exceptions.java
+++ b/reactor-core/src/main/java/reactor/core/Exceptions.java
@@ -23,7 +23,6 @@
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
 /**
@@ -104,7 +103,7 @@ public static <T> boolean addThrowable(AtomicReferenceFieldUpdater<T, Throwable>
 	 * suppressed exceptions
 	 * @see #addThrowable(AtomicReferenceFieldUpdater, Object, Throwable)
 	 */
-	public static RuntimeException multiple(Throwable @NonNull ... throwables) {
+	public static RuntimeException multiple(Throwable... throwables) {
 		CompositeException multiple = new CompositeException();
 		//noinspection ConstantConditions
 		if (throwables != null) {
@@ -129,7 +128,7 @@ public static RuntimeException multiple(Throwable @NonNull ... throwables) {
 	 * suppressed exceptions
 	 * @see #addThrowable(AtomicReferenceFieldUpdater, Object, Throwable)
 	 */
-	public static RuntimeException multiple(Iterable<@NonNull Throwable> throwables) {
+	public static RuntimeException multiple(Iterable<Throwable> throwables) {
 		RuntimeException multiple = new RuntimeException("Multiple exceptions");
 		//noinspection ConstantConditions
 		if (throwables != null) {
diff --git a/reactor-core/src/main/java/reactor/core/Scannable.java b/reactor-core/src/main/java/reactor/core/Scannable.java
index b2c4f86a3c..ec5bb379d6 100644
--- a/reactor-core/src/main/java/reactor/core/Scannable.java
+++ b/reactor-core/src/main/java/reactor/core/Scannable.java
@@ -18,13 +18,13 @@
 
 import java.util.Iterator;
 import java.util.Objects;
+import java.util.Set;
 import java.util.Spliterators;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
-import reactor.util.function.Tuple2;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
+import reactor.util.function.Tuple2;
 
 /**
  * A Scannable component exposes state in a non strictly memory consistent way and
@@ -214,7 +214,7 @@ public boolean isScanAvailable() {
 			}
 		};
 
-		static Stream<? extends @NonNull Scannable> recurse(Scannable _s,
+		static Stream<? extends Scannable> recurse(Scannable _s,
 				Attr<Scannable> key){
 			Scannable s = Scannable.from(_s.scan(key));
 			if(!s.isScanAvailable()) {
@@ -265,7 +265,7 @@ static Scannable from(@Nullable Object o) {
 	 * @return a {@link Stream} navigating the {@link org.reactivestreams.Subscriber}
 	 * chain (downward)
 	 */
-	default Stream<? extends @NonNull Scannable> actuals() {
+	default Stream<? extends Scannable> actuals() {
 		return Attr.recurse(this, Attr.ACTUAL);
 	}
 
@@ -274,7 +274,7 @@ static Scannable from(@Nullable Object o) {
 	 *
 	 * @return a {@link Stream} of referenced inners (flatmap, multicast etc)
 	 */
-	default Stream<? extends @NonNull Scannable> inners() {
+	default Stream<? extends Scannable> inners() {
 		return Stream.empty();
 	}
 
@@ -330,7 +330,7 @@ default String operatorName() {
 	 * @return a {@link Stream} navigating the {@link org.reactivestreams.Subscription}
 	 * chain (upward)
 	 */
-	default Stream<? extends @NonNull Scannable> parents() {
+	default Stream<? extends Scannable> parents() {
 		return Attr.recurse(this, Attr.PARENT);
 	}
 
@@ -361,7 +361,7 @@ default String operatorName() {
 	 *
 	 */
 	@Nullable
-	default <T> T scan(Attr<@Nullable T> key) {
+	default <T> T scan(Attr<T> key) {
 		@SuppressWarnings("unchecked")
 		T value = (T) scanUnsafe(key);
 		if (value == null)
@@ -379,7 +379,7 @@ default <T> T scan(Attr<@Nullable T> key) {
 	 *
 	 * @return a value associated to the key or the provided default if unmatched or unresolved
 	 */
-	default <T> T scanOrDefault(Attr<@Nullable T> key, T defaultValue) {
+	default <T> T scanOrDefault(Attr<T> key, T defaultValue) {
 		@SuppressWarnings("unchecked")
 		T v = (T) scanUnsafe(key);
 		if (v == null) {
@@ -394,7 +394,7 @@ default <T> T scanOrDefault(Attr<@Nullable T> key, T defaultValue) {
 	 *
 	 * @return the stream of tags for this {@link Scannable} and its parents
 	 */
-	default Stream<@NonNull Tuple2<@NonNull String, @NonNull String>> tags() {
+	default Stream<Tuple2<String, String>> tags() {
 		Stream<Tuple2<String, String>> parentTags =
 				parents().flatMap(s -> s.scan(Attr.TAGS));
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/BlockingIterable.java b/reactor-core/src/main/java/reactor/core/publisher/BlockingIterable.java
index 38f7ce606d..b1bbe14ebd 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/BlockingIterable.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/BlockingIterable.java
@@ -34,8 +34,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * An iterable that consumes a Publisher in a blocking fashion.
@@ -74,7 +74,7 @@ public Object scanUnsafe(Attr key) {
 	}
 
 	@Override
-	public Iterator<@NonNull T> iterator() {
+	public Iterator<T> iterator() {
 		SubscriberIterator<T> it = createIterator();
 
 		source.subscribe(it);
@@ -83,7 +83,7 @@ public Object scanUnsafe(Attr key) {
 	}
 
 	@Override
-	public Spliterator<@NonNull T> spliterator() {
+	public Spliterator<T> spliterator() {
 		return stream().spliterator(); // cancellation should be composed through this way
 	}
 
@@ -91,7 +91,7 @@ public Object scanUnsafe(Attr key) {
 	 * @return a {@link Stream} of unknown size with onClose attached to {@link
 	 * Subscription#cancel()}
 	 */
-	public Stream<@NonNull T> stream() {
+	public Stream<T> stream() {
 		SubscriberIterator<T> it = createIterator();
 		source.subscribe(it);
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ConnectableFlux.java b/reactor-core/src/main/java/reactor/core/publisher/ConnectableFlux.java
index 886984eb7d..15430b84b5 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ConnectableFlux.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ConnectableFlux.java
@@ -22,7 +22,6 @@
 import reactor.core.Fuseable;
 import reactor.core.scheduler.Scheduler;
 import reactor.core.scheduler.Schedulers;
-import reactor.util.annotation.NonNull;
 
 /**
  * The abstract base class for connectable publishers that let subscribers pile up
@@ -43,7 +42,7 @@ public abstract class ConnectableFlux<T> extends Flux<T> {
 	 *
 	 * @return a {@link Flux} that connects to the upstream source when the first {@link org.reactivestreams.Subscriber} subscribes
 	 */
-	public final Flux<@NonNull T> autoConnect() {
+	public final Flux<T> autoConnect() {
 		return autoConnect(1);
 	}
 
@@ -61,7 +60,7 @@ public abstract class ConnectableFlux<T> extends Flux<T> {
 	 *
 	 * @return a {@link Flux} that connects to the upstream source when the given amount of Subscribers subscribed
 	 */
-	public final Flux<@NonNull T> autoConnect(int minSubscribers) {
+	public final Flux<T> autoConnect(int minSubscribers) {
 		return autoConnect(minSubscribers, NOOP_DISCONNECT);
 	}
 
@@ -76,7 +75,7 @@ public abstract class ConnectableFlux<T> extends Flux<T> {
 	 *
 	 * @return a {@link Flux} that connects to the upstream source when the given amount of subscribers subscribed
 	 */
-	public final Flux<@NonNull T> autoConnect(int minSubscribers, Consumer<? super Disposable> cancelSupport) {
+	public final Flux<T> autoConnect(int minSubscribers, Consumer<? super Disposable> cancelSupport) {
 		if (minSubscribers == 0) {
 			connect(cancelSupport);
 			return this;
@@ -112,7 +111,7 @@ public final Disposable connect() {
 	 * @param cancelSupport the callback is called with a Disposable instance that can
 	 * be called to disconnect the source, even synchronously.
 	 */
-	public abstract void connect(Consumer<? super @NonNull Disposable> cancelSupport);
+	public abstract void connect(Consumer<? super Disposable> cancelSupport);
 
 	/**
 	 * Connects to the upstream source when the first {@link org.reactivestreams.Subscriber} subscribes and disconnects
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ConnectableFluxOnAssembly.java b/reactor-core/src/main/java/reactor/core/publisher/ConnectableFluxOnAssembly.java
index 097cc1ec8e..cebdd3c7e3 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ConnectableFluxOnAssembly.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ConnectableFluxOnAssembly.java
@@ -22,7 +22,6 @@
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
 import reactor.core.publisher.FluxOnAssembly.AssemblySnapshotException;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
 /**
@@ -51,18 +50,18 @@ final class ConnectableFluxOnAssembly<T> extends ConnectableFlux<T> implements
 
 	final AssemblySnapshotException stacktrace;
 
-	ConnectableFluxOnAssembly(ConnectableFlux<@NonNull T> source) {
+	ConnectableFluxOnAssembly(ConnectableFlux<T> source) {
 		this.source = source;
 		this.stacktrace = new AssemblySnapshotException();
 	}
 	
 	@Override
-	public void subscribe(CoreSubscriber<? super @NonNull T> actual) {
+	public void subscribe(CoreSubscriber<? super T> actual) {
 		FluxOnAssembly.subscribe(actual, source, stacktrace);
 	}
 
 	@Override
-	public void connect(Consumer<? super @NonNull Disposable> cancelSupport) {
+	public void connect(Consumer<? super Disposable> cancelSupport) {
 		source.connect(cancelSupport);
 	}
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/DelegateProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/DelegateProcessor.java
index c6c5e7b61d..c3cc1ac5b8 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/DelegateProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/DelegateProcessor.java
@@ -22,9 +22,10 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
+import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * @author Stephane Maldini
diff --git a/reactor-core/src/main/java/reactor/core/publisher/DirectProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/DirectProcessor.java
index cfc107f5da..94aa70051f 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/DirectProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/DirectProcessor.java
@@ -25,7 +25,6 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
 /**
@@ -133,7 +132,7 @@ public void onComplete() {
 	}
 
 	@Override
-	public void subscribe(CoreSubscriber<? super @NonNull T> actual) {
+	public void subscribe(CoreSubscriber<? super T> actual) {
 		Objects.requireNonNull(actual, "subscribe");
 
 		DirectInner<T> p = new DirectInner<>(actual, this);
@@ -156,7 +155,7 @@ public void subscribe(CoreSubscriber<? super @NonNull T> actual) {
 	}
 
 	@Override
-	public Stream<? extends @NonNull Scannable> inners() {
+	public Stream<? extends Scannable> inners() {
 		return Stream.of(subscribers);
 	}
 
@@ -170,7 +169,7 @@ public long downstreamCount() {
 		return subscribers.length;
 	}
 
-	boolean add(DirectInner<@NonNull T> s) {
+	boolean add(DirectInner<T> s) {
 		DirectInner<T>[] a = subscribers;
 		if (a == TERMINATED) {
 			return false;
@@ -194,7 +193,7 @@ boolean add(DirectInner<@NonNull T> s) {
 	}
 
 	@SuppressWarnings("unchecked")
-	void remove(DirectInner<@NonNull T> s) {
+	void remove(DirectInner<T> s) {
 		DirectInner<T>[] a = subscribers;
 		if (a == TERMINATED || a == EMPTY) {
 			return;
@@ -259,7 +258,7 @@ static final class DirectInner<T> implements InnerProducer<T> {
 		static final AtomicLongFieldUpdater<DirectInner> REQUESTED =
 				AtomicLongFieldUpdater.newUpdater(DirectInner.class, "requested");
 
-		DirectInner(CoreSubscriber<? super @NonNull T> actual, DirectProcessor<T> parent) {
+		DirectInner(CoreSubscriber<? super T> actual, DirectProcessor<T> parent) {
 			this.actual = actual;
 			this.parent = parent;
 		}
@@ -289,7 +288,7 @@ public Object scanUnsafe(Attr key) {
 		}
 
 		@Override
-		public CoreSubscriber<? super @NonNull T> actual() {
+		public CoreSubscriber<? super T> actual() {
 			return actual;
 		}
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/DrainUtils.java b/reactor-core/src/main/java/reactor/core/publisher/DrainUtils.java
index 98907a6a30..88dd274098 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/DrainUtils.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/DrainUtils.java
@@ -21,7 +21,6 @@
 
 import org.reactivestreams.Subscriber;
 import reactor.core.CoreSubscriber;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
 abstract class DrainUtils {
@@ -91,8 +90,8 @@ static <T, F> boolean postCompleteRequest(long n,
 	 * @return true if the queue was completely drained or the drain process was cancelled
 	 */
 	static <T, F> boolean postCompleteDrain(long n,
-			Subscriber<? super @NonNull T> actual,
-			Queue<@NonNull T> queue,
+			Subscriber<? super T> actual,
+			Queue<T> queue,
 			AtomicLongFieldUpdater<F> field,
 			F instance,
 			BooleanSupplier isCancelled) {
@@ -173,8 +172,8 @@ static <T, F> boolean postCompleteDrain(long n,
 	 * @param instance the parent instance of the requested field
 	 * @param isCancelled callback to detect cancellation
 	 */
-	public static <T, F> void postComplete(CoreSubscriber<? super @NonNull T> actual,
-			Queue<@NonNull T> queue,
+	public static <T, F> void postComplete(CoreSubscriber<? super T> actual,
+			Queue<T> queue,
 			AtomicLongFieldUpdater<F> field,
 			F instance,
 			BooleanSupplier isCancelled) {
@@ -223,8 +222,8 @@ public static <T, F> void postComplete(CoreSubscriber<? super @NonNull T> actual
      * @return true if the state indicates a completion state.
      */
     public static <T, F> boolean postCompleteRequestDelayError(long n,
-            Subscriber<? super @NonNull T> actual,
-            Queue<@NonNull T> queue,
+            Subscriber<? super T> actual,
+            Queue<T> queue,
             AtomicLongFieldUpdater<F> field,
             F instance,
             BooleanSupplier isCancelled, Throwable error) {
@@ -267,8 +266,8 @@ public static <T, F> boolean postCompleteRequestDelayError(long n,
      * @return true if the queue was completely drained or the drain process was cancelled
      */
     static <T, F> boolean postCompleteDrainDelayError(long n,
-            Subscriber<? super @NonNull T> actual,
-            Queue<@NonNull T> queue,
+            Subscriber<? super T> actual,
+            Queue<T> queue,
             AtomicLongFieldUpdater<F> field,
             F instance,
             BooleanSupplier isCancelled,
@@ -339,12 +338,12 @@ static <T, F> boolean postCompleteDrainDelayError(long n,
      * @param isCancelled callback to detect cancellation
      * @param error if not null, the error to signal after the queue has been drained
      */
-    public static <T, F> void postCompleteDelayError(CoreSubscriber<? super @NonNull T> actual,
-            Queue<@NonNull T> queue,
+    public static <T, F> void postCompleteDelayError(CoreSubscriber<? super T> actual,
+            Queue<T> queue,
             AtomicLongFieldUpdater<F> field,
             F instance,
             BooleanSupplier isCancelled,
-            @Nullable Throwable error) {
+		    @Nullable Throwable error) {
 
         if (queue.isEmpty()) {
             if (error == null) {
diff --git a/reactor-core/src/main/java/reactor/core/publisher/EmitterProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/EmitterProcessor.java
index 73b3c14eed..937b517d3c 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/EmitterProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/EmitterProcessor.java
@@ -29,9 +29,8 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.concurrent.Queues;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
+import reactor.util.concurrent.Queues;
 
 import static reactor.core.publisher.FluxPublish.PublishSubscriber.EMPTY;
 import static reactor.core.publisher.FluxPublish.PublishSubscriber.TERMINATED;
@@ -63,7 +62,7 @@ public final class EmitterProcessor<T> extends FluxProcessor<T, T> {
 	 *
 	 * @return a fresh processor
 	 */
-	public static <E> EmitterProcessor<@NonNull E> create() {
+	public static <E> EmitterProcessor<E> create() {
 		return create(Queues.SMALL_BUFFER_SIZE, true);
 	}
 
@@ -155,12 +154,12 @@ public static <E> EmitterProcessor<E> create(int bufferSize, boolean autoCancel)
 	}
 
 	@Override
-	public Stream<? extends @NonNull Scannable> inners() {
+	public Stream<? extends Scannable> inners() {
 		return Stream.of(subscribers);
 	}
 
 	@Override
-	public void subscribe(CoreSubscriber<? super @NonNull T> actual) {
+	public void subscribe(CoreSubscriber<? super T> actual) {
 		Objects.requireNonNull(actual, "subscribe");
 		EmitterInner<T> inner = new EmitterInner<>(actual, this);
 		actual.onSubscribe(inner);
@@ -442,7 +441,7 @@ final void drain() {
 	}
 
 	@SuppressWarnings("unchecked")
-	FluxPublish.PubSubInner<@NonNull T> @NonNull[] terminate() {
+	FluxPublish.PubSubInner<T>[] terminate() {
 		return SUBSCRIBERS.getAndSet(this, TERMINATED);
 	}
 
@@ -479,7 +478,7 @@ else if (empty) {
 		return false;
 	}
 
-	final boolean add(EmitterInner<@NonNull T> inner) {
+	final boolean add(EmitterInner<T> inner) {
 		for (; ; ) {
 			FluxPublish.PubSubInner<T>[] a = subscribers;
 			if (a == TERMINATED) {
@@ -495,7 +494,7 @@ final boolean add(EmitterInner<@NonNull T> inner) {
 		}
 	}
 
-	final void remove(FluxPublish.PubSubInner<@NonNull T> inner) {
+	final void remove(FluxPublish.PubSubInner<T> inner) {
 		for (; ; ) {
 			FluxPublish.PubSubInner<T>[] a = subscribers;
 			if (a == TERMINATED || a == EMPTY) {
@@ -548,7 +547,7 @@ static final class EmitterInner<T> extends FluxPublish.PubSubInner<T> {
 
 		final EmitterProcessor<T> parent;
 
-		EmitterInner(CoreSubscriber<? super @NonNull T> actual, EmitterProcessor<@NonNull T> parent) {
+		EmitterInner(CoreSubscriber<? super T> actual, EmitterProcessor<T> parent) {
 			super(actual);
 			this.parent = parent;
 		}
diff --git a/reactor-core/src/main/java/reactor/core/publisher/EventLoopProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/EventLoopProcessor.java
index d25709de26..19a963a131 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/EventLoopProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/EventLoopProcessor.java
@@ -33,11 +33,9 @@
 import org.reactivestreams.Subscription;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.concurrent.WaitStrategy;
-import reactor.util.annotation.NonNull;
-import reactor.util.annotation.Nullable;
-
 
 /**
  * A base processor used by executor backed processors to take care of their ExecutorService
@@ -47,7 +45,7 @@
 abstract class EventLoopProcessor<IN> extends FluxProcessor<IN, IN>
 		implements Runnable {
 
-	static <E> Flux<E> coldSource(RingBuffer<@NonNull Slot<@NonNull E>> ringBuffer,
+	static <E> Flux<E> coldSource(RingBuffer<Slot<E>> ringBuffer,
 			@Nullable Throwable t,
 			@Nullable Throwable error,
 			RingBuffer.Sequence start){
@@ -88,7 +86,7 @@ static <E> Flux<E> coldSource(RingBuffer<@NonNull Slot<@NonNull E>> ringBuffer,
 	static Runnable createRequestTask(
 			Subscription upstream,
 			EventLoopProcessor<?> p,
-			@Nullable Consumer<@NonNull Long> postWaitCallback, LongSupplier readCount) {
+			@Nullable Consumer<Long> postWaitCallback, LongSupplier readCount) {
 		return new RequestTask(upstream, p, postWaitCallback, readCount);
 	}
 
@@ -207,7 +205,7 @@ static long getAndSub(RingBuffer.Sequence sequence, long toSub) {
 			ExecutorService requestExecutor,
 			boolean autoCancel,
 			boolean multiproducers,
-			Supplier<@NonNull Slot<@NonNull IN>> factory,
+			Supplier<Slot<IN>> factory,
 			WaitStrategy strategy) {
 
 		if (!Queues.isPowerOfTwo(bufferSize)) {
@@ -326,7 +324,7 @@ public final boolean awaitAndShutdown(long timeout, TimeUnit timeUnit) {
 
 	//FIXME store current subscribers
 	@Override
-	public Stream<? extends @NonNull Scannable> inners() {
+	public Stream<? extends Scannable> inners() {
 		return Stream.empty();
 	}
 
@@ -336,7 +334,7 @@ public final boolean awaitAndShutdown(long timeout, TimeUnit timeUnit) {
 	 *
 	 * @return a {@link Flux} sequence possibly unbounded of incoming buffered values or empty if not supported.
 	 */
-	public Flux<@NonNull IN> drain(){
+	public Flux<IN> drain(){
 		return Flux.empty();
 	}
 
@@ -345,7 +343,7 @@ public final boolean awaitAndShutdown(long timeout, TimeUnit timeUnit) {
 	 * not yet been executed.
 	 * @return a Flux instance with the remaining undelivered values
 	 */
-	final public Flux<@NonNull IN> forceShutdown() {
+	final public Flux<IN> forceShutdown() {
 		int t = terminated;
 		if (t != FORCED_SHUTDOWN && TERMINATED.compareAndSet(this, t, FORCED_SHUTDOWN)) {
 			executor.shutdownNow();
@@ -487,7 +485,7 @@ static final class RequestTask implements Runnable {
 
 		 RequestTask(Subscription upstream,
 				 EventLoopProcessor<?> p,
-				 @Nullable Consumer<@NonNull Long> postWaitCallback,
+				 @Nullable Consumer<Long> postWaitCallback,
 				LongSupplier readCount) {
 			this.parent = p;
 			this.readCount = readCount;
diff --git a/reactor-core/src/main/java/reactor/core/publisher/Flux.java b/reactor-core/src/main/java/reactor/core/publisher/Flux.java
index 58f38003e7..468c2c8b56 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/Flux.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/Flux.java
@@ -59,6 +59,7 @@
 import reactor.core.scheduler.Scheduler.Worker;
 import reactor.core.scheduler.Schedulers;
 import reactor.util.Logger;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.context.Context;
 import reactor.util.function.Tuple2;
@@ -67,8 +68,6 @@
 import reactor.util.function.Tuple5;
 import reactor.util.function.Tuple6;
 import reactor.util.function.Tuples;
-import reactor.util.annotation.NonNull;
-import reactor.util.annotation.Nullable;
 
 /**
  * A Reactive Streams {@link Publisher} with rx operators that emits 0 to N elements, and then completes
@@ -124,7 +123,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a {@link Flux} based on the produced combinations
 	 */
 	@SafeVarargs
-	public static <T, V> Flux<@NonNull V> combineLatest(Function<@NonNull Object @NonNull [], @NonNull V> combinator, Publisher<? extends @NonNull T> @NonNull ... sources) {
+	public static <T, V> Flux<V> combineLatest(Function<Object[], V> combinator, Publisher<? extends T>... sources) {
 		return combineLatest(combinator, Queues.XS_BUFFER_SIZE, sources);
 	}
 
@@ -145,8 +144,8 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a {@link Flux} based on the produced combinations
 	 */
 	@SafeVarargs
-	public static <T, V> Flux<@NonNull V> combineLatest(Function<@NonNull Object @NonNull [], @NonNull V> combinator, int prefetch,
-			Publisher<? extends T> @NonNull ... sources) {
+	public static <T, V> Flux<V> combineLatest(Function<Object[], V> combinator, int prefetch,
+			Publisher<? extends T>... sources) {
 		if (sources.length == 0) {
 			return empty();
 		}
@@ -183,9 +182,9 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a {@link Flux} based on the produced combinations
 	 */
     @SuppressWarnings("unchecked")
-    public static <T1, T2, V> Flux<@NonNull V> combineLatest(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull V> combinator) {
+    public static <T1, T2, V> Flux<V> combineLatest(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			BiFunction<? super T1, ? super T2, ? extends V> combinator) {
 	    return combineLatest(tuple -> combinator.apply((T1)tuple[0], (T2)tuple[1]), source1, source2);
 	}
 
@@ -208,10 +207,10 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Flux} based on the produced combinations
 	 */
-	public static <T1, T2, T3, V> Flux<@NonNull V> combineLatest(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			Publisher<? extends @NonNull T3> source3,
-			Function<@NonNull Object @NonNull [], @NonNull V> combinator) {
+	public static <T1, T2, T3, V> Flux<V> combineLatest(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			Publisher<? extends T3> source3,
+			Function<Object[], V> combinator) {
 		return combineLatest(combinator, source1, source2, source3);
 	}
 
@@ -236,11 +235,11 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Flux} based on the produced combinations
 	 */
-	public static <T1, T2, T3, T4, V> Flux<@NonNull V> combineLatest(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			Publisher<? extends @NonNull T3> source3,
-			Publisher<? extends @NonNull T4> source4,
-			Function<@NonNull Object @NonNull [], @NonNull V> combinator) {
+	public static <T1, T2, T3, T4, V> Flux<V> combineLatest(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			Publisher<? extends T3> source3,
+			Publisher<? extends T4> source4,
+			Function<Object[], V> combinator) {
 		return combineLatest(combinator, source1, source2, source3, source4);
 	}
 
@@ -267,12 +266,12 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Flux} based on the produced combinations
 	 */
-	public static <T1, T2, T3, T4, T5, V> Flux<@NonNull V> combineLatest(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			Publisher<? extends @NonNull T3> source3,
-			Publisher<? extends @NonNull T4> source4,
-			Publisher<? extends @NonNull T5> source5,
-			Function<@NonNull Object @NonNull [], @NonNull V> combinator) {
+	public static <T1, T2, T3, T4, T5, V> Flux<V> combineLatest(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			Publisher<? extends T3> source3,
+			Publisher<? extends T4> source4,
+			Publisher<? extends T5> source5,
+			Function<Object[], V> combinator) {
 		return combineLatest(combinator, source1, source2, source3, source4, source5);
 	}
 
@@ -301,13 +300,13 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Flux} based on the produced combinations
 	 */
-	public static <T1, T2, T3, T4, T5, T6, V> Flux<@NonNull V> combineLatest(Publisher<? extends T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			Publisher<? extends @NonNull T3> source3,
-			Publisher<? extends @NonNull T4> source4,
-			Publisher<? extends @NonNull T5> source5,
-			Publisher<? extends @NonNull T6> source6,
-			Function<@NonNull Object @NonNull [], @NonNull V> combinator) {
+	public static <T1, T2, T3, T4, T5, T6, V> Flux<V> combineLatest(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			Publisher<? extends T3> source3,
+			Publisher<? extends T4> source4,
+			Publisher<? extends T5> source5,
+			Publisher<? extends T6> source6,
+			Function<Object[], V> combinator) {
 		return combineLatest(combinator, source1, source2, source3, source4, source5, source6);
 	}
 
@@ -326,8 +325,8 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Flux} based on the produced combinations
 	 */
-	public static <T, V> Flux<@NonNull V> combineLatest(Iterable<? extends @NonNull Publisher<? extends @NonNull T>> sources,
-			Function<@NonNull Object @NonNull [], @NonNull V> combinator) {
+	public static <T, V> Flux<V> combineLatest(Iterable<? extends Publisher<? extends T>> sources,
+			Function<Object[], V> combinator) {
 		return combineLatest(sources, Queues.XS_BUFFER_SIZE, combinator);
 	}
 
@@ -347,9 +346,9 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Flux} based on the produced combinations
 	 */
-	public static <T, V> Flux<@NonNull V> combineLatest(Iterable<? extends @NonNull Publisher<? extends @NonNull T>> sources,
+	public static <T, V> Flux<V> combineLatest(Iterable<? extends Publisher<? extends T>> sources,
 			int prefetch,
-			Function<@NonNull Object @NonNull [], @NonNull V> combinator) {
+			Function<Object[], V> combinator) {
 
 		return onAssembly(new FluxCombineLatest<T, V>(sources,
 				combinator,
@@ -372,7 +371,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} concatenating all source sequences
 	 */
-	public static <T> Flux<@NonNull T> concat(Iterable<? extends @NonNull Publisher<? extends @NonNull T>> sources) {
+	public static <T> Flux<T> concat(Iterable<? extends Publisher<? extends T>> sources) {
 		return onAssembly(new FluxConcatIterable<>(sources));
 	}
 
@@ -392,7 +391,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} concatenating all inner sources sequences
 	 */
-	public static <T> Flux<@NonNull T> concat(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> sources) {
+	public static <T> Flux<T> concat(Publisher<? extends Publisher<? extends T>> sources) {
 		return concat(sources, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -413,7 +412,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} concatenating all inner sources sequences
 	 */
-	public static <T> Flux<@NonNull T> concat(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> sources, int prefetch) {
+	public static <T> Flux<T> concat(Publisher<? extends Publisher<? extends T>> sources, int prefetch) {
 		return onAssembly(new FluxConcatMap<>(from(sources),
 				identityFunction(),
 				Queues.get(prefetch), prefetch,
@@ -437,7 +436,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a new {@link Flux} concatenating all source sequences
 	 */
 	@SafeVarargs
-	public static <T> Flux<@NonNull T> concat(Publisher<? extends @NonNull T> @NonNull ... sources) {
+	public static <T> Flux<T> concat(Publisher<? extends T>... sources) {
 		return onAssembly(new FluxConcatArray<>(false, sources));
 	}
 
@@ -457,7 +456,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} concatenating all inner sources sequences, delaying errors
 	 */
-	public static <T> Flux<@NonNull T> concatDelayError(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> sources) {
+	public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources) {
 		return concatDelayError(sources, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -478,7 +477,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} concatenating all inner sources sequences until complete or error
 	 */
-	public static <T> Flux<@NonNull T> concatDelayError(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> sources, int prefetch) {
+	public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources, int prefetch) {
 		return onAssembly(new FluxConcatMap<>(from(sources),
 				identityFunction(),
 				Queues.get(prefetch), prefetch,
@@ -507,8 +506,8 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} concatenating all inner sources sequences until complete or error
 	 */
-	public static <T> Flux<@NonNull T> concatDelayError(Publisher<? extends @NonNull Publisher<? extends
-            @NonNull T>> sources, boolean delayUntilEnd, int prefetch) {
+	public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends
+			T>> sources, boolean delayUntilEnd, int prefetch) {
 		return onAssembly(new FluxConcatMap<>(from(sources),
 				identityFunction(),
 				Queues.get(prefetch), prefetch,
@@ -532,7 +531,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a new {@link Flux} concatenating all source sequences
 	 */
 	@SafeVarargs
-	public static <T> Flux<@NonNull T> concatDelayError(Publisher<? extends @NonNull T> @NonNull ... sources) {
+	public static <T> Flux<T> concatDelayError(Publisher<? extends T>... sources) {
 		return onAssembly(new FluxConcatArray<>(true, sources));
 	}
 
@@ -569,7 +568,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @param emitter Consume the {@link FluxSink} provided per-subscriber by Reactor to generate signals.
 	 * @return a {@link Flux}
 	 */
-    public static <T> Flux<@NonNull T> create(Consumer<? super @NonNull FluxSink<@NonNull T>> emitter) {
+    public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter) {
 	    return create(emitter, OverflowStrategy.BUFFER);
     }
 
@@ -608,7 +607,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @param emitter Consume the {@link FluxSink} provided per-subscriber by Reactor to generate signals.
 	 * @return a {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> create(Consumer<? super @NonNull FluxSink<@NonNull T>> emitter, OverflowStrategy backpressure) {
+	public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter, OverflowStrategy backpressure) {
 		return onAssembly(new FluxCreate<>(emitter, backpressure, FluxCreate.CreateMode.PUSH_PULL));
 	}
 
@@ -645,7 +644,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @param emitter Consume the {@link FluxSink} provided per-subscriber by Reactor to generate signals.
 	 * @return a {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> push(Consumer<? super @NonNull FluxSink<@NonNull T>> emitter) {
+	public static <T> Flux<T> push(Consumer<? super FluxSink<T>> emitter) {
 		return onAssembly(new FluxCreate<>(emitter, OverflowStrategy.BUFFER, FluxCreate.CreateMode.PUSH_ONLY));
 	}
 
@@ -684,7 +683,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @param emitter Consume the {@link FluxSink} provided per-subscriber by Reactor to generate signals.
 	 * @return a {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> push(Consumer<? super @NonNull FluxSink<@NonNull T>> emitter, OverflowStrategy backpressure) {
+	public static <T> Flux<T> push(Consumer<? super FluxSink<T>> emitter, OverflowStrategy backpressure) {
 		return onAssembly(new FluxCreate<>(emitter, backpressure, FluxCreate.CreateMode.PUSH_ONLY));
 	}
 
@@ -703,7 +702,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a deferred {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> defer(Supplier<? extends @NonNull Publisher<@NonNull T>> supplier) {
+	public static <T> Flux<T> defer(Supplier<? extends Publisher<T>> supplier) {
 		return onAssembly(new FluxDefer<>(supplier));
 	}
 
@@ -716,7 +715,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return an empty {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> empty() {
+	public static <T> Flux<T> empty() {
 		return FluxEmpty.instance();
 	}
 
@@ -731,7 +730,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new failed {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> error(Throwable error) {
+	public static <T> Flux<T> error(Throwable error) {
 		return error(error, false);
 	}
 
@@ -748,7 +747,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new failed {@link Flux}
 	 */
-	public static <O> Flux<@NonNull O> error(Throwable throwable, boolean whenRequested) {
+	public static <O> Flux<O> error(Throwable throwable, boolean whenRequested) {
 		if (whenRequested) {
 			return onAssembly(new FluxErrorOnRequest<>(throwable));
 		}
@@ -772,7 +771,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a new {@link Flux} behaving like the fastest of its sources
 	 */
 	@SafeVarargs
-	public static <I> Flux<@NonNull I> first(Publisher<? extends @NonNull I> @NonNull ... sources) {
+	public static <I> Flux<I> first(Publisher<? extends I>... sources) {
 		return onAssembly(new FluxFirstEmitting<>(sources));
 	}
 
@@ -790,7 +789,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} behaving like the fastest of its sources
 	 */
-	public static <I> Flux<@NonNull I> first(Iterable<? extends @NonNull Publisher<? extends @NonNull I>> sources) {
+	public static <I> Flux<I> first(Iterable<? extends Publisher<? extends I>> sources) {
 		return onAssembly(new FluxFirstEmitting<>(sources));
 	}
 
@@ -804,7 +803,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> from(Publisher<? extends @NonNull T> source) {
+	public static <T> Flux<T> from(Publisher<? extends T> source) {
 		if (source instanceof Flux) {
 			@SuppressWarnings("unchecked")
 			Flux<T> casted = (Flux<T>) source;
@@ -837,7 +836,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> fromArray(@NonNull T @NonNull [] array) {
+	public static <T> Flux<T> fromArray(T[] array) {
 		if (array.length == 0) {
 			return empty();
 		}
@@ -858,7 +857,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> fromIterable(Iterable<? extends @NonNull T> it) {
+	public static <T> Flux<T> fromIterable(Iterable<? extends T> it) {
 		return onAssembly(new FluxIterable<>(it));
 	}
 
@@ -875,7 +874,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> fromStream(Stream<? extends @NonNull T> s) {
+	public static <T> Flux<T> fromStream(Stream<? extends T> s) {
 		return onAssembly(new FluxStream<>(s));
 	}
 
@@ -892,7 +891,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> generate(Consumer<@NonNull SynchronousSink<@NonNull T>> generator) {
+	public static <T> Flux<T> generate(Consumer<SynchronousSink<T>> generator) {
 		Objects.requireNonNull(generator, "generator");
 		return onAssembly(new FluxGenerate<>(generator));
 	}
@@ -912,7 +911,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * and return a (new) state.
 	 * @return a {@link Flux}
 	 */
-	public static <T, S> Flux<@NonNull T> generate(Callable<@Nullable S> stateSupplier, BiFunction<@NonNull S, SynchronousSink<@NonNull T>, @NonNull S> generator) {
+	public static <T, S> Flux<T> generate(Callable<S> stateSupplier, BiFunction<S, SynchronousSink<T>, S> generator) {
 		return onAssembly(new FluxGenerate<>(stateSupplier, generator));
 	}
 
@@ -936,7 +935,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Flux}
 	 */
-	public static <T, S> Flux<@NonNull T> generate(Callable<@Nullable S> stateSupplier, BiFunction<@NonNull S, SynchronousSink<@NonNull T>, @NonNull S> generator, Consumer<? super @NonNull S> stateConsumer) {
+	public static <T, S> Flux<T> generate(Callable<S> stateSupplier, BiFunction<S, SynchronousSink<T>, S> generator, Consumer<? super S> stateConsumer) {
 		return onAssembly(new FluxGenerate<>(stateSupplier, generator, stateConsumer));
 	}
 
@@ -952,7 +951,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @param period the period {@link Duration} between each increment
 	 * @return a new {@link Flux} emitting increasing numbers at regular intervals
 	 */
-	public static Flux<@NonNull Long> interval(Duration period) {
+	public static Flux<Long> interval(Duration period) {
 		return interval(period, Schedulers.parallel());
 	}
 
@@ -970,7 +969,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} emitting increasing numbers at regular intervals
 	 */
-	public static Flux<@NonNull Long> interval(Duration delay, Duration period) {
+	public static Flux<Long> interval(Duration delay, Duration period) {
 		return interval(delay, period, Schedulers.parallel());
 	}
 
@@ -986,7 +985,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} emitting increasing numbers at regular intervals
 	 */
-	public static Flux<@NonNull Long> interval(Duration period, Scheduler timer) {
+	public static Flux<Long> interval(Duration period, Scheduler timer) {
 		return onAssembly(new FluxInterval(period.toMillis(), period.toMillis(), TimeUnit.MILLISECONDS, timer));
 	}
 
@@ -1004,7 +1003,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} emitting increasing numbers at regular intervals
 	 */
-	public static Flux<@NonNull Long> interval(Duration delay, Duration period, Scheduler timer) {
+	public static Flux<Long> interval(Duration delay, Duration period, Scheduler timer) {
 		return onAssembly(new FluxInterval(delay.toMillis(), period.toMillis(), TimeUnit.MILLISECONDS, timer));
 	}
 
@@ -1019,7 +1018,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a new {@link Flux}
 	 */
 	@SafeVarargs
-	public static <T> Flux<@NonNull T> just(@NonNull T @NonNull ... data) {
+	public static <T> Flux<T> just(T... data) {
 		return fromArray(data);
 	}
 
@@ -1033,7 +1032,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> just(T data) {
+	public static <T> Flux<T> just(T data) {
 		return onAssembly(new FluxJust<>(data));
 	}
 
@@ -1054,7 +1053,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> merge(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> source) {
+	public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source) {
 		return merge(source,
 				Queues.SMALL_BUFFER_SIZE,
 				Queues.XS_BUFFER_SIZE);
@@ -1079,7 +1078,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> merge(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> source, int concurrency) {
+	public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source, int concurrency) {
 		return merge(source, concurrency, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -1103,7 +1102,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> merge(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> source, int concurrency, int prefetch) {
+	public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source, int concurrency, int prefetch) {
 		return onAssembly(new FluxFlatMap<>(
 				from(source),
 				identityFunction(),
@@ -1132,7 +1131,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}
 	 */
-	public static <I> Flux<@NonNull I> merge(Iterable<? extends @NonNull Publisher<? extends I>> sources) {
+	public static <I> Flux<I> merge(Iterable<? extends Publisher<? extends I>> sources) {
 		return merge(fromIterable(sources));
 	}
 
@@ -1154,7 +1153,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a merged {@link Flux}
 	 */
 	@SafeVarargs
-	public static <I> Flux<@NonNull I> merge(Publisher<? extends @NonNull I> @NonNull ... sources) {
+	public static <I> Flux<I> merge(Publisher<? extends I>... sources) {
 		return merge(Queues.XS_BUFFER_SIZE, sources);
 	}
 
@@ -1177,7 +1176,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a fresh Reactive {@link Flux} publisher ready to be subscribed
 	 */
 	@SafeVarargs
-	public static <I> Flux<@NonNull I> merge(int prefetch, Publisher<? extends @NonNull I> @NonNull ... sources) {
+	public static <I> Flux<I> merge(int prefetch, Publisher<? extends I>... sources) {
 		return merge(prefetch, false, sources);
 	}
 
@@ -1201,7 +1200,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a fresh Reactive {@link Flux} publisher ready to be subscribed
 	 */
 	@SafeVarargs
-	public static <I> Flux<@NonNull I> mergeDelayError(int prefetch, Publisher<? extends @NonNull I> @NonNull ... sources) {
+	public static <I> Flux<I> mergeDelayError(int prefetch, Publisher<? extends I>... sources) {
 		return merge(prefetch, true, sources);
 	}
 
@@ -1218,7 +1217,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public static <T> Flux<@NonNull T> mergeSequential(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> sources) {
+	public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources) {
 		return mergeSequential(sources, false, Queues.SMALL_BUFFER_SIZE,
 				Queues.XS_BUFFER_SIZE);
 	}
@@ -1238,7 +1237,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public static <T> Flux<@NonNull T> mergeSequential(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> sources,
+	public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources,
 			int maxConcurrency, int prefetch) {
 		return mergeSequential(sources, false, maxConcurrency, prefetch);
 	}
@@ -1259,7 +1258,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public static <T> Flux<@NonNull T> mergeSequentialDelayError(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> sources,
+	public static <T> Flux<T> mergeSequentialDelayError(Publisher<? extends Publisher<? extends T>> sources,
 			int maxConcurrency, int prefetch) {
 		return mergeSequential(sources, true, maxConcurrency, prefetch);
 	}
@@ -1277,7 +1276,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
 	@SafeVarargs
-	public static <I> Flux<@NonNull I> mergeSequential(Publisher<? extends @NonNull I> @NonNull ... sources) {
+	public static <I> Flux<I> mergeSequential(Publisher<? extends I>... sources) {
 		return mergeSequential(Queues.XS_BUFFER_SIZE, false, sources);
 	}
 
@@ -1295,7 +1294,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
 	@SafeVarargs
-	public static <I> Flux<@NonNull I> mergeSequential(int prefetch, Publisher<? extends @NonNull I> @NonNull ... sources) {
+	public static <I> Flux<I> mergeSequential(int prefetch, Publisher<? extends I>... sources) {
 		return mergeSequential(prefetch, false, sources);
 	}
 
@@ -1315,7 +1314,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
 	@SafeVarargs
-	public static <I> Flux<@NonNull I> mergeSequentialDelayError(int prefetch, Publisher<? extends @NonNull I> @NonNull ... sources) {
+	public static <I> Flux<I> mergeSequentialDelayError(int prefetch, Publisher<? extends I>... sources) {
 		return mergeSequential(prefetch, true, sources);
 	}
 
@@ -1331,7 +1330,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public static <I> Flux<@NonNull I> mergeSequential(Iterable<? extends @NonNull Publisher<? extends @NonNull I>> sources) {
+	public static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources) {
 		return mergeSequential(sources, false, Queues.SMALL_BUFFER_SIZE,
 				Queues.XS_BUFFER_SIZE);
 	}
@@ -1351,7 +1350,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public static <I> Flux<@NonNull I> mergeSequential(Iterable<? extends @NonNull Publisher<? extends I>> sources,
+	public static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources,
 			int maxConcurrency, int prefetch) {
 		return mergeSequential(sources, false, maxConcurrency, prefetch);
 	}
@@ -1373,7 +1372,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public static <I> Flux<@NonNull I> mergeSequentialDelayError(Iterable<? extends @NonNull Publisher<? extends @NonNull I>> sources,
+	public static <I> Flux<I> mergeSequentialDelayError(Iterable<? extends Publisher<? extends I>> sources,
 			int maxConcurrency, int prefetch) {
 		return mergeSequential(sources, true, maxConcurrency, prefetch);
 	}
@@ -1387,7 +1386,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a never completing {@link Flux}
 	 */
-	public static <T> Flux<@NonNull T> never() {
+	public static <T> Flux<T> never() {
 		return FluxNever.instance();
 	}
 
@@ -1403,7 +1402,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @param count the total number of incrementing values to emit, including the first value
 	 * @return a ranged {@link Flux}
 	 */
-	public static Flux<@NonNull Integer> range(int start, int count) {
+	public static Flux<Integer> range(int start, int count) {
 		if (count == 1) {
 			return just(start);
 		}
@@ -1429,7 +1428,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link FluxProcessor} accepting publishers and producing T
 	 */
-	public static <T> Flux<@NonNull T> switchOnNext(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> mergedPublishers) {
+	public static <T> Flux<T> switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers) {
 		return switchOnNext(mergedPublishers, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -1450,7 +1449,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a {@link FluxProcessor} accepting publishers and producing T
 	 */
-	public static <T> Flux<@NonNull T> switchOnNext(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> mergedPublishers, int prefetch) {
+	public static <T> Flux<T> switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers, int prefetch) {
 		return onAssembly(new FluxSwitchMap<>(from(mergedPublishers),
 				identityFunction(),
 				Queues.unbounded(prefetch), prefetch));
@@ -1475,8 +1474,8 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} built around a disposable resource
 	 */
-	public static <T, D> Flux<@NonNull T> using(Callable<? extends @NonNull D> resourceSupplier, Function<? super @NonNull D, ? extends
-            @NonNull Publisher<? extends @NonNull T>> sourceSupplier, Consumer<? super @NonNull D> resourceCleanup) {
+	public static <T, D> Flux<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends
+			Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup) {
 		return using(resourceSupplier, sourceSupplier, resourceCleanup, true);
 	}
 
@@ -1500,8 +1499,8 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Flux} built around a disposable resource
 	 */
-	public static <T, D> Flux<@NonNull T> using(Callable<? extends @NonNull D> resourceSupplier, Function<? super @NonNull D, ? extends
-            @NonNull Publisher<? extends @NonNull T>> sourceSupplier, Consumer<? super @NonNull D> resourceCleanup, boolean eager) {
+	public static <T, D> Flux<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends
+			Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup, boolean eager) {
 		return onAssembly(new FluxUsing<>(resourceSupplier,
 				sourceSupplier,
 				resourceCleanup,
@@ -1528,9 +1527,9 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-    public static <T1, T2, O> Flux<@NonNull O> zip(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			final BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull O> combinator) {
+    public static <T1, T2, O> Flux<O> zip(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			final BiFunction<? super T1, ? super T2, ? extends O> combinator) {
 
 		return onAssembly(new FluxZip<T1, O>(source1,
 				source2,
@@ -1555,7 +1554,7 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public static <T1, T2> Flux<@NonNull Tuple2<@NonNull T1, @NonNull T2>> zip(Publisher<? extends @NonNull T1> source1, Publisher<? extends @NonNull T2> source2) {
+	public static <T1, T2> Flux<Tuple2<T1, T2>> zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2) {
 		return zip(source1, source2, tuple2Function());
 	}
 
@@ -1577,9 +1576,9 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public static <T1, T2, T3> Flux<@NonNull Tuple3<@NonNull T1, @NonNull T2, @NonNull T3>> zip(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			Publisher<? extends @NonNull T3> source3) {
+	public static <T1, T2, T3> Flux<Tuple3<T1, T2, T3>> zip(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			Publisher<? extends T3> source3) {
 		return zip(Tuples.fn3(), source1, source2, source3);
 	}
 
@@ -1603,10 +1602,10 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public static <T1, T2, T3, T4> Flux<@NonNull Tuple4<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4>> zip(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			Publisher<? extends @NonNull T3> source3,
-			Publisher<? extends @NonNull T4> source4) {
+	public static <T1, T2, T3, T4> Flux<Tuple4<T1, T2, T3, T4>> zip(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			Publisher<? extends T3> source3,
+			Publisher<? extends T4> source4) {
 		return zip(Tuples.fn4(), source1, source2, source3, source4);
 	}
 
@@ -1632,11 +1631,11 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public static <T1, T2, T3, T4, T5> Flux<@NonNull Tuple5<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5>> zip(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			Publisher<? extends @NonNull T3> source3,
-			Publisher<? extends @NonNull T4> source4,
-			Publisher<? extends @NonNull T5> source5) {
+	public static <T1, T2, T3, T4, T5> Flux<Tuple5<T1, T2, T3, T4, T5>> zip(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			Publisher<? extends T3> source3,
+			Publisher<? extends T4> source4,
+			Publisher<? extends T5> source5) {
 		return zip(Tuples.fn5(), source1, source2, source3, source4, source5);
 	}
 
@@ -1664,12 +1663,12 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public static <T1, T2, T3, T4, T5, T6> Flux<@NonNull Tuple6<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6>> zip(Publisher<? extends @NonNull T1> source1,
-			Publisher<? extends @NonNull T2> source2,
-			Publisher<? extends @NonNull T3> source3,
-			Publisher<? extends @NonNull T4> source4,
-			Publisher<? extends @NonNull T5> source5,
-			Publisher<? extends @NonNull T6> source6) {
+	public static <T1, T2, T3, T4, T5, T6> Flux<Tuple6<T1, T2, T3, T4, T5, T6>> zip(Publisher<? extends T1> source1,
+			Publisher<? extends T2> source2,
+			Publisher<? extends T3> source3,
+			Publisher<? extends T4> source4,
+			Publisher<? extends T5> source5,
+			Publisher<? extends T6> source6) {
 		return zip(Tuples.fn6(), source1, source2, source3, source4, source5, source6);
 	}
 
@@ -1693,8 +1692,8 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public static <O> Flux<@NonNull O> zip(Iterable<? extends @NonNull Publisher<@NonNull ?>> sources,
-			final Function<? super @NonNull Object @NonNull [], ? extends @NonNull O> combinator) {
+	public static <O> Flux<O> zip(Iterable<? extends Publisher<?>> sources,
+			final Function<? super Object[], ? extends O> combinator) {
 
 		return zip(sources, Queues.XS_BUFFER_SIZE, combinator);
 	}
@@ -1720,9 +1719,9 @@ public abstract class Flux<T> implements Publisher<T> {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public static <O> Flux<@NonNull O> zip(Iterable<? extends @NonNull Publisher<@NonNull ?>> sources,
+	public static <O> Flux<O> zip(Iterable<? extends Publisher<?>> sources,
 			int prefetch,
-			final Function<? super @NonNull Object @NonNull [], ? extends @NonNull O> combinator) {
+			final Function<? super Object[], ? extends O> combinator) {
 
 		return onAssembly(new FluxZip<Object, O>(sources,
 				combinator,
@@ -1749,8 +1748,8 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a zipped {@link Flux}
 	 */
 	@SafeVarargs
-	public static <I, O> Flux<@NonNull O> zip(
-			final Function<? super @NonNull Object @NonNull [], ? extends @NonNull O> combinator, Publisher<? extends @NonNull I> @NonNull ... sources) {
+	public static <I, O> Flux<O> zip(
+			final Function<? super Object[], ? extends O> combinator, Publisher<? extends I>... sources) {
 		return zip(combinator, Queues.XS_BUFFER_SIZE, sources);
 	}
 
@@ -1774,9 +1773,9 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a zipped {@link Flux}
 	 */
 	@SafeVarargs
-	public static <I, O> Flux<@NonNull O> zip(final Function<? super @NonNull Object[], ? extends @NonNull O> combinator,
+	public static <I, O> Flux<O> zip(final Function<? super Object[], ? extends O> combinator,
 			int prefetch,
-			Publisher<? extends @NonNull I> @NonNull ... sources) {
+			Publisher<? extends I>... sources) {
 
 		if (sources.length == 0) {
 			return empty();
@@ -1820,9 +1819,9 @@ public abstract class Flux<T> implements Publisher<T> {
 	 * @return a {@link Flux} based on the produced value
 	 */
 	@SuppressWarnings({ "rawtypes", "unchecked" })
-    public static <TUPLE extends Tuple2, V> Flux<@NonNull V> zip(Publisher<? extends
-            @NonNull Publisher<@NonNull ?>> sources,
-			final Function<? super @NonNull TUPLE, ? extends @NonNull V> combinator) {
+    public static <TUPLE extends Tuple2, V> Flux<V> zip(Publisher<? extends
+			Publisher<?>> sources,
+			final Function<? super TUPLE, ? extends V> combinator) {
 
 		return onAssembly(new FluxBuffer<>(from(sources), Integer.MAX_VALUE, listSupplier())
 		                    .flatMap(new Function<List<? extends Publisher<?>>, Publisher<V>>() {
@@ -1851,7 +1850,7 @@ public Publisher<V> apply(List<? extends Publisher<?>> publishers) {
 	 * @return a new {@link Mono} with <code>true</code> if all values satisfies a predicate and <code>false</code>
 	 * otherwise
 	 */
-	public final Mono<Boolean> all(Predicate<? super @NonNull T> predicate) {
+	public final Mono<Boolean> all(Predicate<? super T> predicate) {
 		return Mono.onAssembly(new MonoAll<>(this, predicate));
 	}
 
@@ -1870,7 +1869,7 @@ public final Mono<Boolean> all(Predicate<? super @NonNull T> predicate) {
 	 * @return a new {@link Mono} with <code>true</code> if any value satisfies a predicate and <code>false</code>
 	 * otherwise
 	 */
-	public final Mono<Boolean> any(Predicate<? super @NonNull T> predicate) {
+	public final Mono<Boolean> any(Predicate<? super T> predicate) {
 		return Mono.onAssembly(new MonoAny<>(this, predicate));
 	}
 
@@ -1887,7 +1886,7 @@ public final Mono<Boolean> any(Predicate<? super @NonNull T> predicate) {
 	 * @return the {@link Flux} transformed to an instance of P
 	 * @see #compose for a bounded conversion to {@link Publisher}
 	 */
-	public final <P> P as(Function<? super @NonNull Flux<@NonNull T>, @NonNull P> transformer) {
+	public final <P> P as(Function<? super Flux<T>, P> transformer) {
 		return transformer.apply(this);
 	}
 
@@ -1980,7 +1979,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a buffered {@link Flux} of at most one {@link List}
 	 * @see #collectList() for an alternative collecting algorithm returning {@link Mono}
 	 */
-    public final Flux<@NonNull List<@NonNull T>> buffer() {
+    public final Flux<List<T>> buffer() {
 	    return buffer(Integer.MAX_VALUE);
 	}
 
@@ -1996,7 +1995,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link List}
 	 */
-	public final Flux<@NonNull List<@NonNull T>> buffer(int maxSize) {
+	public final Flux<List<T>> buffer(int maxSize) {
 		return buffer(maxSize, listSupplier());
 	}
 
@@ -2014,7 +2013,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link Collection}
 	 */
-	public final <C extends Collection<? super T>> Flux<@NonNull C> buffer(int maxSize, Supplier<@NonNull C> bufferSupplier) {
+	public final <C extends Collection<? super T>> Flux<C> buffer(int maxSize, Supplier<C> bufferSupplier) {
 		return onAssembly(new FluxBuffer<>(this, maxSize, bufferSupplier));
 	}
 
@@ -2044,7 +2043,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of possibly overlapped or gapped {@link List}
 	 */
-	public final Flux<@NonNull List<@NonNull T>> buffer(int maxSize, int skip) {
+	public final Flux<List<T>> buffer(int maxSize, int skip) {
 		return buffer(maxSize, skip, listSupplier());
 	}
 
@@ -2077,8 +2076,8 @@ public final T blockLast(Duration timeout) {
 	 * @return a microbatched {@link Flux} of possibly overlapped or gapped
 	 * {@link Collection}
 	 */
-	public final <C extends Collection<? super T>> Flux<@NonNull C> buffer(int maxSize,
-			int skip, Supplier<@NonNull C> bufferSupplier) {
+	public final <C extends Collection<? super T>> Flux<C> buffer(int maxSize,
+			int skip, Supplier<C> bufferSupplier) {
 		return onAssembly(new FluxBuffer<>(this, maxSize, skip, bufferSupplier));
 	}
 
@@ -2093,7 +2092,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link List} delimited by signals from a {@link Publisher}
 	 */
-	public final Flux<@NonNull List<@NonNull T>> buffer(Publisher<?> other) {
+	public final Flux<List<T>> buffer(Publisher<?> other) {
 		return buffer(other, listSupplier());
 	}
 
@@ -2111,7 +2110,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link Collection} delimited by signals from a {@link Publisher}
 	 */
-	public final <C extends Collection<? super @NonNull T>> Flux<@NonNull C> buffer(Publisher<@NonNull ?> other, Supplier<@NonNull C> bufferSupplier) {
+	public final <C extends Collection<? super T>> Flux<C> buffer(Publisher<?> other, Supplier<C> bufferSupplier) {
 		return onAssembly(new FluxBufferBoundary<>(this, other, bufferSupplier));
 	}
 
@@ -2126,7 +2125,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link List} delimited by the given time span
 	 */
-	public final Flux<@NonNull List<@NonNull T>> buffer(Duration timespan) {
+	public final Flux<List<T>> buffer(Duration timespan) {
 		return buffer(timespan, Schedulers.parallel());
 	}
 
@@ -2155,7 +2154,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link List} delimited by the given period timeshift and sized by timespan
 	 */
-	public final Flux<@NonNull List<@NonNull T>> buffer(Duration timespan, Duration timeshift) {
+	public final Flux<List<T>> buffer(Duration timespan, Duration timeshift) {
 		return buffer(timespan, timeshift, Schedulers.parallel());
 	}
 
@@ -2171,7 +2170,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link List} delimited by the given period
 	 */
-	public final Flux<@NonNull List<@NonNull T>> buffer(Duration timespan, Scheduler timer) {
+	public final Flux<List<T>> buffer(Duration timespan, Scheduler timer) {
 		return buffer(interval(timespan, timer));
 	}
 
@@ -2202,7 +2201,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link List} delimited by the given period timeshift and sized by timespan
 	 */
-	public final Flux<@NonNull List<@NonNull T>> buffer(Duration timespan, Duration timeshift, Scheduler timer) {
+	public final Flux<List<T>> buffer(Duration timespan, Duration timeshift, Scheduler timer) {
 		if (timespan.equals(timeshift)) {
 			return buffer(timespan, timer);
 		}
@@ -2223,7 +2222,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link List} delimited by given size or a given period timeout
 	 */
-	public final Flux<@NonNull List<@NonNull T>> bufferTimeout(int maxSize, Duration timespan) {
+	public final Flux<List<T>> bufferTimeout(int maxSize, Duration timespan) {
 		return bufferTimeout(maxSize, timespan, listSupplier());
 	}
 
@@ -2241,7 +2240,7 @@ public final T blockLast(Duration timeout) {
 	 * @param <C> the {@link Collection} buffer type
 	 * @return a microbatched {@link Flux} of {@link Collection} delimited by given size or a given period timeout
 	 */
-	public final <C extends Collection<? super T>> Flux<@NonNull C> bufferTimeout(int maxSize, Duration timespan, Supplier<@NonNull C> bufferSupplier) {
+	public final <C extends Collection<? super T>> Flux<C> bufferTimeout(int maxSize, Duration timespan, Supplier<C> bufferSupplier) {
 		return bufferTimeout(maxSize, timespan, Schedulers.parallel(),
 				bufferSupplier);
 	}
@@ -2260,7 +2259,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a microbatched {@link Flux} of {@link List} delimited by given size or a given period timeout
 	 */
-	public final Flux<@NonNull List<@NonNull T>> bufferTimeout(int maxSize, Duration timespan, Scheduler timer) {
+	public final Flux<List<T>> bufferTimeout(int maxSize, Duration timespan, Scheduler timer) {
 		return bufferTimeout(maxSize, timespan, timer, listSupplier());
 	}
 
@@ -2279,8 +2278,8 @@ public final T blockLast(Duration timeout) {
 	 * @param <C> the {@link Collection} buffer type
 	 * @return a microbatched {@link Flux} of {@link Collection} delimited by given size or a given period timeout
 	 */
-	public final  <C extends Collection<? super T>> Flux<@NonNull C> bufferTimeout(int maxSize, Duration timespan,
-			Scheduler timer, Supplier<@NonNull C> bufferSupplier) {
+	public final  <C extends Collection<? super T>> Flux<C> bufferTimeout(int maxSize, Duration timespan,
+			Scheduler timer, Supplier<C> bufferSupplier) {
 		return onAssembly(new FluxBufferTimeOrSize<>(this, maxSize, timespan.toMillis(), timer, bufferSupplier));
 	}
 
@@ -2300,7 +2299,7 @@ public final T blockLast(Duration timeout) {
 	 * @param predicate a predicate that triggers the next buffer when it becomes true.
 	 * @return a microbatched {@link Flux} of {@link List}
 	 */
-	public final Flux<@NonNull List<@NonNull T>> bufferUntil(Predicate<? super @NonNull T> predicate) {
+	public final Flux<List<T>> bufferUntil(Predicate<? super T> predicate) {
 		return onAssembly(new FluxBufferPredicate<>(this, predicate,
 				listSupplier(), FluxBufferPredicate.Mode.UNTIL));
 	}
@@ -2324,7 +2323,7 @@ public final T blockLast(Duration timeout) {
 	 * @param cutBefore push to true to include the triggering element in the new buffer rather than the old.
 	 * @return a microbatched {@link Flux} of {@link List}
 	 */
-	public final Flux<@NonNull List<@NonNull T>> bufferUntil(Predicate<? super @NonNull T> predicate, boolean cutBefore) {
+	public final Flux<List<T>> bufferUntil(Predicate<? super T> predicate, boolean cutBefore) {
 		return onAssembly(new FluxBufferPredicate<>(this, predicate, listSupplier(),
 				cutBefore ? FluxBufferPredicate.Mode.UNTIL_CUT_BEFORE
 						  : FluxBufferPredicate.Mode.UNTIL));
@@ -2334,7 +2333,7 @@ public final T blockLast(Duration timeout) {
 	 * Collect incoming values into multiple {@link List} buffers that will be emitted by
 	 * the resulting {@link Flux}. Each buffer continues aggregating values while the
 	 * given predicate returns true, and a new buffer is created as soon as the
-	 * predicate returns false ... Note that the element that triggers the predicate
+	 * predicate returns false... Note that the element that triggers the predicate
 	 * to return false (and thus closes a buffer) is NOT included in any emitted buffer.
 	 * <p>
 	 * <img class="marble" src="https://raw.githubusercontent.com/reactor/reactor-core/v3.1.0.RC1/src/docs/marble/buffersize.png"
@@ -2347,7 +2346,7 @@ public final T blockLast(Duration timeout) {
 	 * @param predicate a predicate that triggers the next buffer when it becomes false.
 	 * @return a microbatched {@link Flux} of {@link List}
 	 */
-	public final Flux<@NonNull List<@NonNull T>> bufferWhile(Predicate<? super @NonNull T> predicate) {
+	public final Flux<List<T>> bufferWhile(Predicate<? super T> predicate) {
 		return onAssembly(new FluxBufferPredicate<>(this, predicate,
 				listSupplier(), FluxBufferPredicate.Mode.WHILE));
 	}
@@ -2381,7 +2380,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a microbatched {@link Flux} of {@link List} delimited by an opening {@link Publisher} and a relative
 	 * closing {@link Publisher}
 	 */
-	public final <U, V> Flux<@NonNull List<@NonNull T>> bufferWhen(Publisher<@NonNull U> bucketOpening,
+	public final <U, V> Flux<List<T>> bufferWhen(Publisher<U> bucketOpening,
 			Function<? super U, ? extends Publisher<V>> closeSelector) {
 		return bufferWhen(bucketOpening, closeSelector, listSupplier());
 	}
@@ -2417,8 +2416,8 @@ public final T blockLast(Duration timeout) {
 	 * @return a microbatched {@link Flux} of {@link Collection} delimited by an opening {@link Publisher} and a relative
 	 * closing {@link Publisher}
 	 */
-	public final <U, V, C extends Collection<? super @NonNull T>> Flux<@NonNull C> bufferWhen(Publisher<@NonNull U> bucketOpening,
-			Function<? super @NonNull U, ? extends @NonNull Publisher<@NonNull V>> closeSelector, Supplier<@NonNull C> bufferSupplier) {
+	public final <U, V, C extends Collection<? super T>> Flux<C> bufferWhen(Publisher<U> bucketOpening,
+			Function<? super U, ? extends Publisher<V>> closeSelector, Supplier<C> bufferSupplier) {
 		return onAssembly(new FluxBufferWhen<>(this, bucketOpening, closeSelector,
 				bufferSupplier, Queues.unbounded(Queues.XS_BUFFER_SIZE)));
 	}
@@ -2433,7 +2432,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a replaying {@link Flux}
 	 */
-	public final Flux<@NonNull T> cache() {
+	public final Flux<T> cache() {
 		return cache(Integer.MAX_VALUE);
 	}
 
@@ -2452,7 +2451,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a replaying {@link Flux}
 	 *
 	 */
-	public final Flux<@NonNull T> cache(int history) {
+	public final Flux<T> cache(int history) {
 		return replay(history).autoConnect();
 	}
 
@@ -2470,7 +2469,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a replaying {@link Flux}
 	 */
-	public final Flux<@NonNull T> cache(Duration ttl) {
+	public final Flux<T> cache(Duration ttl) {
 		return replay(Integer.MAX_VALUE, ttl).autoConnect();
 	}
 
@@ -2490,7 +2489,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a replaying {@link Flux}
 	 */
-	public final Flux<@NonNull T> cache(int history, Duration ttl) {
+	public final Flux<T> cache(int history, Duration ttl) {
 		return replay(history, ttl).autoConnect();
 	}
 
@@ -2505,7 +2504,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a casted {@link Flux}
 	 */
-	public final <E> Flux<@NonNull E> cast(Class<E> clazz) {
+	public final <E> Flux<E> cast(Class<E> clazz) {
 		Objects.requireNonNull(clazz, "clazz");
 		return map(clazz::cast);
 	}
@@ -2519,7 +2518,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a scheduled cancel {@link Flux}
 	 */
-	public final Flux<@NonNull T> cancelOn(Scheduler scheduler) {
+	public final Flux<T> cancelOn(Scheduler scheduler) {
 		return onAssembly(new FluxCancelOn<>(this, scheduler));
 	}
 
@@ -2533,7 +2532,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return the assembly tracing {@link Flux}.
 	 */
-	public final Flux<@NonNull T> checkpoint() {
+	public final Flux<T> checkpoint() {
 		return checkpoint(null, true);
 	}
 
@@ -2553,7 +2552,7 @@ public final T blockLast(Duration timeout) {
 	 * @param description a unique enough description to include in the light assembly traceback.
 	 * @return the assembly marked {@link Flux}
 	 */
-	public final Flux<@NonNull T> checkpoint(String description) {
+	public final Flux<T> checkpoint(String description) {
 		return checkpoint(Objects.requireNonNull(description), false);
 	}
 
@@ -2583,7 +2582,7 @@ public final T blockLast(Duration timeout) {
 	 * to use a stack trace.
 	 * @return the assembly marked {@link Flux}.
 	 */
-	public final Flux<@NonNull T> checkpoint(@Nullable String description, boolean forceStackTrace) {
+	public final Flux<T> checkpoint(@Nullable String description, boolean forceStackTrace) {
 		return new FluxOnAssembly<>(this, description, !forceStackTrace);
 	}
 
@@ -2602,7 +2601,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a {@link Mono} of the collected container on complete
 	 *
 	 */
-	public final <E> Mono<@NonNull E> collect(Supplier<@NonNull E> containerSupplier, BiConsumer<@NonNull E, ? super @NonNull T> collector) {
+	public final <E> Mono<E> collect(Supplier<E> containerSupplier, BiConsumer<E, ? super T> collector) {
 		return Mono.onAssembly(new MonoCollect<>(this, containerSupplier, collector));
 	}
 
@@ -2621,7 +2620,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a {@link Mono} of the collected container on complete
 	 *
 	 */
-	public final <R, A> Mono<@NonNull R> collect(Collector<? super @NonNull T, @NonNull A, ? extends @NonNull R> collector) {
+	public final <R, A> Mono<R> collect(Collector<? super T, A, ? extends R> collector) {
 		return Mono.onAssembly(new MonoStreamCollector<>(this, collector));
 	}
 
@@ -2634,7 +2633,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a {@link Mono} of a {@link List} of all values from this {@link Flux}
 	 */
-	public final Mono<@NonNull List<@NonNull T>> collectList() {
+	public final Mono<List<T>> collectList() {
 		if (this instanceof Callable) {
 			if (this instanceof Fuseable.ScalarCallable) {
 				@SuppressWarnings("unchecked")
@@ -2685,7 +2684,7 @@ public final T blockLast(Duration timeout) {
 	 * element in case of key conflicts)
 	 *
 	 */
-	public final <K> Mono<@NonNull Map<@NonNull K, @NonNull T>> collectMap(Function<? super @NonNull T, ? extends @NonNull K> keyExtractor) {
+	public final <K> Mono<Map<K, T>> collectMap(Function<? super T, ? extends K> keyExtractor) {
 		return collectMap(keyExtractor, identityFunction());
 	}
 
@@ -2709,8 +2708,8 @@ public final T blockLast(Duration timeout) {
 	 * @return a {@link Mono} of a {@link Map} of key-element pairs (only including latest
 	 * element's value in case of key conflicts)
 	 */
-	public final <K, V> Mono<@NonNull Map<@NonNull K, @NonNull V>> collectMap(Function<? super @NonNull T, ? extends @NonNull K> keyExtractor,
-			Function<? super @NonNull T, ? extends @NonNull V> valueExtractor) {
+	public final <K, V> Mono<Map<K, V>> collectMap(Function<? super T, ? extends K> keyExtractor,
+			Function<? super T, ? extends V> valueExtractor) {
 		return collectMap(keyExtractor, valueExtractor, () -> new HashMap<>());
 	}
 
@@ -2735,10 +2734,10 @@ public final T blockLast(Duration timeout) {
 	 * @return a {@link Mono} of a {@link Map} of key-value pairs (only including latest
 	 * element's value in case of key conflicts)
 	 */
-	public final <K, V> Mono<@NonNull Map<@NonNull K, @NonNull V>> collectMap(
-			final Function<? super @NonNull T, ? extends @NonNull K> keyExtractor,
-			final Function<? super @NonNull T, ? extends @NonNull V> valueExtractor,
-			Supplier<@NonNull Map<@NonNull K, @NonNull V>> mapSupplier) {
+	public final <K, V> Mono<Map<K, V>> collectMap(
+			final Function<? super T, ? extends K> keyExtractor,
+			final Function<? super T, ? extends V> valueExtractor,
+			Supplier<Map<K, V>> mapSupplier) {
 		Objects.requireNonNull(keyExtractor, "Key extractor is null");
 		Objects.requireNonNull(valueExtractor, "Value extractor is null");
 		Objects.requireNonNull(mapSupplier, "Map supplier is null");
@@ -2760,7 +2759,7 @@ public final T blockLast(Duration timeout) {
 	 * @param <K> the type of the key extracted from each source element
 	 * @return a {@link Mono} of a {@link Map} of key-List(elements) pairs
 	 */
-	public final <K> Mono<@NonNull Map<@NonNull K, @NonNull Collection<@NonNull T>>> collectMultimap(Function<? super @NonNull T, ? extends @NonNull K> keyExtractor) {
+	public final <K> Mono<Map<K, Collection<T>>> collectMultimap(Function<? super T, ? extends K> keyExtractor) {
 		return collectMultimap(keyExtractor, identityFunction());
 	}
 
@@ -2783,8 +2782,8 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a {@link Mono} of a {@link Map} of key-List(values) pairs
 	 */
-	public final <K, V> Mono<@NonNull Map<@NonNull K, @NonNull Collection<@NonNull V>>> collectMultimap(Function<? super @NonNull T, ? extends @NonNull K> keyExtractor,
-			Function<? super @NonNull T, ? extends @NonNull V> valueExtractor) {
+	public final <K, V> Mono<Map<K, Collection<V>>> collectMultimap(Function<? super T, ? extends K> keyExtractor,
+			Function<? super T, ? extends V> valueExtractor) {
 		return collectMultimap(keyExtractor, valueExtractor, () -> new HashMap<>());
 	}
 
@@ -2810,9 +2809,9 @@ public final T blockLast(Duration timeout) {
 	 * @return a {@link Mono} of a {@link Map} of key-Collection(values) pairs
 	 *
 	 */
-	public final <K, V> Mono<@NonNull Map<@NonNull K, @NonNull Collection<@NonNull V>>> collectMultimap(
-			final Function<? super @NonNull T, ? extends @NonNull K> keyExtractor,
-			final Function<? super @NonNull T, ? extends @NonNull V> valueExtractor,
+	public final <K, V> Mono<Map<K, Collection<V>>> collectMultimap(
+			final Function<? super T, ? extends K> keyExtractor,
+			final Function<? super T, ? extends V> valueExtractor,
 			Supplier<Map<K, Collection<V>>> mapSupplier) {
 		Objects.requireNonNull(keyExtractor, "Key extractor is null");
 		Objects.requireNonNull(valueExtractor, "Value extractor is null");
@@ -2834,7 +2833,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a {@link Mono} of a sorted {@link List} of all values from this {@link Flux}, in natural order
 	 */
-	public final Mono<@NonNull List<@NonNull T>> collectSortedList() {
+	public final Mono<List<T>> collectSortedList() {
 		return collectSortedList(null);
 	}
 
@@ -2851,7 +2850,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a {@link Mono} of a sorted {@link List} of all values from this {@link Flux}
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public final Mono<@NonNull List<@NonNull T>> collectSortedList(@Nullable Comparator<? super @NonNull T> comparator) {
+	public final Mono<List<T>> collectSortedList(@Nullable Comparator<? super T> comparator) {
 		return collectList().map(list -> {
 			// Note: this assumes the list emitted by buffer() is mutable
 			if (comparator != null) {
@@ -2880,7 +2879,7 @@ public final T blockLast(Duration timeout) {
 	 * @see #transform  transform() for immmediate transformation of {@link Flux}
 	 * @see #as as() for a loose conversion to an arbitrary type
 	 */
-	public final <V> Flux<@NonNull V> compose(Function<? super @NonNull Flux<@NonNull T>, ? extends @NonNull Publisher<@NonNull V>> transformer) {
+	public final <V> Flux<V> compose(Function<? super Flux<T>, ? extends Publisher<V>> transformer) {
 		return defer(() -> transformer.apply(this));
 	}
 
@@ -2912,7 +2911,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a concatenated {@link Flux}
 	 */
-	public final <V> Flux<@NonNull V> concatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull V>>
+	public final <V> Flux<V> concatMap(Function<? super T, ? extends Publisher<? extends V>>
 			mapper) {
 		return concatMap(mapper, Queues.XS_BUFFER_SIZE);
 	}
@@ -2947,7 +2946,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a concatenated {@link Flux}
 	 */
-	public final <V> Flux<@NonNull V> concatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull V>>
+	public final <V> Flux<V> concatMap(Function<? super T, ? extends Publisher<? extends V>>
 			mapper, int prefetch) {
 		return onAssembly(new FluxConcatMap<>(this, mapper, Queues.get(prefetch), prefetch,
 				FluxConcatMap.ErrorMode.IMMEDIATE));
@@ -2983,7 +2982,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a concatenated {@link Flux}
 	 *
 	 */
-	public final <V> Flux<@NonNull V> concatMapDelayError(Function<? super @NonNull T, @NonNull Publisher<? extends @NonNull V>> mapper) {
+	public final <V> Flux<V> concatMapDelayError(Function<? super T, Publisher<? extends V>> mapper) {
 		return concatMapDelayError(mapper, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -3019,8 +3018,8 @@ public final T blockLast(Duration timeout) {
 	 * @return a concatenated {@link Flux}
 	 *
 	 */
-	public final <V> Flux<@NonNull V> concatMapDelayError(Function<? super @NonNull T, ? extends @NonNull Publisher<?
-			extends @NonNull V>> mapper, int prefetch) {
+	public final <V> Flux<V> concatMapDelayError(Function<? super T, ? extends Publisher<?
+			extends V>> mapper, int prefetch) {
 		return onAssembly(new FluxConcatMap<>(this, mapper, Queues.get(prefetch), prefetch,
 				FluxConcatMap.ErrorMode.BOUNDARY));
 	}
@@ -3060,8 +3059,8 @@ public final T blockLast(Duration timeout) {
 	 * @return a concatenated {@link Flux}
 	 *
 	 */
-	public final <V> Flux<@NonNull V> concatMapDelayError(Function<? super @NonNull T, ? extends @NonNull Publisher<?
-			extends @NonNull V>> mapper, boolean delayUntilEnd, int prefetch) {
+	public final <V> Flux<V> concatMapDelayError(Function<? super T, ? extends Publisher<?
+			extends V>> mapper, boolean delayUntilEnd, int prefetch) {
 		return onAssembly(new FluxConcatMap<>(this, mapper, Queues.get(prefetch), prefetch,
 				delayUntilEnd ? FluxConcatMap.ErrorMode.END : FluxConcatMap.ErrorMode
 						.BOUNDARY));
@@ -3084,7 +3083,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a concatenation of the values from the Iterables obtained from each element in this {@link Flux}
 	 */
-	public final <R> Flux<@NonNull R> concatMapIterable(Function<? super @NonNull T, ? extends @NonNull Iterable<? extends @NonNull R>> mapper) {
+	public final <R> Flux<R> concatMapIterable(Function<? super T, ? extends Iterable<? extends R>> mapper) {
 		return concatMapIterable(mapper, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -3106,7 +3105,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a concatenation of the values from the Iterables obtained from each element in this {@link Flux}
 	 */
-	public final <R> Flux<@NonNull R> concatMapIterable(Function<? super @NonNull T, ? extends @NonNull Iterable<? extends @NonNull R>> mapper,
+	public final <R> Flux<R> concatMapIterable(Function<? super T, ? extends Iterable<? extends R>> mapper,
 			int prefetch) {
 		return onAssembly(new FluxFlattenIterable<>(this, mapper, prefetch,
 				Queues.get(prefetch)));
@@ -3122,7 +3121,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a concatenated {@link Flux}
 	 */
-	public final Flux<@NonNull T> concatWith(Publisher<? extends @NonNull T> other) {
+	public final Flux<T> concatWith(Publisher<? extends T> other) {
 		if (this instanceof FluxConcatArray) {
 			@SuppressWarnings({ "unchecked" })
 			FluxConcatArray<T> fluxConcatArray = (FluxConcatArray<T>) this;
@@ -3141,7 +3140,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a new {@link Mono} of {@link Long} count
 	 */
-	public final Mono<@NonNull Long> count() {
+	public final Mono<Long> count() {
 		return Mono.onAssembly(new MonoCount<>(this));
 	}
 
@@ -3154,7 +3153,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public final Flux<@NonNull T> defaultIfEmpty(T defaultV) {
+	public final Flux<T> defaultIfEmpty(T defaultV) {
 		return onAssembly(new FluxDefaultIfEmpty<>(this, defaultV));
 	}
 
@@ -3171,7 +3170,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a delayed {@link Flux}
 	 * @see #delaySubscription(Duration) delaySubscription to introduce a delay at the beginning of the sequence only
 	 */
-	public final Flux<@NonNull T> delayElements(Duration delay) {
+	public final Flux<T> delayElements(Duration delay) {
 		return delayElements(delay, Schedulers.parallel());
 	}
 
@@ -3187,7 +3186,7 @@ public final T blockLast(Duration timeout) {
 	 * @param timer a time-capable {@link Scheduler} instance to delay each signal on
 	 * @return a delayed {@link Flux}
 	 */
-	public final Flux<@NonNull T> delayElements(Duration delay, Scheduler timer) {
+	public final Flux<T> delayElements(Duration delay, Scheduler timer) {
 		return delayUntil(d -> Mono.delay(delay, timer));
 	}
 
@@ -3210,7 +3209,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return this Flux, but with elements delayed until their derived publisher terminates.
 	 */
-	public final Flux<@NonNull T> delayUntil(Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull ?>> triggerProvider) {
+	public final Flux<T> delayUntil(Function<? super T, ? extends Publisher<?>> triggerProvider) {
 		return concatMap(v -> Mono.just(v)
 		                          .delayUntil(triggerProvider));
 	}
@@ -3228,7 +3227,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a delayed {@link Flux}
 	 *
 	 */
-	public final Flux<@NonNull T> delaySubscription(Duration delay) {
+	public final Flux<T> delaySubscription(Duration delay) {
 		return delaySubscription(delay, Schedulers.parallel());
 	}
 
@@ -3244,7 +3243,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a delayed {@link Flux}
 	 */
-	public final Flux<@NonNull T> delaySubscription(Duration delay, Scheduler timer) {
+	public final Flux<T> delaySubscription(Duration delay, Scheduler timer) {
 		return delaySubscription(Mono.delay(delay, timer));
 	}
 
@@ -3261,7 +3260,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a delayed {@link Flux}
 	 *
 	 */
-	public final <U> Flux<@NonNull T> delaySubscription(Publisher<@NonNull U> subscriptionDelay) {
+	public final <U> Flux<T> delaySubscription(Publisher<U> subscriptionDelay) {
 		return onAssembly(new FluxDelaySubscription<>(this, subscriptionDelay));
 	}
 
@@ -3280,7 +3279,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a dematerialized {@link Flux}
 	 * @see #materialize()
 	 */
-	public final <X> Flux<@NonNull X> dematerialize() {
+	public final <X> Flux<X> dematerialize() {
 		@SuppressWarnings("unchecked")
 		Flux<Signal<X>> thiz = (Flux<Signal<X>>) this;
 		return onAssembly(new FluxDematerialize<>(thiz));
@@ -3295,7 +3294,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a filtering {@link Flux} only emitting distinct values
 	 */
-	public final Flux<@NonNull T> distinct() {
+	public final Flux<T> distinct() {
 		return distinct(hashcodeSupplier());
 	}
 
@@ -3312,7 +3311,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a filtering {@link Flux} only emitting values with distinct keys
 	 */
-	public final <V> Flux<@NonNull T> distinct(Function<? super @NonNull T, ? extends @NonNull V> keySelector) {
+	public final <V> Flux<T> distinct(Function<? super T, ? extends V> keySelector) {
 		return distinct(keySelector, hashSetSupplier());
 	}
 
@@ -3334,9 +3333,9 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a filtering {@link Flux} only emitting values with distinct keys
 	 */
-	public final <V, C extends Collection<? super V>> Flux<@NonNull T> distinct(
-			Function<? super @NonNull T, ? extends @NonNull V> keySelector,
-			Supplier<@NonNull C> distinctCollectionSupplier) {
+	public final <V, C extends Collection<? super V>> Flux<T> distinct(
+			Function<? super T, ? extends V> keySelector,
+			Supplier<C> distinctCollectionSupplier) {
 		if (this instanceof Fuseable) {
 			return onAssembly(new FluxDistinctFuseable<>(this, keySelector,
 					distinctCollectionSupplier));
@@ -3354,7 +3353,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a filtering {@link Flux} with only one occurrence in a row of each element
 	 * (yet elements can repeat in the overall sequence)
 	 */
-	public final Flux<@NonNull T> distinctUntilChanged() {
+	public final Flux<T> distinctUntilChanged() {
 		return distinctUntilChanged(hashcodeSupplier());
 	}
 
@@ -3373,7 +3372,7 @@ public final T blockLast(Duration timeout) {
 	 * @return a filtering {@link Flux} with only one occurrence in a row of each element of
 	 * the same key (yet element keys can repeat in the overall sequence)
 	 */
-	public final <V> Flux<@NonNull T> distinctUntilChanged(Function<? super @NonNull T, ? extends @NonNull V> keySelector) {
+	public final <V> Flux<T> distinctUntilChanged(Function<? super T, ? extends V> keySelector) {
 		return distinctUntilChanged(keySelector, equalPredicate());
 	}
 
@@ -3393,8 +3392,8 @@ public final T blockLast(Duration timeout) {
 	 * of the same key for which the predicate returns true (yet element keys can repeat
 	 * in the overall sequence)
 	 */
-	public final <V> Flux<@NonNull T> distinctUntilChanged(Function<? super @NonNull T, ? extends @NonNull V> keySelector,
-			BiPredicate<? super @NonNull V, ? super @NonNull V> keyComparator) {
+	public final <V> Flux<T> distinctUntilChanged(Function<? super T, ? extends V> keySelector,
+			BiPredicate<? super V, ? super V> keyComparator) {
 		return onAssembly(new FluxDistinctUntilChanged<>(this,
 				keySelector,
 				keyComparator));
@@ -3409,7 +3408,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return an observed  {@link Flux}
 	 */
-	public final Flux<@NonNull T> doAfterTerminate(Runnable afterTerminate) {
+	public final Flux<T> doAfterTerminate(Runnable afterTerminate) {
 		Objects.requireNonNull(afterTerminate, "afterTerminate");
 		return doOnSignal(this, null, null, null, null, afterTerminate, null, null);
 	}
@@ -3423,7 +3422,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return an observed  {@link Flux}
 	 */
-	public final Flux<@NonNull T> doOnCancel(Runnable onCancel) {
+	public final Flux<T> doOnCancel(Runnable onCancel) {
 		Objects.requireNonNull(onCancel, "onCancel");
 		return doOnSignal(this, null, null, null, null, null, null, onCancel);
 	}
@@ -3437,7 +3436,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return an observed  {@link Flux}
 	 */
-	public final Flux<@NonNull T> doOnComplete(Runnable onComplete) {
+	public final Flux<T> doOnComplete(Runnable onComplete) {
 		Objects.requireNonNull(onComplete, "onComplete");
 		return doOnSignal(this, null, null, null, onComplete, null, null, null);
 	}
@@ -3458,7 +3457,7 @@ public final T blockLast(Duration timeout) {
 	 * @see #materialize()
 	 * @see Signal
 	 */
-	public final Flux<@NonNull T> doOnEach(Consumer<? super @NonNull Signal<T>> signalConsumer) {
+	public final Flux<T> doOnEach(Consumer<? super Signal<T>> signalConsumer) {
 		return onAssembly(new FluxDoOnEach<>(this, signalConsumer));
 	}
 
@@ -3471,7 +3470,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return an observed  {@link Flux}
 	 */
-	public final Flux<@NonNull T> doOnError(Consumer<? super @NonNull Throwable> onError) {
+	public final Flux<T> doOnError(Consumer<? super Throwable> onError) {
 		Objects.requireNonNull(onError, "onError");
 		return doOnSignal(this, null, null, onError, null, null, null, null);
 	}
@@ -3488,8 +3487,8 @@ public final T blockLast(Duration timeout) {
 	 * @return an observed  {@link Flux}
 	 *
 	 */
-	public final <E extends Throwable> Flux<@NonNull T> doOnError(Class<E> exceptionType,
-			final Consumer<? super @NonNull E> onError) {
+	public final <E extends Throwable> Flux<T> doOnError(Class<E> exceptionType,
+			final Consumer<? super E> onError) {
 		Objects.requireNonNull(exceptionType, "type");
 		@SuppressWarnings("unchecked")
 		Consumer<Throwable> handler = (Consumer<Throwable>)onError;
@@ -3507,8 +3506,8 @@ public final T blockLast(Duration timeout) {
 	 * @return an observed  {@link Flux}
 	 *
 	 */
-	public final Flux<@NonNull T> doOnError(Predicate<? super @NonNull Throwable> predicate,
-			final Consumer<? super @NonNull Throwable> onError) {
+	public final Flux<T> doOnError(Predicate<? super Throwable> predicate,
+			final Consumer<? super Throwable> onError) {
 		Objects.requireNonNull(predicate, "predicate");
 		return doOnError(t -> {
 			if (predicate.test(t)) {
@@ -3526,7 +3525,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return an observed  {@link Flux}
 	 */
-	public final Flux<@NonNull T> doOnNext(Consumer<? super @NonNull T> onNext) {
+	public final Flux<T> doOnNext(Consumer<? super T> onNext) {
 		Objects.requireNonNull(onNext, "onNext");
 		return doOnSignal(this, null, onNext, null, null, null, null, null);
 	}
@@ -3545,7 +3544,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return an observed  {@link Flux}
 	 */
-	public final Flux<@NonNull T> doOnRequest(LongConsumer consumer) {
+	public final Flux<T> doOnRequest(LongConsumer consumer) {
 		Objects.requireNonNull(consumer, "consumer");
 		return doOnSignal(this, null, null, null, null, null, consumer, null);
 	}
@@ -3559,7 +3558,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return an observed  {@link Flux}
 	 */
-	public final Flux<@NonNull T> doOnSubscribe(Consumer<? super @NonNull Subscription> onSubscribe) {
+	public final Flux<T> doOnSubscribe(Consumer<? super Subscription> onSubscribe) {
 		Objects.requireNonNull(onSubscribe, "onSubscribe");
 		return doOnSignal(this, onSubscribe, null, null, null, null, null, null);
 	}
@@ -3574,7 +3573,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return an observed  {@link Flux}
 	 */
-	public final Flux<@NonNull T> doOnTerminate(Runnable onTerminate) {
+	public final Flux<T> doOnTerminate(Runnable onTerminate) {
 		Objects.requireNonNull(onTerminate, "onTerminate");
 		return doOnSignal(this,
 				null,
@@ -3602,7 +3601,7 @@ public final T blockLast(Duration timeout) {
 	 * or cancel)
 	 * @return an observed {@link Flux}
 	 */
-	public final Flux<@NonNull T> doFinally(Consumer<@NonNull SignalType> onFinally) {
+	public final Flux<T> doFinally(Consumer<SignalType> onFinally) {
 		Objects.requireNonNull(onFinally, "onFinally");
 		if (this instanceof Fuseable) {
 			return onAssembly(new FluxDoFinallyFuseable<>(this, onFinally));
@@ -3621,7 +3620,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a new {@link Flux} that emits a tuple of time elapsed in milliseconds and matching data
 	 */
-	public final Flux<@NonNull Tuple2<@NonNull Long, @NonNull T>> elapsed() {
+	public final Flux<Tuple2<Long, T>> elapsed() {
 		return elapsed(Schedulers.parallel());
 	}
 
@@ -3638,7 +3637,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a new {@link Flux} that emits tuples of time elapsed in milliseconds and matching data
 	 */
-	public final Flux<@NonNull Tuple2<@NonNull Long, @NonNull T>> elapsed(Scheduler scheduler) {
+	public final Flux<Tuple2<Long, T>> elapsed(Scheduler scheduler) {
 		Objects.requireNonNull(scheduler, "scheduler");
 		return onAssembly(new FluxElapsed<>(this, scheduler));
 	}
@@ -3654,7 +3653,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a {@link Mono} of the item at the specified zero-based index
 	 */
-	public final Mono<@NonNull T> elementAt(int index) {
+	public final Mono<T> elementAt(int index) {
 		return Mono.onAssembly(new MonoElementAt<>(this, index));
 	}
 
@@ -3670,7 +3669,7 @@ public final T blockLast(Duration timeout) {
 	 *
 	 * @return a {@link Mono} of the item at the specified zero-based index or a default value
 	 */
-	public final Mono<@NonNull T> elementAt(int index, T defaultValue) {
+	public final Mono<T> elementAt(int index, T defaultValue) {
 		return Mono.onAssembly(new MonoElementAt<>(this, index, defaultValue));
 	}
 
@@ -3839,7 +3838,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a new {@link Flux} containing only values that pass the predicate test
 	 */
-	public final Flux<@NonNull T> filter(Predicate<? super @NonNull T> p) {
+	public final Flux<T> filter(Predicate<? super T> p) {
 		if (this instanceof Fuseable) {
 			return onAssembly(new FluxFilterFuseable<>(this, p));
 		}
@@ -3860,7 +3859,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 * for each value, to filter the Flux with
 	 * @return a filtered {@link Flux}
 	 */
-	public final Flux<@NonNull T> filterWhen(Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull Boolean>> asyncPredicate) {
+	public final Flux<T> filterWhen(Function<? super T, ? extends Publisher<Boolean>> asyncPredicate) {
 		return filterWhen(asyncPredicate, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -3883,7 +3882,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 * the initial request size for the source.
 	 * @return a filtered {@link Flux}
 	 */
-	public final Flux<@NonNull T> filterWhen(Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull Boolean>> asyncPredicate,
+	public final Flux<T> filterWhen(Function<? super T, ? extends Publisher<Boolean>> asyncPredicate,
 			int bufferSize) {
 		return onAssembly(new FluxFilterWhen<>(this, asyncPredicate, bufferSize));
 	}
@@ -3911,7 +3910,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public final <R> Flux<@NonNull R> flatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper) {
+	public final <R> Flux<R> flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper) {
 		return flatMap(mapper, Queues.SMALL_BUFFER_SIZE, Queues
 				.XS_BUFFER_SIZE);
 	}
@@ -3943,7 +3942,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public final <V> Flux<@NonNull V> flatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull V>> mapper, int
+	public final <V> Flux<V> flatMap(Function<? super T, ? extends Publisher<? extends V>> mapper, int
 			concurrency) {
 		return flatMap(mapper, concurrency, Queues.XS_BUFFER_SIZE);
 	}
@@ -3977,7 +3976,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a merged {@link Flux}
 	 */
-	public final <V> Flux<@NonNull V> flatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull V>> mapper, int
+	public final <V> Flux<V> flatMap(Function<? super T, ? extends Publisher<? extends V>> mapper, int
 			concurrency, int prefetch) {
 		return flatMap(mapper, false, concurrency, prefetch);
 	}
@@ -4012,7 +4011,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a merged {@link Flux}
 	 */
-	public final <V> Flux<@NonNull V> flatMapDelayError(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull V>> mapper,
+	public final <V> Flux<V> flatMapDelayError(Function<? super T, ? extends Publisher<? extends V>> mapper,
 			int concurrency, int prefetch) {
 		return flatMap(mapper, true, concurrency, prefetch);
 	}
@@ -4048,10 +4047,10 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public final <R> Flux<@NonNull R> flatMap(
-			@Nullable Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapperOnNext,
-			@Nullable Function<? super @NonNull Throwable, ? extends @NonNull Publisher<? extends @NonNull R>> mapperOnError,
-			@Nullable Supplier<? extends @NonNull Publisher<? extends @NonNull R>> mapperOnComplete) {
+	public final <R> Flux<R> flatMap(
+			@Nullable Function<? super T, ? extends Publisher<? extends R>> mapperOnNext,
+			@Nullable Function<? super Throwable, ? extends Publisher<? extends R>> mapperOnError,
+			@Nullable Supplier<? extends Publisher<? extends R>> mapperOnComplete) {
 		return onAssembly(new FluxFlatMap<>(
 				new FluxMapSignal<>(this, mapperOnNext, mapperOnError, mapperOnComplete),
 				identityFunction(),
@@ -4078,7 +4077,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a concatenation of the values from the Iterables obtained from each element in this {@link Flux}
 	 */
-	public final <R> Flux<@NonNull R> flatMapIterable(Function<? super @NonNull T, ? extends @NonNull Iterable<? extends @NonNull R>> mapper) {
+	public final <R> Flux<R> flatMapIterable(Function<? super T, ? extends Iterable<? extends R>> mapper) {
 		return flatMapIterable(mapper, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -4101,7 +4100,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a concatenation of the values from the Iterables obtained from each element in this {@link Flux}
 	 */
-	public final <R> Flux<@NonNull R> flatMapIterable(Function<? super @NonNull T, ? extends @NonNull Iterable<? extends @NonNull R>> mapper, int prefetch) {
+	public final <R> Flux<R> flatMapIterable(Function<? super T, ? extends Iterable<? extends R>> mapper, int prefetch) {
 		return onAssembly(new FluxFlattenIterable<>(this, mapper, prefetch,
 				Queues.get(prefetch)));
 	}
@@ -4138,8 +4137,8 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public final <R> Flux<@NonNull R> flatMapSequential(Function<? super @NonNull T, ? extends
-            @NonNull Publisher<? extends @NonNull R>> mapper) {
+	public final <R> Flux<R> flatMapSequential(Function<? super T, ? extends
+			Publisher<? extends R>> mapper) {
 		return flatMapSequential(mapper, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -4179,8 +4178,8 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public final <R> Flux<@NonNull R> flatMapSequential(Function<? super @NonNull T, ? extends
-            @NonNull Publisher<? extends @NonNull R>> mapper, int maxConcurrency) {
+	public final <R> Flux<R> flatMapSequential(Function<? super T, ? extends
+			Publisher<? extends R>> mapper, int maxConcurrency) {
 		return flatMapSequential(mapper, maxConcurrency, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -4223,8 +4222,8 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public final <R> Flux<@NonNull R> flatMapSequential(Function<? super @NonNull T, ? extends
-            @NonNull Publisher<? extends @NonNull R>> mapper, int maxConcurrency, int prefetch) {
+	public final <R> Flux<R> flatMapSequential(Function<? super T, ? extends
+			Publisher<? extends R>> mapper, int maxConcurrency, int prefetch) {
 		return flatMapSequential(mapper, false, maxConcurrency, prefetch);
 	}
 
@@ -4268,8 +4267,8 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a merged {@link Flux}, subscribing early but keeping the original ordering
 	 */
-	public final <R> Flux<@NonNull R> flatMapSequentialDelayError(Function<? super @NonNull T, ? extends
-            @NonNull Publisher<? extends @NonNull R>> mapper, int maxConcurrency, int prefetch) {
+	public final <R> Flux<R> flatMapSequentialDelayError(Function<? super T, ? extends
+			Publisher<? extends R>> mapper, int maxConcurrency, int prefetch) {
 		return flatMapSequential(mapper, true, maxConcurrency, prefetch);
 	}
 
@@ -4301,7 +4300,7 @@ public int getPrefetch() {
 	 *
 	 * @return a {@link Flux} of {@link GroupedFlux} grouped sequences
 	 */
-	public final <K> Flux<@NonNull GroupedFlux<@NonNull K, @NonNull T>> groupBy(Function<? super @NonNull T, ? extends @NonNull K> keyMapper) {
+	public final <K> Flux<GroupedFlux<K, T>> groupBy(Function<? super T, ? extends K> keyMapper) {
 		return groupBy(keyMapper, identityFunction());
 	}
 
@@ -4326,7 +4325,7 @@ public int getPrefetch() {
 	 *
 	 * @return a {@link Flux} of {@link GroupedFlux} grouped sequences
 	 */
-	public final <K> Flux<@NonNull GroupedFlux<@NonNull K, @NonNull T>> groupBy(Function<? super @NonNull T, ? extends @NonNull K> keyMapper, int prefetch) {
+	public final <K> Flux<GroupedFlux<K, T>> groupBy(Function<? super T, ? extends K> keyMapper, int prefetch) {
 		return groupBy(keyMapper, identityFunction(), prefetch);
 	}
 
@@ -4354,8 +4353,8 @@ public int getPrefetch() {
 	 * @return a {@link Flux} of {@link GroupedFlux} grouped sequences
 	 *
 	 */
-	public final <K, V> Flux<@NonNull GroupedFlux<@NonNull K, @NonNull V>> groupBy(Function<? super @NonNull T, ? extends @NonNull K> keyMapper,
-			Function<? super @NonNull T, ? extends @NonNull V> valueMapper) {
+	public final <K, V> Flux<GroupedFlux<K, V>> groupBy(Function<? super T, ? extends K> keyMapper,
+			Function<? super T, ? extends V> valueMapper) {
 		return groupBy(keyMapper, valueMapper, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -4385,8 +4384,8 @@ public int getPrefetch() {
 	 * @return a {@link Flux} of {@link GroupedFlux} grouped sequences
 	 *
 	 */
-	public final <K, V> Flux<@NonNull GroupedFlux<@NonNull K, @NonNull V>> groupBy(Function<? super @NonNull T, ? extends @NonNull K> keyMapper,
-			Function<? super @NonNull T, ? extends @NonNull V> valueMapper, int prefetch) {
+	public final <K, V> Flux<GroupedFlux<K, V>> groupBy(Function<? super T, ? extends K> keyMapper,
+			Function<? super T, ? extends V> valueMapper, int prefetch) {
 		return onAssembly(new FluxGroupBy<>(this, keyMapper, valueMapper,
 				Queues.unbounded(prefetch),
 				Queues.unbounded(prefetch), prefetch));
@@ -4423,11 +4422,11 @@ public int getPrefetch() {
 	 * @return a joining {@link Flux}
 	 * @see #join(Publisher, Function, Function, BiFunction)
 	 */
-	public final <TRight, TLeftEnd, TRightEnd, R> Flux<@NonNull R> groupJoin(
-			Publisher<? extends @NonNull TRight> other,
-			Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull TLeftEnd>> leftEnd,
-			Function<? super @NonNull TRight, ? extends @NonNull Publisher<@NonNull TRightEnd>> rightEnd,
-			BiFunction<? super @NonNull T, ? super @NonNull Flux<@NonNull TRight>, ? extends @NonNull R> resultSelector
+	public final <TRight, TLeftEnd, TRightEnd, R> Flux<R> groupJoin(
+			Publisher<? extends TRight> other,
+			Function<? super T, ? extends Publisher<TLeftEnd>> leftEnd,
+			Function<? super TRight, ? extends Publisher<TRightEnd>> rightEnd,
+			BiFunction<? super T, ? super Flux<TRight>, ? extends R> resultSelector
 	) {
 		return onAssembly(new FluxGroupJoin<T, TRight, TLeftEnd, TRightEnd, R>(
 				this, other, leftEnd, rightEnd, resultSelector,
@@ -4446,7 +4445,7 @@ public int getPrefetch() {
 	 *
 	 * @return a transformed {@link Flux}
 	 */
-	public final <R> Flux<R> handle(BiConsumer<? super @NonNull T, SynchronousSink<@NonNull R>> handler) {
+	public final <R> Flux<R> handle(BiConsumer<? super T, SynchronousSink<R>> handler) {
 		if (this instanceof Fuseable) {
 			return onAssembly(new FluxHandleFuseable<>(this, handler));
 		}
@@ -4540,11 +4539,11 @@ public final Mono<T> ignoreElements() {
 	 * @return a joining {@link Flux}
 	 * @see #groupJoin(Publisher, Function, Function, BiFunction)
 	 */
-	public final <TRight, TLeftEnd, TRightEnd, R> Flux<@NonNull R> join(
-			Publisher<? extends @NonNull TRight> other,
-			Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull TLeftEnd>> leftEnd,
-			Function<? super @NonNull TRight, ? extends @NonNull Publisher<@NonNull TRightEnd>> rightEnd,
-			BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector
+	public final <TRight, TLeftEnd, TRightEnd, R> Flux<R> join(
+			Publisher<? extends TRight> other,
+			Function<? super T, ? extends Publisher<TLeftEnd>> leftEnd,
+			Function<? super TRight, ? extends Publisher<TRightEnd>> rightEnd,
+			BiFunction<? super T, ? super TRight, ? extends R> resultSelector
 	) {
 		return onAssembly(new FluxJoin<T, TRight, TLeftEnd, TRightEnd, R>(
 				this, other, leftEnd, rightEnd, resultSelector, Queues
@@ -4561,7 +4560,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a {@link Mono} with the last value in this {@link Flux}
 	 */
-    public final Mono<@NonNull T> last() {
+    public final Mono<T> last() {
 	    if (this instanceof Callable) {
 		    @SuppressWarnings("unchecked")
 		    Callable<T> thiz = (Callable<T>)this;
@@ -4580,7 +4579,7 @@ public final Mono<T> ignoreElements() {
 	 * @param defaultValue  a single fallback item if this {@link Flux} is empty
 	 * @return a {@link Mono} with the last value in this {@link Flux}
 	 */
-    public final Mono<@NonNull T> last(T defaultValue) {
+    public final Mono<T> last(T defaultValue) {
 	    if (this instanceof Callable) {
 		    @SuppressWarnings("unchecked")
 		    Callable<T> thiz = (Callable<T>)this;
@@ -4611,7 +4610,7 @@ public final Mono<T> ignoreElements() {
 	 * <p>
 	 * Typically used for scenarios where consumer(s) request a large amount of data
 	 * (eg. {@code Long.MAX_VALUE}) but the data source behaves better or can be optimized
-	 * with smaller requests (eg. database paging, etc ...). All data is still processed.
+	 * with smaller requests (eg. database paging, etc...). All data is still processed.
 	 * <p>
 	 * Equivalent to {@code flux.publishOn(Schedulers.immediate(), prefetchRate).subscribe() }
 	 *
@@ -4620,7 +4619,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a {@link Flux} limiting downstream's backpressure
 	 * @see #publishOn(Scheduler, int)
 	 */
-	public final Flux<@NonNull T> limitRate(int prefetchRate) {
+	public final Flux<T> limitRate(int prefetchRate) {
 		return onAssembly(this.publishOn(Schedulers.immediate(), prefetchRate));
 	}
 
@@ -4636,7 +4635,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new {@link Flux} that logs signals
 	 */
-	public final Flux<@NonNull T> log() {
+	public final Flux<T> log() {
 		return log(null, Level.INFO);
 	}
 
@@ -4653,7 +4652,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new {@link Flux} that logs signals
 	 */
-	public final Flux<@NonNull T> log(String category) {
+	public final Flux<T> log(String category) {
 		return log(category, Level.INFO);
 	}
 
@@ -4678,7 +4677,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new {@link Flux} that logs signals
 	 */
-	public final Flux<@NonNull T> log(@Nullable String category, Level level, SignalType @NonNull ... options) {
+	public final Flux<T> log(@Nullable String category, Level level, SignalType... options) {
 		return log(category, level, false, options);
 	}
 
@@ -4705,10 +4704,10 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new {@link Flux} that logs signals
 	 */
-	public final Flux<@NonNull T> log(@Nullable String category,
+	public final Flux<T> log(@Nullable String category,
 			Level level,
 			boolean showOperatorLine,
-			SignalType @NonNull ... options) {
+			SignalType... options) {
 		SignalLogger<T> log = new SignalLogger<>(this, category, level,
 				showOperatorLine, options);
 
@@ -4729,7 +4728,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a transformed {@link Flux}
 	 */
-	public final <V> Flux<@NonNull V> map(Function<? super @NonNull T, ? extends @NonNull V> mapper) {
+	public final <V> Flux<V> map(Function<? super T, ? extends V> mapper) {
 		if (this instanceof Fuseable) {
 			return onAssembly(new FluxMapFuseable<>(this, mapper));
 		}
@@ -4748,7 +4747,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a {@link Flux} of materialized {@link Signal}
 	 * @see #dematerialize()
 	 */
-	public final Flux<@NonNull Signal<@NonNull T>> materialize() {
+	public final Flux<Signal<T>> materialize() {
 		return onAssembly(new FluxMaterialize<>(this));
 	}
 
@@ -4768,7 +4767,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public final Flux<@NonNull T> mergeWith(Publisher<? extends @NonNull T> other) {
+	public final Flux<T> mergeWith(Publisher<? extends T> other) {
 		if (this instanceof FluxMerge) {
 			FluxMerge<T> fluxMerge = (FluxMerge<T>) this;
 			return fluxMerge.mergeAdditionalSource(other, Queues::get);
@@ -4783,7 +4782,7 @@ public final Mono<T> ignoreElements() {
 	 * @param name a name for the sequence
 	 * @return the same sequence, but bearing a name
 	 */
-	public final Flux<@NonNull T> name(String name) {
+	public final Flux<T> name(String name) {
 		return FluxName.createOrAppend(this, name);
 	}
 
@@ -4795,7 +4794,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new {@link Mono} emitting the first value in this {@link Flux}
 	 */
-	public final Mono<@NonNull T> next() {
+	public final Mono<T> next() {
 		if(this instanceof Callable){
 			@SuppressWarnings("unchecked")
 			Callable<T> m = (Callable<T>)this;
@@ -4816,7 +4815,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new {@link Flux} filtered on items of the requested type
 	 */
-	public final <U> Flux<@NonNull U> ofType(final Class<U> clazz) {
+	public final <U> Flux<U> ofType(final Class<U> clazz) {
 			Objects.requireNonNull(clazz, "clazz");
 			return filter(o -> clazz.isAssignableFrom(o.getClass())).cast(clazz);
 	}
@@ -4832,7 +4831,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a backpressured {@link Flux} that buffers with unbounded capacity
 	 *
 	 */
-	public final Flux<@NonNull T> onBackpressureBuffer() {
+	public final Flux<T> onBackpressureBuffer() {
 		return onAssembly(new FluxOnBackpressureBuffer<>(this, Queues
 				.SMALL_BUFFER_SIZE, true, null));
 	}
@@ -4850,7 +4849,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a backpressured {@link Flux} that buffers with bounded capacity
 	 *
 	 */
-	public final Flux<@NonNull T> onBackpressureBuffer(int maxSize) {
+	public final Flux<T> onBackpressureBuffer(int maxSize) {
 		return onAssembly(new FluxOnBackpressureBuffer<>(this, maxSize, false, null));
 	}
 
@@ -4869,7 +4868,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a backpressured {@link Flux} that buffers with a bounded capacity
 	 *
 	 */
-	public final Flux<@NonNull T> onBackpressureBuffer(int maxSize, Consumer<? super @NonNull T> onOverflow) {
+	public final Flux<T> onBackpressureBuffer(int maxSize, Consumer<? super T> onOverflow) {
 		Objects.requireNonNull(onOverflow, "onOverflow");
 		return onAssembly(new FluxOnBackpressureBuffer<>(this, maxSize, false, onOverflow));
 	}
@@ -4891,7 +4890,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a backpressured {@link Flux} that buffers up to a capacity then applies an
 	 * overflow strategy
 	 */
-	public final Flux<@NonNull T> onBackpressureBuffer(int maxSize, BufferOverflowStrategy bufferOverflowStrategy) {
+	public final Flux<T> onBackpressureBuffer(int maxSize, BufferOverflowStrategy bufferOverflowStrategy) {
 		Objects.requireNonNull(bufferOverflowStrategy, "bufferOverflowStrategy");
 		return onAssembly(new FluxOnBackpressureBufferStrategy<>(this, maxSize,
 				null, bufferOverflowStrategy));
@@ -4922,7 +4921,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a backpressured {@link Flux} that buffers up to a capacity then applies an
 	 * overflow strategy
 	 */
-	public final Flux<@NonNull T> onBackpressureBuffer(int maxSize, Consumer<? super @NonNull T> onBufferOverflow,
+	public final Flux<T> onBackpressureBuffer(int maxSize, Consumer<? super T> onBufferOverflow,
 			BufferOverflowStrategy bufferOverflowStrategy) {
 		Objects.requireNonNull(onBufferOverflow, "onBufferOverflow");
 		Objects.requireNonNull(bufferOverflowStrategy, "bufferOverflowStrategy");
@@ -4950,7 +4949,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a backpressured {@link Flux} that buffers with a TTL and up to a capacity then applies an
 	 * overflow strategy
 	 */
-	public final Flux<@NonNull T> onBackpressureBuffer(Duration ttl, int maxSize, Consumer<? super @NonNull T> onBufferEviction) {
+	public final Flux<T> onBackpressureBuffer(Duration ttl, int maxSize, Consumer<? super T> onBufferEviction) {
 		return onBackpressureBuffer(ttl, maxSize, onBufferEviction, Schedulers.parallel());
 	}
 
@@ -4974,7 +4973,7 @@ public final Mono<T> ignoreElements() {
 	 * @return a backpressured {@link Flux} that buffers with a TTL and up to a capacity then applies an
 	 * overflow strategy
 	 */
-	public final Flux<@NonNull T> onBackpressureBuffer(Duration ttl, int maxSize, Consumer<? super @NonNull T> onBufferEviction, Scheduler scheduler) {
+	public final Flux<T> onBackpressureBuffer(Duration ttl, int maxSize, Consumer<? super T> onBufferEviction, Scheduler scheduler) {
 		Objects.requireNonNull(ttl, "ttl");
 		Objects.requireNonNull(onBufferEviction, "onBufferEviction");
 		return onAssembly(new FluxOnBackpressureBufferTimeout<>(this, ttl, scheduler, maxSize, onBufferEviction));
@@ -4989,7 +4988,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a backpressured {@link Flux} that drops overflowing elements
 	 */
-	public final Flux<@NonNull T> onBackpressureDrop() {
+	public final Flux<T> onBackpressureDrop() {
 		return onAssembly(new FluxOnBackpressureDrop<>(this));
 	}
 
@@ -5004,7 +5003,7 @@ public final Mono<T> ignoreElements() {
 	 * @param onDropped the Consumer called when an value gets dropped due to lack of downstream requests
 	 * @return a backpressured {@link Flux} that drops overflowing elements
 	 */
-	public final Flux<@NonNull T> onBackpressureDrop(Consumer<? super @NonNull T> onDropped) {
+	public final Flux<T> onBackpressureDrop(Consumer<? super T> onDropped) {
 		return onAssembly(new FluxOnBackpressureDrop<>(this, onDropped));
 	}
 
@@ -5018,7 +5017,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a backpressured {@link Flux} that errors on overflowing elements
 	 */
-	public final Flux<@NonNull T> onBackpressureError() {
+	public final Flux<T> onBackpressureError() {
 		return onBackpressureDrop(t -> { throw Exceptions.failWithOverflow();});
 	}
 
@@ -5031,7 +5030,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a backpressured {@link Flux} that will only keep a reference to the last observed item
 	 */
-	public final Flux<@NonNull T> onBackpressureLatest() {
+	public final Flux<T> onBackpressureLatest() {
 		return onAssembly(new FluxOnBackpressureLatest<>(this));
 	}
 
@@ -5047,7 +5046,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a {@link Flux} that transforms source errors to other errors
 	 */
-	public final Flux<@NonNull T> onErrorMap(Function<? super @NonNull Throwable, ? extends @NonNull Throwable> mapper) {
+	public final Flux<T> onErrorMap(Function<? super Throwable, ? extends Throwable> mapper) {
 		return onErrorResume(e -> Mono.error(mapper.apply(e)));
 	}
 
@@ -5063,8 +5062,8 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a {@link Flux} that transforms some source errors to other errors
 	 */
-	public final <E extends Throwable> Flux<@NonNull T> onErrorMap(Class<E> type,
-			Function<? super @NonNull E, ? extends @NonNull Throwable> mapper) {
+	public final <E extends Throwable> Flux<T> onErrorMap(Class<E> type,
+			Function<? super E, ? extends Throwable> mapper) {
 		@SuppressWarnings("unchecked")
 		Function<Throwable, Throwable> handler = (Function<Throwable, Throwable>)mapper;
 		return onErrorMap(type::isInstance, handler);
@@ -5082,8 +5081,8 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a {@link Flux} that transforms some source errors to other errors
 	 */
-	public final Flux<@NonNull T> onErrorMap(Predicate<? super @NonNull Throwable> predicate,
-			Function<? super @NonNull Throwable, ? extends @NonNull Throwable> mapper) {
+	public final Flux<T> onErrorMap(Predicate<? super Throwable> predicate,
+			Function<? super Throwable, ? extends Throwable> mapper) {
 		return onErrorResume(predicate, e -> Mono.error(mapper.apply(e)));
 	}
 
@@ -5098,7 +5097,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a {@link Flux} falling back upon source onError
 	 */
-	public final Flux<@NonNull T> onErrorResume(Function<? super @NonNull Throwable, ? extends @NonNull Publisher<? extends @NonNull T>> fallback) {
+	public final Flux<T> onErrorResume(Function<? super Throwable, ? extends Publisher<? extends T>> fallback) {
 		return onAssembly(new FluxOnErrorResume<>(this, fallback));
 	}
 
@@ -5115,8 +5114,8 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a {@link Flux} falling back upon source onError
 	 */
-	public final <E extends Throwable> Flux<@NonNull T> onErrorResume(Class<E> type,
-			Function<? super @NonNull E, ? extends @NonNull Publisher<? extends @NonNull T>> fallback) {
+	public final <E extends Throwable> Flux<T> onErrorResume(Class<E> type,
+			Function<? super E, ? extends Publisher<? extends T>> fallback) {
 		Objects.requireNonNull(type, "type");
 		@SuppressWarnings("unchecked")
 		Function<? super Throwable, Publisher<? extends T>> handler = (Function<?
@@ -5136,8 +5135,8 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a {@link Flux} falling back upon source onError
 	 */
-	public final Flux<@NonNull T> onErrorResume(Predicate<? super @NonNull Throwable> predicate,
-			Function<? super @NonNull Throwable, ? extends @NonNull Publisher<? extends @NonNull T>> fallback) {
+	public final Flux<T> onErrorResume(Predicate<? super Throwable> predicate,
+			Function<? super Throwable, ? extends Publisher<? extends T>> fallback) {
 		Objects.requireNonNull(predicate, "predicate");
 		return onErrorResume(e -> predicate.test(e) ? fallback.apply(e) : error(e));
 	}
@@ -5151,7 +5150,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new falling back {@link Flux}
 	 */
-	public final Flux<@NonNull T> onErrorReturn(T fallbackValue) {
+	public final Flux<T> onErrorReturn(T fallbackValue) {
 		return onErrorResume(t -> just(fallbackValue));
 	}
 
@@ -5166,7 +5165,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new falling back {@link Flux}
 	 */
-	public final <E extends Throwable> Flux<@NonNull T> onErrorReturn(Class<E> type,
+	public final <E extends Throwable> Flux<T> onErrorReturn(Class<E> type,
 			T fallbackValue) {
 		return onErrorResume(type, t -> just(fallbackValue));
 	}
@@ -5181,7 +5180,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a new falling back {@link Flux}
 	 */
-	public final Flux<@NonNull T> onErrorReturn(Predicate<? super @NonNull Throwable> predicate, T fallbackValue) {
+	public final Flux<T> onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue) {
 		return onErrorResume(predicate, t -> just(fallbackValue));
 	}
 
@@ -5193,7 +5192,7 @@ public final Mono<T> ignoreElements() {
 	 *
 	 * @return a detachable {@link Flux}
 	 */
-	public final Flux<@NonNull T> onTerminateDetach() {
+	public final Flux<T> onTerminateDetach() {
 		return new FluxDetach<>(this);
 	}
 
@@ -5233,7 +5232,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> parallel() {
+	public final ParallelFlux<T> parallel() {
 		return parallel(Runtime.getRuntime()
 		                       .availableProcessors());
 	}
@@ -5251,7 +5250,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> parallel(int parallelism) {
+	public final ParallelFlux<T> parallel(int parallelism) {
 		return parallel(parallelism, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -5270,7 +5269,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> parallel(int parallelism, int prefetch) {
+	public final ParallelFlux<T> parallel(int parallelism, int prefetch) {
 		return ParallelFlux.from(this,
 				parallelism,
 				prefetch,
@@ -5291,7 +5290,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link ConnectableFlux}
 	 */
-	public final ConnectableFlux<@NonNull T> publish() {
+	public final ConnectableFlux<T> publish() {
 		return publish(Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -5310,7 +5309,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link ConnectableFlux}
 	 */
-	public final ConnectableFlux<@NonNull T> publish(int prefetch) {
+	public final ConnectableFlux<T> publish(int prefetch) {
 		return onAssembly(new FluxPublish<>(this, prefetch, Queues
 				.get(prefetch)));
 	}
@@ -5325,8 +5324,8 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public final <R> Flux<@NonNull R> publish(Function<? super @NonNull Flux<@NonNull T>, ? extends @NonNull Publisher<?
-			extends @NonNull R>> transform) {
+	public final <R> Flux<R> publish(Function<? super Flux<T>, ? extends Publisher<?
+			extends R>> transform) {
 		return publish(transform, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -5341,8 +5340,8 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link Flux}
 	 */
-	public final <R> Flux<@NonNull R> publish(Function<? super @NonNull Flux<T>, ? extends @NonNull Publisher<?
-			extends @NonNull R>> transform, int prefetch) {
+	public final <R> Flux<R> publish(Function<? super Flux<T>, ? extends Publisher<?
+			extends R>> transform, int prefetch) {
 		return onAssembly(new FluxPublishMulticast<>(this, transform, prefetch, Queues
 				.get(prefetch)));
 	}
@@ -5357,7 +5356,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<@NonNull T> publishNext() {
+	public final Mono<T> publishNext() {
 		return Mono.onAssembly(new MonoProcessor<>(this));
 	}
 
@@ -5379,7 +5378,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} producing asynchronously on a given {@link Scheduler}
 	 */
-	public final Flux<@NonNull T> publishOn(Scheduler scheduler) {
+	public final Flux<T> publishOn(Scheduler scheduler) {
 		return publishOn(scheduler, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -5402,7 +5401,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} producing asynchronously
 	 */
-	public final Flux<@NonNull T> publishOn(Scheduler scheduler, int prefetch) {
+	public final Flux<T> publishOn(Scheduler scheduler, int prefetch) {
 		return publishOn(scheduler, true, prefetch);
 	}
 
@@ -5426,7 +5425,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} producing asynchronously
 	 */
-	public final Flux<@NonNull T> publishOn(Scheduler scheduler, boolean delayError, int prefetch) {
+	public final Flux<T> publishOn(Scheduler scheduler, boolean delayError, int prefetch) {
 		if (this instanceof Callable) {
 			if (this instanceof Fuseable.ScalarCallable) {
 				@SuppressWarnings("unchecked")
@@ -5460,7 +5459,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a reduced {@link Flux}
 	 */
-	public final Mono<@NonNull T> reduce(BiFunction<@NonNull T, @NonNull T, @NonNull T> aggregator) {
+	public final Mono<T> reduce(BiFunction<T, T, T> aggregator) {
 		if (this instanceof Callable){
 			@SuppressWarnings("unchecked")
 			Callable<T> thiz = (Callable<T>)this;
@@ -5486,7 +5485,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a reduced {@link Flux}
 	 *
 	 */
-	public final <A> Mono<@NonNull A> reduce(A initial, BiFunction<@NonNull A, ? super @NonNull T, @NonNull A> accumulator) {
+	public final <A> Mono<A> reduce(A initial, BiFunction<A, ? super T, A> accumulator) {
 		return reduceWith(() -> initial, accumulator);
 	}
 
@@ -5507,7 +5506,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a reduced {@link Flux}
 	 *
 	 */
-	public final <A> Mono<@NonNull A> reduceWith(Supplier<@NonNull A> initial, BiFunction<@NonNull A, ? super @NonNull T, @NonNull A> accumulator) {
+	public final <A> Mono<A> reduceWith(Supplier<A> initial, BiFunction<A, ? super T, A> accumulator) {
 		return Mono.onAssembly(new MonoReduceSeed<>(this, initial, accumulator));
 	}
 
@@ -5520,7 +5519,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return an indefinitely repeated {@link Flux} on onComplete
 	 */
-	public final Flux<@NonNull T> repeat() {
+	public final Flux<T> repeat() {
 		return repeat(ALWAYS_BOOLEAN_SUPPLIER);
 	}
 
@@ -5534,7 +5533,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} that repeats on onComplete while the predicate matches
 	 */
-	public final Flux<@NonNull T> repeat(BooleanSupplier predicate) {
+	public final Flux<T> repeat(BooleanSupplier predicate) {
 		return onAssembly(new FluxRepeatPredicate<>(this, predicate));
 	}
 
@@ -5548,7 +5547,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} that repeats on onComplete, up to the specified number of repetitions
 	 */
-	public final Flux<@NonNull T> repeat(long numRepeat) {
+	public final Flux<T> repeat(long numRepeat) {
 		if(numRepeat == 0L){
 			return empty();
 		}
@@ -5568,7 +5567,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} that repeats on onComplete while the predicate matches,
 	 * up to the specified number of repetitions
 	 */
-	public final Flux<@NonNull T> repeat(long numRepeat, BooleanSupplier predicate) {
+	public final Flux<T> repeat(long numRepeat, BooleanSupplier predicate) {
 		return defer( () -> repeat(countingBooleanSupplier(predicate, numRepeat)));
 	}
 
@@ -5588,7 +5587,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} that repeats on onComplete when the companion {@link Publisher} produces an
 	 * onNext signal
 	 */
-	public final Flux<@NonNull T> repeatWhen(Function<@NonNull Flux<@NonNull Long>, ? extends @NonNull Publisher<@NonNull ?>> repeatFactory) {
+	public final Flux<T> repeatWhen(Function<Flux<Long>, ? extends Publisher<?>> repeatFactory) {
 		return onAssembly(new FluxRepeatWhen<>(this, repeatFactory));
 	}
 
@@ -5602,7 +5601,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a replaying {@link ConnectableFlux}
 	 */
-	public final ConnectableFlux<@NonNull T> replay() {
+	public final ConnectableFlux<T> replay() {
 		return replay(Integer.MAX_VALUE);
 	}
 
@@ -5624,7 +5623,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a replaying {@link ConnectableFlux}
 	 *
 	 */
-	public final ConnectableFlux<@NonNull T> replay(int history) {
+	public final ConnectableFlux<T> replay(int history) {
 		return onAssembly(new FluxReplay<>(this, history, 0L, null));
 	}
 
@@ -5644,7 +5643,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a replaying {@link ConnectableFlux}
 	 */
-	public final ConnectableFlux<@NonNull T> replay(Duration ttl) {
+	public final ConnectableFlux<T> replay(Duration ttl) {
 		return replay(Integer.MAX_VALUE, ttl);
 	}
 
@@ -5665,7 +5664,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a replaying {@link ConnectableFlux}
 	 */
-	public final ConnectableFlux<@NonNull T> replay(int history, Duration ttl) {
+	public final ConnectableFlux<T> replay(int history, Duration ttl) {
 		return replay(history, ttl, Schedulers.parallel());
 	}
 
@@ -5685,7 +5684,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a replaying {@link ConnectableFlux}
 	 */
-	public final ConnectableFlux<@NonNull T> replay(Duration ttl, Scheduler timer) {
+	public final ConnectableFlux<T> replay(Duration ttl, Scheduler timer) {
 		return replay(Integer.MAX_VALUE, ttl, timer);
 	}
 
@@ -5706,7 +5705,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a replaying {@link ConnectableFlux}
 	 */
-	public final ConnectableFlux<@NonNull T> replay(int history, Duration ttl, Scheduler timer) {
+	public final ConnectableFlux<T> replay(int history, Duration ttl, Scheduler timer) {
 		Objects.requireNonNull(timer, "timer");
 		return onAssembly(new FluxReplay<>(this, history, ttl.toMillis(), timer));
 	}
@@ -5718,7 +5717,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} that retries on onError
 	 */
-	public final Flux<@NonNull T> retry() {
+	public final Flux<T> retry() {
 		return retry(Long.MAX_VALUE);
 	}
 
@@ -5735,7 +5734,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} that retries on onError up to the specified number of retry attempts.
 	 *
 	 */
-	public final Flux<@NonNull T> retry(long numRetries) {
+	public final Flux<T> retry(long numRetries) {
 		return onAssembly(new FluxRetry<>(this, numRetries));
 	}
 
@@ -5750,7 +5749,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} that retries on onError if the predicates matches.
 	 */
-	public final Flux<@NonNull T> retry(Predicate<? super @NonNull Throwable> retryMatcher) {
+	public final Flux<T> retry(Predicate<? super Throwable> retryMatcher) {
 		return onAssembly(new FluxRetryPredicate<>(this, retryMatcher));
 	}
 
@@ -5767,7 +5766,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} that retries on onError up to the specified number of retry
 	 * attempts, only if the predicate matches.
 	 */
-	public final Flux<@NonNull T> retry(long numRetries, Predicate<? super @NonNull Throwable> retryMatcher) {
+	public final Flux<T> retry(long numRetries, Predicate<? super Throwable> retryMatcher) {
 		return defer(() -> retry(countingPredicate(retryMatcher, numRetries)));
 	}
 
@@ -5787,7 +5786,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} that retries on onError when the companion {@link Publisher} produces an
 	 * onNext signal
 	 */
-	public final Flux<@NonNull T> retryWhen(Function<@NonNull Flux<@NonNull Throwable>, ? extends @NonNull Publisher<@NonNull ?>> whenFactory) {
+	public final Flux<T> retryWhen(Function<Flux<Throwable>, ? extends Publisher<?>> whenFactory) {
 		return onAssembly(new FluxRetryWhen<>(this, whenFactory));
 	}
 
@@ -5805,7 +5804,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} sampled to the last item seen over each periodic window
 	 */
-	public final Flux<@NonNull T> sample(Duration timespan) {
+	public final Flux<T> sample(Duration timespan) {
 		return sample(interval(timespan));
 	}
 
@@ -5831,7 +5830,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} sampled to the last item observed each time the sampler {@link Publisher} signals
 	 */
-	public final <U> Flux<@NonNull T> sample(Publisher<@NonNull U> sampler) {
+	public final <U> Flux<T> sample(Publisher<U> sampler) {
 		return onAssembly(new FluxSample<>(this, sampler));
 	}
 
@@ -5846,7 +5845,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} sampled to the first item of each duration-based window
 	 */
-	public final Flux<@NonNull T> sampleFirst(Duration timespan) {
+	public final Flux<T> sampleFirst(Duration timespan) {
 		return sampleFirst(t -> Mono.delay(timespan));
 	}
 
@@ -5862,7 +5861,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} sampled to the first item observed in each window closed by the sampler signals
 	 */
-	public final <U> Flux<@NonNull T> sampleFirst(Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull U>> samplerFactory) {
+	public final <U> Flux<T> sampleFirst(Function<? super T, ? extends Publisher<U>> samplerFactory) {
 		return onAssembly(new FluxSampleFirst<>(this, samplerFactory));
 	}
 
@@ -5884,7 +5883,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} sampled to items not followed by any other item within a window
 	 * defined by a companion {@link Publisher}
 	 */
-	public final <U> Flux<@NonNull T> sampleTimeout(Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull U>> throttlerFactory) {
+	public final <U> Flux<T> sampleTimeout(Function<? super T, ? extends Publisher<U>> throttlerFactory) {
 		return sampleTimeout(throttlerFactory, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -5909,7 +5908,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} sampled to items not followed by any other item within a window
 	 * defined by a companion {@link Publisher}
 	 */
-	public final <U> Flux<@NonNull T> sampleTimeout(Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull U>>
+	public final <U> Flux<T> sampleTimeout(Function<? super T, ? extends Publisher<U>>
 			throttlerFactory, int maxConcurrency) {
 		return onAssembly(new FluxSampleTimeout<>(this, throttlerFactory,
 				Queues.get(maxConcurrency)));
@@ -5938,7 +5937,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return an accumulating {@link Flux}
 	 */
-	public final Flux<@NonNull T> scan(BiFunction<@NonNull T, @NonNull T, @NonNull T> accumulator) {
+	public final Flux<T> scan(BiFunction<T, T, T> accumulator) {
 		return onAssembly(new FluxScan<>(this, accumulator));
 	}
 
@@ -5965,7 +5964,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return an accumulating {@link Flux} starting with initial state
 	 *
 	 */
-	public final <A> Flux<@NonNull A> scan(A initial, BiFunction<@NonNull A, ? super @NonNull T, @NonNull A> accumulator) {
+	public final <A> Flux<A> scan(A initial, BiFunction<A, ? super T, A> accumulator) {
 		Objects.requireNonNull(initial, "seed");
 		return scanWith(() -> initial, accumulator);
 	}
@@ -5995,7 +5994,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return an accumulating {@link Flux} starting with initial state
 	 *
 	 */
-	public final <A> Flux<@NonNull A> scanWith(Supplier<@NonNull A> initial, BiFunction<@NonNull A, ? super @NonNull T, @NonNull A>
+	public final <A> Flux<A> scanWith(Supplier<A> initial, BiFunction<A, ? super T, A>
 			accumulator) {
 		return onAssembly(new FluxScanSeed<>(this, initial, accumulator));
 	}
@@ -6011,7 +6010,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} that upon first subscribe causes the source {@link Flux}
 	 * to subscribe once, late subscribers might therefore miss items.
 	 */
-	public final Flux<@NonNull T> share() {
+	public final Flux<T> share() {
 		return onAssembly(new FluxRefCount<>(
 				new FluxPublish<>(this, Queues.SMALL_BUFFER_SIZE, Queues.small()), 1)
 		);
@@ -6027,7 +6026,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Mono} with the single item or an error signal
 	 */
-    public final Mono<@NonNull T> single() {
+    public final Mono<T> single() {
 	    if (this instanceof Callable) {
 	        if (this instanceof Fuseable.ScalarCallable) {
 		        @SuppressWarnings("unchecked")
@@ -6064,7 +6063,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Mono} with the expected single item, the supplied default value or
 	 * and error signal
 	 */
-    public final Mono<@NonNull T> single(T defaultValue) {
+    public final Mono<T> single(T defaultValue) {
         if (this instanceof Callable) {
             if (this instanceof Fuseable.ScalarCallable) {
 	            @SuppressWarnings("unchecked")
@@ -6098,7 +6097,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Mono} with the expected single item, no item or an error
 	 */
-    public final Mono<@NonNull T> singleOrEmpty() {
+    public final Mono<T> singleOrEmpty() {
 	    if (this instanceof Callable) {
 		    @SuppressWarnings("unchecked")
 		    Callable<T> thiz = (Callable<T>)this;
@@ -6119,7 +6118,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a dropping {@link Flux} with the specified number of elements skipped at
 	 * the beginning
 	 */
-	public final Flux<@NonNull T> skip(long skipped) {
+	public final Flux<T> skip(long skipped) {
 		if (skipped == 0L) {
 			return this;
 		}
@@ -6138,7 +6137,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} dropping at the beginning until the end of the given duration
 	 */
-	public final Flux<@NonNull T> skip(Duration timespan) {
+	public final Flux<T> skip(Duration timespan) {
 		return skip(timespan, Schedulers.parallel());
 	}
 
@@ -6154,7 +6153,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} dropping at the beginning for the given duration
 	 */
-	public final Flux<@NonNull T> skip(Duration timespan, Scheduler timer) {
+	public final Flux<T> skip(Duration timespan, Scheduler timer) {
 		if(!timespan.isZero()) {
 			return skipUntilOther(Mono.delay(timespan, timer));
 		}
@@ -6175,7 +6174,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * sequence
 	 *
 	 */
-	public final Flux<@NonNull T> skipLast(int n) {
+	public final Flux<T> skipLast(int n) {
 		if (n == 0) {
 			return this;
 		}
@@ -6193,7 +6192,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} dropping until the {@link Predicate} matches
 	 */
-	public final Flux<@NonNull T> skipUntil(Predicate<? super @NonNull T> untilPredicate) {
+	public final Flux<T> skipUntil(Predicate<? super T> untilPredicate) {
 		return onAssembly(new FluxSkipUntil<>(this, untilPredicate));
 	}
 
@@ -6209,7 +6208,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a {@link Flux} dropping until the other {@link Publisher} emits
 	 *
 	 */
-	public final Flux<@NonNull T> skipUntilOther(Publisher<@NonNull ?> other) {
+	public final Flux<T> skipUntilOther(Publisher<?> other) {
 		return onAssembly(new FluxSkipUntilOther<>(this, other));
 	}
 
@@ -6223,7 +6222,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a {@link Flux} dropping while the {@link Predicate} matches
 	 */
-	public final Flux<@NonNull T> skipWhile(Predicate<? super @NonNull T> skipPredicate) {
+	public final Flux<T> skipWhile(Predicate<? super T> skipPredicate) {
 		return onAssembly(new FluxSkipWhile<>(this, skipPredicate));
 	}
 
@@ -6240,7 +6239,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * {@link Comparable} with respect to all other items emitted by the {@link Flux}
 	 * @return a sorted {@link Flux}
 	 */
-	public final Flux<@NonNull T> sort(){
+	public final Flux<T> sort(){
 		return collectSortedList().flatMapIterable(identityFunction());
 	}
 
@@ -6256,7 +6255,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * to indicate their sort order
 	 * @return a sorted {@link Flux}
 	 */
-	public final Flux<@NonNull T> sort(Comparator<? super @NonNull T> sortFunction) {
+	public final Flux<T> sort(Comparator<? super T> sortFunction) {
 		return collectSortedList(sortFunction).flatMapIterable(identityFunction());
 	}
 
@@ -6270,7 +6269,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link Flux} prefixed with elements from an {@link Iterable}
 	 */
-	public final Flux<@NonNull T> startWith(Iterable<? extends @NonNull T> iterable) {
+	public final Flux<T> startWith(Iterable<? extends T> iterable) {
 		return startWith(fromIterable(iterable));
 	}
 
@@ -6285,7 +6284,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 * @return a new {@link Flux} prefixed with the given elements
 	 */
 	@SafeVarargs
-	public final Flux<@NonNull T> startWith(T @NonNull ... values) {
+	public final Flux<T> startWith(T... values) {
 		return startWith(just(values));
 	}
 
@@ -6299,7 +6298,7 @@ public final Flux<T> or(Publisher<? extends T> other) {
 	 *
 	 * @return a new {@link Flux} prefixed with the given {@link Publisher} sequence
 	 */
-	public final Flux<@NonNull T> startWith(Publisher<? extends @NonNull T> publisher) {
+	public final Flux<T> startWith(Publisher<? extends T> publisher) {
 		if (this instanceof FluxConcatArray) {
 			FluxConcatArray<T> fluxConcatArray = (FluxConcatArray<T>) this;
 			return fluxConcatArray.concatAdditionalSourceFirst(publisher);
@@ -6343,7 +6342,7 @@ public final Disposable subscribe() {
 	 *
 	 * @return a new {@link Disposable} that can be used to cancel the underlying {@link Subscription}
 	 */
-	public final Disposable subscribe(Consumer<? super @NonNull T> consumer) {
+	public final Disposable subscribe(Consumer<? super T> consumer) {
 		Objects.requireNonNull(consumer, "consumer");
 		return subscribe(consumer, null, null);
 	}
@@ -6370,7 +6369,7 @@ public final Disposable subscribe(Consumer<? super @NonNull T> consumer) {
 	 *
 	 * @return a new {@link Disposable} that can be used to cancel the underlying {@link Subscription}
 	 */
-	public final Disposable subscribe(@Nullable Consumer<? super @NonNull T> consumer, Consumer<? super @NonNull Throwable> errorConsumer) {
+	public final Disposable subscribe(@Nullable Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer) {
 		Objects.requireNonNull(errorConsumer, "errorConsumer");
 		return subscribe(consumer, errorConsumer, null);
 	}
@@ -6399,8 +6398,8 @@ public final Disposable subscribe(@Nullable Consumer<? super @NonNull T> consume
 	 * @return a new {@link Disposable} that can be used to cancel the underlying {@link Subscription}
 	 */
 	public final Disposable subscribe(
-			@Nullable Consumer<? super @NonNull T> consumer,
-			@Nullable Consumer<? super @NonNull Throwable> errorConsumer,
+			@Nullable Consumer<? super T> consumer,
+			@Nullable Consumer<? super Throwable> errorConsumer,
 			@Nullable Runnable completeConsumer) {
 		return subscribe(consumer, errorConsumer, completeConsumer, null);
 	}
@@ -6434,17 +6433,17 @@ public final Disposable subscribe(
 	 * @return a new {@link Disposable} that can be used to cancel the underlying {@link Subscription}
 	 */
 	public final Disposable subscribe(
-			@Nullable Consumer<? super @NonNull T> consumer,
-			@Nullable Consumer<? super @NonNull Throwable> errorConsumer,
+			@Nullable Consumer<? super T> consumer,
+			@Nullable Consumer<? super Throwable> errorConsumer,
 			@Nullable Runnable completeConsumer,
-			@Nullable Consumer<? super @NonNull Subscription> subscriptionConsumer) {
+			@Nullable Consumer<? super Subscription> subscriptionConsumer) {
 		return subscribeWith(new LambdaSubscriber<>(consumer, errorConsumer,
 				completeConsumer,
 				subscriptionConsumer));
 	}
 
 	@Override
-	public final void subscribe(Subscriber<? super @NonNull T> actual) {
+	public final void subscribe(Subscriber<? super T> actual) {
 		onLastAssembly(this).subscribe(Operators.toCoreSubscriber(actual));
 	}
 
@@ -6458,7 +6457,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @param actual the {@link Subscriber} interested into the published sequence
 	 * @see Flux#subscribe(Subscriber)
 	 */
-	public abstract void subscribe(CoreSubscriber<? super @NonNull T> actual);
+	public abstract void subscribe(CoreSubscriber<? super T> actual);
 
 	/**
 	 * Enrich a potentially empty downstream {@link Context} by adding all values
@@ -6480,7 +6479,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a contextualized {@link Flux}
 	 * @see Context
 	 */
-	public final Flux<@NonNull T> subscriberContext(Context mergeContext) {
+	public final Flux<T> subscriberContext(Context mergeContext) {
 		return subscriberContext(c -> c.putAll(mergeContext));
 	}
 
@@ -6504,7 +6503,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a contextualized {@link Flux}
 	 * @see Context
 	 */
-	public final Flux<@NonNull T> subscriberContext(Function<@NonNull Context, @NonNull Context> doOnContext) {
+	public final Flux<T> subscriberContext(Function<Context, Context> doOnContext) {
 		return new FluxContextStart<>(this, doOnContext);
 	}
 
@@ -6539,7 +6538,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @see #publishOn(Scheduler)
 	 * @see #subscribeOn(Scheduler, boolean)
 	 */
-	public final Flux<@NonNull T> subscribeOn(Scheduler scheduler) {
+	public final Flux<T> subscribeOn(Scheduler scheduler) {
 		return subscribeOn(scheduler, true);
 	}
 
@@ -6578,7 +6577,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @see #publishOn(Scheduler)
 	 * @see #subscribeOn(Scheduler)
 	 */
-	public final Flux<@NonNull T> subscribeOn(Scheduler scheduler, boolean requestOnSeparateThread) {
+	public final Flux<T> subscribeOn(Scheduler scheduler, boolean requestOnSeparateThread) {
 		if (this instanceof Callable) {
 			if (this instanceof Fuseable.ScalarCallable) {
 				try {
@@ -6611,7 +6610,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return the passed {@link Subscriber}
 	 */
-	public final <E extends @NonNull Subscriber<? super @NonNull T>> E subscribeWith(E subscriber) {
+	public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber) {
 		subscribe(subscriber);
 		return subscriber;
 	}
@@ -6625,7 +6624,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a new {@link Flux} that falls back on a {@link Publisher} if source is empty
 	 */
-	public final Flux<@NonNull T> switchIfEmpty(Publisher<? extends @NonNull T> alternate) {
+	public final Flux<T> switchIfEmpty(Publisher<? extends T> alternate) {
 		return onAssembly(new FluxSwitchIfEmpty<>(this, alternate));
 	}
 
@@ -6644,7 +6643,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * for each source onNext
 	 *
 	 */
-	public final <V> Flux<@NonNull V> switchMap(Function<? super @NonNull T, Publisher<? extends @NonNull V>> fn) {
+	public final <V> Flux<V> switchMap(Function<? super T, Publisher<? extends V>> fn) {
 		return switchMap(fn, Queues.XS_BUFFER_SIZE);
 	}
 
@@ -6664,7 +6663,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Flux} that emits values from an alternative {@link Publisher}
 	 * for each source onNext
 	 */
-	public final <V> Flux<@NonNull V> switchMap(Function<? super @NonNull T, @NonNull Publisher<? extends @NonNull V>> fn, int prefetch) {
+	public final <V> Flux<V> switchMap(Function<? super T, Publisher<? extends V>> fn, int prefetch) {
 		return onAssembly(new FluxSwitchMap<>(this, fn, Queues.unbounded(prefetch), prefetch));
 	}
 
@@ -6678,7 +6677,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @param value a tag value
 	 * @return the same sequence, but bearing tags
 	 */
-	public final Flux<@NonNull T> tag(String key, String value) {
+	public final Flux<T> tag(String key, String value) {
 		return FluxName.createOrAppend(this, key, value);
 	}
 
@@ -6696,7 +6695,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} limited to size N
 	 */
-	public final Flux<@NonNull T> take(long n) {
+	public final Flux<T> take(long n) {
 		if (this instanceof Fuseable) {
 			return onAssembly(new FluxTakeFuseable<>(this, n));
 		}
@@ -6717,7 +6716,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} limited to elements emitted within a specific duration
 	 */
-	public final Flux<@NonNull T> take(Duration timespan) {
+	public final Flux<T> take(Duration timespan) {
 		return take(timespan, Schedulers.parallel());
 	}
 
@@ -6737,7 +6736,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} limited to elements emitted within a specific duration
 	 */
-	public final Flux<@NonNull T> take(Duration timespan, Scheduler timer) {
+	public final Flux<T> take(Duration timespan, Scheduler timer) {
 		if (!timespan.isZero()) {
 			return takeUntilOther(Mono.delay(timespan, timer));
 		}
@@ -6757,7 +6756,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a terminating {@link Flux} sub-sequence
 	 *
 	 */
-	public final Flux<@NonNull T> takeLast(int n) {
+	public final Flux<T> takeLast(int n) {
 		if(n == 1){
 			return onAssembly(new FluxTakeLastOne<>(this));
 		}
@@ -6777,7 +6776,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Flux} limited by the predicate
 	 *
 	 */
-	public final Flux<@NonNull T> takeUntil(Predicate<? super @NonNull T> predicate) {
+	public final Flux<T> takeUntil(Predicate<? super T> predicate) {
 		return onAssembly(new FluxTakeUntil<>(this, predicate));
 	}
 
@@ -6792,7 +6791,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Flux} limited by a companion {@link Publisher}
 	 *
 	 */
-	public final Flux<@NonNull T> takeUntilOther(Publisher<@NonNull ?> other) {
+	public final Flux<T> takeUntilOther(Publisher<?> other) {
 		return onAssembly(new FluxTakeUntilOther<>(this, other));
 	}
 
@@ -6809,7 +6808,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a new {@link Flux} taking values from the source while the predicate matches
 	 */
-	public final Flux<@NonNull T> takeWhile(Predicate<? super @NonNull T> continuePredicate) {
+	public final Flux<T> takeWhile(Predicate<? super T> continuePredicate) {
 		return onAssembly(new FluxTakeWhile<>(this, continuePredicate));
 	}
 
@@ -6821,7 +6820,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * <p>
 	 * @return a new {@link Mono} representing the termination of this {@link Flux}
 	 */
-	public final Mono<@NonNull Void> then() {
+	public final Mono<Void> then() {
 		@SuppressWarnings("unchecked")
 		Mono<Void> then = (Mono<Void>) new MonoIgnoreElements<>(this);
 		return Mono.onAssembly(then);
@@ -6842,7 +6841,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a new {@link Flux} that wait for source completion then emits from the supplied {@link Mono}
 	 */
-	public final <V> Mono<@NonNull V> then(Mono<@NonNull V> other) {
+	public final <V> Mono<V> then(Mono<V> other) {
 		return Mono.onAssembly(new MonoIgnoreThen<>(new Publisher[] { this }, other));
 	}
 
@@ -6858,7 +6857,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Mono} completing when both publishers have completed in
 	 * sequence
 	 */
-	public final Mono<@NonNull Void> thenEmpty(Publisher<@NonNull Void> other) {
+	public final Mono<Void> thenEmpty(Publisher<Void> other) {
 		return then(Mono.fromDirect(other));
 	}
 
@@ -6876,7 +6875,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Flux} that emits from the supplied {@link Publisher} after
 	 * this Flux completes.
 	 */
-	public final <V> Flux<@NonNull V> thenMany(Publisher<@NonNull V> other) {
+	public final <V> Flux<V> thenMany(Publisher<V> other) {
 		if (this instanceof FluxConcatArray) {
 			@SuppressWarnings({ "unchecked" })
 			FluxConcatArray<T> fluxConcatArray = (FluxConcatArray<T>) this;
@@ -6899,7 +6898,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} that can time out on a per-item basis
 	 */
-	public final Flux<@NonNull T> timeout(Duration timeout) {
+	public final Flux<T> timeout(Duration timeout) {
 		return timeout(timeout, null, Schedulers.parallel());
 	}
 
@@ -6917,7 +6916,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} that will fallback to a different {@link Publisher} in case of a per-item timeout
 	 */
-	public final Flux<@NonNull T> timeout(Duration timeout, @Nullable Publisher<? extends @NonNull T> fallback) {
+	public final Flux<T> timeout(Duration timeout, @Nullable Publisher<? extends T> fallback) {
 		return timeout(timeout, fallback, Schedulers.parallel());
 	}
 
@@ -6934,7 +6933,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} that can time out on a per-item basis
 	 */
-	public final Flux<@NonNull T> timeout(Duration timeout, Scheduler timer) {
+	public final Flux<T> timeout(Duration timeout, Scheduler timer) {
 		return timeout(timeout, null, timer);
 	}
 
@@ -6954,8 +6953,8 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} that will fallback to a different {@link Publisher} in case of a per-item timeout
 	 */
-	public final Flux<@NonNull T> timeout(Duration timeout,
-			@Nullable Publisher<? extends @NonNull T> fallback,
+	public final Flux<T> timeout(Duration timeout,
+			@Nullable Publisher<? extends T> fallback,
 			Scheduler timer) {
 		final Mono<Long> _timer = Mono.delay(timeout, timer).onErrorReturn(0L);
 		final Function<T, Publisher<Long>> rest = o -> _timer;
@@ -6982,7 +6981,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * a signal from a companion {@link Publisher}
 	 *
 	 */
-	public final <U> Flux<@NonNull T> timeout(Publisher<@NonNull U> firstTimeout) {
+	public final <U> Flux<T> timeout(Publisher<U> firstTimeout) {
 		return timeout(firstTimeout, t -> never());
 	}
 
@@ -7004,8 +7003,8 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} that can time out if each element does not come before
 	 * a signal from a per-item companion {@link Publisher}
 	 */
-	public final <U, V> Flux<@NonNull T> timeout(Publisher<@NonNull U> firstTimeout,
-			Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull V>> nextTimeoutFactory) {
+	public final <U, V> Flux<T> timeout(Publisher<U> firstTimeout,
+			Function<? super T, ? extends Publisher<V>> nextTimeoutFactory) {
 		return onAssembly(new FluxTimeout<>(this, firstTimeout, nextTimeoutFactory));
 	}
 
@@ -7028,8 +7027,8 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} that can time out if each element does not come before
 	 * a signal from a per-item companion {@link Publisher}
 	 */
-	public final <U, V> Flux<@NonNull T> timeout(Publisher<@NonNull U> firstTimeout,
-			Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull V>> nextTimeoutFactory, Publisher<? extends @NonNull T>
+	public final <U, V> Flux<T> timeout(Publisher<U> firstTimeout,
+			Function<? super T, ? extends Publisher<V>> nextTimeoutFactory, Publisher<? extends T>
 			fallback) {
 		return onAssembly(new FluxTimeout<>(this, firstTimeout, nextTimeoutFactory,
 				fallback));
@@ -7045,7 +7044,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a timestamped {@link Flux}
 	 */
-	public final Flux<@NonNull Tuple2<@NonNull Long, @NonNull T>> timestamp() {
+	public final Flux<Tuple2<Long, T>> timestamp() {
 		return timestamp(Schedulers.parallel());
 	}
 
@@ -7060,7 +7059,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @param scheduler the {@link Scheduler} to read time from
 	 * @return a timestamped {@link Flux}
 	 */
-	public final Flux<@NonNull Tuple2<@NonNull Long, @NonNull T>> timestamp(Scheduler scheduler) {
+	public final Flux<Tuple2<Long, T>> timestamp(Scheduler scheduler) {
 		Objects.requireNonNull(scheduler, "scheduler");
 		return map(d -> Tuples.of(scheduler.now(TimeUnit.MILLISECONDS), d));
 	}
@@ -7075,7 +7074,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a blocking {@link Iterable}
 	 */
-	public final Iterable<@NonNull T> toIterable() {
+	public final Iterable<T> toIterable() {
 		return toIterable(Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -7092,7 +7091,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a blocking {@link Iterable}
 	 */
-	public final Iterable<@NonNull T> toIterable(int batchSize) {
+	public final Iterable<T> toIterable(int batchSize) {
 		return toIterable(batchSize, null);
 	}
 
@@ -7110,7 +7109,8 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a blocking {@link Iterable}
 	 */
-	public final Iterable<@NonNull T> toIterable(int batchSize, @Nullable Supplier<@NonNull Queue<@NonNull T>> queueProvider) {
+	public final Iterable<T> toIterable(int batchSize, @Nullable Supplier<Queue<T>>
+			queueProvider) {
 		final Supplier<Queue<T>> provider;
 		if(queueProvider == null){
 			provider = Queues.get(batchSize);
@@ -7130,7 +7130,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Stream} of unknown size with onClose attached to {@link Subscription#cancel()}
 	 */
-	public final Stream<@NonNull T> toStream() {
+	public final Stream<T> toStream() {
 		return toStream(Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -7145,7 +7145,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Stream} of unknown size with onClose attached to {@link Subscription#cancel()}
 	 */
-	public final Stream<@NonNull T> toStream(int batchSize) {
+	public final Stream<T> toStream(int batchSize) {
 		final Supplier<Queue<T>> provider;
 		provider = Queues.get(batchSize);
 		return new BlockingIterable<>(this, batchSize, provider).stream();
@@ -7170,7 +7170,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @see #compose(Function) for deferred composition of {@link Flux} for each {@link Subscriber}
 	 * @see #as for a loose conversion to an arbitrary type
 	 */
-	public final <V> Flux<@NonNull V> transform(Function<? super @NonNull Flux<@NonNull T>, ? extends @NonNull Publisher<@NonNull V>> transformer) {
+	public final <V> Flux<V> transform(Function<? super Flux<T>, ? extends Publisher<V>> transformer) {
 		return onAssembly(from(transformer.apply(this)));
 	}
 
@@ -7186,7 +7186,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} of {@link Flux} windows based on element count
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> window(int maxSize) {
+	public final Flux<Flux<T>> window(int maxSize) {
 		return onAssembly(new FluxWindow<>(this, maxSize, Queues.get(maxSize)));
 	}
 
@@ -7212,7 +7212,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} of {@link Flux} windows based on element count and opened every skipCount
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> window(int maxSize, int skip) {
+	public final Flux<Flux<T>> window(int maxSize, int skip) {
 		return onAssembly(new FluxWindow<>(this,
 				maxSize,
 				skip,
@@ -7231,7 +7231,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} of {@link Flux} windows delimited by a given {@link Publisher}
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> window(Publisher<@NonNull ?> boundary) {
+	public final Flux<Flux<T>> window(Publisher<?> boundary) {
 		return onAssembly(new FluxWindowBoundary<>(this,
 				boundary,
 				Queues.unbounded(Queues.XS_BUFFER_SIZE),
@@ -7250,7 +7250,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} of {@link Flux} windows continuously opened for a given {@link Duration}
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> window(Duration timespan) {
+	public final Flux<Flux<T>> window(Duration timespan) {
 		return window(timespan, Schedulers.parallel());
 	}
 
@@ -7281,7 +7281,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * closed after a {@link Duration}
 	 *
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> window(Duration timespan, Duration timeshift) {
+	public final Flux<Flux<T>> window(Duration timespan, Duration timeshift) {
 		return window(timespan, timeshift, Schedulers.parallel());
 	}
 
@@ -7297,7 +7297,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} of {@link Flux} windows continuously opened for a given {@link Duration}
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> window(Duration timespan, Scheduler timer) {
+	public final Flux<Flux<T>> window(Duration timespan, Scheduler timer) {
 		return window(interval(timespan, timer));
 	}
 
@@ -7328,7 +7328,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} of {@link Flux} windows opened at regular intervals and
 	 * closed after a {@link Duration}
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> window(Duration timespan, Duration timeshift, Scheduler timer) {
+	public final Flux<Flux<T>> window(Duration timespan, Duration timeshift, Scheduler timer) {
 		if (timeshift.equals(timespan)) {
 			return window(timespan);
 		}
@@ -7350,7 +7350,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} of {@link Flux} windows based on element count and duration
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> windowTimeout(int maxSize, Duration timespan) {
+	public final Flux<Flux<T>> windowTimeout(int maxSize, Duration timespan) {
 		return windowTimeout(maxSize, timespan , Schedulers.parallel());
 	}
 
@@ -7370,7 +7370,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Flux} of {@link Flux} windows based on element count and duration
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> windowTimeout(int maxSize, Duration timespan, Scheduler timer) {
+	public final Flux<Flux<T>> windowTimeout(int maxSize, Duration timespan, Scheduler timer) {
 		return onAssembly(new FluxWindowTimeOrSize<>(this, maxSize, timespan.toMillis(), timer));
 	}
 
@@ -7386,7 +7386,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} of {@link Flux} windows, bounded depending
 	 * on the predicate.
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> windowUntil(Predicate<@NonNull T> boundaryTrigger) {
+	public final Flux<Flux<T>> windowUntil(Predicate<T> boundaryTrigger) {
 		return windowUntil(boundaryTrigger, false);
 	}
 
@@ -7411,7 +7411,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} of {@link Flux} windows, bounded depending
 	 * on the predicate.
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> windowUntil(Predicate<@NonNull T> boundaryTrigger, boolean cutBefore) {
+	public final Flux<Flux<T>> windowUntil(Predicate<T> boundaryTrigger, boolean cutBefore) {
 		return windowUntil(boundaryTrigger, cutBefore, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -7438,7 +7438,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} of {@link Flux} windows, bounded depending
 	 * on the predicate.
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> windowUntil(Predicate<@NonNull T> boundaryTrigger, boolean cutBefore, int prefetch) {
+	public final Flux<Flux<T>> windowUntil(Predicate<T> boundaryTrigger, boolean cutBefore, int prefetch) {
 		return onAssembly(new FluxWindowPredicate<>(this,
 				Queues.unbounded(prefetch),
 				Queues.unbounded(prefetch),
@@ -7462,7 +7462,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} of {@link Flux} windows, each containing
 	 * subsequent elements that all passed a predicate.
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> windowWhile(Predicate<@NonNull T> inclusionPredicate) {
+	public final Flux<Flux<T>> windowWhile(Predicate<T> inclusionPredicate) {
 		return windowWhile(inclusionPredicate, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -7482,7 +7482,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} of {@link Flux} windows, each containing
 	 * subsequent elements that all passed a predicate.
 	 */
-	public final Flux<@NonNull Flux<@NonNull T>> windowWhile(Predicate<@NonNull T> inclusionPredicate, int prefetch) {
+	public final Flux<Flux<T>> windowWhile(Predicate<T> inclusionPredicate, int prefetch) {
 		return onAssembly(new FluxWindowPredicate<>(this,
 				Queues.unbounded(prefetch),
 				Queues.unbounded(prefetch),
@@ -7518,8 +7518,8 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} of {@link Flux} windows opened by signals from a first
 	 * {@link Publisher} and lasting until a selected second {@link Publisher} emits
 	 */
-	public final <U, V> Flux<@NonNull Flux<@NonNull T>> windowWhen(Publisher<@NonNull U> bucketOpening,
-			final Function<? super @NonNull U, ? extends @NonNull Publisher<@NonNull V>> closeSelector) {
+	public final <U, V> Flux<Flux<T>> windowWhen(Publisher<U> bucketOpening,
+			final Function<? super U, ? extends Publisher<V>> closeSelector) {
 		return onAssembly(new FluxWindowWhen<>(this,
 				bucketOpening,
 				closeSelector,
@@ -7548,8 +7548,8 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a combined {@link Flux} gated by another {@link Publisher}
 	 */
-	public final <U, R> Flux<@NonNull R> withLatestFrom(Publisher<? extends @NonNull U> other, BiFunction<? super @NonNull T, ? super @NonNull U, ?
-			extends @NonNull R> resultSelector){
+	public final <U, R> Flux<R> withLatestFrom(Publisher<? extends U> other, BiFunction<? super T, ? super U, ?
+			extends R > resultSelector){
 		return onAssembly(new FluxWithLatestFrom<>(this, other, resultSelector));
 	}
 
@@ -7568,7 +7568,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a zipped {@link Flux}
 	 *
 	 */
-	public final <T2> Flux<@NonNull Tuple2<@NonNull T, @NonNull T2>> zipWith(Publisher<? extends @NonNull T2> source2) {
+	public final <T2> Flux<Tuple2<T, T2>> zipWith(Publisher<? extends T2> source2) {
 		return zipWith(source2, tuple2Function());
 	}
 
@@ -7590,8 +7590,8 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public final <T2, V> Flux<@NonNull V> zipWith(Publisher<? extends @NonNull T2> source2,
-			final BiFunction<? super @NonNull T, ? super @NonNull T2, ? extends @NonNull V> combinator) {
+	public final <T2, V> Flux<V> zipWith(Publisher<? extends T2> source2,
+			final BiFunction<? super T, ? super T2, ? extends V> combinator) {
 		if (this instanceof FluxZip) {
 			@SuppressWarnings("unchecked")
 			FluxZip<T, V> o = (FluxZip<T, V>) this;
@@ -7623,9 +7623,9 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a zipped {@link Flux}
 	 */
 	@SuppressWarnings("unchecked")
-	public final <T2, V> Flux<@NonNull V> zipWith(Publisher<? extends @NonNull T2> source2,
+	public final <T2, V> Flux<V> zipWith(Publisher<? extends T2> source2,
 			int prefetch,
-			BiFunction<? super @NonNull T, ? super @NonNull T2, ? extends @NonNull V> combinator) {
+			BiFunction<? super T, ? super T2, ? extends V> combinator) {
 		return zip(objects -> combinator.apply((T) objects[0], (T2) objects[1]),
 				prefetch,
 				this,
@@ -7648,7 +7648,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a zipped {@link Flux}
 	 */
-	public final <T2> Flux<@NonNull Tuple2<@NonNull T, @NonNull T2>> zipWith(Publisher<? extends @NonNull T2> source2, int prefetch) {
+	public final <T2> Flux<Tuple2<T, T2>> zipWith(Publisher<? extends T2> source2, int prefetch) {
 		return zipWith(source2, prefetch, tuple2Function());
 	}
 
@@ -7666,7 +7666,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 */
 	@SuppressWarnings("unchecked")
-	public final <T2> Flux<@NonNull Tuple2<@NonNull T, @NonNull T2>> zipWithIterable(Iterable<? extends @NonNull T2> iterable) {
+	public final <T2> Flux<Tuple2<T, T2>> zipWithIterable(Iterable<? extends T2> iterable) {
 		return zipWithIterable(iterable, tuple2Function());
 	}
 
@@ -7687,8 +7687,8 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a zipped {@link Flux}
 	 *
 	 */
-	public final <T2, V> Flux<@NonNull V> zipWithIterable(Iterable<? extends @NonNull T2> iterable,
-			BiFunction<? super @NonNull T, ? super @NonNull T2, ? extends @NonNull V> zipper) {
+	public final <T2, V> Flux<V> zipWithIterable(Iterable<? extends T2> iterable,
+			BiFunction<? super T, ? super T2, ? extends V> zipper) {
 		return onAssembly(new FluxZipIterable<>(this, iterable, zipper));
 	}
 
@@ -7704,7 +7704,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return the source, potentially wrapped with assembly time cross-cutting behavior
 	 */
 	@SuppressWarnings("unchecked")
-	protected static <T> Flux<@NonNull T> onAssembly(Flux<@NonNull T> source) {
+	protected static <T> Flux<T> onAssembly(Flux<T> source) {
 		Function<Publisher, Publisher> hook = Hooks.onEachOperatorHook;
 		if(hook == null) {
 			return source;
@@ -7724,7 +7724,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return the source, potentially wrapped with assembly time cross-cutting behavior
 	 */
 	@SuppressWarnings("unchecked")
-	protected static <T> Flux<@NonNull T> onLastAssembly(Flux<@NonNull T> source) {
+	protected static <T> Flux<T> onLastAssembly(Flux<T> source) {
 		Function<Publisher, Publisher> hook = Hooks.onLastOperatorHook;
 		if(hook == null) {
 			return source;
@@ -7744,7 +7744,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return the source, potentially wrapped with assembly time cross-cutting behavior
 	 */
 	@SuppressWarnings("unchecked")
-	protected static <T> ConnectableFlux<@NonNull T> onAssembly(ConnectableFlux<@NonNull T> source) {
+	protected static <T> ConnectableFlux<T> onAssembly(ConnectableFlux<T> source) {
 		Function<Publisher, Publisher> hook = Hooks.onEachOperatorHook;
 		if(hook == null) {
 			return source;
@@ -7758,8 +7758,8 @@ public String toString() {
 	}
 
 
-	final <V> Flux<@NonNull V> flatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends
-            @NonNull V>> mapper, boolean delayError, int concurrency, int prefetch) {
+	final <V> Flux<V> flatMap(Function<? super T, ? extends Publisher<? extends
+			V>> mapper, boolean delayError, int concurrency, int prefetch) {
 		return onAssembly(new FluxFlatMap<>(
 				this,
 				mapper,
@@ -7771,8 +7771,8 @@ public String toString() {
 		));
 	}
 
-	final <R> Flux<@NonNull R> flatMapSequential(Function<? super @NonNull T, ? extends
-            @NonNull Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency,
+	final <R> Flux<R> flatMapSequential(Function<? super T, ? extends
+			Publisher<? extends R>> mapper, boolean delayError, int maxConcurrency,
 			int prefetch) {
 		return onAssembly(new FluxMergeSequential<>(this, mapper, maxConcurrency,
 				prefetch, delayError ? FluxConcatMap.ErrorMode.END :
@@ -7780,10 +7780,10 @@ public String toString() {
 	}
 
 	@SuppressWarnings("unchecked")
-	static <T> Flux<@NonNull T> doOnSignal(Flux<@NonNull T> source,
-			@Nullable Consumer<? super @NonNull Subscription> onSubscribe,
-			@Nullable Consumer<? super @NonNull T> onNext,
-			@Nullable Consumer<? super @NonNull Throwable> onError,
+	static <T> Flux<T> doOnSignal(Flux<T> source,
+			@Nullable Consumer<? super Subscription> onSubscribe,
+			@Nullable Consumer<? super T> onNext,
+			@Nullable Consumer<? super Throwable> onError,
 			@Nullable Runnable onComplete,
 			@Nullable Runnable onAfterTerminate,
 			@Nullable LongConsumer onRequest,
@@ -7815,7 +7815,7 @@ public String toString() {
 	 *
 	 * @return the mono representing that Flux
 	 */
-	static <T> Mono<@NonNull T> convertToMono(Callable<@Nullable T> supplier) {
+	static <T> Mono<T> convertToMono(Callable<T> supplier) {
 		if (supplier instanceof Fuseable.ScalarCallable) {
 			Fuseable.ScalarCallable<T> scalarCallable = (Fuseable.ScalarCallable<T>) supplier;
 
@@ -7835,7 +7835,7 @@ public String toString() {
 	}
 
 	@SafeVarargs
-	static <I> Flux<@NonNull I> merge(int prefetch, boolean delayError, Publisher<? extends @NonNull I> @NonNull ... sources) {
+	static <I> Flux<I> merge(int prefetch, boolean delayError, Publisher<? extends I>... sources) {
 		if (sources.length == 0) {
 			return empty();
 		}
@@ -7851,8 +7851,8 @@ public String toString() {
 	}
 
 	@SafeVarargs
-	static <I> Flux<@NonNull I> mergeSequential(int prefetch, boolean delayError,
-			Publisher<? extends @NonNull I> @NonNull ... sources) {
+	static <I> Flux<I> mergeSequential(int prefetch, boolean delayError,
+			Publisher<? extends I>... sources) {
 		if (sources.length == 0) {
 			return empty();
 		}
@@ -7864,7 +7864,7 @@ public String toString() {
 				delayError ? FluxConcatMap.ErrorMode.END : FluxConcatMap.ErrorMode.IMMEDIATE));
 	}
 
-	static <T> Flux<@NonNull T> mergeSequential(Publisher<? extends @NonNull Publisher<? extends @NonNull T>> sources,
+	static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources,
 			boolean delayError, int maxConcurrency, int prefetch) {
 		return onAssembly(new FluxMergeSequential<>(from(sources),
 				identityFunction(),
@@ -7872,7 +7872,7 @@ public String toString() {
 				FluxConcatMap.ErrorMode.IMMEDIATE));
 	}
 
-	static <I> Flux<@NonNull I> mergeSequential(Iterable<? extends @NonNull Publisher<? extends @NonNull I>> sources,
+	static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources,
 			boolean delayError, int maxConcurrency, int prefetch) {
 		return onAssembly(new FluxMergeSequential<>(new FluxIterable<>(sources),
 				identityFunction(), maxConcurrency, prefetch,
@@ -7894,7 +7894,7 @@ public boolean getAsBoolean() {
 		};
 	}
 
-	static <O> Predicate<@NonNull O> countingPredicate(Predicate<@NonNull O> predicate, long max) {
+	static <O> Predicate<O> countingPredicate(Predicate<O> predicate, long max) {
 		if (max == 0) {
 			return predicate;
 		}
@@ -7909,32 +7909,32 @@ public boolean test(O o) {
 	}
 
 	@SuppressWarnings("unchecked")
-	static <O> Supplier<@NonNull Set<@NonNull O>> hashSetSupplier() {
+	static <O> Supplier<Set<O>> hashSetSupplier() {
 		return SET_SUPPLIER;
 	}
 
 	@SuppressWarnings("unchecked")
-	static <O> Supplier<@NonNull List<@NonNull O>> listSupplier() {
+	static <O> Supplier<List<O>> listSupplier() {
 		return LIST_SUPPLIER;
 	}
 
 	@SuppressWarnings("unchecked")
-	static <U, V> Function<@NonNull U, @NonNull V> hashcodeSupplier() {
+	static <U, V> Function<U, V> hashcodeSupplier() {
 		return HASHCODE_EXTRACTOR;
 	}
 
 	@SuppressWarnings("unchecked")
-	static <U, V> BiPredicate<@NonNull U, @NonNull V> equalPredicate() {
+	static <U, V> BiPredicate<U, V> equalPredicate() {
 		return OBJECT_EQUAL;
 	}
 
 	@SuppressWarnings("unchecked")
-	static <T> Function<@NonNull T, @NonNull T> identityFunction(){
+	static <T> Function<T, T> identityFunction(){
 		return IDENTITY_FUNCTION;
 	}
 
 	@SuppressWarnings("unchecked")
-	static <A, B> BiFunction<@NonNull A, @NonNull B, @NonNull Tuple2<@NonNull A, @NonNull B>> tuple2Function() {
+	static <A, B> BiFunction<A, B, Tuple2<A, B>> tuple2Function() {
 		return TUPLE2_BIFUNCTION;
 	}
 
@@ -7946,7 +7946,7 @@ public boolean test(O o) {
 	 * @return a wrapped {@link Flux}
 	 */
 	@SuppressWarnings("unchecked")
-	static <I> Flux<@NonNull I> wrap(Publisher<? extends @NonNull I> source){
+	static <I> Flux<I> wrap(Publisher<? extends I> source){
 		if(source instanceof Mono){
 			if(source instanceof Fuseable){
 				return new FluxSourceMonoFuseable<>((Mono<I>)source);
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxBufferBoundary.java b/reactor-core/src/main/java/reactor/core/publisher/FluxBufferBoundary.java
index b5be7dce21..6b4f4731c8 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxBufferBoundary.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxBufferBoundary.java
@@ -26,8 +26,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Buffers elements into custom collections where the buffer boundary is signalled
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxBufferWhen.java b/reactor-core/src/main/java/reactor/core/publisher/FluxBufferWhen.java
index daeacdebf2..62aa0ff293 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxBufferWhen.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxBufferWhen.java
@@ -34,8 +34,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * buffers elements into possibly overlapping buffers whose boundaries are determined
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxCombineLatest.java b/reactor-core/src/main/java/reactor/core/publisher/FluxCombineLatest.java
index 85c377ce9c..f17a6a6137 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxCombineLatest.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxCombineLatest.java
@@ -33,8 +33,8 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Combines the latest values from multiple sources through a function.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxConcatMap.java b/reactor-core/src/main/java/reactor/core/publisher/FluxConcatMap.java
index 8915713abc..16a4d55682 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxConcatMap.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxConcatMap.java
@@ -29,8 +29,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 import static reactor.core.Exceptions.TERMINATED;
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxContextStart.java b/reactor-core/src/main/java/reactor/core/publisher/FluxContextStart.java
index 7e83918ab9..2cc471350f 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxContextStart.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxContextStart.java
@@ -22,8 +22,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 final class FluxContextStart<T> extends FluxOperator<T, T> implements Fuseable {
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxCreate.java b/reactor-core/src/main/java/reactor/core/publisher/FluxCreate.java
index 98c967fc40..d4cdfa453d 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxCreate.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxCreate.java
@@ -32,9 +32,9 @@
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
 import reactor.core.publisher.FluxSink.OverflowStrategy;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.context.Context;
-import reactor.util.annotation.Nullable;
 
 /**
  * Provides a multi-valued sink API for a callback that is called for each individual
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxDelaySubscription.java b/reactor-core/src/main/java/reactor/core/publisher/FluxDelaySubscription.java
index b069a51388..2cb8bd9ad4 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxDelaySubscription.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxDelaySubscription.java
@@ -21,8 +21,8 @@
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Delays the subscription to the main source until another Publisher
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxElapsed.java b/reactor-core/src/main/java/reactor/core/publisher/FluxElapsed.java
index 812205c988..42e065ed57 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxElapsed.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxElapsed.java
@@ -22,9 +22,9 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
 import reactor.core.scheduler.Scheduler;
+import reactor.util.annotation.Nullable;
 import reactor.util.function.Tuple2;
 import reactor.util.function.Tuples;
-import reactor.util.annotation.Nullable;
 
 /**
  * @author Stephane Maldini
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxErrorOnRequest.java b/reactor-core/src/main/java/reactor/core/publisher/FluxErrorOnRequest.java
index 94d9160fd7..cc6153a11f 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxErrorOnRequest.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxErrorOnRequest.java
@@ -19,6 +19,7 @@
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 
+import org.reactivestreams.Subscriber;
 import reactor.core.CoreSubscriber;
 import reactor.util.annotation.Nullable;
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxFilterWhen.java b/reactor-core/src/main/java/reactor/core/publisher/FluxFilterWhen.java
index ad1fc10e4e..ab5717c4ff 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxFilterWhen.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxFilterWhen.java
@@ -31,9 +31,9 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.context.Context;
-import reactor.util.annotation.Nullable;
 
 /**
  * Maps each upstream value into a single {@code true} or {@code false} value provided by
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxFlatMap.java b/reactor-core/src/main/java/reactor/core/publisher/FluxFlatMap.java
index 4dee8efef2..ba56bf75d7 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxFlatMap.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxFlatMap.java
@@ -33,8 +33,8 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Maps a sequence of values each into a Publisher and flattens them
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxGenerate.java b/reactor-core/src/main/java/reactor/core/publisher/FluxGenerate.java
index c716fba696..7ade8088be 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxGenerate.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxGenerate.java
@@ -24,8 +24,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Generate signals one-by-one via a function callback.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxGroupBy.java b/reactor-core/src/main/java/reactor/core/publisher/FluxGroupBy.java
index 664239e514..e175a23a95 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxGroupBy.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxGroupBy.java
@@ -33,8 +33,8 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Groups upstream items into their own Publisher sequence based on a key selector.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxGroupJoin.java b/reactor-core/src/main/java/reactor/core/publisher/FluxGroupJoin.java
index 396ae942f5..961b0b94ed 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxGroupJoin.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxGroupJoin.java
@@ -37,8 +37,8 @@
 import reactor.core.Disposables;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * A Publisher that correlates two Publishers when they overlap in time and groups the
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxHandle.java b/reactor-core/src/main/java/reactor/core/publisher/FluxHandle.java
index 7887cca0ac..3dc8a72d8f 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxHandle.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxHandle.java
@@ -21,8 +21,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Maps the values of the source publisher one-on-one via a handler function as long as the handler function result is
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxHandleFuseable.java b/reactor-core/src/main/java/reactor/core/publisher/FluxHandleFuseable.java
index 23d532ce63..d1cc13a66b 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxHandleFuseable.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxHandleFuseable.java
@@ -23,8 +23,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Maps the values of the source publisher one-on-one via a handler function.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxMergeSequential.java b/reactor-core/src/main/java/reactor/core/publisher/FluxMergeSequential.java
index 1a45408c72..3f0c580802 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxMergeSequential.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxMergeSequential.java
@@ -34,9 +34,9 @@
 import reactor.core.Fuseable.QueueSubscription;
 import reactor.core.Scannable;
 import reactor.core.publisher.FluxConcatMap.ErrorMode;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.context.Context;
-import reactor.util.annotation.Nullable;
 
 /**
  * Maps each upstream value into a Publisher and concatenates them into one
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxName.java b/reactor-core/src/main/java/reactor/core/publisher/FluxName.java
index f3145db8f6..61edd5f953 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxName.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxName.java
@@ -23,9 +23,9 @@
 
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
+import reactor.util.annotation.Nullable;
 import reactor.util.function.Tuple2;
 import reactor.util.function.Tuples;
-import reactor.util.annotation.Nullable;
 
 /**
  * An operator that just bears a name or a set of tags, which can be retrieved via the
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxNameFuseable.java b/reactor-core/src/main/java/reactor/core/publisher/FluxNameFuseable.java
index 159bc02eac..a9b01b1e4f 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxNameFuseable.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxNameFuseable.java
@@ -20,8 +20,8 @@
 
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
-import reactor.util.function.Tuple2;
 import reactor.util.annotation.Nullable;
+import reactor.util.function.Tuple2;
 
 /**
  * An operator that just bears a name or a set of tags, which can be retrieved via the
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxOnAssembly.java b/reactor-core/src/main/java/reactor/core/publisher/FluxOnAssembly.java
index 43f25b3c5e..774c68080a 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxOnAssembly.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxOnAssembly.java
@@ -24,9 +24,9 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
+import reactor.util.annotation.Nullable;
 import reactor.util.function.Tuple3;
 import reactor.util.function.Tuples;
-import reactor.util.annotation.Nullable;
 
 /**
  * Captures the current stacktrace when this publisher is created and
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxOnBackpressureBuffer.java b/reactor-core/src/main/java/reactor/core/publisher/FluxOnBackpressureBuffer.java
index 5e5b24c719..d8b8e69cd8 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxOnBackpressureBuffer.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxOnBackpressureBuffer.java
@@ -26,8 +26,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
-import reactor.util.concurrent.Queues;
 import reactor.util.annotation.Nullable;
+import reactor.util.concurrent.Queues;
 
 /**
  * @author Stephane Maldini
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxOperator.java b/reactor-core/src/main/java/reactor/core/publisher/FluxOperator.java
index 917c8fb9ed..3b7e83f8b6 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxOperator.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxOperator.java
@@ -17,8 +17,11 @@
 package reactor.core.publisher;
 
 import java.util.Objects;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 
 import org.reactivestreams.Publisher;
+import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
 import reactor.util.annotation.Nullable;
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxPeek.java b/reactor-core/src/main/java/reactor/core/publisher/FluxPeek.java
index bf80da1c88..67aeb4fcb4 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxPeek.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxPeek.java
@@ -23,8 +23,8 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable.ConditionalSubscriber;
 import reactor.core.publisher.FluxPeekFuseable.PeekConditionalSubscriber;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Peek into the lifecycle events and signals of a sequence.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxPeekFuseable.java b/reactor-core/src/main/java/reactor/core/publisher/FluxPeekFuseable.java
index 29bb662ddf..9a66a49117 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxPeekFuseable.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxPeekFuseable.java
@@ -23,8 +23,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Peek into the lifecycle events and signals of a sequence.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxPublishMulticast.java b/reactor-core/src/main/java/reactor/core/publisher/FluxPublishMulticast.java
index 7f7b8fe8be..e20c8c9246 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxPublishMulticast.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxPublishMulticast.java
@@ -31,8 +31,8 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Shares a sequence for the duration of a function that may transform it and
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxRepeatWhen.java b/reactor-core/src/main/java/reactor/core/publisher/FluxRepeatWhen.java
index 6850122a17..f0b3007504 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxRepeatWhen.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxRepeatWhen.java
@@ -26,8 +26,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Repeats a source when a companion sequence signals an item in response to the main's
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxReplay.java b/reactor-core/src/main/java/reactor/core/publisher/FluxReplay.java
index cf5cf86f33..9430dc0492 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxReplay.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxReplay.java
@@ -34,8 +34,8 @@
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
 import reactor.core.scheduler.Scheduler;
-import reactor.util.concurrent.Queues;
 import reactor.util.annotation.Nullable;
+import reactor.util.concurrent.Queues;
 
 /**
  * @param <T>
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxRetryWhen.java b/reactor-core/src/main/java/reactor/core/publisher/FluxRetryWhen.java
index 9107e5b406..534318bba2 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxRetryWhen.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxRetryWhen.java
@@ -25,8 +25,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * retries a source when a companion sequence signals
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxSample.java b/reactor-core/src/main/java/reactor/core/publisher/FluxSample.java
index 12c8ca6e51..719304a5a3 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxSample.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxSample.java
@@ -25,8 +25,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Samples the main source and emits its latest value whenever the other Publisher
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxSampleFirst.java b/reactor-core/src/main/java/reactor/core/publisher/FluxSampleFirst.java
index f10cd615ac..5250115d2f 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxSampleFirst.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxSampleFirst.java
@@ -28,8 +28,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Takes a value from upstream then uses the duration provided by a
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxSampleTimeout.java b/reactor-core/src/main/java/reactor/core/publisher/FluxSampleTimeout.java
index 3f5550280f..775070c822 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxSampleTimeout.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxSampleTimeout.java
@@ -31,8 +31,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Emits the last value from upstream only if there were no newer values emitted
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxSkipUntilOther.java b/reactor-core/src/main/java/reactor/core/publisher/FluxSkipUntilOther.java
index 463c3079c9..99ec4ac0de 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxSkipUntilOther.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxSkipUntilOther.java
@@ -24,8 +24,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Skips values from the main publisher until the other publisher signals
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxSwitchMap.java b/reactor-core/src/main/java/reactor/core/publisher/FluxSwitchMap.java
index cc4ea3f066..0aece4a0a5 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxSwitchMap.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxSwitchMap.java
@@ -32,8 +32,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Switches to a new Publisher generated via a function whenever the upstream produces an
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxTakeUntilOther.java b/reactor-core/src/main/java/reactor/core/publisher/FluxTakeUntilOther.java
index 606a650e07..0e587d41dc 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxTakeUntilOther.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxTakeUntilOther.java
@@ -23,8 +23,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Relays values from the main Publisher until another Publisher signals an event.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxWindowBoundary.java b/reactor-core/src/main/java/reactor/core/publisher/FluxWindowBoundary.java
index 3d46eb196d..a9a02f19c1 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxWindowBoundary.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxWindowBoundary.java
@@ -30,8 +30,8 @@
 import reactor.core.Disposable;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Splits the source sequence into continuous, non-overlapping windowEnds
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxWithLatestFrom.java b/reactor-core/src/main/java/reactor/core/publisher/FluxWithLatestFrom.java
index b712f1b89f..5bbbf73e43 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxWithLatestFrom.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxWithLatestFrom.java
@@ -25,8 +25,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Combines values from a main Publisher with values from another
diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxZip.java b/reactor-core/src/main/java/reactor/core/publisher/FluxZip.java
index a66ad0b342..0ef19a8c11 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/FluxZip.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/FluxZip.java
@@ -35,8 +35,8 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 import static reactor.core.Fuseable.ASYNC;
 import static reactor.core.Fuseable.SYNC;
diff --git a/reactor-core/src/main/java/reactor/core/publisher/Hooks.java b/reactor-core/src/main/java/reactor/core/publisher/Hooks.java
index 7fa106d96c..e7122f02f8 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/Hooks.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/Hooks.java
@@ -31,9 +31,8 @@
 import reactor.core.Exceptions;
 import reactor.util.Logger;
 import reactor.util.Loggers;
-import reactor.util.context.Context;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * A push of overridable lifecycle hooks that can be used for cross-cutting
@@ -66,7 +65,7 @@ public abstract class Hooks {
 	 * @see #resetOnEachOperator()
 	 * @see #onLastOperator(Function)
 	 */
-	public static void onEachOperator(Function<? super @NonNull Publisher<@NonNull Object>, ? extends @NonNull Publisher<@NonNull Object>> onEachOperator) {
+	public static void onEachOperator(Function<? super Publisher<Object>, ? extends Publisher<Object>> onEachOperator) {
 		onEachOperator(onEachOperator.toString(), onEachOperator);
 	}
 
@@ -95,7 +94,7 @@ public static void onEachOperator(Function<? super @NonNull Publisher<@NonNull O
 	 * @see #resetOnEachOperator()
 	 * @see #onLastOperator(String, Function)
 	 */
-	public static void onEachOperator(String key, Function<? super @NonNull Publisher<@NonNull Object>, ? extends @NonNull Publisher<@NonNull Object>> onEachOperator) {
+	public static void onEachOperator(String key, Function<? super Publisher<Object>, ? extends Publisher<Object>> onEachOperator) {
 		Objects.requireNonNull(key, "key");
 		Objects.requireNonNull(onEachOperator, "onEachOperator");
 		log.debug("Hooking onEachOperator: {}", key);
@@ -142,7 +141,7 @@ public static void resetOnEachOperator() {
 	 *
 	 * @param c the {@link Consumer} to apply to dropped errors
 	 */
-	public static void onErrorDropped(Consumer<? super @NonNull Throwable> c) {
+	public static void onErrorDropped(Consumer<? super Throwable> c) {
 		Objects.requireNonNull(c, "onErrorDroppedHook");
 		log.debug("Hooking new default : onErrorDropped");
 
@@ -177,7 +176,7 @@ public static void onErrorDropped(Consumer<? super @NonNull Throwable> c) {
 	 * @see #resetOnLastOperator()
 	 * @see #onEachOperator(Function)
 	 */
-	public static void onLastOperator(Function<? super @NonNull Publisher<@NonNull Object>, ? extends @NonNull Publisher<@NonNull Object>> onLastOperator) {
+	public static void onLastOperator(Function<? super Publisher<Object>, ? extends Publisher<Object>> onLastOperator) {
 		onLastOperator(onLastOperator.toString(), onLastOperator);
 	}
 
@@ -202,7 +201,7 @@ public static void onLastOperator(Function<? super @NonNull Publisher<@NonNull O
 	 * @see #resetOnLastOperator()
 	 * @see #onEachOperator(String, Function)
 	 */
-	public static void onLastOperator(String key, Function<? super @NonNull Publisher<@NonNull Object>, ? extends @NonNull Publisher<@NonNull Object>> onLastOperator) {
+	public static void onLastOperator(String key, Function<? super Publisher<Object>, ? extends Publisher<Object>> onLastOperator) {
 		Objects.requireNonNull(key, "key");
 		Objects.requireNonNull(onLastOperator, "onLastOperator");
 		log.debug("Hooking onLastOperator: {}", key);
@@ -250,7 +249,7 @@ public static void resetOnLastOperator() {
 	 * @param c the {@link Consumer} to apply to data (onNext) that is dropped
 	 * @see #onNextDroppedFail()
 	 */
-	public static void onNextDropped(Consumer<@NonNull Object> c) {
+	public static void onNextDropped(Consumer<Object> c) {
 		Objects.requireNonNull(c, "onNextDroppedHook");
 		log.debug("Hooking new default : onNextDropped");
 
@@ -319,7 +318,7 @@ public static void resetOnOperatorDebug() {
 	 * @see #resetOnOperatorError(String)
 	 * @see #resetOnOperatorError()
 	 */
-	public static void onOperatorError(BiFunction<? super @NonNull Throwable, @Nullable Object, ? extends @NonNull Throwable> onOperatorError) {
+	public static void onOperatorError(BiFunction<? super Throwable, Object, ? extends Throwable> onOperatorError) {
 		onOperatorError(onOperatorError.toString(), onOperatorError);
 	}
 
@@ -346,7 +345,7 @@ public static void onOperatorError(BiFunction<? super @NonNull Throwable, @Nulla
 	 * @see #resetOnOperatorError(String)
 	 * @see #resetOnOperatorError()
 	 */
-	public static void onOperatorError(String key, BiFunction<? super @NonNull Throwable, @Nullable Object, ? extends @NonNull Throwable> onOperatorError) {
+	public static void onOperatorError(String key, BiFunction<? super Throwable, Object, ? extends Throwable> onOperatorError) {
 		Objects.requireNonNull(key, "key");
 		Objects.requireNonNull(onOperatorError, "onOperatorError");
 		log.debug("Hooking onOperatorError: {}", key);
@@ -409,7 +408,7 @@ public static void resetOnNextDropped() {
 
 	@Nullable
 	@SuppressWarnings("unchecked")
-	static Function<@NonNull Publisher, @NonNull Publisher> createOrUpdateOpHook(Collection<Function<? super @NonNull Publisher<@NonNull Object>, ? extends @NonNull Publisher<@NonNull Object>>> hooks) {
+	static Function<Publisher, Publisher> createOrUpdateOpHook(Collection<Function<? super Publisher<Object>, ? extends Publisher<Object>>> hooks) {
 		Function<Publisher, Publisher> composite = null;
 		for (Function<? super Publisher<Object>, ? extends Publisher<Object>> function : hooks) {
 			Function<? super Publisher, ? extends Publisher> op = (Function<? super Publisher, ? extends Publisher>) function;
@@ -424,7 +423,7 @@ public static void resetOnNextDropped() {
 	}
 
 	@Nullable
-	static BiFunction<? super @NonNull Throwable, @Nullable Object, ? extends @NonNull Throwable> createOrUpdateOpErrorHook(Collection<@NonNull BiFunction<? super @NonNull Throwable, @Nullable Object, ? extends @NonNull Throwable>> hooks) {
+	static BiFunction<? super Throwable, Object, ? extends Throwable> createOrUpdateOpErrorHook(Collection<BiFunction<? super Throwable, Object, ? extends Throwable>> hooks) {
 		BiFunction<? super Throwable, Object, ? extends Throwable> composite = null;
 		for (BiFunction<? super Throwable, Object, ? extends Throwable> function : hooks) {
 			if (composite != null) {
@@ -488,13 +487,13 @@ final static class OnOperatorDebug<T>
 
 
 		@SuppressWarnings("unchecked")
-		static <T> OnOperatorDebug<@NonNull T> instance(){
+		static <T> OnOperatorDebug<T> instance(){
 			return (OnOperatorDebug<T>)INSTANCE;
 		}
 
 		@Override
 		@SuppressWarnings("unchecked")
-		public Publisher<@NonNull T> apply(Publisher<@NonNull T> publisher) {
+		public Publisher<T> apply(Publisher<T> publisher) {
 			if (publisher instanceof Callable) {
 				if (publisher instanceof Mono) {
 					return new MonoCallableOnAssembly<>((Mono<T>) publisher);
diff --git a/reactor-core/src/main/java/reactor/core/publisher/LambdaMonoSubscriber.java b/reactor-core/src/main/java/reactor/core/publisher/LambdaMonoSubscriber.java
index 9310a6c23c..7e5df69b2a 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/LambdaMonoSubscriber.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/LambdaMonoSubscriber.java
@@ -23,8 +23,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.Disposable;
 import reactor.core.Exceptions;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * An unbounded Java Lambda adapter to {@link Subscriber}, targetted at {@link Mono}.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/LambdaSubscriber.java b/reactor-core/src/main/java/reactor/core/publisher/LambdaSubscriber.java
index a0db50d509..6700f1c74d 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/LambdaSubscriber.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/LambdaSubscriber.java
@@ -23,9 +23,9 @@
 import org.reactivestreams.Subscription;
 import reactor.core.Disposable;
 import reactor.core.Exceptions;
+import reactor.util.annotation.Nullable;
 import reactor.util.context.Context;
 
-import reactor.util.annotation.Nullable;
 
 /**
  * An unbounded Java Lambda adapter to {@link Subscriber}
diff --git a/reactor-core/src/main/java/reactor/core/publisher/Mono.java b/reactor-core/src/main/java/reactor/core/publisher/Mono.java
index b844374a1a..e09f2f7fcc 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/Mono.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/Mono.java
@@ -48,6 +48,7 @@
 import reactor.core.scheduler.Scheduler.Worker;
 import reactor.core.scheduler.Schedulers;
 import reactor.util.Logger;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.context.Context;
 import reactor.util.function.Tuple2;
@@ -56,8 +57,6 @@
 import reactor.util.function.Tuple5;
 import reactor.util.function.Tuple6;
 import reactor.util.function.Tuples;
-import reactor.util.annotation.NonNull;
-import reactor.util.annotation.Nullable;
 
 /**
  * A Reactive Streams {@link Publisher} with basic rx operators that completes successfully by emitting an element, or
@@ -168,7 +167,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @param <T> The type of the value emitted
 	 * @return a {@link Mono}
 	 */
-	public static <T> Mono<@NonNull T> create(Consumer<@NonNull MonoSink<@NonNull T>> callback) {
+	public static <T> Mono<T> create(Consumer<MonoSink<T>> callback) {
 	    return onAssembly(new MonoCreate<>(callback));
 	}
 
@@ -185,7 +184,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Mono} factory
 	 */
-	public static <T> Mono<@NonNull T> defer(Supplier<? extends @NonNull Mono<? extends @NonNull T>> supplier) {
+	public static <T> Mono<T> defer(Supplier<? extends Mono<? extends T>> supplier) {
 		return onAssembly(new MonoDefer<>(supplier));
 	}
 
@@ -202,7 +201,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public static Mono<@NonNull Long> delay(Duration duration) {
+	public static Mono<Long> delay(Duration duration) {
 		return delay(duration, Schedulers.parallel());
 	}
 
@@ -219,7 +218,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public static Mono<@NonNull Long> delay(Duration duration, Scheduler timer) {
+	public static Mono<Long> delay(Duration duration, Scheduler timer) {
 		return onAssembly(new MonoDelay(duration.toMillis(), TimeUnit.MILLISECONDS, timer));
 	}
 
@@ -233,7 +232,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a completed {@link Mono}
 	 */
-	public static <T> Mono<@NonNull T> empty() {
+	public static <T> Mono<T> empty() {
 		return MonoEmpty.instance();
 	}
 
@@ -248,7 +247,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a failed {@link Mono}
 	 */
-	public static <T> Mono<@NonNull T> error(Throwable error) {
+	public static <T> Mono<T> error(Throwable error) {
 		return onAssembly(new MonoError<>(error));
 	}
 
@@ -265,7 +264,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @return a new {@link Mono} behaving like the fastest of its sources.
 	 */
 	@SafeVarargs
-	public static <T> Mono<@NonNull T> first(Mono<? extends @NonNull T> @NonNull ... monos) {
+	public static <T> Mono<T> first(Mono<? extends T>... monos) {
 		return onAssembly(new MonoFirst<>(monos));
 	}
 
@@ -280,7 +279,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> first(Iterable<? extends @NonNull Mono<? extends @NonNull T>> monos) {
+	public static <T> Mono<T> first(Iterable<? extends Mono<? extends T>> monos) {
 		return onAssembly(new MonoFirst<>(monos));
 	}
 
@@ -295,7 +294,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return the next item emitted as a {@link Mono}
 	 */
-	public static <T> Mono<@NonNull T> from(Publisher<? extends @NonNull T> source) {
+	public static <T> Mono<T> from(Publisher<? extends T> source) {
 		if (source instanceof Mono) {
 			@SuppressWarnings("unchecked")
 			Mono<T> casted = (Mono<T>) source;
@@ -321,7 +320,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return A {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> fromCallable(Callable<? extends @Nullable T> supplier) {
+	public static <T> Mono<T> fromCallable(Callable<? extends T> supplier) {
 		return onAssembly(new MonoCallable<>(supplier));
 	}
 
@@ -336,7 +335,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @param <T> type of the expected value
 	 * @return A {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> fromCompletionStage(CompletionStage<? extends @Nullable T> completionStage) {
+	public static <T> Mono<T> fromCompletionStage(CompletionStage<? extends T> completionStage) {
 		return onAssembly(new MonoCompletionStage<>(completionStage));
 	}
 
@@ -352,7 +351,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @param <I> type of the value emitted by the publisher
 	 * @return a wrapped {@link Mono}
 	 */
-	public static <I> Mono<@NonNull I> fromDirect(Publisher<? extends @NonNull I> source){
+	public static <I> Mono<I> fromDirect(Publisher<? extends I> source){
 		if(source instanceof Mono){
 			@SuppressWarnings("unchecked")
 			Mono<I> m = (Mono<I>)source;
@@ -384,7 +383,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @return A {@link Mono}.
 	 * @see #fromCompletionStage(CompletionStage) fromCompletionStage for a generalization
 	 */
-	public static <T> Mono<@NonNull T> fromFuture(CompletableFuture<? extends @Nullable T> future) {
+	public static <T> Mono<T> fromFuture(CompletableFuture<? extends T> future) {
 		return onAssembly(new MonoCompletionStage<>(future));
 	}
 
@@ -400,7 +399,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @param <T> The generic type of the upstream, which is preserved by this operator
 	 * @return A {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> fromRunnable(Runnable runnable) {
+	public static <T> Mono<T> fromRunnable(Runnable runnable) {
 		return onAssembly(new MonoRunnable<>(runnable));
 	}
 
@@ -416,7 +415,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return A {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> fromSupplier(Supplier<? extends @Nullable T> supplier) {
+	public static <T> Mono<T> fromSupplier(Supplier<? extends T> supplier) {
 		return onAssembly(new MonoSupplier<>(supplier));
 	}
 
@@ -433,7 +432,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a new completable {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> ignoreElements(Publisher<@NonNull T> source) {
+	public static <T> Mono<T> ignoreElements(Publisher<T> source) {
 		return onAssembly(new MonoIgnorePublisher<>(source));
 	}
 
@@ -449,7 +448,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> just(T data) {
+	public static <T> Mono<T> just(T data) {
 		return onAssembly(new MonoJust<>(data));
 	}
 
@@ -465,7 +464,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> justOrEmpty(@Nullable Optional<? extends T> data) {
+	public static <T> Mono<T> justOrEmpty(@Nullable Optional<? extends T> data) {
 		return data != null && data.isPresent() ? just(data.get()) : empty();
 	}
 
@@ -481,7 +480,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <T> Mono<@NonNull T> justOrEmpty(@Nullable T data) {
+	public static <T> Mono<T> justOrEmpty(@Nullable T data) {
 		return data != null ? just(data) : empty();
 	}
 
@@ -496,7 +495,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a never completing {@link Mono}
 	 */
-	public static <T> Mono<@NonNull T> never() {
+	public static <T> Mono<T> never() {
 		return MonoNever.instance();
 	}
 
@@ -512,7 +511,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *            the type of items emitted by each Publisher
 	 * @return a Mono that emits a Boolean value that indicates whether the two sequences are the same
 	 */
-	public static <T> Mono<@NonNull Boolean> sequenceEqual(Publisher<? extends @NonNull T> source1, Publisher<? extends @NonNull T> source2) {
+	public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2) {
 		return sequenceEqual(source1, source2, equalsBiPredicate(), Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -532,7 +531,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @return a Mono that emits a Boolean value that indicates whether the two Publisher two sequences
 	 *         are the same according to the specified function
 	 */
-	public static <T> Mono<@NonNull Boolean> sequenceEqual(Publisher<? extends @NonNull T> source1, Publisher<? extends @NonNull T> source2,
+	public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2,
 			BiPredicate<? super T, ? super T> isEqual) {
 		return sequenceEqual(source1, source2, isEqual, Queues.SMALL_BUFFER_SIZE);
 	}
@@ -555,9 +554,9 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @return a Mono that emits a Boolean value that indicates whether the two Publisher two sequences
 	 *         are the same according to the specified function
 	 */
-	public static <T> Mono<@NonNull Boolean> sequenceEqual(Publisher<? extends @NonNull T> source1,
-			Publisher<? extends @NonNull T> source2,
-			BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual, int prefetch) {
+	public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1,
+			Publisher<? extends T> source2,
+			BiPredicate<? super T, ? super T> isEqual, int prefetch) {
 		return onAssembly(new MonoSequenceEqual<>(source1, source2, isEqual, prefetch));
 	}
 
@@ -573,7 +572,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 * @return a new {@link Mono} emitting current context
 	 * @see #subscribe(CoreSubscriber)
 	 */
-	public static  Mono<@NonNull Context> subscriberContext() {
+	public static  Mono<Context> subscriberContext() {
 		return onAssembly(MonoCurrentContext.INSTANCE);
 	}
 
@@ -597,9 +596,9 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return new {@link Mono}
 	 */
-	public static <T, D> Mono<@NonNull T> using(Callable<? extends @NonNull D> resourceSupplier,
-			Function<? super @NonNull D, ? extends Mono<? extends @NonNull T>> sourceSupplier,
-			Consumer<? super @NonNull D> resourceCleanup,
+	public static <T, D> Mono<T> using(Callable<? extends D> resourceSupplier,
+			Function<? super D, ? extends Mono<? extends T>> sourceSupplier,
+			Consumer<? super D> resourceCleanup,
 			boolean eager) {
 		return onAssembly(new MonoUsing<>(resourceSupplier, sourceSupplier,
 				resourceCleanup, eager));
@@ -624,9 +623,9 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return new {@link Mono}
 	 */
-	public static <T, D> Mono<@NonNull T> using(Callable<? extends @NonNull D> resourceSupplier,
-			Function<? super @NonNull D, ? extends Mono<? extends @NonNull T>> sourceSupplier,
-			Consumer<? super @NonNull D> resourceCleanup) {
+	public static <T, D> Mono<T> using(Callable<? extends D> resourceSupplier,
+			Function<? super D, ? extends Mono<? extends T>> sourceSupplier,
+			Consumer<? super D> resourceCleanup) {
 		return using(resourceSupplier, sourceSupplier, resourceCleanup, true);
 	}
 
@@ -641,7 +640,7 @@ public abstract class Mono<T> implements Publisher<T> {
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static Mono<Void> when(Publisher<@NonNull ?> @NonNull ... sources) {
+	public static Mono<Void> when(Publisher<?>... sources) {
 		if (sources.length == 0) {
 			return empty();
 		}
@@ -666,7 +665,7 @@ public static Mono<Void> when(Publisher<@NonNull ?> @NonNull ... sources) {
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static Mono<Void> when(final @NonNull Iterable<? extends @NonNull Publisher<@NonNull ?>> sources) {
+	public static Mono<Void> when(final Iterable<? extends Publisher<?>> sources) {
 		return onAssembly(new MonoWhen(false, sources));
 	}
 
@@ -685,7 +684,7 @@ public static Mono<Void> when(final @NonNull Iterable<? extends @NonNull Publish
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static Mono<Void> whenDelayError(final Iterable<? extends @NonNull Publisher<@NonNull ?>> sources) {
+	public static Mono<Void> whenDelayError(final Iterable<? extends Publisher<?>> sources) {
 		return onAssembly(new MonoWhen(true, sources));
 	}
 
@@ -701,7 +700,7 @@ public static Mono<Void> whenDelayError(final Iterable<? extends @NonNull Publis
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static  Mono<Void> whenDelayError(Publisher<@NonNull ?> @NonNull ... sources) {
+	public static  Mono<Void> whenDelayError(Publisher<?>... sources) {
 		if (sources.length == 0) {
 			return empty();
 		}
@@ -727,7 +726,7 @@ public static  Mono<Void> whenDelayError(Publisher<@NonNull ?> @NonNull ... sour
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <T1, T2> Mono<@NonNull Tuple2<@NonNull T1, @NonNull T2>> zip(Mono<? extends @NonNull T1> p1, Mono<? extends @NonNull T2> p2) {
+	public static <T1, T2> Mono<Tuple2<T1, T2>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2) {
 		return zip(p1, p2, Flux.tuple2Function());
 	}
 
@@ -750,8 +749,8 @@ public static  Mono<Void> whenDelayError(Publisher<@NonNull ?> @NonNull ... sour
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
-			extends @NonNull T2> p2, BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull O> combinator) {
+	public static <T1, T2, O> Mono<O> zip(Mono<? extends T1> p1, Mono<?
+			extends T2> p2, BiFunction<? super T1, ? super T2, ? extends O> combinator) {
 		return onAssembly(new MonoZip<T1, O>(false, p1, p2, combinator));
 	}
 
@@ -774,7 +773,7 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2, T3> Mono<@NonNull Tuple3<@NonNull T1, @NonNull T2, @NonNull T3>> zip(Mono<? extends @NonNull T1> p1, Mono<? extends @NonNull T2> p2, Mono<? extends @NonNull T3> p3) {
+	public static <T1, T2, T3> Mono<Tuple3<T1, T2, T3>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3) {
 		return onAssembly(new MonoZip(false, a -> Tuples.fromArray((Object[])a), p1, p2, p3));
 	}
 
@@ -799,7 +798,7 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2, T3, T4> Mono<@NonNull Tuple4<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4>> zip(Mono<? extends @NonNull T1> p1,
+	public static <T1, T2, T3, T4> Mono<Tuple4<T1, T2, T3, T4>> zip(Mono<? extends T1> p1,
 			Mono<? extends T2> p2,
 			Mono<? extends T3> p3,
 			Mono<? extends T4> p4) {
@@ -829,11 +828,11 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2, T3, T4, T5> Mono<@NonNull Tuple5<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5>> zip(Mono<? extends @NonNull T1> p1,
-			Mono<? extends @NonNull T2> p2,
-			Mono<? extends @NonNull T3> p3,
-			Mono<? extends @NonNull T4> p4,
-			Mono<? extends @NonNull T5> p5) {
+	public static <T1, T2, T3, T4, T5> Mono<Tuple5<T1, T2, T3, T4, T5>> zip(Mono<? extends T1> p1,
+			Mono<? extends T2> p2,
+			Mono<? extends T3> p3,
+			Mono<? extends T4> p4,
+			Mono<? extends T5> p5) {
 		return onAssembly(new MonoZip(false, a -> Tuples.fromArray((Object[])a), p1, p2, p3, p4, p5));
 	}
 
@@ -862,12 +861,12 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2, T3, T4, T5, T6> Mono<@NonNull Tuple6<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6>> zip(Mono<? extends @NonNull T1> p1,
-			Mono<? extends @NonNull T2> p2,
-			Mono<? extends @NonNull T3> p3,
-			Mono<? extends @NonNull T4> p4,
-			Mono<? extends @NonNull T5> p5,
-			Mono<? extends @NonNull T6> p6) {
+	public static <T1, T2, T3, T4, T5, T6> Mono<Tuple6<T1, T2, T3, T4, T5, T6>> zip(Mono<? extends T1> p1,
+			Mono<? extends T2> p2,
+			Mono<? extends T3> p3,
+			Mono<? extends T4> p4,
+			Mono<? extends T5> p5,
+			Mono<? extends T6> p6) {
 		return onAssembly(new MonoZip(false, a -> Tuples.fromArray((Object[])a), p1, p2, p3, p4, p5, p6));
 	}
 
@@ -887,7 +886,7 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <R> Mono<@NonNull R> zip(final Iterable<? extends @NonNull Mono<@NonNull ?>> monos, Function<? super @NonNull Object @NonNull [], ? extends @NonNull R> combinator) {
+	public static <R> Mono<R> zip(final Iterable<? extends Mono<?>> monos, Function<? super Object[], ? extends R> combinator) {
 		return onAssembly(new MonoZip<>(false, combinator, monos));
 	}
 
@@ -906,7 +905,7 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <R> Mono<@NonNull R> zip(Function<? super @NonNull Object @NonNull [], ? extends @NonNull R> combinator, Mono<@NonNull ?> @NonNull ... monos) {
+	public static <R> Mono<R> zip(Function<? super Object[], ? extends R> combinator, Mono<?>... monos) {
 		if (monos.length == 0) {
 			return empty();
 		}
@@ -932,7 +931,7 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2> Mono<@NonNull Tuple2<@NonNull T1, @NonNull T2>> zipDelayError(Mono<? extends @NonNull T1> p1, Mono<? extends @NonNull T2> p2) {
+	public static <T1, T2> Mono<Tuple2<T1, T2>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2) {
 		return onAssembly(new MonoZip(true, a -> Tuples.fromArray((Object[])a), p1, p2));
 	}
 
@@ -954,7 +953,7 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2, T3> Mono<@NonNull Tuple3<@NonNull T1, @NonNull T2, @NonNull T3>> zipDelayError(Mono<? extends @NonNull T1> p1, Mono<? extends @NonNull T2> p2, Mono<? extends @NonNull T3> p3) {
+	public static <T1, T2, T3> Mono<Tuple3<T1, T2, T3>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3) {
 		return onAssembly(new MonoZip(true, a -> Tuples.fromArray((Object[])a), p1, p2, p3));
 	}
 
@@ -978,10 +977,10 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2, T3, T4> Mono<@NonNull Tuple4<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4>> zipDelayError(Mono<? extends @NonNull T1> p1,
-			Mono<? extends @NonNull T2> p2,
-			Mono<? extends @NonNull T3> p3,
-			Mono<? extends @NonNull T4> p4) {
+	public static <T1, T2, T3, T4> Mono<Tuple4<T1, T2, T3, T4>> zipDelayError(Mono<? extends T1> p1,
+			Mono<? extends T2> p2,
+			Mono<? extends T3> p3,
+			Mono<? extends T4> p4) {
 		return onAssembly(new MonoZip(true, a -> Tuples.fromArray((Object[])a), p1, p2, p3, p4));
 	}
 
@@ -1006,11 +1005,11 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2, T3, T4, T5> Mono<@NonNull Tuple5<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5>> zipDelayError(Mono<? extends @NonNull T1> p1,
-			Mono<? extends @NonNull T2> p2,
-			Mono<? extends @NonNull T3> p3,
-			Mono<? extends @NonNull T4> p4,
-			Mono<? extends @NonNull T5> p5) {
+	public static <T1, T2, T3, T4, T5> Mono<Tuple5<T1, T2, T3, T4, T5>> zipDelayError(Mono<? extends T1> p1,
+			Mono<? extends T2> p2,
+			Mono<? extends T3> p3,
+			Mono<? extends T4> p4,
+			Mono<? extends T5> p5) {
 		return onAssembly(new MonoZip(true, a -> Tuples.fromArray((Object[])a), p1, p2, p3, p4, p5));
 	}
 
@@ -1038,12 +1037,12 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return a {@link Mono}.
 	 */
 	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static <T1, T2, T3, T4, T5, T6> Mono<@NonNull Tuple6<@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6>> zipDelayError(Mono<? extends @NonNull T1> p1,
-			Mono<? extends @NonNull T2> p2,
-			Mono<? extends @NonNull T3> p3,
-			Mono<? extends @NonNull T4> p4,
-			Mono<? extends @NonNull T5> p5,
-			Mono<? extends @NonNull T6> p6) {
+	public static <T1, T2, T3, T4, T5, T6> Mono<Tuple6<T1, T2, T3, T4, T5, T6>> zipDelayError(Mono<? extends T1> p1,
+			Mono<? extends T2> p2,
+			Mono<? extends T3> p3,
+			Mono<? extends T4> p4,
+			Mono<? extends T5> p5,
+			Mono<? extends T6> p6) {
 		return onAssembly(new MonoZip(true, a -> Tuples.fromArray((Object[])a), p1, p2, p3, p4, p5, p6));
 	}
 
@@ -1064,7 +1063,7 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 *
 	 * @return a {@link Mono}.
 	 */
-	public static <R> Mono<@NonNull R> zipDelayError(final Iterable<? extends @NonNull Mono<@NonNull ?>> monos, Function<? super @NonNull Object @NonNull [], ? extends @NonNull R> combinator) {
+	public static <R> Mono<R> zipDelayError(final Iterable<? extends Mono<?>> monos, Function<? super Object[], ? extends R> combinator) {
 		return onAssembly(new MonoZip<>(true, combinator, monos));
 	}
 
@@ -1084,8 +1083,8 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 *
 	 * @return a combined {@link Mono}.
 	 */
-	public static <R>  Mono<@NonNull R> zipDelayError(Function<? super @NonNull Object @NonNull [], ? extends @NonNull R>
-			combinator, Mono<?> @NonNull ... monos) {
+	public static <R>  Mono<R> zipDelayError(Function<? super Object[], ? extends R>
+			combinator, Mono<?>... monos) {
 		if (monos.length == 0) {
 			return empty();
 		}
@@ -1113,7 +1112,7 @@ public static <T1, T2, O> Mono<O> zip(Mono<? extends @NonNull T1> p1, Mono<?
 	 * @return the {@link Mono} transformed to an instance of P
 	 * @see #compose for a bounded conversion to {@link Publisher}
 	 */
-	public final <P> P as(Function<? super @NonNull Mono<@NonNull T>, @NonNull P> transformer) {
+	public final <P> P as(Function<? super Mono<T>, P> transformer) {
 		return transformer.apply(this);
 	}
 
@@ -1129,7 +1128,7 @@ public final <P> P as(Function<? super @NonNull Mono<@NonNull T>, @NonNull P> tr
 	 * @return a new combined Mono
 	 * @see #when
 	 */
-	public final Mono<Void> and(Publisher<@NonNull ?> other) {
+	public final Mono<Void> and(Publisher<?> other) {
 		if (this instanceof MonoWhen) {
 			@SuppressWarnings("unchecked") MonoWhen o = (MonoWhen) this;
 			Mono<Void> result = o.whenAdditionalSource(other);
@@ -1197,7 +1196,7 @@ public T block(Duration timeout) {
 	 *
 	 * @return a casted {@link Mono}
 	 */
-	public final <E> Mono<@NonNull E> cast(Class<E> clazz) {
+	public final <E> Mono<E> cast(Class<E> clazz) {
 		Objects.requireNonNull(clazz, "clazz");
 		return map(clazz::cast);
 	}
@@ -1211,11 +1210,11 @@ public T block(Duration timeout) {
 	 *
 	 * @return a replaying {@link Mono}
 	 */
-	public final Mono<@NonNull T> cache() {
+	public final Mono<T> cache() {
 		return onAssembly(new MonoProcessor<>(this));
 	}
 
-	public final Mono<@NonNull T> cache(Duration ttl) {
+	public final Mono<T> cache(Duration ttl) {
 		return onAssembly(new MonoCacheTime<>(this, ttl, Schedulers.parallel()));
 	}
 
@@ -1228,7 +1227,7 @@ public T block(Duration timeout) {
 	 *
 	 * @return a scheduled cancel {@link Mono}
 	 */
-	public final Mono<@NonNull T> cancelOn(Scheduler scheduler) {
+	public final Mono<T> cancelOn(Scheduler scheduler) {
 		return onAssembly(new MonoCancelOn<>(this, scheduler));
 	}
 
@@ -1242,7 +1241,7 @@ public T block(Duration timeout) {
 	 *
 	 * @return the assembly tracing {@link Mono}
 	 */
-	public final Mono<@NonNull T> checkpoint() {
+	public final Mono<T> checkpoint() {
 		return checkpoint(null, true);
 	}
 
@@ -1262,7 +1261,7 @@ public T block(Duration timeout) {
 	 * @param description a unique enough description to include in the light assembly traceback.
 	 * @return the assembly marked {@link Mono}
 	 */
-	public final Mono<@NonNull T> checkpoint(String description) {
+	public final Mono<T> checkpoint(String description) {
 		return checkpoint(Objects.requireNonNull(description), false);
 	}
 
@@ -1292,7 +1291,7 @@ public T block(Duration timeout) {
 	 * to use a stack trace.
 	 * @return the assembly marked {@link Mono}.
 	 */
-	public final Mono<@NonNull T> checkpoint(@Nullable String description, boolean forceStackTrace) {
+	public final Mono<T> checkpoint(@Nullable String description, boolean forceStackTrace) {
 		return new MonoOnAssembly<>(this, description, !forceStackTrace);
 	}
 
@@ -1313,7 +1312,7 @@ public T block(Duration timeout) {
 	 * @see #as as() for a loose conversion to an arbitrary type
 	 * @see #transform(Function)
 	 */
-	public final <V> Mono<@NonNull V> compose(Function<? super @NonNull Mono<@NonNull T>, ? extends @NonNull Publisher<@NonNull V>> transformer) {
+	public final <V> Mono<V> compose(Function<? super Mono<T>, ? extends Publisher<V>> transformer) {
 		return defer(() -> from(transformer.apply(this)));
 	}
 
@@ -1327,7 +1326,7 @@ public T block(Duration timeout) {
 	 *
 	 * @return a concatenated {@link Flux}
 	 */
-	public final Flux<@NonNull T> concatWith(Publisher<? extends @NonNull T> other) {
+	public final Flux<T> concatWith(Publisher<? extends T> other) {
 		return Flux.concat(this, other);
 	}
 
@@ -1343,7 +1342,7 @@ public T block(Duration timeout) {
 	 *
 	 * @see Flux#defaultIfEmpty(Object)
 	 */
-	public final Mono<@NonNull T> defaultIfEmpty(T defaultV) {
+	public final Mono<T> defaultIfEmpty(T defaultV) {
 	    if (this instanceof Fuseable.ScalarCallable) {
 		    try {
 			    T v = block();
@@ -1374,7 +1373,7 @@ public T block(Duration timeout) {
 	 * @param delay duration by which to delay the {@link Subscriber#onNext} signal
 	 * @return a delayed {@link Mono}
 	 */
-	public final Mono<@NonNull T> delayElement(Duration delay) {
+	public final Mono<T> delayElement(Duration delay) {
 		return delayElement(delay, Schedulers.parallel());
 	}
 
@@ -1394,7 +1393,7 @@ public T block(Duration timeout) {
 	 * @param timer a time-capable {@link Scheduler} instance to delay the value signal on
 	 * @return a delayed {@link Mono}
 	 */
-	public final Mono<@NonNull T> delayElement(Duration delay, Scheduler timer) {
+	public final Mono<T> delayElement(Duration delay, Scheduler timer) {
 		return onAssembly(new MonoDelayElement<>(this, delay.toMillis(), TimeUnit.MILLISECONDS, timer));
 	}
 
@@ -1418,7 +1417,7 @@ public T block(Duration timeout) {
 	 *
 	 * @return this Mono, but delayed until the derived publisher terminates.
 	 */
-	public final Mono<@NonNull T> delayUntil(Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull ?>> triggerProvider) {
+	public final Mono<T> delayUntil(Function<? super T, ? extends Publisher<?>> triggerProvider) {
 		Objects.requireNonNull(triggerProvider, "triggerProvider required");
 		if (this instanceof MonoDelayUntil) {
 			return ((MonoDelayUntil<T>) this).copyWithNewTriggerGenerator(false,triggerProvider);
@@ -1438,7 +1437,7 @@ public T block(Duration timeout) {
 	 * @return a delayed {@link Mono}
 	 *
 	 */
-	public final Mono<@NonNull T> delaySubscription(Duration delay) {
+	public final Mono<T> delaySubscription(Duration delay) {
 		return delaySubscription(delay, Schedulers.parallel());
 	}
 
@@ -1455,7 +1454,7 @@ public T block(Duration timeout) {
 	 * @return a delayed {@link Mono}
 	 *
 	 */
-	public final Mono<@NonNull T> delaySubscription(Duration delay, Scheduler timer) {
+	public final Mono<T> delaySubscription(Duration delay, Scheduler timer) {
 		return delaySubscription(Mono.delay(delay, timer));
 	}
 
@@ -1473,7 +1472,7 @@ public T block(Duration timeout) {
 	 * @return a delayed {@link Mono}
 	 *
 	 */
-	public final <U> Mono<@NonNull T> delaySubscription(Publisher<@NonNull U> subscriptionDelay) {
+	public final <U> Mono<T> delaySubscription(Publisher<U> subscriptionDelay) {
 		return onAssembly(new MonoDelaySubscription<>(this, subscriptionDelay));
 	}
 
@@ -1491,7 +1490,7 @@ public T block(Duration timeout) {
 	 * @return a dematerialized {@link Mono}
 	 * @see #materialize()
 	 */
-	public final <X> Mono<@NonNull X> dematerialize() {
+	public final <X> Mono<X> dematerialize() {
 		@SuppressWarnings("unchecked")
 		Mono<Signal<X>> thiz = (Mono<Signal<X>>) this;
 		return onAssembly(new MonoDematerialize<>(thiz));
@@ -1513,7 +1512,7 @@ public T block(Duration timeout) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<@NonNull T> doAfterSuccessOrError(BiConsumer<? super @Nullable T, @Nullable Throwable> afterSuccessOrError) {
+	public final Mono<T> doAfterSuccessOrError(BiConsumer<? super T, Throwable> afterSuccessOrError) {
 		return onAssembly(new MonoPeekTerminal<>(this, null, null, afterSuccessOrError));
 	}
 
@@ -1548,7 +1547,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 * or cancel)
 	 * @return an observed {@link Mono}
 	 */
-	public final Mono<@NonNull T> doFinally(Consumer<@NonNull SignalType> onFinally) {
+	public final Mono<T> doFinally(Consumer<SignalType> onFinally) {
 		Objects.requireNonNull(onFinally, "onFinally");
 		if (this instanceof Fuseable) {
 			return onAssembly(new MonoDoFinallyFuseable<>(this, onFinally));
@@ -1567,7 +1566,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<@NonNull T> doOnCancel(Runnable onCancel) {
+	public final Mono<T> doOnCancel(Runnable onCancel) {
 		Objects.requireNonNull(onCancel, "onCancel");
 		return doOnSignal(this, null, null, null, null, null, onCancel);
 	}
@@ -1583,7 +1582,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<@NonNull T> doOnNext(Consumer<? super @NonNull T> onNext) {
+	public final Mono<T> doOnNext(Consumer<? super T> onNext) {
 		Objects.requireNonNull(onNext, "onNext");
 		return doOnSignal(this, null, onNext, null, null, null, null);
 	}
@@ -1605,7 +1604,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<@NonNull T> doOnSuccess(Consumer<? super @Nullable T> onSuccess) {
+	public final Mono<T> doOnSuccess(Consumer<? super T> onSuccess) {
 		Objects.requireNonNull(onSuccess, "onSuccess");
 		return onAssembly(new MonoPeekTerminal<>(this, onSuccess, null, null));
 	}
@@ -1625,7 +1624,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 * @see #materialize()
 	 * @see Signal
 	 */
-	public final Mono<@NonNull T> doOnEach(Consumer<? super @NonNull Signal<@Nullable T>> signalConsumer) {
+	public final Mono<T> doOnEach(Consumer<? super Signal<T>> signalConsumer) {
 		Objects.requireNonNull(signalConsumer, "signalConsumer");
 		return doOnSignal(this,
 				null,
@@ -1644,7 +1643,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<@NonNull T> doOnError(Consumer<? super @NonNull Throwable> onError) {
+	public final Mono<T> doOnError(Consumer<? super Throwable> onError) {
 		Objects.requireNonNull(onError, "onError");
 		return doOnSignal(this, null, null, onError, null, null, null);
 	}
@@ -1662,8 +1661,8 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 * @return an observed  {@link Mono}
 	 *
 	 */
-	public final <E extends Throwable> Mono<@NonNull T> doOnError(Class<E> exceptionType,
-			final Consumer<? super @NonNull E> onError) {
+	public final <E extends Throwable> Mono<T> doOnError(Class<E> exceptionType,
+			final Consumer<? super E> onError) {
 		Objects.requireNonNull(exceptionType, "type");
 		@SuppressWarnings("unchecked")
 		Consumer<Throwable> handler = (Consumer<Throwable>)onError;
@@ -1681,8 +1680,8 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 * @return an observed  {@link Mono}
 	 *
 	 */
-	public final Mono<@NonNull T> doOnError(Predicate<? super @NonNull Throwable> predicate,
-			final Consumer<? super @NonNull Throwable> onError) {
+	public final Mono<T> doOnError(Predicate<? super Throwable> predicate,
+			final Consumer<? super Throwable> onError) {
 		Objects.requireNonNull(predicate, "predicate");
 		return doOnError(t -> {
 			if (predicate.test(t)) {
@@ -1703,7 +1702,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 *
 	 * @return an observed  {@link Mono}
 	 */
-	public final Mono<@NonNull T> doOnRequest(final LongConsumer consumer) {
+	public final Mono<T> doOnRequest(final LongConsumer consumer) {
 		Objects.requireNonNull(consumer, "consumer");
 		return doOnSignal(this, null, null, null, null, consumer, null);
 	}
@@ -1718,7 +1717,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<@NonNull T> doOnSubscribe(Consumer<? super @NonNull Subscription> onSubscribe) {
+	public final Mono<T> doOnSubscribe(Consumer<? super Subscription> onSubscribe) {
 		Objects.requireNonNull(onSubscribe, "onSubscribe");
 		return doOnSignal(this, onSubscribe, null, null,  null, null, null);
 	}
@@ -1739,7 +1738,7 @@ public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<T> doOnSuccessOrError(BiConsumer<? super @Nullable T, @Nullable Throwable> onSuccessOrError) {
+	public final Mono<T> doOnSuccessOrError(BiConsumer<? super T, Throwable> onSuccessOrError) {
 		Objects.requireNonNull(onSuccessOrError, "onSuccessOrError");
 		return onAssembly(new MonoPeekTerminal<>(this, null, onSuccessOrError, null));
 	}
@@ -1775,7 +1774,7 @@ public final Mono<T> doOnTerminate(Runnable onTerminate) {
 	 *
 	 * @return a new {@link Mono} that emits a tuple of time elapsed in milliseconds and matching data
 	 */
-	public final Mono<@NonNull Tuple2<@NonNull Long, @NonNull T>> elapsed() {
+	public final Mono<Tuple2<Long, T>> elapsed() {
 		return elapsed(Schedulers.parallel());
 	}
 
@@ -1790,7 +1789,7 @@ public final Mono<T> doOnTerminate(Runnable onTerminate) {
 	 * @param scheduler a {@link Scheduler} instance to read time from
 	 * @return a new {@link Mono} that emits a tuple of time elapsed in milliseconds and matching data
 	 */
-	public final Mono<@NonNull Tuple2<@NonNull Long, @NonNull T>> elapsed(Scheduler scheduler) {
+	public final Mono<Tuple2<Long, T>> elapsed(Scheduler scheduler) {
 		Objects.requireNonNull(scheduler, "scheduler");
 		return onAssembly(new MonoElapsed<>(this, scheduler));
 	}
@@ -1960,7 +1959,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a filtered {@link Mono}
 	 */
-	public final Mono<@NonNull T> filter(final Predicate<? super @NonNull T> tester) {
+	public final Mono<T> filter(final Predicate<? super T> tester) {
 		if (this instanceof Fuseable) {
 			return onAssembly(new MonoFilterFuseable<>(this, tester));
 		}
@@ -1980,7 +1979,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 * to filter the Mono with
 	 * @return a filtered {@link Mono}
 	 */
-	public final Mono<@NonNull T> filterWhen(Function<? super @NonNull T, ? extends @NonNull Publisher<@NonNull Boolean>> asyncPredicate) {
+	public final Mono<T> filterWhen(Function<? super T, ? extends Publisher<Boolean>> asyncPredicate) {
 		return onAssembly(new MonoFilterWhen<>(this, asyncPredicate));
 	}
 
@@ -1996,7 +1995,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a new {@link Mono} with an asynchronously mapped value.
 	 */
-	public final <R> Mono<@NonNull R> flatMap(Function<? super @NonNull T, ? extends @NonNull Mono<? extends @NonNull R>>
+	public final <R> Mono<R> flatMap(Function<? super T, ? extends Mono<? extends R>>
 			transformer) {
 		return onAssembly(new MonoFlatMap<>(this, transformer));
 	}
@@ -2014,7 +2013,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a new {@link Flux} as the sequence is not guaranteed to be single at most
 	 */
-	public final <R> Flux<@NonNull R> flatMapMany(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper) {
+	public final <R> Flux<R> flatMapMany(Function<? super T, ? extends Publisher<? extends R>> mapper) {
 		return Flux.onAssembly(new MonoFlatMapMany<>(this, mapper));
 	}
 
@@ -2034,7 +2033,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @see Flux#flatMap(Function, Function, Supplier)
 	 */
-	public final <R> Flux<@NonNull R> flatMapMany(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapperOnNext,
+	public final <R> Flux<R> flatMapMany(Function<? super T, ? extends Publisher<? extends R>> mapperOnNext,
 			Function<? super Throwable, ? extends Publisher<? extends R>> mapperOnError,
 			Supplier<? extends Publisher<? extends R>> mapperOnComplete) {
 		return flux().flatMap(mapperOnNext, mapperOnError, mapperOnComplete);
@@ -2054,7 +2053,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 * @return a merged {@link Flux}
 	 *
 	 */
-	public final <R> Flux<@NonNull R> flatMapIterable(Function<? super @NonNull T, ? extends @NonNull Iterable<? extends @NonNull R>> mapper) {
+	public final <R> Flux<R> flatMapIterable(Function<? super T, ? extends Iterable<? extends R>> mapper) {
 		return Flux.onAssembly(new MonoFlattenIterable<>(this, mapper, Integer
 				.MAX_VALUE, Queues.one()));
 	}
@@ -2064,7 +2063,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a {@link Flux} variant of this {@link Mono}
 	 */
-    public final Flux<@NonNull T> flux() {
+    public final Flux<T> flux() {
 	    if (this instanceof Callable) {
 	        if (this instanceof Fuseable.ScalarCallable) {
 		        T v;
@@ -2094,7 +2093,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 * @return a new {@link Mono} with <code>true</code> if a value is emitted and <code>false</code>
 	 * otherwise
 	 */
-	public final Mono<@NonNull Boolean> hasElement() {
+	public final Mono<Boolean> hasElement() {
 		return onAssembly(new MonoHasElement<>(this));
 	}
 
@@ -2109,7 +2108,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a transformed {@link Mono}
 	 */
-	public final <R> Mono<@NonNull R> handle(BiConsumer<? super @NonNull T, @NonNull SynchronousSink<@NonNull R>> handler) {
+	public final <R> Mono<R> handle(BiConsumer<? super T, SynchronousSink<R>> handler) {
 		if (this instanceof Fuseable) {
 			return onAssembly(new MonoHandleFuseable<>(this, handler));
 		}
@@ -2124,7 +2123,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a new {@link Mono} preventing {@link Publisher} / {@link Subscription} based Reactor optimizations
 	 */
-	public final Mono<@NonNull T> hide() {
+	public final Mono<T> hide() {
 	    return onAssembly(new MonoHide<>(this));
 	}
 	
@@ -2137,7 +2136,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @return a new empty {@link Mono} representing the completion of this {@link Mono}.
 	 */
-	public final Mono<@NonNull T> ignoreElement() {
+	public final Mono<T> ignoreElement() {
 		return onAssembly(new MonoIgnoreElement<>(this));
 	}
 
@@ -2156,7 +2155,7 @@ public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>
 	 *
 	 * @see Flux#log()
 	 */
-	public final Mono<@NonNull T> log() {
+	public final Mono<T> log() {
 		return log(null, Level.INFO);
 	}
 
@@ -2198,7 +2197,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a new {@link Mono}
 	 *
 	 */
-	public final Mono<@NonNull T> log(@Nullable String category, Level level, SignalType @NonNull ... options) {
+	public final Mono<T> log(@Nullable String category, Level level, SignalType... options) {
 		return log(category, level, false, options);
 	}
 
@@ -2226,10 +2225,10 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a new unaltered {@link Mono}
 	 */
-	public final Mono<@NonNull T> log(@Nullable String category,
+	public final Mono<T> log(@Nullable String category,
 			Level level,
 			boolean showOperatorLine,
-			SignalType @NonNull ... options) {
+			SignalType... options) {
 		SignalLogger<T> log = new SignalLogger<>(this, category, level,
 				showOperatorLine, options);
 
@@ -2250,7 +2249,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final <R> Mono<@NonNull R> map(Function<? super @NonNull T, ? extends @NonNull R> mapper) {
+	public final <R> Mono<R> map(Function<? super T, ? extends R> mapper) {
 		if (this instanceof Fuseable) {
 			return onAssembly(new MonoMapFuseable<>(this, mapper));
 		}
@@ -2269,7 +2268,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a {@link Mono} of materialized {@link Signal}
 	 * @see #dematerialize()
 	 */
-	public final Mono<@NonNull Signal<@Nullable T>> materialize() {
+	public final Mono<Signal<T>> materialize() {
 		return onAssembly(new MonoMaterialize<>(this));
 	}
 
@@ -2284,7 +2283,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a new {@link Flux} as the sequence is not guaranteed to be at most 1
 	 */
-	public final Flux<@NonNull T> mergeWith(Publisher<? extends @NonNull T> other) {
+	public final Flux<T> mergeWith(Publisher<? extends T> other) {
 		return Flux.merge(this, other);
 	}
 
@@ -2295,7 +2294,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @param name a name for the sequence
 	 * @return the same sequence, but bearing a name
 	 */
-	public final Mono<@NonNull T> name(String name) {
+	public final Mono<T> name(String name) {
 		return MonoName.createOrAppend(this, name);
 	}
 
@@ -2310,7 +2309,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a new {@link Mono}
 	 * @see #first
 	 */
-	public final Mono<@NonNull T> or(Mono<? extends @NonNull T> other) {
+	public final Mono<T> or(Mono<? extends T> other) {
 		if (this instanceof MonoFirst) {
 			MonoFirst<T> a = (MonoFirst<T>) this;
 			Mono<T> result =  a.orAdditionalSource(other);
@@ -2333,7 +2332,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a new {@link Mono} filtered on the requested type
 	 */
-	public final <U> Mono<@NonNull U> ofType(final Class<U> clazz) {
+	public final <U> Mono<U> ofType(final Class<U> clazz) {
 		Objects.requireNonNull(clazz, "clazz");
 		return filter(o -> clazz.isAssignableFrom(o.getClass())).cast(clazz);
 	}
@@ -2350,8 +2349,8 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a {@link Mono} that transforms some source errors to other errors
 	 */
-	public final Mono<@NonNull T> onErrorMap(Predicate<? super @NonNull Throwable> predicate,
-			Function<? super @NonNull Throwable, ? extends @NonNull Throwable> mapper) {
+	public final Mono<T> onErrorMap(Predicate<? super Throwable> predicate,
+			Function<? super Throwable, ? extends Throwable> mapper) {
 		return onErrorResume(predicate, e -> Mono.error(mapper.apply(e)));
 	}
 
@@ -2365,7 +2364,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a {@link Mono} that transforms source errors to other errors
 	 */
-	public final Mono<@NonNull T> onErrorMap(Function<? super @NonNull Throwable, ? extends @NonNull Throwable> mapper) {
+	public final Mono<T> onErrorMap(Function<? super Throwable, ? extends Throwable> mapper) {
 		return onErrorResume(e -> Mono.error(mapper.apply(e)));
 	}
 
@@ -2381,8 +2380,8 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a {@link Mono} that transforms some source errors to other errors
 	 */
-	public final <E extends Throwable> Mono<@NonNull T> onErrorMap(Class<E> type,
-			Function<? super @NonNull E, ? extends @NonNull Throwable> mapper) {
+	public final <E extends Throwable> Mono<T> onErrorMap(Class<E> type,
+			Function<? super E, ? extends Throwable> mapper) {
 		@SuppressWarnings("unchecked")
 		Function<Throwable, Throwable> handler = (Function<Throwable, Throwable>)mapper;
 		return onErrorMap(type::isInstance, handler);
@@ -2401,8 +2400,8 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @see Flux#onErrorResume
 	 */
-	public final Mono<@NonNull T> onErrorResume(Function<? super @NonNull Throwable, ? extends @NonNull Mono<? extends
-            @NonNull T>> fallback) {
+	public final Mono<T> onErrorResume(Function<? super Throwable, ? extends Mono<? extends
+			T>> fallback) {
 		return onAssembly(new MonoOnErrorResume<>(this, fallback));
 	}
 
@@ -2420,8 +2419,8 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a {@link Mono} falling back upon source onError
 	 * @see Flux#onErrorResume
 	 */
-	public final <E extends Throwable> Mono<@NonNull T> onErrorResume(Class<E> type,
-			Function<? super @NonNull E, ? extends @NonNull Mono<? extends @NonNull T>> fallback) {
+	public final <E extends Throwable> Mono<T> onErrorResume(Class<E> type,
+			Function<? super E, ? extends Mono<? extends T>> fallback) {
 		Objects.requireNonNull(type, "type");
 		@SuppressWarnings("unchecked")
 		Function<? super Throwable, Mono<? extends T>> handler = (Function<? super
@@ -2441,8 +2440,8 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a {@link Mono} falling back upon source onError
 	 * @see Flux#onErrorResume
 	 */
-	public final Mono<@NonNull T> onErrorResume(Predicate<? super @NonNull Throwable> predicate,
-			Function<? super @NonNull Throwable, ? extends @NonNull Mono<? extends @NonNull T>> fallback) {
+	public final Mono<T> onErrorResume(Predicate<? super Throwable> predicate,
+			Function<? super Throwable, ? extends Mono<? extends T>> fallback) {
 		Objects.requireNonNull(predicate, "predicate");
 		return onErrorResume(e -> predicate.test(e) ? fallback.apply(e) : error(e));
 	}
@@ -2457,7 +2456,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a new falling back {@link Mono}
 	 */
-	public final Mono<@NonNull T> onErrorReturn(final T fallback) {
+	public final Mono<T> onErrorReturn(final T fallback) {
 		return onErrorResume(throwable -> just(fallback));
 	}
 
@@ -2472,7 +2471,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a new falling back {@link Mono}
 	 */
-	public final <E extends Throwable> Mono<@NonNull T> onErrorReturn(Class<E> type, T fallbackValue) {
+	public final <E extends Throwable> Mono<T> onErrorReturn(Class<E> type, T fallbackValue) {
 		return onErrorResume(type, throwable -> just(fallbackValue));
 	}
 
@@ -2486,7 +2485,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final Mono<@NonNull T> onErrorReturn(Predicate<? super @NonNull Throwable> predicate, T fallbackValue) {
+	public final Mono<T> onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue) {
 		return onErrorResume(predicate,  throwable -> just(fallbackValue));
 	}
 
@@ -2498,7 +2497,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a detachable {@link Mono}
 	 */
-	public final Mono<@NonNull T> onTerminateDetach() {
+	public final Mono<T> onTerminateDetach() {
 		return new MonoDetach<>(this);
 	}
 
@@ -2512,8 +2511,8 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a new {@link Mono}
 	 */
-	public final <R> Mono<@NonNull R> publish(Function<? super @NonNull Mono<T>, ? extends @NonNull Mono<? extends
-            @NonNull R>> transform) {
+	public final <R> Mono<R> publish(Function<? super Mono<T>, ? extends Mono<? extends
+			R>> transform) {
 		return onAssembly(new MonoPublishMulticast<>(this, transform));
 	}
 
@@ -2536,7 +2535,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return an asynchronously producing {@link Mono}
 	 */
-	public final Mono<@NonNull T> publishOn(Scheduler scheduler) {
+	public final Mono<T> publishOn(Scheduler scheduler) {
 		if(this instanceof Callable) {
 			if (this instanceof Fuseable.ScalarCallable) {
 				try {
@@ -2563,7 +2562,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return an indefinitely repeated {@link Flux} on onComplete
 	 */
-	public final Flux<@NonNull T> repeat() {
+	public final Flux<T> repeat() {
 		return repeat(Flux.ALWAYS_BOOLEAN_SUPPLIER);
 	}
 
@@ -2578,7 +2577,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a {@link Flux} that repeats on onComplete while the predicate matches
 	 *
 	 */
-	public final Flux<@NonNull T> repeat(BooleanSupplier predicate) {
+	public final Flux<T> repeat(BooleanSupplier predicate) {
 		return Flux.onAssembly(new MonoRepeatPredicate<>(this, predicate));
 	}
 
@@ -2592,7 +2591,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a {@link Flux} that repeats on onComplete, up to the specified number of repetitions
 	 */
-	public final Flux<@NonNull T> repeat(long numRepeat) {
+	public final Flux<T> repeat(long numRepeat) {
 		if(numRepeat == 0){
 			return Flux.empty();
 		}
@@ -2612,7 +2611,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a {@link Flux} that repeats on onComplete while the predicate matches,
 	 * up to the specified number of repetitions
 	 */
-	public final Flux<@NonNull T> repeat(long numRepeat, BooleanSupplier predicate) {
+	public final Flux<T> repeat(long numRepeat, BooleanSupplier predicate) {
 		return Flux.defer(() -> repeat(Flux.countingBooleanSupplier(predicate, numRepeat)));
 	}
 
@@ -2633,7 +2632,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a {@link Flux} that repeats on onComplete when the companion {@link Publisher} produces an
 	 * onNext signal
 	 */
-	public final Flux<@NonNull T> repeatWhen(Function<@NonNull Flux<@NonNull Long>, ? extends @NonNull Publisher<@NonNull ?>> repeatFactory) {
+	public final Flux<T> repeatWhen(Function<Flux<Long>, ? extends Publisher<?>> repeatFactory) {
 		return Flux.onAssembly(new MonoRepeatWhen<>(this, repeatFactory));
 	}
 
@@ -2653,7 +2652,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * as long as the companion {@link Publisher} produces an onNext signal
 	 *
 	 */
-	public final Mono<@NonNull T> repeatWhenEmpty(Function<@NonNull Flux<@NonNull Long>, ? extends @NonNull Publisher<@NonNull ?>> repeatFactory) {
+	public final Mono<T> repeatWhenEmpty(Function<Flux<Long>, ? extends Publisher<?>> repeatFactory) {
 		return repeatWhenEmpty(Integer.MAX_VALUE, repeatFactory);
 	}
 
@@ -2676,7 +2675,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a {@link Mono} that resubscribes to this {@link Mono} if the previous subscription was empty,
 	 * as long as the companion {@link Publisher} produces an onNext signal and the maximum number of repeats isn't exceeded.
 	 */
-	public final Mono<@NonNull T> repeatWhenEmpty(int maxRepeat, Function<@NonNull Flux<@NonNull Long>, ? extends @NonNull Publisher<@NonNull ?>> repeatFactory) {
+	public final Mono<T> repeatWhenEmpty(int maxRepeat, Function<Flux<Long>, ? extends Publisher<?>> repeatFactory) {
 		return Mono.defer(() -> {
 			Flux<Long> iterations;
 
@@ -2704,7 +2703,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a {@link Mono} that retries on onError
 	 */
-	public final Mono<@NonNull T> retry() {
+	public final Mono<T> retry() {
 		return retry(Long.MAX_VALUE);
 	}
 
@@ -2720,7 +2719,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a {@link Mono} that retries on onError up to the specified number of retry attempts.
 	 */
-	public final Mono<@NonNull T> retry(long numRetries) {
+	public final Mono<T> retry(long numRetries) {
 		return onAssembly(new MonoRetry<>(this, numRetries));
 	}
 
@@ -2735,7 +2734,7 @@ public final Mono<T> log(@Nullable String category) {
 	 *
 	 * @return a {@link Mono} that retries on onError if the predicates matches.
 	 */
-	public final Mono<@NonNull T> retry(Predicate<? super @NonNull Throwable> retryMatcher) {
+	public final Mono<T> retry(Predicate<? super Throwable> retryMatcher) {
 		return onAssembly(new MonoRetryPredicate<>(this, retryMatcher));
 	}
 
@@ -2753,7 +2752,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * attempts, only if the predicate matches.
 	 *
 	 */
-	public final Mono<@NonNull T> retry(long numRetries, Predicate<? super @NonNull Throwable> retryMatcher) {
+	public final Mono<T> retry(long numRetries, Predicate<? super Throwable> retryMatcher) {
 		return defer(() -> retry(Flux.countingPredicate(retryMatcher, numRetries)));
 	}
 
@@ -2773,7 +2772,7 @@ public final Mono<T> log(@Nullable String category) {
 	 * @return a {@link Mono} that retries on onError when the companion {@link Publisher} produces an
 	 * onNext signal
 	 */
-	public final Mono<@NonNull T> retryWhen(Function<@NonNull Flux<@NonNull Throwable>, ? extends @NonNull Publisher<@NonNull ?>> whenFactory) {
+	public final Mono<T> retryWhen(Function<Flux<Throwable>, ? extends Publisher<?>> whenFactory) {
 		return onAssembly(new MonoRetryWhen<>(this, whenFactory));
 	}
 
@@ -2817,7 +2816,7 @@ public final Disposable subscribe() {
 	 *
 	 * @return a new {@link Disposable} that can be used to cancel the underlying {@link Subscription}
 	 */
-	public final Disposable subscribe(Consumer<? super @NonNull T> consumer) {
+	public final Disposable subscribe(Consumer<? super T> consumer) {
 		Objects.requireNonNull(consumer, "consumer");
 		return subscribe(consumer, null, null);
 	}
@@ -2842,7 +2841,7 @@ public final Disposable subscribe(Consumer<? super @NonNull T> consumer) {
 	 *
 	 * @return a new {@link Disposable} that can be used to cancel the underlying {@link Subscription}
 	 */
-	public final Disposable subscribe(@Nullable Consumer<? super @NonNull T> consumer, Consumer<? super @NonNull Throwable> errorConsumer) {
+	public final Disposable subscribe(@Nullable Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer) {
 		Objects.requireNonNull(errorConsumer, "errorConsumer");
 		return subscribe(consumer, errorConsumer, null);
 	}
@@ -2869,8 +2868,8 @@ public final Disposable subscribe(@Nullable Consumer<? super @NonNull T> consume
 	 * @return a new {@link Disposable} that can be used to cancel the underlying {@link Subscription}
 	 */
 	public final Disposable subscribe(
-			@Nullable Consumer<? super @NonNull T> consumer,
-			@Nullable Consumer<? super @NonNull Throwable> errorConsumer,
+			@Nullable Consumer<? super T> consumer,
+			@Nullable Consumer<? super Throwable> errorConsumer,
 			@Nullable Runnable completeConsumer) {
 		return subscribe(consumer, errorConsumer, completeConsumer, null);
 	}
@@ -2901,16 +2900,16 @@ public final Disposable subscribe(
 	 * @return a new {@link Disposable} that can be used to cancel the underlying {@link Subscription}
 	 */
 	public final Disposable subscribe(
-			@Nullable Consumer<? super @NonNull T> consumer,
-			@Nullable Consumer<? super @NonNull Throwable> errorConsumer,
+			@Nullable Consumer<? super T> consumer,
+			@Nullable Consumer<? super Throwable> errorConsumer,
 			@Nullable Runnable completeConsumer,
-			@Nullable Consumer<? super @Nullable Subscription> subscriptionConsumer) {
+			@Nullable Consumer<? super Subscription> subscriptionConsumer) {
 		return subscribeWith(new LambdaMonoSubscriber<>(consumer, errorConsumer,
 				completeConsumer, subscriptionConsumer));
 	}
 
 	@Override
-	public final void subscribe(Subscriber<? super @NonNull T> actual) {
+	public final void subscribe(Subscriber<? super T> actual) {
 		onLastAssembly(this).subscribe(Operators.toCoreSubscriber(actual));
 	}
 
@@ -2924,7 +2923,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @param actual the {@link Subscriber} interested into the published sequence
 	 * @see Publisher#subscribe(Subscriber)
 	 */
-	public abstract void subscribe(CoreSubscriber<? super @NonNull T> actual);
+	public abstract void subscribe(CoreSubscriber<? super T> actual);
 
 	/**
 	 * Enrich a potentially empty downstream {@link Context} by adding all values
@@ -2946,7 +2945,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a contextualized {@link Mono}
 	 * @see Context
 	 */
-	public final Mono<@NonNull T> subscriberContext(Context mergeContext) {
+	public final Mono<T> subscriberContext(Context mergeContext) {
 		return subscriberContext(c -> c.putAll(mergeContext));
 	}
 
@@ -2969,7 +2968,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a contextualized {@link Mono}
 	 * @see Context
 	 */
-	public final Mono<@NonNull T> subscriberContext(Function<@NonNull Context, @NonNull Context> doOnContext) {
+	public final Mono<T> subscriberContext(Function<Context, Context> doOnContext) {
 		return new MonoSubscriberContext<>(this, doOnContext);
 	}
 
@@ -2990,7 +2989,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Flux} requesting asynchronously
 	 * @see #publishOn(Scheduler)
 	 */
-	public final Mono<@NonNull T> subscribeOn(Scheduler scheduler) {
+	public final Mono<T> subscribeOn(Scheduler scheduler) {
 		if(this instanceof Callable) {
 			if (this instanceof Fuseable.ScalarCallable) {
 				try {
@@ -3018,7 +3017,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return the passed {@link Subscriber} after subscribing it to this {@link Mono}
 	 */
-	public final <E extends @NonNull Subscriber<? super @NonNull T>> E subscribeWith(E subscriber) {
+	public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber) {
 		subscribe(subscriber);
 		return subscriber;
 	}
@@ -3034,7 +3033,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a {@link Mono} falling back upon source completing without elements
 	 * @see Flux#switchIfEmpty
 	 */
-	public final Mono<@NonNull T> switchIfEmpty(Mono<? extends @NonNull T> alternate) {
+	public final Mono<T> switchIfEmpty(Mono<? extends T> alternate) {
 		return onAssembly(new MonoSwitchIfEmpty<>(this, alternate));
 	}
 
@@ -3048,7 +3047,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @param value a tag value
 	 * @return the same sequence, but bearing tags
 	 */
-	public final Mono<@NonNull T> tag(String key, String value) {
+	public final Mono<T> tag(String key, String value) {
 		return MonoName.createOrAppend(this, key, value);
 	}
 
@@ -3063,7 +3062,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Mono} that will propagate the signals from the source unless
 	 * no signal is received for {@code duration}, in which case it completes.
 	 */
-	public final Mono<@NonNull T> take(Duration duration) {
+	public final Mono<T> take(Duration duration) {
 		return take(duration, Schedulers.parallel());
 	}
 
@@ -3080,7 +3079,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Mono} that will propagate the signals from the source unless
 	 * no signal is received for {@code duration}, in which case it completes.
 	 */
-	public final Mono<@NonNull T> take(Duration duration, Scheduler timer) {
+	public final Mono<T> take(Duration duration, Scheduler timer) {
 		return takeUntilOther(Mono.delay(duration, timer));
 	}
 
@@ -3096,7 +3095,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * a signal is first received from the companion {@link Publisher}, in which case it
 	 * completes.
 	 */
-	public final Mono<@NonNull T> takeUntilOther(Publisher<@NonNull ?> other) {
+	public final Mono<T> takeUntilOther(Publisher<?> other) {
 		return onAssembly(new MonoTakeUntilOther<>(this, other));
 	}
 
@@ -3109,7 +3108,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * <p>
 	 * @return a {@link Mono} ignoring its payload (actively dropping)
 	 */
-	public final Mono<@NonNull Void> then() {
+	public final Mono<Void> then() {
 		return empty(this);
 	}
 
@@ -3128,7 +3127,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a new {@link Mono} that emits from the supplied {@link Mono}
 	 */
-	public final <V> Mono<@NonNull V> then(Mono<@NonNull V> other) {
+	public final <V> Mono<V> then(Mono<V> other) {
 		if (this instanceof MonoIgnoreThen) {
             MonoIgnoreThen<T> a = (MonoIgnoreThen<T>) this;
             return a.shift(other);
@@ -3148,7 +3147,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Mono} completing when both publishers have completed in
 	 * sequence
 	 */
-	public final Mono<@NonNull Void> thenEmpty(Publisher<@NonNull Void> other) {
+	public final Mono<Void> thenEmpty(Publisher<Void> other) {
 		return then(fromDirect(other));
 	}
 
@@ -3167,7 +3166,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return a new {@link Flux} that emits from the supplied {@link Publisher} after
 	 * this Mono completes.
 	 */
-	public final <V> Flux<@NonNull V> thenMany(Publisher<@NonNull V> other) {
+	public final <V> Flux<V> thenMany(Publisher<V> other) {
 		@SuppressWarnings("unchecked")
 		Flux<V> concat = (Flux<V>)Flux.concat(ignoreElement(), other);
 		return Flux.onAssembly(concat);
@@ -3184,7 +3183,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Mono} that can time out
 	 */
-	public final Mono<@NonNull T> timeout(Duration timeout) {
+	public final Mono<T> timeout(Duration timeout) {
 		return timeout(timeout, Schedulers.parallel());
 	}
 
@@ -3202,7 +3201,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link Mono} that will fallback to a different {@link Mono} in case of timeout
 	 */
-	public final Mono<@NonNull T> timeout(Duration timeout, @Nullable Mono<? extends @NonNull T> fallback) {
+	public final Mono<T> timeout(Duration timeout, Mono<? extends T> fallback) {
 		return timeout(timeout, fallback, Schedulers.parallel());
 	}
 
@@ -3218,7 +3217,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return an expirable {@link Mono}
 	 */
-	public final Mono<@NonNull T> timeout(Duration timeout, Scheduler timer) {
+	public final Mono<T> timeout(Duration timeout, Scheduler timer) {
 		return timeout(timeout, null, timer);
 	}
 
@@ -3237,7 +3236,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return an expirable {@link Mono} with a fallback {@link Mono}
 	 */
-	public final Mono<@NonNull T> timeout(Duration timeout, @Nullable Mono<? extends @NonNull T> fallback,
+	public final Mono<T> timeout(Duration timeout, @Nullable Mono<? extends T> fallback,
 			Scheduler timer) {
 		final Mono<Long> _timer = Mono.delay(timeout, timer).onErrorReturn(0L);
 
@@ -3260,7 +3259,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @return an expirable {@link Mono} if the item does not come before a {@link Publisher} signals
 	 *
 	 */
-	public final <U> Mono<@NonNull T> timeout(Publisher<@NonNull U> firstTimeout) {
+	public final <U> Mono<T> timeout(Publisher<U> firstTimeout) {
 		return onAssembly(new MonoTimeout<>(this, firstTimeout));
 	}
 
@@ -3280,7 +3279,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * come before a {@link Publisher} signals
 	 *
 	 */
-	public final <U> Mono<@NonNull T> timeout(Publisher<@NonNull U> firstTimeout, Mono<? extends @NonNull T> fallback) {
+	public final <U> Mono<T> timeout(Publisher<U> firstTimeout, Mono<? extends T> fallback) {
 		return onAssembly(new MonoTimeout<>(this, firstTimeout, fallback));
 	}
 
@@ -3294,7 +3293,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a timestamped {@link Mono}
 	 */
-	public final Mono<@NonNull Tuple2<@NonNull Long, @NonNull T>> timestamp() {
+	public final Mono<Tuple2<Long, T>> timestamp() {
 		return timestamp(Schedulers.parallel());
 	}
 
@@ -3309,7 +3308,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @param scheduler a {@link Scheduler} instance to read time from
 	 * @return a timestamped {@link Mono}
 	 */
-	public final Mono<@NonNull Tuple2<@NonNull Long, @NonNull T>> timestamp(Scheduler scheduler) {
+	public final Mono<Tuple2<Long, T>> timestamp(Scheduler scheduler) {
 		Objects.requireNonNull(scheduler, "scheduler");
 		return map(d -> Tuples.of(scheduler.now(TimeUnit.MILLISECONDS), d));
 	}
@@ -3324,7 +3323,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link CompletableFuture}
 	 */
-	public final CompletableFuture<@Nullable T> toFuture() {
+	public final CompletableFuture<T> toFuture() {
 		return subscribeWith(new MonoToCompletableFuture<>());
 	}
 
@@ -3340,7 +3339,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 *
 	 * @return a {@link MonoProcessor} to use to either retrieve value or cancel the underlying {@link Subscription}
 	 */
-	public final MonoProcessor<@NonNull T> toProcessor() {
+	public final MonoProcessor<T> toProcessor() {
 		MonoProcessor<T> result;
 		if (this instanceof MonoProcessor) {
 			result = (MonoProcessor<T>)this;
@@ -3372,7 +3371,7 @@ public final void subscribe(Subscriber<? super @NonNull T> actual) {
 	 * @see #compose(Function) compose(Function) for deferred composition of {@link Mono} for each {@link Subscriber}
 	 * @see #as(Function) as(Function) for a loose conversion to an arbitrary type
 	 */
-	public final <V> Mono<@NonNull V> transform(Function<? super @NonNull Mono<@NonNull T>, ? extends @NonNull Publisher<@NonNull V>> transformer) {
+	public final <V> Mono<V> transform(Function<? super Mono<T>, ? extends Publisher<V>> transformer) {
 		return onAssembly(from(transformer.apply(this)));
 	}
 
@@ -3425,7 +3424,7 @@ public final <T2, O> Mono<O> zipWhen(Function<T, Mono<? extends T2>> rightGenera
 	 *
 	 * @return a new combined Mono
 	 */
-	public final <T2> Mono<@NonNull Tuple2<@NonNull T, @NonNull T2>> zipWith(Mono<? extends @NonNull T2> other) {
+	public final <T2> Mono<Tuple2<T, T2>> zipWith(Mono<? extends T2> other) {
 		return zipWith(other, Flux.tuple2Function());
 	}
 
@@ -3444,7 +3443,7 @@ public final <T2, O> Mono<O> zipWhen(Function<T, Mono<? extends T2>> rightGenera
 	 *
 	 * @return a new combined Mono
 	 */
-	public final <T2, O> Mono<@NonNull O> zipWith(Mono<? extends @NonNull T2> other,
+	public final <T2, O> Mono<O> zipWith(Mono<? extends T2> other,
 			BiFunction<? super T, ? super T2, ? extends O> combinator) {
 		if (this instanceof MonoZip) {
 			@SuppressWarnings("unchecked") MonoZip<T, O> o = (MonoZip<T, O>) this;
@@ -3469,7 +3468,7 @@ public final <T2, O> Mono<O> zipWhen(Function<T, Mono<? extends T2>> rightGenera
 	 * @return the source, potentially wrapped with assembly time cross-cutting behavior
 	 */
 	@SuppressWarnings("unchecked")
-	protected static <T> Mono<@NonNull T> onAssembly(Mono<@NonNull T> source) {
+	protected static <T> Mono<T> onAssembly(Mono<T> source) {
 		Function<Publisher, Publisher> hook = Hooks.onEachOperatorHook;
 		if(hook == null) {
 			return source;
@@ -3489,7 +3488,7 @@ public final <T2, O> Mono<O> zipWhen(Function<T, Mono<? extends T2>> rightGenera
 	 * @return the source, potentially wrapped with assembly time cross-cutting behavior
 	 */
 	@SuppressWarnings("unchecked")
-	protected static <T> Mono<@NonNull T> onLastAssembly(Mono<@NonNull T> source) {
+	protected static <T> Mono<T> onLastAssembly(Mono<T> source) {
 		Function<Publisher, Publisher> hook = Hooks.onLastOperatorHook;
 		if(hook == null) {
 			return source;
@@ -3510,7 +3509,7 @@ static <T> Mono<Void> empty(Publisher<T> source) {
 	}
 
 	@SuppressWarnings("unchecked")
-	static <T> Mono<@NonNull T> doOnSignal(Mono<T> source,
+	static <T> Mono<T> doOnSignal(Mono<T> source,
 			@Nullable Consumer<? super Subscription> onSubscribe,
 			@Nullable Consumer<? super T> onNext,
 			@Nullable Consumer<? super Throwable> onError,
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoCreate.java b/reactor-core/src/main/java/reactor/core/publisher/MonoCreate.java
index 00b46d0f40..2fdac82b70 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoCreate.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoCreate.java
@@ -26,8 +26,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Disposable;
 import reactor.core.publisher.FluxCreate.SinkDisposable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Wraps a the downstream Subscriber into a single emission object and calls the given
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoDelayUntil.java b/reactor-core/src/main/java/reactor/core/publisher/MonoDelayUntil.java
index cde071e431..bd908a95d6 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoDelayUntil.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoDelayUntil.java
@@ -27,8 +27,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Waits for a Mono source to terminate or produce a value, in which case the value is
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoFilterWhen.java b/reactor-core/src/main/java/reactor/core/publisher/MonoFilterWhen.java
index 0f70f0ab2f..4185d70e19 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoFilterWhen.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoFilterWhen.java
@@ -27,8 +27,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Maps the upstream value into a single {@code true} or {@code false} value
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoFlatMap.java b/reactor-core/src/main/java/reactor/core/publisher/MonoFlatMap.java
index 5dd72d550b..8bfcf3f849 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoFlatMap.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoFlatMap.java
@@ -26,8 +26,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Given a Mono source, applies a function on its single item and continues
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoFlatMapMany.java b/reactor-core/src/main/java/reactor/core/publisher/MonoFlatMapMany.java
index 1de27cdf74..f1ecc21033 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoFlatMapMany.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoFlatMapMany.java
@@ -27,8 +27,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 final class MonoFlatMapMany<T, R> extends FluxFromMonoOperator<T, R> {
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoIgnoreThen.java b/reactor-core/src/main/java/reactor/core/publisher/MonoIgnoreThen.java
index 3624d884bd..9a96a02e7f 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoIgnoreThen.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoIgnoreThen.java
@@ -27,8 +27,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Concatenates a several Mono sources with a final Mono source by
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoName.java b/reactor-core/src/main/java/reactor/core/publisher/MonoName.java
index 2dd0dccfd7..bd9ea34aac 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoName.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoName.java
@@ -23,9 +23,9 @@
 
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
+import reactor.util.annotation.Nullable;
 import reactor.util.function.Tuple2;
 import reactor.util.function.Tuples;
-import reactor.util.annotation.Nullable;
 
 /**
  * An operator that just bears a name or a set of tags, which can be retrieved via the
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoNameFuseable.java b/reactor-core/src/main/java/reactor/core/publisher/MonoNameFuseable.java
index 6c37b5cf1a..7d53032a86 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoNameFuseable.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoNameFuseable.java
@@ -20,8 +20,8 @@
 
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
-import reactor.util.function.Tuple2;
 import reactor.util.annotation.Nullable;
+import reactor.util.function.Tuple2;
 
 /**
  * An operator that just bears a name or a set of tags, which can be retrieved via the
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoOperator.java b/reactor-core/src/main/java/reactor/core/publisher/MonoOperator.java
index f6b860e887..a657c8d63b 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoOperator.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoOperator.java
@@ -17,9 +17,12 @@
 package reactor.core.publisher;
 
 import java.util.Objects;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 
 
 import org.reactivestreams.Publisher;
+import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
 import reactor.util.annotation.Nullable;
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/MonoProcessor.java
index 34a85a1a6e..0e195ec568 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoProcessor.java
@@ -31,8 +31,9 @@
 import reactor.core.Disposable;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.concurrent.WaitStrategy;
 import reactor.util.annotation.Nullable;
+import reactor.util.concurrent.WaitStrategy;
+import reactor.util.context.Context;
 
 /**
  * A {@code MonoProcessor} is a {@link Mono} extension that implements stateful semantics. Multi-subscribe is allowed.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoSequenceEqual.java b/reactor-core/src/main/java/reactor/core/publisher/MonoSequenceEqual.java
index d89162b37f..2f01765fb3 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoSequenceEqual.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoSequenceEqual.java
@@ -27,9 +27,9 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.context.Context;
-import reactor.util.annotation.Nullable;
 
 import static reactor.core.publisher.Operators.cancelledSubscription;
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoSink.java b/reactor-core/src/main/java/reactor/core/publisher/MonoSink.java
index e8c1d3a0ca..120398864b 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoSink.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoSink.java
@@ -22,8 +22,8 @@
 
 import reactor.core.CoreSubscriber;
 import reactor.core.Disposable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Wrapper API around an actual downstream Subscriber
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoSupplier.java b/reactor-core/src/main/java/reactor/core/publisher/MonoSupplier.java
index 8cde3046ed..00c8799bdb 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoSupplier.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoSupplier.java
@@ -20,6 +20,7 @@
 import java.util.concurrent.Callable;
 import java.util.function.Supplier;
 
+
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
 import reactor.util.annotation.Nullable;
diff --git a/reactor-core/src/main/java/reactor/core/publisher/MonoZip.java b/reactor-core/src/main/java/reactor/core/publisher/MonoZip.java
index 3d52f25be4..9989111954 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/MonoZip.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/MonoZip.java
@@ -28,8 +28,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Waits for all Mono sources to produce a value or terminate, and if all of them produced
diff --git a/reactor-core/src/main/java/reactor/core/publisher/Operators.java b/reactor-core/src/main/java/reactor/core/publisher/Operators.java
index 7fd5dd0ee9..3619b41f50 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/Operators.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/Operators.java
@@ -34,9 +34,8 @@
 import reactor.core.Scannable;
 import reactor.util.Logger;
 import reactor.util.Loggers;
-import reactor.util.context.Context;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * An helper to support "Operator" writing, handle noop subscriptions, validate request
@@ -98,7 +97,7 @@ public static long addCap(long a, long b) {
 	 */
 	@SuppressWarnings("unchecked")
 	@Nullable
-	public static <T> Fuseable.QueueSubscription<@NonNull T> as(Subscription s) {
+	public static <T> Fuseable.QueueSubscription<T> as(Subscription s) {
 		if (s instanceof Fuseable.QueueSubscription) {
 			return (Fuseable.QueueSubscription<T>) s;
 		}
@@ -124,7 +123,7 @@ public static Subscription cancelledSubscription() {
 	 *
 	 * @param s the target subscriber
 	 */
-	public static void complete(Subscriber<@NonNull ?> s) {
+	public static void complete(Subscriber<?> s) {
 		s.onSubscribe(EmptySubscription.INSTANCE);
 		s.onComplete();
 	}
@@ -137,7 +136,7 @@ public static void complete(Subscriber<@NonNull ?> s) {
 	 * @return a new {@link Subscriber} whose sole purpose is to request Long.MAX
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> CoreSubscriber<@NonNull T> drainSubscriber() {
+	public static <T> CoreSubscriber<T> drainSubscriber() {
 		return (CoreSubscriber<T>)DrainSubscriber.INSTANCE;
 	}
 
@@ -149,7 +148,7 @@ public static void complete(Subscriber<@NonNull ?> s) {
 	 * @return a placeholder subscriber
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> CoreSubscriber<@NonNull T> emptySubscriber() {
+	public static <T> CoreSubscriber<T> emptySubscriber() {
 		return (CoreSubscriber<T>) EMPTY_SUBSCRIBER;
 	}
 
@@ -174,7 +173,7 @@ public static Subscription emptySubscription() {
 	 * @param s target Subscriber to error
 	 * @param e the actual error
 	 */
-	public static void error(Subscriber<@NonNull ?> s, Throwable e) {
+	public static void error(Subscriber<?> s, Throwable e) {
 		s.onSubscribe(EmptySubscription.INSTANCE);
 		s.onError(e);
 	}
@@ -218,7 +217,7 @@ public static <T> long getAndAddCap(AtomicLongFieldUpdater<T> updater, T instanc
 	 *
 	 * @return a new {@link Function}
 	 */
-	public static <I, O> Function<? super @NonNull Publisher<@NonNull I>, ? extends @NonNull Publisher<@NonNull O>> lift(BiFunction<@NonNull Scannable, ? super @NonNull CoreSubscriber<? super O>, ? extends @NonNull CoreSubscriber<? super @NonNull I>> lifter) {
+	public static <I, O> Function<? super Publisher<I>, ? extends Publisher<O>> lift(BiFunction<Scannable, ? super CoreSubscriber<? super O>, ? extends CoreSubscriber<? super I>> lifter) {
 		return new LiftFunction<>(null, lifter);
 	}
 
@@ -244,7 +243,7 @@ public static <T> long getAndAddCap(AtomicLongFieldUpdater<T> updater, T instanc
 	 *
 	 * @return a new {@link Function}
 	 */
-	public static <O> Function<? super @NonNull Publisher<O>, ? extends @NonNull Publisher<@NonNull O>> lift(
+	public static <O> Function<? super Publisher<O>, ? extends Publisher<O>> lift(
 			Predicate<Scannable> filter,
 			BiFunction<Scannable, ? super CoreSubscriber<? super O>, ? extends CoreSubscriber<? super O>> lifter) {
 		return new LiftFunction<>(filter, lifter);
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ParallelFlux.java b/reactor-core/src/main/java/reactor/core/publisher/ParallelFlux.java
index 4b693518bd..c484d7ea16 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ParallelFlux.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ParallelFlux.java
@@ -42,9 +42,8 @@
 import reactor.core.publisher.FluxConcatMap.ErrorMode;
 import reactor.core.scheduler.Scheduler;
 import reactor.util.Logger;
-import reactor.util.concurrent.Queues;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
+import reactor.util.concurrent.Queues;
 
 /**
  * A ParallelFlux publishes to an array of Subscribers, in parallel 'rails' (or
@@ -75,7 +74,7 @@ public abstract class ParallelFlux<T> implements Publisher<T> {
 	 *
 	 * @return the {@link ParallelFlux} instance
 	 */
-	public static <T> ParallelFlux<@NonNull T> from(Publisher<? extends @NonNull T> source) {
+	public static <T> ParallelFlux<T> from(Publisher<? extends T> source) {
 		return from(source,
 				Runtime.getRuntime()
 				       .availableProcessors(), Queues.SMALL_BUFFER_SIZE,
@@ -92,7 +91,7 @@ public abstract class ParallelFlux<T> implements Publisher<T> {
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public static <T> ParallelFlux<@NonNull T> from(Publisher<? extends @NonNull T> source,
+	public static <T> ParallelFlux<T> from(Publisher<? extends T> source,
 			int parallelism) {
 		return from(source,
 				parallelism, Queues.SMALL_BUFFER_SIZE,
@@ -113,7 +112,7 @@ public abstract class ParallelFlux<T> implements Publisher<T> {
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public static <T> ParallelFlux<@NonNull T> from(Publisher<? extends @NonNull T> source,
+	public static <T> ParallelFlux<T> from(Publisher<? extends T> source,
 			int parallelism,
 			int prefetch,
 			Supplier<Queue<T>> queueSupplier) {
@@ -135,7 +134,7 @@ public abstract class ParallelFlux<T> implements Publisher<T> {
 	 * @return the new {@link ParallelFlux} instance
 	 */
 	@SafeVarargs
-	public static <T> ParallelFlux<@NonNull T> from(Publisher<T> @NonNull ... publishers) {
+	public static <T> ParallelFlux<T> from(Publisher<T>... publishers) {
 		return onAssembly(new ParallelArraySource<>(publishers));
 	}
 
@@ -148,7 +147,7 @@ public abstract class ParallelFlux<T> implements Publisher<T> {
 	 *
 	 * @return the value returned by the converter function
 	 */
-	public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNull U> converter) {
+	public final <U> U as(Function<? super ParallelFlux<T>, U> converter) {
 		return converter.apply(this);
 	}
 
@@ -162,7 +161,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the assembly tracing {@link ParallelFlux}
 	 */
-	public final ParallelFlux<@NonNull T> checkpoint() {
+	public final ParallelFlux<T> checkpoint() {
 		return new ParallelFluxOnAssembly<>(this, null);
 	}
 
@@ -182,7 +181,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 * @param description a unique enough description to include in the light assembly traceback.
 	 * @return the assembly marked {@link ParallelFlux}
 	 */
-	public final ParallelFlux<@NonNull T> checkpoint(String description) {
+	public final ParallelFlux<T> checkpoint(String description) {
 		return new ParallelFluxOnAssembly<>(this, description, true);
 	}
 
@@ -212,7 +211,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 * to use a stack trace.
 	 * @return the assembly marked {@link ParallelFlux}.
 	 */
-	public final ParallelFlux<@NonNull T> checkpoint(String description, boolean forceStackTrace) {
+	public final ParallelFlux<T> checkpoint(String description, boolean forceStackTrace) {
 		return new ParallelFluxOnAssembly<>(this, description, !forceStackTrace);
 	}
 
@@ -228,8 +227,8 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <C> ParallelFlux<@NonNull C> collect(Supplier<? extends @NonNull C> collectionSupplier,
-			BiConsumer<? super @NonNull C, ? super @NonNull T> collector) {
+	public final <C> ParallelFlux<C> collect(Supplier<? extends C> collectionSupplier,
+			BiConsumer<? super C, ? super T> collector) {
 		return onAssembly(new ParallelCollect<>(this, collectionSupplier, collector));
 	}
 
@@ -243,7 +242,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new Flux instance
 	 */
-	public final Mono<@NonNull List<@NonNull T>> collectSortedList(Comparator<? super @NonNull T> comparator) {
+	public final Mono<List<T>> collectSortedList(Comparator<? super T> comparator) {
 		return collectSortedList(comparator, 16);
 	}
 
@@ -258,7 +257,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new Mono instance
 	 */
-	public final Mono<@NonNull List<@NonNull T>> collectSortedList(Comparator<? super @NonNull T> comparator,
+	public final Mono<List<T>> collectSortedList(Comparator<? super T> comparator,
 			int capacityHint) {
 		int ch = capacityHint / parallelism() + 1;
 		ParallelFlux<List<T>> railReduced =
@@ -289,7 +288,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 * @param <U> the type of the resulting parallelized flux
 	 * @return a {@link ParallelFlux} of the composed groups
 	 */
-	public final <U> ParallelFlux<@NonNull U> composeGroup(Function<? super @NonNull GroupedFlux<@NonNull Integer, @NonNull T>,
+	public final <U> ParallelFlux<U> composeGroup(Function<? super GroupedFlux<Integer, T>,
 			? extends Publisher<? extends U>> composer) {
 		return from(groups().flatMap(composer::apply));
 	}
@@ -304,7 +303,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <R> ParallelFlux<@NonNull R> concatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper) {
+	public final <R> ParallelFlux<R> concatMap(Function<? super T, ? extends Publisher<? extends R>> mapper) {
 		return concatMap(mapper, 2, ErrorMode.IMMEDIATE);
 	}
 
@@ -319,7 +318,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <R> ParallelFlux<@NonNull R> concatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper,
+	public final <R> ParallelFlux<R> concatMap(Function<? super T, ? extends Publisher<? extends R>> mapper,
 			int prefetch) {
 		return concatMap(mapper, prefetch, ErrorMode.IMMEDIATE);
 	}
@@ -334,8 +333,8 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <R> ParallelFlux<@NonNull R> concatMapDelayError(Function<? super @NonNull T, ? extends
-            @NonNull Publisher<? extends @NonNull R>> mapper) {
+	public final <R> ParallelFlux<R> concatMapDelayError(Function<? super T, ? extends
+			Publisher<? extends R>> mapper) {
 		return concatMap(mapper, 2, ErrorMode.END);
 	}
 
@@ -346,7 +345,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> doAfterTerminate(Runnable afterTerminate) {
+	public final ParallelFlux<T> doAfterTerminate(Runnable afterTerminate) {
 		Objects.requireNonNull(afterTerminate, "afterTerminate");
 		return doOnSignal(this, null, null, null, null, afterTerminate, null, null, null);
 	}
@@ -358,7 +357,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> doOnCancel(Runnable onCancel) {
+	public final ParallelFlux<T> doOnCancel(Runnable onCancel) {
 		Objects.requireNonNull(onCancel, "onCancel");
 		return doOnSignal(this, null, null, null, null, null, null, null, onCancel);
 	}
@@ -370,7 +369,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> doOnComplete(Runnable onComplete) {
+	public final ParallelFlux<T> doOnComplete(Runnable onComplete) {
 		Objects.requireNonNull(onComplete, "onComplete");
 		return doOnSignal(this, null, null, null, onComplete, null, null, null, null);
 	}
@@ -398,7 +397,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 * @see #subscribe(CoreSubscriber[])
 	 * @see Signal
 	 */
-	public final ParallelFlux<@NonNull T> doOnEach(Consumer<? super @NonNull Signal<T>> signalConsumer) {
+	public final ParallelFlux<T> doOnEach(Consumer<? super Signal<T>> signalConsumer) {
 		Objects.requireNonNull(signalConsumer, "signalConsumer");
 		return doOnSignal(this,
 				v -> signalConsumer.accept(Signal.next(v)),
@@ -415,7 +414,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> doOnError(Consumer<? super @NonNull Throwable> onError) {
+	public final ParallelFlux<T> doOnError(Consumer<? super Throwable> onError) {
 		Objects.requireNonNull(onError, "onError");
 		return doOnSignal(this, null, null, onError, null, null, null, null, null);
 	}
@@ -428,7 +427,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> doOnSubscribe(Consumer<? super @NonNull Subscription> onSubscribe) {
+	public final ParallelFlux<T> doOnSubscribe(Consumer<? super Subscription> onSubscribe) {
 		Objects.requireNonNull(onSubscribe, "onSubscribe");
 		return doOnSignal(this, null, null, null, null, null, onSubscribe, null, null);
 	}
@@ -440,7 +439,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> doOnNext(Consumer<? super @NonNull T> onNext) {
+	public final ParallelFlux<T> doOnNext(Consumer<? super T> onNext) {
 		Objects.requireNonNull(onNext, "onNext");
 		return doOnSignal(this, onNext, null, null, null, null, null, null, null);
 	}
@@ -453,7 +452,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> doOnRequest(LongConsumer onRequest) {
+	public final ParallelFlux<T> doOnRequest(LongConsumer onRequest) {
 		Objects.requireNonNull(onRequest, "onRequest");
 		return doOnSignal(this, null, null, null, null, null, null, onRequest, null);
 	}
@@ -464,7 +463,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return an observed  {@link ParallelFlux}
 	 */
-	public final ParallelFlux<@NonNull T> doOnTerminate(Runnable onTerminate) {
+	public final ParallelFlux<T> doOnTerminate(Runnable onTerminate) {
 		Objects.requireNonNull(onTerminate, "onTerminate");
 		return doOnSignal(this,
 				null,
@@ -487,7 +486,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> filter(Predicate<? super @NonNull T> predicate) {
+	public final ParallelFlux<T> filter(Predicate<? super T> predicate) {
 		Objects.requireNonNull(predicate, "predicate");
 		return onAssembly(new ParallelFilter<>(this, predicate));
 	}
@@ -503,7 +502,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <R> ParallelFlux<@NonNull R> flatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper) {
+	public final <R> ParallelFlux<R> flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper) {
 		return flatMap(mapper,
 				false,
 				Integer.MAX_VALUE, Queues.SMALL_BUFFER_SIZE);
@@ -521,7 +520,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <R> ParallelFlux<@NonNull R> flatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper,
+	public final <R> ParallelFlux<R> flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper,
 			boolean delayError) {
 		return flatMap(mapper,
 				delayError,
@@ -543,7 +542,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <R> ParallelFlux<@NonNull R> flatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper,
+	public final <R> ParallelFlux<R> flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper,
 			boolean delayError,
 			int maxConcurrency) {
 		return flatMap(mapper,
@@ -566,7 +565,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <R> ParallelFlux<@NonNull R> flatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper,
+	public final <R> ParallelFlux<R> flatMap(Function<? super T, ? extends Publisher<? extends R>> mapper,
 			boolean delayError,
 			int maxConcurrency,
 			int prefetch) {
@@ -587,7 +586,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new Flux instance
 	 */
-	public final Flux<@NonNull GroupedFlux<@NonNull Integer, @NonNull T>> groups() {
+	public final Flux<GroupedFlux<Integer, T>> groups() {
 		return Flux.onAssembly(new ParallelGroup<>(this));
 	}
 
@@ -597,7 +596,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return a new {@link ParallelFlux} defeating any {@link Publisher} / {@link Subscription} feature-detection
 	 */
-	public final ParallelFlux<@NonNull T> hide() {
+	public final ParallelFlux<T> hide() {
 		return new ParallelFluxHide<>(this);
 	}
 
@@ -614,7 +613,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return a new unaltered {@link ParallelFlux}
 	 */
-	public final ParallelFlux<@NonNull T> log() {
+	public final ParallelFlux<T> log() {
 		return log(null, Level.INFO);
 	}
 
@@ -633,7 +632,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return a new unaltered {@link ParallelFlux}
 	 */
-	public final ParallelFlux<@NonNull T> log(@Nullable String category) {
+	public final ParallelFlux<T> log(@Nullable String category) {
 		return log(category, Level.INFO);
 	}
 
@@ -661,9 +660,9 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return a new unaltered {@link ParallelFlux}
 	 */
-	public final ParallelFlux<@NonNull T> log(@Nullable String category,
+	public final ParallelFlux<T> log(@Nullable String category,
 			Level level,
-			SignalType @NonNull ... options) {
+			SignalType... options) {
 		return log(category, level, false, options);
 	}
 
@@ -693,10 +692,10 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return a new unaltered {@link ParallelFlux}
 	 */
-	public final ParallelFlux<@NonNull T> log(@Nullable String category,
+	public final ParallelFlux<T> log(@Nullable String category,
 			Level level,
 			boolean showOperatorLine,
-			SignalType @NonNull ... options) {
+			SignalType... options) {
 		return onAssembly(new ParallelLog<>(this, new SignalLogger<>(this, category, level, showOperatorLine, options)));
 	}
 
@@ -711,7 +710,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <U> ParallelFlux<@NonNull U> map(Function<? super @NonNull T, ? extends @NonNull U> mapper) {
+	public final <U> ParallelFlux<U> map(Function<? super T, ? extends U> mapper) {
 		Objects.requireNonNull(mapper, "mapper");
 		return onAssembly(new ParallelMap<>(this, mapper));
 	}
@@ -723,7 +722,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 * @param name a name for the sequence
 	 * @return the same sequence, but bearing a name
 	 */
-	public final ParallelFlux<@NonNull T> name(String name) {
+	public final ParallelFlux<T> name(String name) {
 		return ParallelFluxName.createOrAppend(this, name);
 	}
 
@@ -746,7 +745,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 * @return the new Mono instance emitting the reduced value or empty if the
 	 * {@link ParallelFlux} was empty
 	 */
-	public final Mono<@NonNull T> reduce(BiFunction<@NonNull T, @NonNull T, @NonNull T> reducer) {
+	public final Mono<T> reduce(BiFunction<T, T, T> reducer) {
 		Objects.requireNonNull(reducer, "reducer");
 		return Mono.onAssembly(new ParallelMergeReduce<>(this, reducer));
 	}
@@ -766,8 +765,8 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final <R> ParallelFlux<@NonNull R> reduce(Supplier<@NonNull R> initialSupplier,
-			BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) {
+	public final <R> ParallelFlux<R> reduce(Supplier<R> initialSupplier,
+			BiFunction<R, ? super T, R> reducer) {
 		Objects.requireNonNull(initialSupplier, "initialSupplier");
 		Objects.requireNonNull(reducer, "reducer");
 		return onAssembly(new ParallelReduceSeed<>(this, initialSupplier, reducer));
@@ -794,7 +793,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> runOn(Scheduler scheduler) {
+	public final ParallelFlux<T> runOn(Scheduler scheduler) {
 		return runOn(scheduler, Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -820,7 +819,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	public final ParallelFlux<@NonNull T> runOn(Scheduler scheduler, int prefetch) {
+	public final ParallelFlux<T> runOn(Scheduler scheduler, int prefetch) {
 		Objects.requireNonNull(scheduler, "scheduler");
 		return onAssembly(new ParallelRunOn<>(this,
 				scheduler,
@@ -840,7 +839,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @see ParallelFlux#sequential(int)
 	 */
-	public final Flux<@NonNull T> sequential() {
+	public final Flux<T> sequential() {
 		return sequential(Queues.SMALL_BUFFER_SIZE);
 	}
 
@@ -853,7 +852,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new Flux instance
 	 */
-	public final Flux<@NonNull T> sequential(int prefetch) {
+	public final Flux<T> sequential(int prefetch) {
 		return Flux.onAssembly(new ParallelMergeSequential<>(this,
 				prefetch,
 				Queues.get(prefetch)));
@@ -869,7 +868,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new Flux instance
 	 */
-	public final Flux<@NonNull T> sorted(Comparator<? super @NonNull T> comparator) {
+	public final Flux<T> sorted(Comparator<? super T> comparator) {
 		return sorted(comparator, 16);
 	}
 
@@ -884,7 +883,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 *
 	 * @return the new Flux instance
 	 */
-	public final Flux<@NonNull T> sorted(Comparator<? super @NonNull T> comparator, int capacityHint) {
+	public final Flux<T> sorted(Comparator<? super T> comparator, int capacityHint) {
 		int ch = capacityHint / parallelism() + 1;
 		ParallelFlux<List<T>> railReduced = reduce(() -> new ArrayList<>(ch), (a, b) -> {
 					a.add(b);
@@ -905,7 +904,7 @@ public final <U> U as(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNu
 	 * @param subscribers the subscribers array to run in parallel, the number of items
 	 * must be equal to the parallelism level of this ParallelFlux
 	 */
-	protected abstract void subscribe(CoreSubscriber<? super @NonNull T> @NonNull [] subscribers);
+	protected abstract void subscribe(CoreSubscriber<? super T>[] subscribers);
 
 	/**
 	 * Subscribes to this {@link ParallelFlux} and triggers the execution chain for all
@@ -921,7 +920,7 @@ public final Disposable subscribe(){
 	 *
 	 * @param onNext consumer of onNext signals
 	 */
-	public final Disposable subscribe(Consumer<? super @NonNull T> onNext){
+	public final Disposable subscribe(Consumer<? super T> onNext){
 		return subscribe(onNext, null, null);
 	}
 
@@ -932,7 +931,7 @@ public final Disposable subscribe(Consumer<? super @NonNull T> onNext){
 	 * @param onNext consumer of onNext signals
 	 * @param onError consumer of error signal
 	 */
-	public final Disposable subscribe(@Nullable Consumer<? super @NonNull T> onNext, Consumer<? super @NonNull Throwable>
+	public final Disposable subscribe(@Nullable Consumer<? super T> onNext, Consumer<? super Throwable>
 			onError){
 		return subscribe(onNext, onError, null);
 	}
@@ -946,8 +945,8 @@ public final Disposable subscribe(@Nullable Consumer<? super @NonNull T> onNext,
 	 * @param onComplete callback on completion signal
 	 */
 	public final Disposable subscribe(
-			@Nullable Consumer<? super @NonNull T> onNext,
-			@Nullable Consumer<? super @NonNull Throwable> onError,
+			@Nullable Consumer<? super T> onNext,
+			@Nullable Consumer<? super Throwable> onError,
 			@Nullable Runnable onComplete) {
 		return subscribe(onNext, onError, onComplete, null);
 	}
@@ -963,10 +962,10 @@ public final Disposable subscribe(
 	 * @param onSubscribe consumer of the subscription signal
 	 */
 	public final Disposable subscribe(
-			@Nullable Consumer<? super @NonNull T> onNext,
-			@Nullable Consumer<? super @NonNull Throwable> onError,
+			@Nullable Consumer<? super T> onNext,
+			@Nullable Consumer<? super Throwable> onError,
 			@Nullable Runnable onComplete,
-			@Nullable Consumer<? super @NonNull Subscription> onSubscribe){
+			@Nullable Consumer<? super Subscription> onSubscribe){
 
 		@SuppressWarnings("unchecked")
 		LambdaSubscriber<? super T>[] subscribers = new LambdaSubscriber[parallelism()];
@@ -989,7 +988,7 @@ public final Disposable subscribe(
 	 */
 	@Override
 	@SuppressWarnings("unchecked")
-	public final void subscribe(Subscriber<? super @NonNull T> s) {
+	public final void subscribe(Subscriber<? super T> s) {
 		Flux.onLastAssembly(sequential())
 		    .subscribe(new FluxHide.SuppressFuseableSubscriber<>(Operators.toCoreSubscriber(s)));
 	}
@@ -1005,7 +1004,7 @@ public final void subscribe(Subscriber<? super @NonNull T> s) {
 	 * @param value a tag value
 	 * @return the same sequence, but bearing tags
 	 */
-	public final ParallelFlux<@NonNull T> tag(String key, String value) {
+	public final ParallelFlux<T> tag(String key, String value) {
 		return ParallelFluxName.createOrAppend(this, key, value);
 	}
 
@@ -1019,7 +1018,7 @@ public final void subscribe(Subscriber<? super @NonNull T> s) {
 	 *
 	 * @return the {@link ParallelFlux} returned by the function
 	 */
-	public final <U> ParallelFlux<@NonNull U> transform(Function<? super @NonNull ParallelFlux<@NonNull T>, @NonNull ParallelFlux<@NonNull U>> composer) {
+	public final <U> ParallelFlux<U> transform(Function<? super ParallelFlux<T>, ParallelFlux<U>> composer) {
 		return onAssembly(as(composer));
 	}
 
@@ -1036,7 +1035,7 @@ public String toString() {
 	 *
 	 * @return true if the number of subscribers equals to the parallelism level
 	 */
-	protected final boolean validate(Subscriber<@NonNull ?> @NonNull [] subscribers) {
+	protected final boolean validate(Subscriber<?>[] subscribers) {
 		int p = parallelism();
 		if (subscribers.length != p) {
 			IllegalArgumentException iae = new IllegalArgumentException("parallelism = " +
@@ -1061,7 +1060,7 @@ protected final boolean validate(Subscriber<@NonNull ?> @NonNull [] subscribers)
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	final <R> ParallelFlux<@NonNull R> concatMap(Function<? super @NonNull T, ? extends @NonNull Publisher<? extends @NonNull R>> mapper,
+	final <R> ParallelFlux<R> concatMap(Function<? super T, ? extends Publisher<? extends R>> mapper,
 			int prefetch,
 			ErrorMode errorMode) {
 		return onAssembly(new ParallelConcatMap<>(this,
@@ -1083,8 +1082,8 @@ protected final boolean validate(Subscriber<@NonNull ?> @NonNull [] subscribers)
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	final <R> ParallelFlux<@NonNull R> concatMapDelayError(Function<? super @NonNull T, ? extends
-            @NonNull Publisher<? extends @NonNull R>> mapper,
+	final <R> ParallelFlux<R> concatMapDelayError(Function<? super T, ? extends
+			Publisher<? extends R>> mapper,
 			boolean delayUntilEnd,
 			int prefetch) {
 		return concatMap(mapper, prefetch, delayUntilEnd ? ErrorMode.END: ErrorMode.BOUNDARY);
@@ -1101,8 +1100,8 @@ protected final boolean validate(Subscriber<@NonNull ?> @NonNull [] subscribers)
 	 *
 	 * @return the new {@link ParallelFlux} instance
 	 */
-	final <R> ParallelFlux<@NonNull R> concatMapDelayError(Function<? super @NonNull T, ? extends
-            @NonNull Publisher<? extends @NonNull R>> mapper, int prefetch) {
+	final <R> ParallelFlux<R> concatMapDelayError(Function<? super T, ? extends
+			Publisher<? extends R>> mapper, int prefetch) {
 		return concatMap(mapper, prefetch, ErrorMode.END);
 	}
 
@@ -1126,7 +1125,7 @@ public int getPrefetch() {
 	 * @return the potentially wrapped source
 	 */
 	@SuppressWarnings("unchecked")
-	protected static <T> ParallelFlux<@NonNull T> onAssembly(ParallelFlux<@NonNull T> source) {
+	protected static <T> ParallelFlux<T> onAssembly(ParallelFlux<T> source) {
 		Function<Publisher, Publisher> hook = Hooks.onEachOperatorHook;
 		if (hook == null) {
 			return source;
@@ -1144,7 +1143,7 @@ public int getPrefetch() {
 	 * @return the potentially wrapped source
 	 */
 	@SuppressWarnings("unchecked")
-	protected static <T> ParallelFlux<@NonNull T> onLastAssembly(ParallelFlux<@NonNull T> source) {
+	protected static <T> ParallelFlux<T> onLastAssembly(ParallelFlux<T> source) {
 		Function<Publisher, Publisher> hook = Hooks.onLastOperatorHook;
 		if (hook == null) {
 			return source;
@@ -1154,7 +1153,7 @@ public int getPrefetch() {
 	}
 
 	@SuppressWarnings("unchecked")
-	static <T> ParallelFlux<@NonNull T> doOnSignal(ParallelFlux<@NonNull T> source,
+	static <T> ParallelFlux<T> doOnSignal(ParallelFlux<T> source,
 			@Nullable Consumer<? super T> onNext,
 			@Nullable Consumer<? super T> onAfterNext,
 			@Nullable Consumer<? super Throwable> onError,
@@ -1174,7 +1173,7 @@ public int getPrefetch() {
 				onCancel));
 	}
 
-	static final <T> List<@NonNull T> sortedMerger(List<@NonNull T> a, List<@NonNull T> b, Comparator<? super @NonNull T> comparator) {
+	static final <T> List<T> sortedMerger(List<T> a, List<T> b, Comparator<? super T> comparator) {
 		int n = a.size() + b.size();
 		if (n == 0) {
 			return new ArrayList<>();
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ParallelFluxName.java b/reactor-core/src/main/java/reactor/core/publisher/ParallelFluxName.java
index 73f0c607bd..0c271c8ed4 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ParallelFluxName.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ParallelFluxName.java
@@ -23,9 +23,9 @@
 
 import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
+import reactor.util.annotation.Nullable;
 import reactor.util.function.Tuple2;
 import reactor.util.function.Tuples;
-import reactor.util.annotation.Nullable;
 
 /**
  * Hides the identities of the upstream Publisher object and its Subscription as well.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeReduce.java b/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeReduce.java
index 1289c064b7..1ad9ed8294 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeReduce.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeReduce.java
@@ -25,8 +25,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Reduces all 'rails' into a single value which then gets reduced into a single
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeSequential.java b/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeSequential.java
index 77b0427c05..b58ca59c7a 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeSequential.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeSequential.java
@@ -27,8 +27,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Merges the individual 'rails' of the source ParallelFlux, unordered,
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeSort.java b/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeSort.java
index 8edf7d2e72..2720c172f6 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeSort.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ParallelMergeSort.java
@@ -28,8 +28,8 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Given sorted rail sequences (according to the provided comparator) as List
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ParallelPeek.java b/reactor-core/src/main/java/reactor/core/publisher/ParallelPeek.java
index 3020f5fbf8..fdbd4a1656 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ParallelPeek.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ParallelPeek.java
@@ -20,8 +20,8 @@
 
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
-import reactor.util.annotation.Nullable;
 import reactor.core.Fuseable;
+import reactor.util.annotation.Nullable;
 
 /**
  * Execute a Consumer in each 'rail' for the current element passing through.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ParallelSource.java b/reactor-core/src/main/java/reactor/core/publisher/ParallelSource.java
index 1f9d8bde3c..c4578d5688 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ParallelSource.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ParallelSource.java
@@ -28,8 +28,8 @@
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Dispatches the values from upstream in a round robin fashion to subscribers which are
diff --git a/reactor-core/src/main/java/reactor/core/publisher/ReplayProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/ReplayProcessor.java
index 424160e037..521979c051 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/ReplayProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/ReplayProcessor.java
@@ -30,9 +30,8 @@
 import reactor.core.Scannable;
 import reactor.core.scheduler.Scheduler;
 import reactor.core.scheduler.Schedulers;
-import reactor.util.concurrent.Queues;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
+import reactor.util.concurrent.Queues;
 
 import static reactor.core.publisher.FluxReplay.ReplaySubscriber.EMPTY;
 import static reactor.core.publisher.FluxReplay.ReplaySubscriber.TERMINATED;
@@ -62,7 +61,7 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 * @return a new {@link ReplayProcessor} that replays its last pushed element to each new
 	 * {@link Subscriber}
 	 */
-	public static <T> ReplayProcessor<@NonNull T> cacheLast() {
+	public static <T> ReplayProcessor<T> cacheLast() {
 		return cacheLastOrDefault(null);
 	}
 
@@ -82,7 +81,7 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 * @return a new {@link ReplayProcessor} that replays its last pushed element to each new
 	 * {@link Subscriber}, or a default one if nothing was pushed yet
 	 */
-	public static <T> ReplayProcessor<@NonNull T> cacheLastOrDefault(@Nullable T value) {
+	public static <T> ReplayProcessor<T> cacheLastOrDefault(@Nullable T value) {
 		ReplayProcessor<T> b = create(1);
 		if (value != null) {
 			b.onNext(value);
@@ -99,7 +98,7 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 * @return a new {@link ReplayProcessor} that replays the whole history to each new
 	 * {@link Subscriber}.
 	 */
-	public static <E> ReplayProcessor<@NonNull E> create() {
+	public static <E> ReplayProcessor<E> create() {
 		return create(Queues.SMALL_BUFFER_SIZE, true);
 	}
 
@@ -113,7 +112,7 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 * @return a new {@link ReplayProcessor} that replays a limited history to each new
 	 * {@link Subscriber}.
 	 */
-	public static <E> ReplayProcessor<@NonNull E> create(int historySize) {
+	public static <E> ReplayProcessor<E> create(int historySize) {
 		return create(historySize, false);
 	}
 
@@ -128,8 +127,8 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 * @return a new {@link ReplayProcessor} that replays the whole history to each new
 	 * {@link Subscriber} if configured as unbounded, a limited history otherwise.
 	 */
-	public static <E> ReplayProcessor<@NonNull E> create(int historySize, boolean unbounded) {
-		FluxReplay.ReplayBuffer<@NonNull E> buffer;
+	public static <E> ReplayProcessor<E> create(int historySize, boolean unbounded) {
+		FluxReplay.ReplayBuffer<E> buffer;
 		if (unbounded) {
 			buffer = new FluxReplay.UnboundedReplayBuffer<>(historySize);
 		}
@@ -170,7 +169,7 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 *
 	 * @return a new {@link ReplayProcessor} that replays elements based on their age.
 	 */
-	public static <T> ReplayProcessor<@NonNull T> createTimeout(Duration maxAge) {
+	public static <T> ReplayProcessor<T> createTimeout(Duration maxAge) {
 		return createTimeout(maxAge, Schedulers.parallel());
 	}
 
@@ -205,7 +204,7 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 *
 	 * @return a new {@link ReplayProcessor} that replays elements based on their age.
 	 */
-	public static <T> ReplayProcessor<@NonNull T> createTimeout(Duration maxAge, Scheduler scheduler) {
+	public static <T> ReplayProcessor<T> createTimeout(Duration maxAge, Scheduler scheduler) {
 		return createSizeAndTimeout(Integer.MAX_VALUE, maxAge, scheduler);
 	}
 
@@ -243,7 +242,7 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 * @return a new {@link ReplayProcessor} that replay up to {@code size} elements, but
 	 * will evict them from its history based on their age.
 	 */
-	public static <T> ReplayProcessor<@NonNull T> createSizeAndTimeout(int size, Duration maxAge) {
+	public static <T> ReplayProcessor<T> createSizeAndTimeout(int size, Duration maxAge) {
 		return createSizeAndTimeout(size, maxAge, Schedulers.parallel());
 	}
 
@@ -281,7 +280,7 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 	 * @return a new {@link ReplayProcessor} that replay up to {@code size} elements, but
 	 * will evict them from its history based on their age.
 	 */
-	public static <T> ReplayProcessor<@NonNull T> createSizeAndTimeout(int size,
+	public static <T> ReplayProcessor<T> createSizeAndTimeout(int size,
 			Duration maxAge,
 			Scheduler scheduler) {
 		Objects.requireNonNull(scheduler, "scheduler is null");
@@ -304,13 +303,13 @@ public final class ReplayProcessor<T> extends FluxProcessor<T, T>
 			FluxReplay.ReplaySubscription[].class,
 			"subscribers");
 
-	ReplayProcessor(FluxReplay.ReplayBuffer<@NonNull T> buffer) {
+	ReplayProcessor(FluxReplay.ReplayBuffer<T> buffer) {
 		this.buffer = buffer;
 		SUBSCRIBERS.lazySet(this, EMPTY);
 	}
 
 	@Override
-	public void subscribe(CoreSubscriber<? super @NonNull T> actual) {
+	public void subscribe(CoreSubscriber<? super T> actual) {
 		Objects.requireNonNull(actual, "subscribe");
 		FluxReplay.ReplaySubscription<T> rs = new ReplayInner<>(actual, this);
 		actual.onSubscribe(rs);
@@ -342,7 +341,7 @@ public Object scanUnsafe(Attr key) {
 	}
 
 	@Override
-	public Stream<? extends @NonNull Scannable> inners() {
+	public Stream<? extends Scannable> inners() {
 		return Stream.of(subscribers);
 	}
 
@@ -356,7 +355,7 @@ public boolean isTerminated() {
 		return buffer.isDone();
 	}
 
-	boolean add(FluxReplay.ReplaySubscription<@NonNull T> rs) {
+	boolean add(FluxReplay.ReplaySubscription<T> rs) {
 		for (; ; ) {
 			FluxReplay.ReplaySubscription<T>[] a = subscribers;
 			if (a == TERMINATED) {
@@ -375,7 +374,7 @@ boolean add(FluxReplay.ReplaySubscription<@NonNull T> rs) {
 	}
 
 	@SuppressWarnings("unchecked")
-	void remove(FluxReplay.ReplaySubscription<@NonNull T> rs) {
+	void remove(FluxReplay.ReplaySubscription<T> rs) {
 		outer:
 		for (; ; ) {
 			FluxReplay.ReplaySubscription<T>[] a = subscribers;
@@ -503,8 +502,8 @@ static final class ReplayInner<T>
 
 		int fusionMode;
 
-		ReplayInner(CoreSubscriber<? super @NonNull T> actual,
-				ReplayProcessor<@NonNull T> parent) {
+		ReplayInner(CoreSubscriber<? super T> actual,
+				ReplayProcessor<T> parent) {
 			this.actual = actual;
 			this.parent = parent;
 			this.buffer = parent.buffer;
diff --git a/reactor-core/src/main/java/reactor/core/publisher/RingBuffer.java b/reactor-core/src/main/java/reactor/core/publisher/RingBuffer.java
index 4592f4f1fb..72ebdf05b5 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/RingBuffer.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/RingBuffer.java
@@ -25,9 +25,9 @@
 import java.util.function.LongSupplier;
 import java.util.function.Supplier;
 
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.concurrent.WaitStrategy;
-import reactor.util.annotation.Nullable;
 import sun.misc.Unsafe;
 
 import static java.util.Arrays.copyOf;
diff --git a/reactor-core/src/main/java/reactor/core/publisher/Signal.java b/reactor-core/src/main/java/reactor/core/publisher/Signal.java
index 8f8ca2037d..d0ce02bcb8 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/Signal.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/Signal.java
@@ -21,7 +21,6 @@
 
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
 /**
@@ -43,7 +42,7 @@ public interface Signal<T> extends Supplier<T>, Consumer<Subscriber<? super T>>
 	 * @return an {@code OnCompleted} variety of {@code Signal}
 	 */
 	@SuppressWarnings("unchecked")
-	static <T> Signal<@Nullable T> complete() {
+	static <T> Signal<T> complete() {
 		return (Signal<T>) ImmutableSignal.ON_COMPLETE;
 	}
 
@@ -56,7 +55,7 @@ public interface Signal<T> extends Supplier<T>, Consumer<Subscriber<? super T>>
 	 *
 	 * @return an {@code OnError} variety of {@code Signal}
 	 */
-	static <T> Signal<@Nullable T> error(Throwable e) {
+	static <T> Signal<T> error(Throwable e) {
 		return new ImmutableSignal<>(SignalType.ON_ERROR, null, e, null);
 	}
 
@@ -79,7 +78,7 @@ static <T> Signal<T> next(T t) {
 	 * @param o the object to check
 	 * @return true if object represents the completion signal
 	 */
-	static boolean isComplete(@Nullable Object o) {
+	static boolean isComplete(Object o) {
 		return o == ImmutableSignal.ON_COMPLETE;
 	}
 
@@ -89,7 +88,7 @@ static boolean isComplete(@Nullable Object o) {
 	 * @param o the object to check
 	 * @return true if object represents the error signal
 	 */
-	static boolean isError(@Nullable Object o) {
+	static boolean isError(Object o) {
 		return o instanceof Signal && ((Signal) o).getType() == SignalType.ON_ERROR;
 	}
 
@@ -101,7 +100,7 @@ static boolean isError(@Nullable Object o) {
 	 *
 	 * @return an {@code OnSubscribe} variety of {@code Signal}
 	 */
-	static <T> Signal<@Nullable T> subscribe(Subscription subscription) {
+	static <T> Signal<T> subscribe(Subscription subscription) {
 		return new ImmutableSignal<>(SignalType.ON_SUBSCRIBE, null, null, subscription);
 	}
 
@@ -206,7 +205,7 @@ default boolean isOnNext() {
 	 * @param observer the {@link Subscriber} to play the {@link Signal} on
 	 */
 	@Override
-	default void accept(Subscriber<? super @NonNull T> observer) {
+	default void accept(Subscriber<? super T> observer) {
 		if (isOnNext()) {
 			observer.onNext(get());
 		}
diff --git a/reactor-core/src/main/java/reactor/core/publisher/SignalLogger.java b/reactor-core/src/main/java/reactor/core/publisher/SignalLogger.java
index d431c9354c..1672e2385a 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/SignalLogger.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/SignalLogger.java
@@ -29,10 +29,8 @@
 import reactor.core.publisher.FluxOnAssembly.AssemblySnapshotException;
 import reactor.util.Logger;
 import reactor.util.Loggers;
-import reactor.util.context.Context;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
-
+import reactor.util.context.Context;
 
 /**
  * A logging interceptor that intercepts all reactive calls and trace them.
@@ -73,7 +71,7 @@ final class SignalLogger<IN> implements SignalPeek<IN> {
 			@Nullable String category,
 			Level level,
 			boolean correlateStack,
-			SignalType @NonNull ... options) {
+			SignalType... options) {
 		this(source, category, level, correlateStack, Loggers::getLogger, options);
 	}
 
@@ -82,7 +80,7 @@ final class SignalLogger<IN> implements SignalPeek<IN> {
 			Level level,
 			boolean correlateStack,
 			Function<String, Logger> loggerSupplier,
-			@Nullable SignalType @NonNull ... options) {
+			@Nullable SignalType... options) {
 
 		this.source = Objects.requireNonNull(source, "source");
 		this.id = IDS.getAndIncrement();
diff --git a/reactor-core/src/main/java/reactor/core/publisher/SignalPeek.java b/reactor-core/src/main/java/reactor/core/publisher/SignalPeek.java
index b514527d9e..e1f902c47a 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/SignalPeek.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/SignalPeek.java
@@ -21,8 +21,8 @@
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Peek into the lifecycle and sequence signals.
diff --git a/reactor-core/src/main/java/reactor/core/publisher/StrictSubscriber.java b/reactor-core/src/main/java/reactor/core/publisher/StrictSubscriber.java
index e3ec769f6f..1fbf5ae1a6 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/StrictSubscriber.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/StrictSubscriber.java
@@ -25,8 +25,8 @@
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
 import reactor.core.Scannable;
-import reactor.util.context.Context;
 import reactor.util.annotation.Nullable;
+import reactor.util.context.Context;
 
 /**
  * Reactive Streams Commons safe exit
diff --git a/reactor-core/src/main/java/reactor/core/publisher/TopicProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/TopicProcessor.java
index 4119b2fa90..240624be9a 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/TopicProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/TopicProcessor.java
@@ -29,10 +29,9 @@
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
 import reactor.core.Exceptions;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.concurrent.WaitStrategy;
-import reactor.util.annotation.NonNull;
-import reactor.util.annotation.Nullable;
 
 /**
  ** An implementation of a RingBuffer backed message-passing Processor implementing publish-subscribe with async event
@@ -103,7 +102,7 @@ public final static class Builder<T> {
 		 *             if {@link #executor(ExecutorService)} is not configured.
 		 * @return builder with provided name
 		 */
-		public Builder<@NonNull T> name(@Nullable String name) {
+		public Builder<T> name(@Nullable String name) {
 			if (executor != null)
 				throw new IllegalArgumentException("Executor service is configured, name will not be used.");
 			this.name = name;
@@ -115,7 +114,7 @@ public final static class Builder<T> {
 		 * @param bufferSize the internal buffer size to hold signals, must be a power of 2.
 		 * @return builder with provided buffer size
 		 */
-		public Builder<@NonNull T> bufferSize(int bufferSize) {
+		public Builder<T> bufferSize(int bufferSize) {
 			if (!Queues.isPowerOfTwo(bufferSize)) {
 				throw new IllegalArgumentException("bufferSize must be a power of 2 : " + bufferSize);
 			}
@@ -134,7 +133,7 @@ public final static class Builder<T> {
 		 * @param waitStrategy A RingBuffer WaitStrategy to use instead of the default blocking wait strategy.
 		 * @return builder with provided wait strategy
 		 */
-		public Builder<@NonNull T> waitStrategy(@Nullable WaitStrategy waitStrategy) {
+		public Builder<T> waitStrategy(@Nullable WaitStrategy waitStrategy) {
 			this.waitStrategy = waitStrategy;
 			return this;
 		}
@@ -144,7 +143,7 @@ public final static class Builder<T> {
 		 * @param autoCancel automatically cancel
 		 * @return builder with provided auto-cancel
 		 */
-		public Builder<@NonNull T> autoCancel(boolean autoCancel) {
+		public Builder<T> autoCancel(boolean autoCancel) {
 			this.autoCancel = autoCancel;
 			return this;
 		}
@@ -156,7 +155,7 @@ public final static class Builder<T> {
 		 * @param executor A provided ExecutorService to manage threading infrastructure
 		 * @return builder with provided executor
 		 */
-		public Builder<@NonNull T> executor(@Nullable ExecutorService executor) {
+		public Builder<T> executor(@Nullable ExecutorService executor) {
 			this.executor = executor;
 			return this;
 		}
@@ -168,7 +167,7 @@ public final static class Builder<T> {
 		 * @param requestTaskExecutor internal request executor
 		 * @return builder with provided internal request executor
 		 */
-		public Builder<@NonNull T> requestTaskExecutor(@Nullable ExecutorService requestTaskExecutor) {
+		public Builder<T> requestTaskExecutor(@Nullable ExecutorService requestTaskExecutor) {
 			this.requestTaskExecutor = requestTaskExecutor;
 			return this;
 		}
@@ -180,7 +179,7 @@ public final static class Builder<T> {
 		 * @param share true to support concurrent onNext calls
 		 * @return builder with specified sharing
 		 */
-		public Builder<@NonNull T> share(boolean share) {
+		public Builder<T> share(boolean share) {
 			this.share = share;
 			return this;
 		}
@@ -190,7 +189,7 @@ public final static class Builder<T> {
 		 * @param signalSupplier A supplier of dispatched signals to preallocate
 		 * @return builder with provided signal supplier
 		 */
-		public Builder<@NonNull T> signalSupplier(@Nullable Supplier<@NonNull T> signalSupplier) {
+		public Builder<T> signalSupplier(@Nullable Supplier<T> signalSupplier) {
 			this.signalSupplier = signalSupplier;
 			return this;
 		}
@@ -200,7 +199,7 @@ public final static class Builder<T> {
 		 * of this builder.
 		 * @return a fresh processor
 		 */
-		public TopicProcessor<@NonNull T>  build() {
+		public TopicProcessor<T>  build() {
 			this.name = this.name != null ? this.name : TopicProcessor.class.getSimpleName();
 			this.waitStrategy = this.waitStrategy != null ? this.waitStrategy : WaitStrategy.phasedOffLiteLock(200, 100, TimeUnit.MILLISECONDS);
 			ThreadFactory threadFactory = this.executor != null ? null : new EventLoopFactory(name, autoCancel);
@@ -221,7 +220,7 @@ public final static class Builder<T> {
 	 * Create a new {@link TopicProcessor} {@link Builder} with default properties.
 	 * @return new TopicProcessor builder
 	 */
-	public static <E> Builder<@NonNull E> builder()  {
+	public static <E> Builder<E> builder()  {
 		return new Builder<>();
 	}
 
@@ -232,7 +231,7 @@ public final static class Builder<T> {
 	 * @param <E> Type of processed signals
 	 * @return a fresh processor
 	 */
-	public static <E> TopicProcessor<@NonNull E> create() {
+	public static <E> TopicProcessor<E> create() {
 		return TopicProcessor.<E>builder().build();
 	}
 
@@ -246,7 +245,7 @@ public final static class Builder<T> {
 	 * @param <E> Type of processed signals
 	 * @return the fresh TopicProcessor instance
 	 */
-	public static <E> TopicProcessor<@NonNull E> create(String name, int bufferSize) {
+	public static <E> TopicProcessor<E> create(String name, int bufferSize) {
 		return TopicProcessor.<E>builder().name(name).bufferSize(bufferSize).build();
 	}
 
@@ -265,7 +264,7 @@ public final static class Builder<T> {
 	 * @param <E> Type of processed signals
 	 * @return a fresh processor
 	 */
-	public static <E> TopicProcessor<@NonNull E> share(String name, int bufferSize) {
+	public static <E> TopicProcessor<E> share(String name, int bufferSize) {
 		return TopicProcessor.<E>builder().share(true).name(name).bufferSize(bufferSize).build();
 	}
 
@@ -281,7 +280,7 @@ public final static class Builder<T> {
 			WaitStrategy waitStrategy,
 			boolean shared,
 			boolean autoCancel,
-			@Nullable final Supplier<@NonNull E> signalSupplier) {
+			@Nullable final Supplier<E> signalSupplier) {
 		super(bufferSize, threadFactory, executor, requestTaskExecutor, autoCancel,
 				shared, () -> {
 			Slot<E> signal = new Slot<>();
@@ -296,7 +295,7 @@ public final static class Builder<T> {
 	}
 
 	@Override
-	public void subscribe(final CoreSubscriber<? super @NonNull E> actual) {
+	public void subscribe(final CoreSubscriber<? super E> actual) {
 		Objects.requireNonNull(actual, "subscribe");
 
 		if (!alive()) {
@@ -422,9 +421,9 @@ public void run() {
 		 * @param pendingRequest holder for the number of pending requests
 		 * @param subscriber the output Subscriber instance
 		 */
-		TopicInner(TopicProcessor<@NonNull T> processor,
+		TopicInner(TopicProcessor<T> processor,
 		                            RingBuffer.Sequence pendingRequest,
-				CoreSubscriber<? super @NonNull T> subscriber) {
+				CoreSubscriber<? super T> subscriber) {
 			this.processor = processor;
 			this.pendingRequest = pendingRequest;
 			this.subscriber = subscriber;
@@ -560,7 +559,7 @@ public Object scanUnsafe(Attr key) {
 		}
 
 		@Override
-		public CoreSubscriber<? super @NonNull T> actual() {
+		public CoreSubscriber<? super T> actual() {
 			return subscriber;
 		}
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/UnicastProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/UnicastProcessor.java
index 8bb7395b49..70a8a03c29 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/UnicastProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/UnicastProcessor.java
@@ -28,10 +28,9 @@
 import reactor.core.Disposable;
 import reactor.core.Exceptions;
 import reactor.core.Fuseable;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.context.Context;
-import reactor.util.annotation.NonNull;
-import reactor.util.annotation.Nullable;
 
 /**
  * A Processor implementation that takes a custom queue and allows
@@ -53,7 +52,7 @@ public final class UnicastProcessor<T>
 	 * @param <E> the relayed type
 	 * @return a unicast {@link FluxProcessor}
 	 */
-	public static <E> UnicastProcessor<@NonNull E> create() {
+	public static <E> UnicastProcessor<E> create() {
 		return new UnicastProcessor<>(Queues.<E>unbounded().get());
 	}
 
@@ -65,7 +64,7 @@ public final class UnicastProcessor<T>
 	 * @param <E> the relayed type
 	 * @return a unicast {@link FluxProcessor}
 	 */
-	public static <E> UnicastProcessor<@NonNull E> create(Queue<@NonNull E> queue) {
+	public static <E> UnicastProcessor<E> create(Queue<E> queue) {
 		return new UnicastProcessor<>(queue);
 	}
 
@@ -78,7 +77,7 @@ public final class UnicastProcessor<T>
 	 * @param <E> the relayed type
 	 * @return a unicast {@link FluxProcessor}
 	 */
-	public static <E> UnicastProcessor<@NonNull E> create(Queue<@NonNull E> queue, Disposable endcallback) {
+	public static <E> UnicastProcessor<E> create(Queue<E> queue, Disposable endcallback) {
 		return new UnicastProcessor<>(queue, endcallback);
 	}
 
@@ -94,8 +93,8 @@ public final class UnicastProcessor<T>
 	 *
 	 * @return a unicast {@link FluxProcessor}
 	 */
-	public static <E> UnicastProcessor<@NonNull E> create(Queue<@NonNull E> queue,
-			Consumer<? super @NonNull E> onOverflow,
+	public static <E> UnicastProcessor<E> create(Queue<E> queue,
+			Consumer<? super E> onOverflow,
 			Disposable endcallback) {
 		return new UnicastProcessor<>(queue, onOverflow, endcallback);
 	}
@@ -132,20 +131,20 @@ public final class UnicastProcessor<T>
 
 	volatile boolean outputFused;
 
-	public UnicastProcessor(Queue<@NonNull T> queue) {
+	public UnicastProcessor(Queue<T> queue) {
 		this.queue = Objects.requireNonNull(queue, "queue");
 		this.onTerminate = null;
 		this.onOverflow = null;
 	}
 
-	public UnicastProcessor(Queue<@NonNull T> queue, Disposable onTerminate) {
+	public UnicastProcessor(Queue<T> queue, Disposable onTerminate) {
 		this.queue = Objects.requireNonNull(queue, "queue");
 		this.onTerminate = Objects.requireNonNull(onTerminate, "onTerminate");
 		this.onOverflow = null;
 	}
 
-	public UnicastProcessor(Queue<@NonNull T> queue,
-			Consumer<? super @NonNull T> onOverflow,
+	public UnicastProcessor(Queue<T> queue,
+			Consumer<? super T> onOverflow,
 			Disposable onTerminate) {
 		this.queue = Objects.requireNonNull(queue, "queue");
 		this.onOverflow = Objects.requireNonNull(onOverflow, "onOverflow");
@@ -164,7 +163,7 @@ void doTerminate() {
 		}
 	}
 
-	void drainRegular(Subscriber<? super @NonNull T> a) {
+	void drainRegular(Subscriber<? super T> a) {
 		int missed = 1;
 
 		final Queue<T> q = queue;
@@ -210,7 +209,7 @@ void drainRegular(Subscriber<? super @NonNull T> a) {
 		}
 	}
 
-	void drainFused(Subscriber<? super @NonNull T> a) {
+	void drainFused(Subscriber<? super T> a) {
 		int missed = 1;
 
 		final Queue<T> q = queue;
@@ -272,7 +271,7 @@ void drain() {
 		}
 	}
 
-	boolean checkTerminated(boolean d, boolean empty, Subscriber<? super @NonNull T> a, Queue<@NonNull T> q) {
+	boolean checkTerminated(boolean d, boolean empty, Subscriber<? super T> a, Queue<T> q) {
 		if (cancelled) {
 			q.clear();
 			actual = null;
@@ -366,7 +365,7 @@ public void onComplete() {
 	}
 
 	@Override
-	public void subscribe(CoreSubscriber<? super @NonNull T> actual) {
+	public void subscribe(CoreSubscriber<? super T> actual) {
 		Objects.requireNonNull(actual, "subscribe");
 		if (once == 0 && ONCE.compareAndSet(this, 0, 1)) {
 
@@ -454,7 +453,7 @@ public Throwable getError() {
 	}
 
 	@Override
-	public CoreSubscriber<? super @NonNull T> actual() {
+	public CoreSubscriber<? super T> actual() {
 		return actual;
 	}
 
diff --git a/reactor-core/src/main/java/reactor/core/publisher/WorkQueueProcessor.java b/reactor-core/src/main/java/reactor/core/publisher/WorkQueueProcessor.java
index 64076dbf25..5746a0297a 100644
--- a/reactor-core/src/main/java/reactor/core/publisher/WorkQueueProcessor.java
+++ b/reactor-core/src/main/java/reactor/core/publisher/WorkQueueProcessor.java
@@ -35,10 +35,9 @@
 import reactor.core.Exceptions;
 import reactor.util.Logger;
 import reactor.util.Loggers;
+import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 import reactor.util.concurrent.WaitStrategy;
-import reactor.util.annotation.NonNull;
-import reactor.util.annotation.Nullable;
 
 /**
  ** An implementation of a RingBuffer backed message-passing Processor implementing work-queue distribution with
@@ -99,7 +98,7 @@ public final static class Builder<T> {
 		 *             if {@link #executor(ExecutorService)} is not configured.
 		 * @return builder with provided name
 		 */
-		public Builder<@NonNull T> name(@Nullable String name) {
+		public Builder<T> name(@Nullable String name) {
 			if (executor != null)
 				throw new IllegalArgumentException("Executor service is configured, name will not be used.");
 			this.name = name;
@@ -111,7 +110,7 @@ public final static class Builder<T> {
 		 * @param bufferSize the internal buffer size to hold signals, must be a power of 2
 		 * @return builder with provided buffer size
 		 */
-		public Builder<@NonNull T> bufferSize(int bufferSize) {
+		public Builder<T> bufferSize(int bufferSize) {
 			if (!Queues.isPowerOfTwo(bufferSize)) {
 				throw new IllegalArgumentException("bufferSize must be a power of 2 : " + bufferSize);
 			}
@@ -130,7 +129,7 @@ public final static class Builder<T> {
 		 * @param waitStrategy A RingBuffer WaitStrategy to use instead of the default smart blocking wait strategy.
 		 * @return builder with provided wait strategy
 		 */
-		public Builder<@NonNull T> waitStrategy(@Nullable WaitStrategy waitStrategy) {
+		public Builder<T> waitStrategy(@Nullable WaitStrategy waitStrategy) {
 			this.waitStrategy = waitStrategy;
 			return this;
 		}
@@ -140,7 +139,7 @@ public final static class Builder<T> {
 		 * @param autoCancel automatically cancel
 		 * @return builder with provided auto-cancel
 		 */
-		public Builder<@NonNull T> autoCancel(boolean autoCancel) {
+		public Builder<T> autoCancel(boolean autoCancel) {
 			this.autoCancel = autoCancel;
 			return this;
 		}
@@ -152,7 +151,7 @@ public final static class Builder<T> {
 		 * @param executor A provided ExecutorService to manage threading infrastructure
 		 * @return builder with provided executor
 		 */
-		public Builder<@NonNull T> executor(@Nullable ExecutorService executor) {
+		public Builder<T> executor(@Nullable ExecutorService executor) {
 			this.executor = executor;
 			return this;
 		}
@@ -163,7 +162,7 @@ public final static class Builder<T> {
 		 * @param requestTaskExecutor internal request executor
 		 * @return builder with provided internal request executor
 		 */
-		public Builder<@NonNull T> requestTaskExecutor(@Nullable ExecutorService requestTaskExecutor) {
+		public Builder<T> requestTaskExecutor(@Nullable ExecutorService requestTaskExecutor) {
 			this.requestTaskExecutor = requestTaskExecutor;
 			return this;
 		}
@@ -175,7 +174,7 @@ public final static class Builder<T> {
 		 * @param share true to support concurrent onNext calls
 		 * @return builder with specified sharing
 		 */
-		public Builder<@NonNull T> share(boolean share) {
+		public Builder<T> share(boolean share) {
 			this.share = share;
 			return this;
 		}
@@ -185,7 +184,7 @@ public final static class Builder<T> {
 		 * of this builder.
 		 * @return a fresh processor
 		 */
-		public WorkQueueProcessor<@NonNull T>  build() {
+		public WorkQueueProcessor<T>  build() {
 			String name = this.name != null ? this.name : WorkQueueProcessor.class.getSimpleName();
 			WaitStrategy waitStrategy = this.waitStrategy != null ? this.waitStrategy : WaitStrategy.liteBlocking();
 			ThreadFactory threadFactory = this.executor != null ? null : new EventLoopFactory(name, autoCancel);
@@ -206,7 +205,7 @@ public final static class Builder<T> {
 	 * Create a new {@link WorkQueueProcessor} {@link Builder} with default properties.
 	 * @return new WorkQueueProcessor builder
 	 */
-	public final static <T> Builder<@NonNull T> builder() {
+	public final static <T> Builder<T> builder() {
 		return new Builder<>();
 	}
 
@@ -217,7 +216,7 @@ public final static class Builder<T> {
 	 * @param <E> Type of processed signals
 	 * @return a fresh processor
 	 */
-	public static <E> WorkQueueProcessor<@NonNull E> create() {
+	public static <E> WorkQueueProcessor<E> create() {
 		return WorkQueueProcessor.<E>builder().build();
 	}
 
@@ -231,7 +230,7 @@ public final static class Builder<T> {
 	 * @param <E> Type of processed signals
 	 * @return a fresh processor
 	 */
-	public static <E> WorkQueueProcessor<@NonNull E> create(String name, int bufferSize) {
+	public static <E> WorkQueueProcessor<E> create(String name, int bufferSize) {
 		return WorkQueueProcessor.<E>builder().name(name).bufferSize(bufferSize).build();
 	}
 
@@ -247,7 +246,7 @@ public final static class Builder<T> {
 	 * @param <E> Type of processed signals
 	 * @return a fresh processor
 	 */
-	public static <E> WorkQueueProcessor<@NonNull E> share(String name, int bufferSize) {
+	public static <E> WorkQueueProcessor<E> share(String name, int bufferSize) {
 		return WorkQueueProcessor.<E>builder().share(true).name(name).bufferSize(bufferSize).build();
 	}
 
@@ -292,7 +291,7 @@ public final static class Builder<T> {
 	}
 
 	@Override
-	public void subscribe(final CoreSubscriber<? super @NonNull E> actual) {
+	public void subscribe(final CoreSubscriber<? super E> actual) {
 		Objects.requireNonNull(actual, "subscribe");
 
 		if (!alive()) {
@@ -430,8 +429,8 @@ public void run() {
 		 * @param subscriber the output Subscriber instance
 		 * @param processor the source processor
 		 */
-		WorkQueueInner(CoreSubscriber<? super @NonNull T> subscriber,
-				WorkQueueProcessor<@NonNull T> processor) {
+		WorkQueueInner(CoreSubscriber<? super T> subscriber,
+				WorkQueueProcessor<T> processor) {
 			this.processor = processor;
 			this.subscriber = subscriber;
 
@@ -656,7 +655,7 @@ boolean replay(final boolean unbounded) {
 			}
 		}
 
-		boolean reschedule(@Nullable Slot<@NonNull T> event) {
+		boolean reschedule(@Nullable Slot<T> event) {
 			if (event != null &&
 					event.value != null) {
 				processor.claimedDisposed.add(event.value);
@@ -691,7 +690,7 @@ public Object scanUnsafe(Attr key) {
 		}
 
 		@Override
-		public CoreSubscriber<? super @NonNull T> actual() {
+		public CoreSubscriber<? super T> actual() {
 			return subscriber;
 		}
 
diff --git a/reactor-core/src/main/java/reactor/util/Logger.java b/reactor-core/src/main/java/reactor/util/Logger.java
index 100e4c470d..9bf3d0cbcd 100644
--- a/reactor-core/src/main/java/reactor/util/Logger.java
+++ b/reactor-core/src/main/java/reactor/util/Logger.java
@@ -15,8 +15,6 @@
  */
 package reactor.util;
 
-import reactor.util.annotation.Nullable;
-
 /**
  * Logger interface designed for internal Reactor usage.
  */
@@ -55,7 +53,7 @@ public interface Logger {
 	 * @param format    the format string
 	 * @param arguments a list of 3 or more arguments
 	 */
-	void trace(String format, @Nullable Object @Nullable ... arguments);
+	void trace(String format, Object... arguments);
 
 	/**
 	 * Log an exception (throwable) at the TRACE level with an
@@ -93,7 +91,7 @@ public interface Logger {
 	 * @param format    the format string
 	 * @param arguments a list of 3 or more arguments
 	 */
-	void debug(String format, @Nullable Object @Nullable ... arguments);
+	void debug(String format, Object... arguments);
 
 	/**
 	 * Log an exception (throwable) at the DEBUG level with an
@@ -131,7 +129,7 @@ public interface Logger {
 	 * @param format    the format string
 	 * @param arguments a list of 3 or more arguments
 	 */
-	void info(String format, @Nullable Object @Nullable ... arguments);
+	void info(String format, Object... arguments);
 
 	/**
 	 * Log an exception (throwable) at the INFO level with an
@@ -169,7 +167,7 @@ public interface Logger {
 	 * @param format    the format string
 	 * @param arguments a list of 3 or more arguments
 	 */
-	void warn(String format, @Nullable Object @Nullable ... arguments);
+	void warn(String format, Object... arguments);
 
 	/**
 	 * Log an exception (throwable) at the WARN level with an
@@ -207,7 +205,7 @@ public interface Logger {
 	 * @param format    the format string
 	 * @param arguments a list of 3 or more arguments
 	 */
-	void error(String format, @Nullable Object @Nullable ... arguments);
+	void error(String format, Object... arguments);
 
 	/**
 	 * Log an exception (throwable) at the ERROR level with an
diff --git a/reactor-core/src/main/java/reactor/util/Loggers.java b/reactor-core/src/main/java/reactor/util/Loggers.java
index 362368ba6f..e13479167b 100644
--- a/reactor-core/src/main/java/reactor/util/Loggers.java
+++ b/reactor-core/src/main/java/reactor/util/Loggers.java
@@ -401,7 +401,7 @@ public void error(String msg, Throwable t) {
 		}
 
 		@Nullable
-		private String format(@Nullable String from, @Nullable Object @Nullable ... arguments){
+		private String format(@Nullable String from, @Nullable Object... arguments){
 			if(from != null) {
 				String computed = from;
 				if (arguments != null && arguments.length != 0) {
@@ -449,7 +449,7 @@ public String getName() {
 		}
 
 		@Nullable
-		private String format(@Nullable String from, @Nullable Object @Nullable ... arguments){
+		private String format(@Nullable String from, @Nullable Object... arguments){
 			if(from != null) {
 				String computed = from;
 				if (arguments != null && arguments.length != 0) {
diff --git a/reactor-core/src/main/java/reactor/util/annotation/NonNull.java b/reactor-core/src/main/java/reactor/util/annotation/NonNull.java
index bc00b6fd1a..f196e8f0ec 100644
--- a/reactor-core/src/main/java/reactor/util/annotation/NonNull.java
+++ b/reactor-core/src/main/java/reactor/util/annotation/NonNull.java
@@ -31,15 +31,13 @@
  * Java to common tools with JSR 305 support and used by Kotlin to infer nullability of
  * Reactor API.
  *
- * <p>Should be used at generic type argument, parameter, return value, and field level.
+ * <p>Should be used at parameter, return value, and field level.
  * Methods overrides should repeat parent {@code @NonNull} annotations unless they behave
  * differently.
  *
  * <p>Use {@code @NonNullApi} (scope = parameters + return values) to set the default
  * behavior to non-nullable in order to avoid annotating your whole codebase with
- * {@code @NonNull}. No default restricted to generic type argument is possible
- * ({@code ElementType.TYPE_USE} scope is too wide) so each generic type argument
- * needs to be annotated with @code @NonNull}.
+ * {@code @NonNull}.
  *
  * @author Sebastien Deleuze
  * @author Juergen Hoeller
@@ -47,7 +45,7 @@
  * @see NonNullApi
  * @see Nullable
  */
-@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE_USE, ElementType.FIELD})
+@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Nonnull
diff --git a/reactor-core/src/main/java/reactor/util/annotation/NonNullApi.java b/reactor-core/src/main/java/reactor/util/annotation/NonNullApi.java
index d23ba1ad99..7087b45609 100644
--- a/reactor-core/src/main/java/reactor/util/annotation/NonNullApi.java
+++ b/reactor-core/src/main/java/reactor/util/annotation/NonNullApi.java
@@ -31,19 +31,12 @@
  * Leverages JSR 305 meta-annotations to indicate nullability in Java to common tools with
  * JSR 305 support and used by Kotlin to infer nullability of Reactor API.
  *
- *
  * <p>Should be used at package level in association with {@link Nullable}
  * annotations at parameter and return value level.
  *
- * <p>This annotation does not define nullability of generic type arguments, because
- * {@code @TypeQualifierDefault(ElementType.TYPE_USE)} scope would be too broad.
- * As a consequence, each API generic type argument should be annotated
- * with {@link Nullable} or {@link NonNull} to specify their nullability.
- *
  * @author Sebastien Deleuze
  * @author Juergen Hoeller
  * @since 3.1.0
-
  * @see Nullable
  * @see NonNull
  */
diff --git a/reactor-core/src/main/java/reactor/util/annotation/Nullable.java b/reactor-core/src/main/java/reactor/util/annotation/Nullable.java
index be1ca82527..851c5c2cf1 100644
--- a/reactor-core/src/main/java/reactor/util/annotation/Nullable.java
+++ b/reactor-core/src/main/java/reactor/util/annotation/Nullable.java
@@ -32,7 +32,7 @@
  * indicate nullability in Java to common tools with JSR 305 support and used by Kotlin to
  * infer nullability of Reactor API.
  *
- * <p>Should be used at generic type argument, parameter, return value, and field level.
+ * <p>Should be used at parameter, return value, and field level.
  * Methods overrides should repeat parent {@code @Nullable} annotations unless they behave
  * differently.
  *
@@ -45,7 +45,7 @@
  * @see NonNullApi
  * @see NonNull
  */
-@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE_USE, ElementType.FIELD})
+@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Nonnull(when = When.MAYBE)
diff --git a/reactor-core/src/main/java/reactor/util/annotation/package-info.java b/reactor-core/src/main/java/reactor/util/annotation/package-info.java
deleted file mode 100644
index 1d12460e7e..0000000000
--- a/reactor-core/src/main/java/reactor/util/annotation/package-info.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2011-2017 Pivotal Software Inc, All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Annotations mainly intended for internal use in order to define nullability
- * of Reactor API, used by tooling (IDEA) and Kotlin.
- */
-package reactor.util.annotation;
-
diff --git a/reactor-core/src/main/java/reactor/util/concurrent/Queues.java b/reactor-core/src/main/java/reactor/util/concurrent/Queues.java
index 9a50d622f0..cd5e2a2f4e 100644
--- a/reactor-core/src/main/java/reactor/util/concurrent/Queues.java
+++ b/reactor-core/src/main/java/reactor/util/concurrent/Queues.java
@@ -24,10 +24,9 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
 
-
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
+
 /**
  * Queue utilities and suppliers for 1-producer/1-consumer ready queues adapted for
  * various given capacities.
@@ -96,7 +95,7 @@ public static int ceilingNextPowerOfTwo(final int x) {
 	 * @return an unbounded or bounded {@link Queue} {@link Supplier}
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> Supplier<@NonNull Queue<@NonNull T>> get(int batchSize) {
+	public static <T> Supplier<Queue<T>> get(int batchSize) {
 		if (batchSize == Integer.MAX_VALUE) {
 			return SMALL_UNBOUNDED;
 		}
@@ -134,7 +133,7 @@ public static boolean isPowerOfTwo(final int x) {
 	 * @return a bounded {@link Queue} {@link Supplier}
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> Supplier<@NonNull Queue<@NonNull T>> one() {
+	public static <T> Supplier<Queue<T>> one() {
 		return ONE_SUPPLIER;
 	}
 
@@ -144,7 +143,7 @@ public static boolean isPowerOfTwo(final int x) {
 	 * @return a bounded {@link Queue} {@link Supplier}
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> Supplier<@NonNull Queue<@NonNull T>> small() {
+	public static <T> Supplier<Queue<T>> small() {
 		return SMALL_SUPPLIER;
 	}
 
@@ -154,7 +153,7 @@ public static boolean isPowerOfTwo(final int x) {
 	 * @return an unbounded {@link Queue} {@link Supplier}
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> Supplier<@NonNull Queue<@NonNull T>> unbounded() {
+	public static <T> Supplier<Queue<T>> unbounded() {
 		return SMALL_UNBOUNDED;
 	}
 
@@ -166,7 +165,7 @@ public static boolean isPowerOfTwo(final int x) {
 	 * @return an unbounded {@link Queue} {@link Supplier}
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> Supplier<@NonNull Queue<@NonNull T>> unbounded(int linkSize) {
+	public static <T> Supplier<Queue<T>> unbounded(int linkSize) {
 		if (linkSize == XS_BUFFER_SIZE) {
 			return XS_UNBOUNDED;
 		}
@@ -182,7 +181,7 @@ else if (linkSize == Integer.MAX_VALUE || linkSize == SMALL_BUFFER_SIZE) {
 	 * @return a bounded {@link Queue} {@link Supplier}
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> Supplier<@NonNull Queue<@NonNull T>> xs() {
+	public static <T> Supplier<Queue<T>> xs() {
 		return XS_SUPPLIER;
 	}
 
diff --git a/reactor-core/src/main/java/reactor/util/context/Context.java b/reactor-core/src/main/java/reactor/util/context/Context.java
index 035821ecc4..8304a8fb79 100644
--- a/reactor-core/src/main/java/reactor/util/context/Context.java
+++ b/reactor-core/src/main/java/reactor/util/context/Context.java
@@ -21,7 +21,6 @@
 import java.util.Optional;
 import java.util.stream.Stream;
 
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
 /**
@@ -251,7 +250,7 @@ default boolean isEmpty() {
 	 *
 	 * @return a {@link Stream} of key/value pairs held by this context
 	 */
-	Stream<Map.@NonNull Entry<@NonNull Object, @NonNull Object>> stream();
+	Stream<Map.Entry<Object,Object>> stream();
 
 	/**
 	 * Create a new {@link Context} by merging the content of this context and a given
diff --git a/reactor-core/src/main/java/reactor/util/context/ContextN.java b/reactor-core/src/main/java/reactor/util/context/ContextN.java
index eda171c163..7a372ec5cb 100644
--- a/reactor-core/src/main/java/reactor/util/context/ContextN.java
+++ b/reactor-core/src/main/java/reactor/util/context/ContextN.java
@@ -17,6 +17,7 @@
 
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.NoSuchElementException;
diff --git a/reactor-core/src/main/java/reactor/util/function/Tuple2.java b/reactor-core/src/main/java/reactor/util/function/Tuple2.java
index 9232f7cee0..816edb5db9 100644
--- a/reactor-core/src/main/java/reactor/util/function/Tuple2.java
+++ b/reactor-core/src/main/java/reactor/util/function/Tuple2.java
@@ -89,7 +89,7 @@ public Object get(int index) {
 	 *
 	 * @return A new Object list.
 	 */
-	public List<@NonNull Object> toList() {
+	public List<Object> toList() {
 		return Arrays.asList(toArray());
 	}
 
@@ -98,7 +98,7 @@ public Object get(int index) {
 	 *
 	 * @return A new Object array.
 	 */
-	public Object @NonNull[] toArray() {
+	public Object[] toArray() {
 		return new Object[]{t1, t2};
 	}
 
diff --git a/reactor-core/src/main/java/reactor/util/function/Tuple3.java b/reactor-core/src/main/java/reactor/util/function/Tuple3.java
index e4d6b8577a..48be782d47 100644
--- a/reactor-core/src/main/java/reactor/util/function/Tuple3.java
+++ b/reactor-core/src/main/java/reactor/util/function/Tuple3.java
@@ -66,7 +66,7 @@ public Object get(int index) {
 	}
 
 	@Override
-	public Object @NonNull [] toArray() {
+	public Object[] toArray() {
 		return new Object[]{t1, t2, t3};
 	}
 
diff --git a/reactor-core/src/main/java/reactor/util/function/Tuple4.java b/reactor-core/src/main/java/reactor/util/function/Tuple4.java
index 5a0354d25d..a97372d6fd 100644
--- a/reactor-core/src/main/java/reactor/util/function/Tuple4.java
+++ b/reactor-core/src/main/java/reactor/util/function/Tuple4.java
@@ -69,7 +69,7 @@ public Object get(int index) {
 	}
 
 	@Override
-	public Object @NonNull [] toArray() {
+	public Object[] toArray() {
 		return new Object[]{t1, t2, t3, t4};
 	}
 
diff --git a/reactor-core/src/main/java/reactor/util/function/Tuple5.java b/reactor-core/src/main/java/reactor/util/function/Tuple5.java
index 2d9851e9ef..04810a286a 100644
--- a/reactor-core/src/main/java/reactor/util/function/Tuple5.java
+++ b/reactor-core/src/main/java/reactor/util/function/Tuple5.java
@@ -72,7 +72,7 @@ public Object get(int index) {
 	}
 
 	@Override
-	public Object @NonNull [] toArray() {
+	public Object[] toArray() {
 		return new Object[]{t1, t2, t3, t4, t5};
 	}
 
diff --git a/reactor-core/src/main/java/reactor/util/function/Tuple6.java b/reactor-core/src/main/java/reactor/util/function/Tuple6.java
index de3fd9e58f..72e823e2fc 100644
--- a/reactor-core/src/main/java/reactor/util/function/Tuple6.java
+++ b/reactor-core/src/main/java/reactor/util/function/Tuple6.java
@@ -75,7 +75,7 @@ public Object get(int index) {
 	}
 
 	@Override
-	public Object @NonNull [] toArray() {
+	public Object[] toArray() {
 		return new Object[]{t1, t2, t3, t4, t5, t6};
 	}
 
diff --git a/reactor-core/src/main/java/reactor/util/function/Tuple7.java b/reactor-core/src/main/java/reactor/util/function/Tuple7.java
index e9c33fccf3..bd8b2f4395 100644
--- a/reactor-core/src/main/java/reactor/util/function/Tuple7.java
+++ b/reactor-core/src/main/java/reactor/util/function/Tuple7.java
@@ -78,7 +78,7 @@ public Object get(int index) {
 	}
 
 	@Override
-	public Object @NonNull [] toArray() {
+	public Object[] toArray() {
 		return new Object[]{t1, t2, t3, t4, t5, t6, t7};
 	}
 
diff --git a/reactor-core/src/main/java/reactor/util/function/Tuple8.java b/reactor-core/src/main/java/reactor/util/function/Tuple8.java
index 325591d8cd..073b065df6 100644
--- a/reactor-core/src/main/java/reactor/util/function/Tuple8.java
+++ b/reactor-core/src/main/java/reactor/util/function/Tuple8.java
@@ -82,7 +82,7 @@ public Object get(int index) {
 	}
 
 	@Override
-	public Object @NonNull [] toArray() {
+	public Object[] toArray() {
 		return new Object[]{t1, t2, t3, t4, t5, t6, t7, t8};
 	}
 
diff --git a/reactor-core/src/main/java/reactor/util/function/Tuples.java b/reactor-core/src/main/java/reactor/util/function/Tuples.java
index a0c92261bd..5f7bf2cb4f 100644
--- a/reactor-core/src/main/java/reactor/util/function/Tuples.java
+++ b/reactor-core/src/main/java/reactor/util/function/Tuples.java
@@ -19,8 +19,6 @@
 import java.util.Collection;
 import java.util.function.Function;
 
-import reactor.util.annotation.NonNull;
-
 /**
  * A {@literal Tuples} is an immutable {@link Collection} of objects, each of which can be of an arbitrary type.
  *
@@ -38,7 +36,7 @@ public abstract class Tuples implements Function {
 	 * @return The new {@link Tuple2}.
 	 * @throws IllegalArgumentException if the array is not of length 1-8
 	 */
-	public static Tuple2 fromArray(Object @NonNull [] list) {
+	public static Tuple2 fromArray(Object[] list) {
 		//noinspection ConstantConditions
 		if (list == null || list.length < 2) {
 			throw new IllegalArgumentException("null or too small array, need between 2 and 8 values");
@@ -477,7 +475,7 @@ public Tuple2 apply(Object o) {
 	 * @return a {@link StringBuilder} initialized with the string representation of the
 	 * values in the Tuple.
 	 */
-	static StringBuilder tupleStringRepresentation(Object @NonNull ... values) {
+	static StringBuilder tupleStringRepresentation(Object... values) {
 		StringBuilder sb = new StringBuilder();
 		for (int i = 0; i < values.length; i++) {
 			Object t = values[i];
diff --git a/reactor-core/src/main/java/reactor/util/package-info.java b/reactor-core/src/main/java/reactor/util/package-info.java
index 5d3c747ea8..447d6cf98a 100644
--- a/reactor-core/src/main/java/reactor/util/package-info.java
+++ b/reactor-core/src/main/java/reactor/util/package-info.java
@@ -21,3 +21,4 @@
 package reactor.util;
 
 import reactor.util.annotation.NonNullApi;
+import javax.annotation.Nullable;
\ No newline at end of file
diff --git a/reactor-core/src/test/java/reactor/core/CoreTest.java b/reactor-core/src/test/java/reactor/core/CoreTest.java
index a1de361036..14fcd15eda 100644
--- a/reactor-core/src/test/java/reactor/core/CoreTest.java
+++ b/reactor-core/src/test/java/reactor/core/CoreTest.java
@@ -17,6 +17,7 @@
 
 import java.util.Collections;
 
+
 import org.junit.Test;
 import reactor.util.annotation.Nullable;
 
diff --git a/reactor-core/src/test/java/reactor/core/publisher/UnicastProcessorTest.java b/reactor-core/src/test/java/reactor/core/publisher/UnicastProcessorTest.java
index 5f901d47e4..f7401e05f9 100644
--- a/reactor-core/src/test/java/reactor/core/publisher/UnicastProcessorTest.java
+++ b/reactor-core/src/test/java/reactor/core/publisher/UnicastProcessorTest.java
@@ -23,6 +23,7 @@
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.function.Consumer;
 
+
 import org.junit.Test;
 
 import reactor.core.Disposable;
diff --git a/reactor-core/src/test/java/reactor/test/publisher/BaseOperatorTest.java b/reactor-core/src/test/java/reactor/test/publisher/BaseOperatorTest.java
index 4bfa604f6a..de1f939104 100644
--- a/reactor-core/src/test/java/reactor/test/publisher/BaseOperatorTest.java
+++ b/reactor-core/src/test/java/reactor/test/publisher/BaseOperatorTest.java
@@ -22,6 +22,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
diff --git a/reactor-core/src/test/java/reactor/test/publisher/FluxEmptySyncFuseable.java b/reactor-core/src/test/java/reactor/test/publisher/FluxEmptySyncFuseable.java
index d7015cdb43..7ef4c803fb 100644
--- a/reactor-core/src/test/java/reactor/test/publisher/FluxEmptySyncFuseable.java
+++ b/reactor-core/src/test/java/reactor/test/publisher/FluxEmptySyncFuseable.java
@@ -15,6 +15,7 @@
  */
 package reactor.test.publisher;
 
+
 import reactor.core.CoreSubscriber;
 import reactor.core.Fuseable;
 import reactor.core.publisher.Flux;
diff --git a/reactor-core/src/test/java/reactor/test/publisher/FluxFuseableExceptionOnPoll.java b/reactor-core/src/test/java/reactor/test/publisher/FluxFuseableExceptionOnPoll.java
index d293f78cc6..0dd81511ba 100644
--- a/reactor-core/src/test/java/reactor/test/publisher/FluxFuseableExceptionOnPoll.java
+++ b/reactor-core/src/test/java/reactor/test/publisher/FluxFuseableExceptionOnPoll.java
@@ -15,6 +15,7 @@
  */
 package reactor.test.publisher;
 
+
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
 import reactor.core.CoreSubscriber;
diff --git a/reactor-core/src/test/java/reactor/test/publisher/MonoOperatorTest.java b/reactor-core/src/test/java/reactor/test/publisher/MonoOperatorTest.java
index 6e9c2223b3..ba6f6338be 100644
--- a/reactor-core/src/test/java/reactor/test/publisher/MonoOperatorTest.java
+++ b/reactor-core/src/test/java/reactor/test/publisher/MonoOperatorTest.java
@@ -22,6 +22,7 @@
 import java.util.function.Function;
 import java.util.function.IntFunction;
 
+
 import org.reactivestreams.Subscription;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
diff --git a/reactor-core/src/test/java/reactor/test/publisher/OperatorScenario.java b/reactor-core/src/test/java/reactor/test/publisher/OperatorScenario.java
index 8b5b097f71..b8d2684fb1 100644
--- a/reactor-core/src/test/java/reactor/test/publisher/OperatorScenario.java
+++ b/reactor-core/src/test/java/reactor/test/publisher/OperatorScenario.java
@@ -21,6 +21,7 @@
 import java.util.function.Function;
 import java.util.function.IntFunction;
 
+
 import org.reactivestreams.Publisher;
 import reactor.test.StepVerifier;
 import reactor.util.annotation.Nullable;
diff --git a/reactor-core/src/test/java/reactor/test/publisher/ParallelOperatorTest.java b/reactor-core/src/test/java/reactor/test/publisher/ParallelOperatorTest.java
index 1c14c22c75..0dc938fd4e 100644
--- a/reactor-core/src/test/java/reactor/test/publisher/ParallelOperatorTest.java
+++ b/reactor-core/src/test/java/reactor/test/publisher/ParallelOperatorTest.java
@@ -21,6 +21,7 @@
 import java.util.function.Function;
 import java.util.function.IntFunction;
 
+
 import org.reactivestreams.Subscription;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
diff --git a/reactor-test/src/main/java/reactor/test/DefaultStepVerifierBuilder.java b/reactor-test/src/main/java/reactor/test/DefaultStepVerifierBuilder.java
index aa1f3394c1..0a1a40dccf 100644
--- a/reactor-test/src/main/java/reactor/test/DefaultStepVerifierBuilder.java
+++ b/reactor-test/src/main/java/reactor/test/DefaultStepVerifierBuilder.java
@@ -53,9 +53,9 @@
 import reactor.test.scheduler.VirtualTimeScheduler;
 import reactor.util.Logger;
 import reactor.util.Loggers;
+import reactor.util.annotation.Nullable;
 import reactor.util.function.Tuple2;
 import reactor.util.function.Tuples;
-import reactor.util.annotation.Nullable;
 
 /**
  * Default implementation of {@link StepVerifier.Step} and
diff --git a/reactor-test/src/main/java/reactor/test/StepVerifier.java b/reactor-test/src/main/java/reactor/test/StepVerifier.java
index 5e64a189bf..c97a879fb0 100644
--- a/reactor-test/src/main/java/reactor/test/StepVerifier.java
+++ b/reactor-test/src/main/java/reactor/test/StepVerifier.java
@@ -25,6 +25,7 @@
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
+
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 import org.reactivestreams.Subscription;
@@ -34,7 +35,6 @@
 import reactor.test.scheduler.VirtualTimeScheduler;
 import reactor.util.annotation.Nullable;
 import reactor.util.function.Tuple2;
-import reactor.util.annotation.NonNull;
 
 /**
  * A {@link StepVerifier} provides a declarative way of creating a verifiable script for
@@ -670,7 +670,7 @@ default Step<T> assertNext(Consumer<? super T> assertionConsumer) {
 		 *
 		 * @see Subscriber#onNext(Object)
 		 */
-		Step<T> expectNext(T @NonNull ... ts);
+		Step<T> expectNext(T... ts);
 
 		/**
 		 * Expect to received {@code count} elements, starting from the previous
@@ -953,14 +953,14 @@ interface Assertions {
 		 * Assert that the tested publisher has dropped at least all of the provided
 		 * elements to the {@link Hooks#onNextDropped(Consumer)} hook, in any order.
 		 */
-		Assertions hasDropped(Object @NonNull ... values);
+		Assertions hasDropped(Object... values);
 
 		/**
 		 * Assert that the tested publisher has dropped all of the provided elements to
 		 * the {@link Hooks#onNextDropped(Consumer)} hook, in any order, and that no
 		 * other elements were dropped.
 		 */
-		Assertions hasDroppedExactly(Object @NonNull ... values);
+		Assertions hasDroppedExactly(Object... values);
 
 		/**
 		 * Assert that the tested publisher has dropped at least one error to the
diff --git a/reactor-test/src/main/java/reactor/test/StepVerifierOptions.java b/reactor-test/src/main/java/reactor/test/StepVerifierOptions.java
index 9705e61441..ffa39005a9 100644
--- a/reactor-test/src/main/java/reactor/test/StepVerifierOptions.java
+++ b/reactor-test/src/main/java/reactor/test/StepVerifierOptions.java
@@ -18,7 +18,6 @@
 import java.util.function.Supplier;
 
 import reactor.test.scheduler.VirtualTimeScheduler;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
 /**
@@ -90,7 +89,7 @@ public long getInitialRequest() {
 	 * @param vtsLookup the supplier of {@link VirtualTimeScheduler} to use.
 	 * @return this instance, to continue setting the options.
 	 */
-	public StepVerifierOptions virtualTimeSchedulerSupplier(Supplier<? extends @NonNull VirtualTimeScheduler> vtsLookup) {
+	public StepVerifierOptions virtualTimeSchedulerSupplier(Supplier<? extends VirtualTimeScheduler> vtsLookup) {
 		this.vtsLookup = vtsLookup;
 		return this;
 	}
@@ -101,7 +100,7 @@ public StepVerifierOptions virtualTimeSchedulerSupplier(Supplier<? extends @NonN
 	 *
 	 */
 	@Nullable
-	public Supplier<? extends @NonNull VirtualTimeScheduler> getVirtualTimeSchedulerSupplier() {
+	public Supplier<? extends VirtualTimeScheduler> getVirtualTimeSchedulerSupplier() {
 		return vtsLookup;
 	}
 }
diff --git a/reactor-test/src/main/java/reactor/test/publisher/TestPublisher.java b/reactor-test/src/main/java/reactor/test/publisher/TestPublisher.java
index 2e02d87c40..689d5feb88 100644
--- a/reactor-test/src/main/java/reactor/test/publisher/TestPublisher.java
+++ b/reactor-test/src/main/java/reactor/test/publisher/TestPublisher.java
@@ -21,7 +21,6 @@
 import org.reactivestreams.Subscriber;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 
 /**
@@ -47,7 +46,7 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @param <T> the type of the publisher
 	 * @return the new {@link TestPublisher}
 	 */
-	public static <T> TestPublisher<@NonNull T> create() {
+	public static <T> TestPublisher<T> create() {
 		return new DefaultTestPublisher<>();
 	}
 
@@ -60,19 +59,19 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @param <T> the type of the publisher
 	 * @return the new noncompliant {@link TestPublisher}
 	 */
-	public static <T> TestPublisher<@Nullable T> createNoncompliant(Violation first, Violation @Nullable ... rest) {
+	public static <T> TestPublisher<T> createNoncompliant(Violation first, Violation... rest) {
 		return new DefaultTestPublisher<>(first, rest);
 	}
 
 	/**
 	 * Convenience method to wrap this {@link TestPublisher} to a {@link Flux}.
 	 */
-	public abstract Flux<@NonNull T> flux();
+	public abstract Flux<T> flux();
 
 	/**
 	 * Convenience method to wrap this {@link TestPublisher} to a {@link Mono}.
 	 */
-	public abstract Mono<@NonNull T> mono();
+	public abstract Mono<T> mono();
 
 	/**
 	 * Assert that the current minimum request of all this publisher's subscribers
@@ -81,14 +80,14 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @param n the expected minimum request
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertMinRequested(long n);
+	public abstract TestPublisher<T> assertMinRequested(long n);
 
 	/**
 	 * Asserts that this publisher has subscribers.
 	 *
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertSubscribers();
+	public abstract TestPublisher<T> assertSubscribers();
 
 	/**
 	 * Asserts that this publisher has exactly n subscribers.
@@ -96,21 +95,21 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @param n the expected number of subscribers
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertSubscribers(int n);
+	public abstract TestPublisher<T> assertSubscribers(int n);
 
 	/**
 	 * Asserts that this publisher has no subscribers.
 	 *
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertNoSubscribers();
+	public abstract TestPublisher<T> assertNoSubscribers();
 
 	/**
 	 * Asserts that this publisher has had at least one subscriber that has been cancelled.
 	 *
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertCancelled();
+	public abstract TestPublisher<T> assertCancelled();
 
 	/**
 	 * Asserts that this publisher has had at least n subscribers that have been cancelled.
@@ -118,14 +117,14 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @param n the expected number of subscribers to have been cancelled.
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertCancelled(int n);
+	public abstract TestPublisher<T> assertCancelled(int n);
 
 	/**
 	 * Asserts that this publisher has had no cancelled subscribers.
 	 *
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertNotCancelled();
+	public abstract TestPublisher<T> assertNotCancelled();
 
 	/**
 	 * Asserts that this publisher has had subscriber that saw request overflow,
@@ -134,7 +133,7 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 *
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertRequestOverflow();
+	public abstract TestPublisher<T> assertRequestOverflow();
 
 	/**
 	 * Asserts that this publisher has had no subscriber with request overflow.
@@ -143,7 +142,7 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 *
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> assertNoRequestOverflow();
+	public abstract TestPublisher<T> assertNoRequestOverflow();
 
 	/**
 	 * Send 1 {@link Subscriber#onNext(Object) onNext} signal to the subscribers.
@@ -151,7 +150,7 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @param value the item to emit (can be null if the relevant {@link Violation} is push)
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> next(@Nullable T value);
+	public abstract TestPublisher<T> next(@Nullable T value);
 
 	/**
 	 * Triggers an {@link Subscriber#onError(Throwable) error} signal to the subscribers.
@@ -159,14 +158,14 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @param t the {@link Throwable} to trigger
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> error(Throwable t);
+	public abstract TestPublisher<T> error(Throwable t);
 
 	/**
 	 * Triggers {@link Subscriber#onComplete() completion} of this publisher.
 	 *
 	 * @return this {@link TestPublisher} for chaining.
 	 */
-	public abstract TestPublisher<@Nullable T> complete();
+	public abstract TestPublisher<T> complete();
 
 	/**
 	 * Send 1-n {@link Subscriber#onNext(Object) onNext} signals to the subscribers.
@@ -177,7 +176,7 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @see #next(Object) next
 	 */
 	@SafeVarargs
-	public final TestPublisher<@Nullable T> next(@Nullable T first, T @Nullable ... rest) {
+	public final TestPublisher<T> next(@Nullable T first, T... rest) {
 		Objects.requireNonNull(rest, "rest array is null, please cast to T if null T required");
 		next(first);
 		for (T t : rest) {
@@ -195,7 +194,7 @@ public abstract class TestPublisher<T> implements Publisher<T>, PublisherProbe<T
 	 * @see #complete() complete
 	 */
 	@SafeVarargs
-	public final TestPublisher<@Nullable T> emit(T @Nullable ... values) {
+	public final TestPublisher<T> emit(T... values) {
 		Objects.requireNonNull(values, "values array is null, please cast to T if null T required");
 		for (T t : values) {
 			next(t);
diff --git a/reactor-test/src/main/java/reactor/test/scheduler/VirtualTimeScheduler.java b/reactor-test/src/main/java/reactor/test/scheduler/VirtualTimeScheduler.java
index 5f07e18228..0ddcbd153f 100644
--- a/reactor-test/src/main/java/reactor/test/scheduler/VirtualTimeScheduler.java
+++ b/reactor-test/src/main/java/reactor/test/scheduler/VirtualTimeScheduler.java
@@ -31,7 +31,6 @@
 import reactor.core.Exceptions;
 import reactor.core.scheduler.Scheduler;
 import reactor.core.scheduler.Schedulers;
-import reactor.util.annotation.NonNull;
 import reactor.util.annotation.Nullable;
 import reactor.util.concurrent.Queues;
 
@@ -109,7 +108,7 @@ public static VirtualTimeScheduler set(VirtualTimeScheduler scheduler) {
 	 * @param schedulerSupplier the supplier executed to obtain a fresh {@link VirtualTimeScheduler}
 	 * @return the scheduler that is actually used after the operation.
 	 */
-	static VirtualTimeScheduler enable(Supplier<@NonNull VirtualTimeScheduler> schedulerSupplier) {
+	static VirtualTimeScheduler enable(Supplier<VirtualTimeScheduler> schedulerSupplier) {
 		return enable(schedulerSupplier, false);
 	}
 
@@ -122,7 +121,7 @@ static VirtualTimeScheduler enable(Supplier<@NonNull VirtualTimeScheduler> sched
 	 * @param exact whether or not to force the use of the supplier, even if there's a matching scheduler
 	 * @return the scheduler that is actually used after the operation.
 	 */
-	static VirtualTimeScheduler enable(Supplier<@NonNull VirtualTimeScheduler>
+	static VirtualTimeScheduler enable(Supplier<VirtualTimeScheduler>
 			schedulerSupplier, boolean exact) {
 		for (; ; ) {
 			VirtualTimeScheduler s = CURRENT.get();
@@ -470,7 +469,7 @@ public void dispose() {
 	static final Disposable CANCELLED = Disposables.disposed();
 	static final Disposable EMPTY = Disposables.never();
 
-	static boolean replace(AtomicReference<@NonNull Disposable> ref, @Nullable Disposable c) {
+	static boolean replace(AtomicReference<Disposable> ref, @Nullable Disposable c) {
 		for (; ; ) {
 			Disposable current = ref.get();
 			if (current == CANCELLED) {
diff --git a/src/docs/asciidoc/advancedFeatures.adoc b/src/docs/asciidoc/advancedFeatures.adoc
index cb7780358d..7b88bb275b 100644
--- a/src/docs/asciidoc/advancedFeatures.adoc
+++ b/src/docs/asciidoc/advancedFeatures.adoc
@@ -784,55 +784,4 @@ public void contextForLibraryReactivePut() {
 	            .expectNext("PUT <Walter> sent to www.example.com with header X-Correlation-ID = 2-j3r9afaf92j-afkaf")
 	            .verifyComplete();
 }
-----
-
-[[null-safety]]
-== Null-safety
-
-Although Java does not allow to express null-safety with its type system, Reactor
-now provides annotations to declare nullability of APIs, similar to those provided by
-Spring Framework 5.
-
-Reactor leverages itself these annotations, but they can also be used in any Reactor based
-Java project to declare null-safe APIs. Nullability of types used inside method bodies
-is outside of the scope of this feature.
-
-These annotations are meta-annotated with https://jcp.org/en/jsr/detail?id=305[JSR 305]
-annotations (a dormant JSR but supported by tools like IntelliJ IDEA) to provide useful
-warnings to Java developers related to null-safety in order to avoid `NullPointerException`
-at runtime. JSR 305 meta-annotations allows tooling vendors to provide null-safety support
-in a generic way, without having to hard-code support for Reactor annotations.
-
-[NOTE]
-====
-It is not necessary nor recommanded to have JSR 305 dependency in user project classpath.
-====
-
-They are also used by Kotlin which supports natively
-https://kotlinlang.org/docs/reference/null-safety.html[null-safety]. By default, types from
-Java APIs used in Kotlin are recognized as
-https://kotlinlang.org/docs/reference/java-interop.html#null-safety-and-platform-types[platform types]
-for which null-checks are relaxed.
-https://github.com/Kotlin/KEEP/blob/jsr-305/proposals/jsr-305-custom-nullability-qualifiers.md[Kotlin support for JSR 305 annotations]
-+ Reactor nullability annotations provide null-safety for the whole Reactor API to Kotlin developers,
-with the advantage of dealing with `null` related issues at compile time rather than bumping into the famous
-`NullPointerException` at runtime.
-
-The following annotations are provided in the `reactor.util.annotation` package:
-
- * https://projectreactor.io/docs/core/release/api/reactor/util/annotation/NonNull.html[`@NonNull`] annotation where specific parameter,
- return value, generic type argument, varargs element, array element or field cannot be `null`
- (not needed on parameter and return value where `@NonNullApi` and `@NonNullFields` applies) .
- * https://projectreactor.io/docs/core/release/api/reactor/util/annotation/Nullable.html[`@Nullable`] annotation where specific
- parameter, return value, generic type argument, varargs element, array element or field
- can be `null`.
- * https://projectreactor.io/docs/core/release/api/reactor/util/annotation/NonNullApi.html[`@NonNullApi`] annotation at package level
- declares non-null as the default behavior for parameters and return values.
-
-[NOTE]
-====
-Generic type arguments, varargs and array elements are out of the scope of `@NonNullApi`,
-because `@TypeQualifierDefault(ElementType.TYPE_USE)` would apply to
-a lot of other use cases. As a consequence, nullability for such elements need to be specified
-explicitly with `@NonNull` and `@Nullable`.
-====
\ No newline at end of file
+----
\ No newline at end of file
diff --git a/src/docs/asciidoc/kotlin.adoc b/src/docs/asciidoc/kotlin.adoc
index a3bea7eb3a..447e5a4726 100644
--- a/src/docs/asciidoc/kotlin.adoc
+++ b/src/docs/asciidoc/kotlin.adoc
@@ -1,7 +1,7 @@
 [[kotlin]]
 = Kotlin support
 
-[[kotlin-introduction]]
+[[introduction]]
 == Introduction
 
 https://kotlinlang.org[Kotlin] is a statically-typed language targeting the JVM (and other platforms)
@@ -11,7 +11,7 @@ existing libraries written in Java.
 
 Reactor 3.1 introduces first-class support for Kotlin which is described in this section.
 
-[[kotlin-requirements]]
+[[requirements]]
 == Requirements ==
 
 Kotlin supports Kotlin 1.1+ and requires
@@ -19,7 +19,7 @@ https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib[`kotlin
 (or one of its https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib-jre7[`kotlin-stdlib-jre7`]
 / https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib-jre8[`kotlin-stdlib-jre8`] variants).
 
-[[kotlin-extensions]]
+[[extensions]]
 == Extensions
 
 Thanks to its great https://kotlinlang.org/docs/reference/java-interop.html[Java interoperability]
@@ -60,7 +60,7 @@ You can see bellow a quick comparison of Reactor with Java versus Reactor with K
 https://projectreactor.io/docs/core/release/kdoc-api/[Reactor KDoc API] lists and documents
 all the Kotlin extensions available.
 
-[[kotlin-null-safety]]
+[[null-safety]]
 == Null-safety
 
 One of Kotlin's key features is https://kotlinlang.org/docs/reference/null-safety.html[null-safety]