Remove static assert models typeof(this) statements

The senders themselves are tested in plenty of unittests, so the static
check is at the minimum taking up compile time.

source/concurrency/fork.d

@@ -10,7 +10,6 @@ import concepts;
 version(Posix)
 	struct ForkSender {
 		alias Value = void;
-		static assert(models!(typeof(this), isSender));
 		alias Fun = void delegate() shared;
 		alias AfterFork = void delegate(int);
 		static struct Operation(Receiver) {

source/concurrency/nursery.d

@@ -18,7 +18,6 @@ class Nursery {
 	import concurrency.sender : isSender, OperationalStateBase;
 	import core.sync.mutex : Mutex;
 	import concepts;
-	static assert(models!(typeof(this), isSender));
 
 	alias Value = void;
 	private {

source/concurrency/operations/completewithcancellation.d

@@ -28,7 +28,6 @@ private struct CompleteWithCancellationReceiver(Receiver) {
 }
 
 struct CompleteWithCancellationSender(Sender) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	static assert(
 		is(Sender.Value == void),
 		"Sender must produce void to be able to complete with cancellation."

source/concurrency/operations/completewitherror.d

@@ -51,7 +51,6 @@ private struct CompleteWithErrorReceiver(Receiver) {
 }
 
 struct CompleteWithErrorSender(Sender) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	Throwable t;

source/concurrency/operations/dofinally.d

@@ -43,7 +43,6 @@ private struct DoFinallyReceiver(Value, SideEffect, Receiver) {
 }
 
 struct DoFinallySender(Sender, SideEffect) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	SideEffect effect;

source/concurrency/operations/forwardon.d

@@ -39,8 +39,6 @@ private struct ForwardOnReceiver(Receiver, Value, Scheduler) {
 }
 
 struct ForwardOnSender(Sender, Scheduler) if (models!(Sender, isSender)) {
-	import std.traits : ReturnType;
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	Scheduler scheduler;

source/concurrency/operations/ignoreerror.d

@@ -12,7 +12,6 @@ IESender!Sender ignoreError(Sender)(Sender sender) {
 }
 
 struct IESender(Sender) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	auto connect(Receiver)(return Receiver receiver) @safe return scope {

source/concurrency/operations/ignorevalue.d

@@ -34,7 +34,6 @@ private struct IgnoreValueReceiver(Value, Receiver) {
 }
 
 struct IgnoreValueSender(Sender) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = void;
 	Sender sender;
 	auto connect(Receiver)(return Receiver receiver) @safe return scope {

source/concurrency/operations/letdone.d

@@ -1,13 +1,16 @@
 module concurrency.operations.letdone;
 
+import concurrency.sender;
+import concepts;
+
 auto letDone(Sender, Fun)(Sender sender, Fun fun) {
    	import concurrency.utils;
 	// static assert(isThreadSafeCallable!Fun);
 
     return LetDone!(Sender, Fun)(sender, fun);
 }
 
-struct LetDone(Sender, Fun) {
+struct LetDone(Sender, Fun) if (models!(Sender, isSender)) {
     import std.traits : ReturnType;
     alias FinalSender = ReturnType!(Fun);
     alias Value = FinalSender.Value;

source/concurrency/operations/letvalue.d

@@ -1,13 +1,16 @@
 module concurrency.operations.letvalue;
 
+import concurrency.sender;
+import concepts;
+
 auto letValue(Sender, Fun)(Sender sender, Fun fun) {
    	import concurrency.utils;
 	// static assert(isThreadSafeCallable!Fun);
 
     return LetValue!(Sender, Fun)(sender, fun);
 }
 
-struct LetValue(Sender, Fun) {
+struct LetValue(Sender, Fun) if (models!(Sender, isSender)) {
     import std.traits : ReturnType;
     alias FinalSender = ReturnType!(Fun);
     alias Value = FinalSender.Value;

source/concurrency/operations/oncompletion.d

@@ -41,7 +41,6 @@ private struct OnCompletionReceiver(Value, SideEffect, Receiver) {
 }
 
 struct OnCompletionSender(Sender, SideEffect) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	SideEffect effect;

source/concurrency/operations/onerror.d

@@ -50,7 +50,6 @@ private struct OnErrorReceiver(Value, SideEffect, Receiver) {
 }
 
 struct OnErrorSender(Sender, SideEffect) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	SideEffect effect;

source/concurrency/operations/onresult.d

@@ -60,7 +60,6 @@ private struct OnResultReceiver(Value, SideEffect, Receiver) {
 }
 
 struct OnResultSender(Sender, SideEffect) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	SideEffect effect;

source/concurrency/operations/ontermination.d

@@ -42,7 +42,6 @@ private struct OnTerminationReceiver(Value, SideEffect, Receiver) {
 }
 
 struct OnTerminationSender(Sender, SideEffect) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	SideEffect effect;

source/concurrency/operations/race.d

@@ -115,7 +115,6 @@ struct RaceSender(Senders...)
 		if ((Senders.length > 1
 				    && allSatisfy!(ApplyRight!(models, isSender), Senders))
 			    || (models!(ArrayElement!(Senders[0]), isSender))) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Result!(Senders);
 	Senders senders;
 	bool noDropouts; // if true then we fail the moment one contender does, otherwise we keep running until one finishes

source/concurrency/operations/repeat.d

@@ -65,7 +65,6 @@ private struct RepeatOp(Receiver, Sender) {
 }
 
 struct RepeatSender(Sender) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	auto connect(Receiver)(return Receiver receiver) @safe return scope {

source/concurrency/operations/retry.d

@@ -99,7 +99,6 @@ private struct RetryOp(Receiver, Sender, Logic) {
 
 struct RetrySender(Sender, Logic)
 		if (models!(Sender, isSender) && models!(Logic, isRetryLogic)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	Logic logic;

source/concurrency/operations/retrywhen.d

@@ -119,8 +119,8 @@ private struct RetryWhenOp(Sender, Receiver, Logic) {
 	}
 }
 
-struct RetryWhenSender(Sender, Logic) if (isRetryWhenLogic!Logic) {
-	static assert(models!(typeof(this), isSender));
+struct RetryWhenSender(Sender, Logic) 
+	if (models!(Sender, isSender) && isRetryWhenLogic!Logic) {
 	alias Value = Sender.Value;
 	Sender sender;
 	Logic logic;

source/concurrency/operations/stopon.d

@@ -43,7 +43,6 @@ private struct StopOnReceiver(Receiver, Value) {
 }
 
 struct StopOn(Sender) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	shared StopToken stopToken;

source/concurrency/operations/stopwhen.d

@@ -56,7 +56,6 @@ private struct StopWhenOp(Receiver, Sender, Trigger) {
 
 struct StopWhenSender(Sender, Trigger)
 		if (models!(Sender, isSender) && models!(Trigger, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	Trigger trigger;

source/concurrency/operations/then.d

@@ -90,7 +90,6 @@ private struct ThenReceiver(Receiver, Value, Fun) {
 
 struct ThenSender(Sender, Fun) if (models!(Sender, isSender)) {
 	import std.traits : ReturnType;
-	static assert(models!(typeof(this), isSender));
 	static if (is(ReturnType!fun == Result!T, T))
 		alias Value = T;
 	else

source/concurrency/operations/toshared.d

@@ -31,7 +31,6 @@ class SharedSender(Sender, Scheduler, ResetLogic resetLogic)
 		if (models!(Sender, isSender)) {
 	import std.traits : ReturnType;
 	import std.sumtype : match;
-	static assert(models!(typeof(this), isSender));
 	alias Props = Properties!(Sender);
 	alias Value = Props.Value;
 	alias InternalValue = Props.InternalValue;

source/concurrency/operations/via.d

@@ -71,7 +71,6 @@ private struct ViaBReceiver(SenderA, ValueB, Receiver) {
 
 struct ViaSender(SenderA, SenderB)
 		if (models!(SenderA, isSender) && models!(SenderB, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	import std.meta : Filter, AliasSeq;
 	SenderA senderA;
 	SenderB senderB;

source/concurrency/operations/whenall.d

@@ -166,7 +166,8 @@ import std.meta : allSatisfy, ApplyRight;
 
 struct WhenAllSender(Senders...)
 		if ((Senders.length > 1
-				    && allSatisfy!(ApplyRight!(models, isSender), Senders))
+				    && allSatisfy!(ApplyRight!(models, isSender), Senders)
+					)
 			    || (models!(ArrayElement!(Senders[0]), isSender))) {
 	alias Result = WhenAllResult!(Senders);
 	static if (hasMember!(Result, "values"))

source/concurrency/operations/withscheduler.d

@@ -41,7 +41,6 @@ private struct WithSchedulerReceiver(Receiver, Value, Scheduler) {
 }
 
 struct WithSchedulerSender(Sender, Scheduler) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	Scheduler scheduler;

source/concurrency/operations/withstopsource.d

@@ -97,7 +97,6 @@ struct SSOp(Receiver, Sender) {
 }
 
 struct SSSender(Sender) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = Sender.Value;
 	Sender sender;
 	shared StopSource* stopSource;

source/concurrency/operations/withstoptoken.d

@@ -75,7 +75,6 @@ private struct STReceiver(Receiver, Value, Fun) {
 }
 
 struct STSender(Sender, Fun) if (models!(Sender, isSender)) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = ReturnType!fun;
 	Sender sender;
 	Fun fun;

source/concurrency/scheduler.d

@@ -91,7 +91,6 @@ auto localThreadScheduler() {
 alias LocalThreadScheduler = typeof(localThreadScheduler());
 
 struct SchedulerAdapter(Worker) {
-	static assert(models!(typeof(this), isScheduler));
 	import concurrency.receiver : setValueOrError;
 	import concurrency.executor : VoidDelegate;
 	import core.time : Duration;
@@ -364,7 +363,6 @@ private struct ProxyScheduler(T, P) {
 }
 
 struct ScheduleAfter {
-	static assert(models!(typeof(this), isSender));
 	alias Value = void;
 	Duration duration;
 	auto connect(Receiver)(return Receiver receiver) @safe return scope {
@@ -376,7 +374,6 @@ struct ScheduleAfter {
 }
 
 struct Schedule {
-	static assert(models!(typeof(this), isSender));
 	alias Value = void;
 	auto connect(Receiver)(return Receiver receiver) @safe return scope {
 		// ensure NRVO

source/concurrency/sender.d

@@ -106,7 +106,6 @@ template isValidOp(Sender, Receiver) {
 
 /// A Sender that sends a single value of type T
 struct ValueSender(T) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = T;
 	static struct Op(Receiver) {
 		Receiver receiver;
@@ -150,7 +149,6 @@ auto just(T...)(T t) {
 }
 
 struct JustFromSender(Fun) {
-	static assert(models!(typeof(this), isSender));
 	alias Value = ReturnType!fun;
 	static struct Op(Receiver) {
 		Receiver receiver;
@@ -214,7 +212,6 @@ interface SenderObjectBase(T) {
 	import concurrency.receiver;
 	import concurrency.scheduler : SchedulerObjectBase;
 	import concurrency.stoptoken : StopToken;
-	static assert(models!(typeof(this), isSender));
 	alias Value = T;
 	alias Op = OperationObject;
 	OperationObject connect(return ReceiverObjectBase!(T) receiver) @safe scope;
@@ -301,7 +298,6 @@ OperationalStateBase connectHeap(Sender, Receiver)(Sender sender,
 /// A class extending from SenderObjectBase that wraps any Sender
 class SenderObjectImpl(Sender) : SenderObjectBase!(Sender.Value) {
 	import concurrency.receiver : ReceiverObjectBase;
-	static assert(models!(typeof(this), isSender));
 	private Sender sender;
 	this(Sender sender) {
 		this.sender = sender;
@@ -322,8 +318,7 @@ class SenderObjectImpl(Sender) : SenderObjectBase!(Sender.Value) {
 }
 
 /// Converts any Sender to a polymorphic SenderObject
-auto toSenderObject(Sender)(Sender sender) {
-	static assert(models!(Sender, isSender));
+auto toSenderObject(Sender)(Sender sender) if (models!(Sender, isSender)) {
 	static if (is(Sender : SenderObjectBase!(Sender.Value))) {
 		return sender;
 	} else
@@ -358,7 +353,6 @@ struct ThrowingSender {
 
 /// A sender that always calls setDone
 struct DoneSender {
-	static assert(models!(typeof(this), isSender));
 	alias Value = void;
 	static struct DoneOp(Receiver) {
 		Receiver receiver;
@@ -384,7 +378,6 @@ struct DoneSender {
 
 /// A sender that always calls setValue with no args
 struct VoidSender {
-	static assert(models!(typeof(this), isSender));
 	alias Value = void;
 	struct VoidOp(Receiver) {
 		Receiver receiver;
@@ -414,7 +407,6 @@ struct VoidSender {
 
 /// A sender that always calls setError
 struct ErrorSender {
-	static assert(models!(typeof(this), isSender));
 	alias Value = void;
 	Throwable exception;
 	static struct ErrorOp(Receiver) {
@@ -696,7 +688,6 @@ shared(Promise!T) promise(T)() {
 
 struct PromiseSender(T) {
 	alias Value = T;
-	static assert(models!(typeof(this), isSender));
 	private shared Promise!T promise;
 
 	auto connect(Receiver)(return Receiver receiver) @safe return scope {
@@ -720,7 +711,6 @@ struct Defer(Fun) {
 	import concurrency.utils;
 	static assert(isThreadSafeCallable!Fun);
 	alias Sender = typeof(fun());
-	static assert(models!(Sender, isSender));
 	alias Value = Sender.Value;
 	Fun fun;
 	auto connect(Receiver)(return Receiver receiver) @safe {

source/concurrency/stream/stream.d

@@ -34,7 +34,6 @@ enum isStream(T) = is(typeof(checkStream!T));
 interface StreamObjectBase(T) {
 	import concurrency.sender : SenderObjectBase;
 	alias ElementType = T;
-	static assert(models!(typeof(this), isStream));
 	alias DG = CollectDelegate!(ElementType);
 
 	SenderObjectBase!void collect(DG dg) @safe;
@@ -44,7 +43,6 @@ interface StreamObjectBase(T) {
 class StreamObjectImpl(Stream) : StreamObjectBase!(Stream.ElementType)
 		if (models!(Stream, isStream)) {
 	import concurrency.receiver : ReceiverObjectBase;
-	static assert(models!(typeof(this), isStream));
 	private Stream stream;
 	this(Stream stream) {
 		this.stream = stream;
@@ -87,7 +85,6 @@ auto fromStreamOp(StreamElementType, SenderValue, alias Op,
 	}
 
 	static struct FromStream {
-		static assert(models!(typeof(this), isStream));
 		alias ElementType = StreamElementType;
 		Args args;
 		auto collect(DG dg) @safe {
@@ -108,7 +105,6 @@ template loopStream(E) {
 	alias DG = CollectDelegate!(E);
 	auto loopStream(T)(T t) {
 		static struct LoopStream {
-			static assert(models!(typeof(this), isStream));
 			alias ElementType = E;
 			static struct LoopOp(Receiver) {
 				T t;

source/concurrency/thread.d

@@ -376,7 +376,6 @@ shared static this() {
 }
 
 struct ThreadSender {
-	static assert(models!(typeof(this), isSender));
 	alias Value = void;
 	static struct Op(Receiver) {
 		private Receiver receiver;