diff --git a/src/blackmisc/variant.h b/src/blackmisc/variant.h
index 17e8da961..24d6c59a3 100644
--- a/src/blackmisc/variant.h
+++ b/src/blackmisc/variant.h
@@ -127,12 +127,6 @@ namespace BlackMisc
             return CVariant(QVariant::fromValue(std::forward<T>(value)));
         }
 
-        //! Call a function and construct a variant from its return value.
-        template <typename F> static CVariant fromResultOf(F &&func)
-        {
-            return fromResultOfImpl(std::forward<F>(func), typename std::is_void<decltype(func())>::type());
-        }
-
         //! Change the value.
         template <typename T> void setValue(T &&value) { m_v.setValue(std::forward<T>(value)); }
 
@@ -296,9 +290,6 @@ namespace BlackMisc
             return result;
         }
         bool isVariantList() const;
-
-        template <typename F> static CVariant fromResultOfImpl(F &&func, std::true_type) { std::forward<F>(func)(); return {}; }
-        template <typename F> static CVariant fromResultOfImpl(F &&func, std::false_type) { return from(std::forward<F>(func)()); }
     };
 } // namespace
 
diff --git a/src/blackmisc/worker.cpp b/src/blackmisc/worker.cpp
index 7c13d6c66..f2ab3de34 100644
--- a/src/blackmisc/worker.cpp
+++ b/src/blackmisc/worker.cpp
@@ -67,14 +67,14 @@ namespace BlackMisc
         Q_UNUSED(ok)
     }
 
-    CWorker *CWorker::fromTaskImpl(QObject *owner, const QString &name, int typeId, const std::function<CVariant()> &task)
+    CWorker *CWorker::fromTaskImpl(QObject *owner, const QString &name, int typeId, const std::function<QVariant()> &task)
     {
         auto *worker = new CWorker(task);
         emit worker->aboutToStart();
         worker->setStarted();
         auto *thread = new CRegularThread(owner);
 
-        if (typeId != QMetaType::Void) { worker->m_result = CVariant(typeId, nullptr); }
+        if (typeId != QMetaType::Void) { worker->m_result = QVariant(typeId, nullptr); }
 
         const QString ownerName = owner->objectName().isEmpty() ? owner->metaObject()->className() : owner->objectName();
         thread->setObjectName(ownerName + ":" + name);
diff --git a/src/blackmisc/worker.h b/src/blackmisc/worker.h
index 44552cded..28d414714 100644
--- a/src/blackmisc/worker.h
+++ b/src/blackmisc/worker.h
@@ -17,7 +17,6 @@
 #include "blackmisc/invoke.h"
 #include "blackmisc/promise.h"
 #include "blackmisc/stacktrace.h"
-#include "blackmisc/variant.h"
 
 #include <QFuture>
 #include <QMetaObject>
@@ -30,6 +29,7 @@
 #include <QString>
 #include <QThread>
 #include <QTimer>
+#include <QVariant>
 #include <QWeakPointer>
 #include <QtGlobal>
 #include <algorithm>
@@ -211,7 +211,7 @@ namespace BlackMisc
         static CWorker *fromTask(QObject *owner, const QString &name, F &&task)
         {
             int typeId = qMetaTypeId<std::decay_t<decltype(std::forward<F>(task)())>>();
-            return fromTaskImpl(owner, name, typeId, [task = std::forward<F>(task)]() mutable { return CVariant::fromResultOf(std::move(task)); });
+            return fromTaskImpl(owner, name, typeId, [task = std::forward<F>(task)]() mutable { return fromResultOf(std::move(task), 0); });
         }
 
         //! Connects to a functor to which will be passed the result when the task is finished.
@@ -252,14 +252,19 @@ namespace BlackMisc
         void ps_runTask();
 
     private:
-        CWorker(const std::function<CVariant()> &task) : m_task(task) {}
-        static CWorker *fromTaskImpl(QObject *owner, const QString &name, int typeId, const std::function<CVariant()> &task);
+        CWorker(const std::function<QVariant()> &task) : m_task(task) {}
+        static CWorker *fromTaskImpl(QObject *owner, const QString &name, int typeId, const std::function<QVariant()> &task);
+
+        template <typename F>
+        static auto fromResultOf(F &&func, std::enable_if_t<std::is_void<decltype(func())>::value, int>) { func(); return QVariant(); }
+        template <typename F>
+        static auto fromResultOf(F &&func, std::enable_if_t<!std::is_void<decltype(func())>::value, int>) { return QVariant::fromValue(func()); }
 
         template <typename R>
         R resultNoWait() { Q_ASSERT(m_result.canConvert<R>()); return m_result.value<R>(); }
 
-        std::function<CVariant()> m_task;
-        CVariant m_result;
+        std::function<QVariant()> m_task;
+        QVariant m_result;
     };
 
     /*!