diff --git a/Threads/Inc/threads_actor.hpp b/Threads/Inc/threads_actor.hpp
index 121a09a..71aace1 100644
--- a/Threads/Inc/threads_actor.hpp
+++ b/Threads/Inc/threads_actor.hpp
@@ -55,20 +55,20 @@ public:
         : q_(q)
     {}
 
-    bool emit(const T& data) override
+    void emit(const T& data) override
     {
       parent::value_type to_send = data;
-      const BaseType_t success = xQueueSend(q_->msg_queue_, &to_send, 0);
-      return success == pdTRUE;
+      xQueueSend(q_->msg_queue_, &to_send, 0);
     }
 
-    std::pair<bool, BaseType_t> emitFromIsr(const T& data) override
+    BaseType_t emitFromIsr(const T& data) override
     {
       parent::value_type to_send = data;
       BaseType_t was_awoken = pdFALSE;
-      const BaseType_t success = xQueueSendFromISR(q_->msg_queue_, &to_send, &was_awoken);
 
-      return {success == pdTRUE, was_awoken};
+      xQueueSendFromISR(q_->msg_queue_, &to_send, &was_awoken);
+
+      return was_awoken;
     }
 
   private:
@@ -192,22 +192,21 @@ private:
         : q(q)
     {}
 
-    bool emit() override
+    void emit() override
     {
       const int data = 0;
 
-      const BaseType_t success = xQueueSend(q.msg_queue_, &data, 0);
-      return success == pdTRUE;
+      xQueueSend(q.msg_queue_, &data, 0);
     }
 
-    std::pair<bool, BaseType_t> emitFromIsr() override
+    BaseType_t emitFromIsr() override
     {
       const int data = 0;
 
       BaseType_t was_awoken = pdFALSE;
-      const BaseType_t success = xQueueSendFromISR(q.msg_queue_, &data, &was_awoken);
+      xQueueSendFromISR(q.msg_queue_, &data, &was_awoken);
 
-      return {success == pdTRUE, was_awoken};
+      return was_awoken;
     }
   };
 
diff --git a/Threads/Inc/threads_exclusivesignal.hpp b/Threads/Inc/threads_exclusivesignal.hpp
index a51ec0e..c7c0726 100644
--- a/Threads/Inc/threads_exclusivesignal.hpp
+++ b/Threads/Inc/threads_exclusivesignal.hpp
@@ -144,28 +144,26 @@ struct ExclusiveSignal<void> : public Signallable<void>
     return currentThread.notifyWait(timeout);
   }
 
-  bool emit() override
+  void emit() override
   {
-    if (!waiting_thread_)
+    if (waiting_thread_)
     {
-      return false;
-    } else
-    {
-      return waiting_thread_->notify(0, eNoAction);
+      auto const _ = waiting_thread_->notify(0, eNoAction);
+      (void) _;
     }
   }
 
-  std::pair<bool, BaseType_t> emitFromIsr() override
+  BaseType_t emitFromIsr() override
   {
     if (!waiting_thread_)
     {
-      return {false, pdFALSE};
+      return pdFALSE;
     } else
     {
       auto const [discard, was_notified] = waiting_thread_->notifyFromIsr(0, eNoAction);
       (void) discard;
 
-      return {true, was_notified};
+      return was_notified;
     }
   }
 
diff --git a/Threads/Inc/threads_signal.hpp b/Threads/Inc/threads_signal.hpp
index b63033f..ee76fb5 100644
--- a/Threads/Inc/threads_signal.hpp
+++ b/Threads/Inc/threads_signal.hpp
@@ -23,8 +23,8 @@ struct Signallable
   static_assert(std::is_trivially_copyable_v<value_type>, "T must be trivially copyable.");
   static_assert(std::is_default_constructible_v<value_type>, "T must be default constructible.");
 
-  virtual bool emit(const T& t) = 0;
-  virtual std::pair<bool, BaseType_t> emitFromIsr(const T& t) = 0;
+  virtual void emit(const T& t) = 0;
+  virtual BaseType_t emitFromIsr(const T& t) = 0;
 };
 
 template<>
@@ -32,8 +32,8 @@ struct Signallable<void>
 {
   using value_type = void;
 
-  virtual bool emit() = 0;
-  virtual std::pair<bool, BaseType_t> emitFromIsr() = 0;
+  virtual void emit() = 0;
+  virtual BaseType_t emitFromIsr() = 0;
 };
 
 template<typename R>