diff --git a/src/Magnum/Math/BoolVector.h b/src/Magnum/Math/BoolVector.h
index 5c76076df..1c8ec6de4 100644
--- a/src/Magnum/Math/BoolVector.h
+++ b/src/Magnum/Math/BoolVector.h
@@ -123,9 +123,6 @@ template<std::size_t size> class BoolVector {
         /** @brief Construct a boolean vector from external representation */
         template<class U, class V = decltype(Implementation::BoolVectorConverter<size, U>::from(std::declval<U>()))> constexpr explicit BoolVector(const U& other) noexcept: BoolVector{Implementation::BoolVectorConverter<size, U>::from(other)} {}
 
-        /** @brief Copy constructor */
-        constexpr /*implicit*/ BoolVector(const BoolVector<size>&) noexcept = default;
-
         /** @brief Convert a boolean vector to external representation */
         template<class U, class V = decltype(Implementation::BoolVectorConverter<size, U>::to(std::declval<BoolVector<size>>()))> constexpr explicit operator U() const {
             return Implementation::BoolVectorConverter<size, U>::to(*this);
diff --git a/src/Magnum/Math/Complex.h b/src/Magnum/Math/Complex.h
index d5b0b7039..496991544 100644
--- a/src/Magnum/Math/Complex.h
+++ b/src/Magnum/Math/Complex.h
@@ -176,9 +176,6 @@ template<class T> class Complex {
         /** @brief Construct a complex number from external representation */
         template<class U, class V = decltype(Implementation::ComplexConverter<T, U>::from(std::declval<U>()))> constexpr explicit Complex(const U& other): Complex{Implementation::ComplexConverter<T, U>::from(other)} {}
 
-        /** @brief Copy constructor */
-        constexpr /*implicit*/ Complex(const Complex<T>&) noexcept = default;
-
         /** @brief Convert a complex number to external representation */
         template<class U, class V = decltype(Implementation::ComplexConverter<T, U>::to(std::declval<Complex<T>>()))> constexpr explicit operator U() const {
             return Implementation::ComplexConverter<T, U>::to(*this);
diff --git a/src/Magnum/Math/Dual.h b/src/Magnum/Math/Dual.h
index 89006a5c3..4f81c45ff 100644
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@@ -111,9 +111,6 @@ template<class T> class Dual {
          */
         template<class U> constexpr explicit Dual(const Dual<U>& other) noexcept: _real{T(other._real)}, _dual{T(other._dual)} {}
 
-        /** @brief Copy constructor */
-        constexpr /*implicit*/ Dual(const Dual<T>&) noexcept = default;
-
         /**
          * @brief Raw data
          * @return One-dimensional array of two elements
diff --git a/src/Magnum/Math/Quaternion.h b/src/Magnum/Math/Quaternion.h
index de92fa39a..f089e0d05 100644
--- a/src/Magnum/Math/Quaternion.h
+++ b/src/Magnum/Math/Quaternion.h
@@ -354,9 +354,6 @@ template<class T> class Quaternion {
         /** @brief Construct quaternion from external representation */
         template<class U, class V = decltype(Implementation::QuaternionConverter<T, U>::from(std::declval<U>()))> constexpr explicit Quaternion(const U& other): Quaternion{Implementation::QuaternionConverter<T, U>::from(other)} {}
 
-        /** @brief Copy constructor */
-        constexpr /*implicit*/ Quaternion(const Quaternion<T>&) noexcept = default;
-
         /** @brief Convert quaternion to external representation */
         template<class U, class V = decltype(Implementation::QuaternionConverter<T, U>::to(std::declval<Quaternion<T>>()))> constexpr explicit operator U() const {
             return Implementation::QuaternionConverter<T, U>::to(*this);
diff --git a/src/Magnum/Math/Range.h b/src/Magnum/Math/Range.h
index 075b736e3..08135bffd 100644
--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@@ -171,9 +171,6 @@ template<UnsignedInt dimensions, class T> class Range {
         /** @brief Construct range from external representation */
         template<class U, class V = decltype(Implementation::RangeConverter<dimensions, T, U>::from(std::declval<U>()))> constexpr explicit Range(const U& other): Range{Implementation::RangeConverter<dimensions, T, U>::from(other)} {}
 
-        /** @brief Copy constructor */
-        constexpr /*implicit*/ Range(const Range<dimensions, T>&) noexcept = default;
-
         /** @brief Convert range to external representation */
         template<class U, class V = decltype(Implementation::RangeConverter<dimensions, T, U>::to(std::declval<Range<dimensions, T>>()))> constexpr explicit operator U() const {
             return Implementation::RangeConverter<dimensions, T, U>::to(*this);
diff --git a/src/Magnum/Math/RectangularMatrix.h b/src/Magnum/Math/RectangularMatrix.h
index a7c56fd0d..942dd8754 100644
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@@ -211,9 +211,6 @@ template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
         /** @brief Construct a matrix from external representation */
         template<class U, class V = decltype(Implementation::RectangularMatrixConverter<cols, rows, T, U>::from(std::declval<U>()))> constexpr explicit RectangularMatrix(const U& other): RectangularMatrix(Implementation::RectangularMatrixConverter<cols, rows, T, U>::from(other)) {}
 
-        /** @brief Copy constructor */
-        constexpr /*implicit*/ RectangularMatrix(const RectangularMatrix<cols, rows, T>&) noexcept = default;
-
         /** @brief Convert a matrix to external representation */
         template<class U, class V = decltype(Implementation::RectangularMatrixConverter<cols, rows, T, U>::to(std::declval<RectangularMatrix<cols, rows, T>>()))> constexpr explicit operator U() const {
             return Implementation::RectangularMatrixConverter<cols, rows, T, U>::to(*this);
diff --git a/src/Magnum/Math/Unit.h b/src/Magnum/Math/Unit.h
index 6a8418c87..fbb152f3e 100644
--- a/src/Magnum/Math/Unit.h
+++ b/src/Magnum/Math/Unit.h
@@ -65,9 +65,6 @@ template<template<class> class Derived, class T> class Unit {
         /** @brief Construct from another underlying type */
         template<class U> constexpr explicit Unit(Unit<Derived, U> value) noexcept: _value(T(value._value)) {}
 
-        /** @brief Copy constructor */
-        constexpr /*implicit*/ Unit(const Unit<Derived, T>& other) noexcept = default;
-
         /** @brief Explicit conversion to underlying type */
         constexpr explicit operator T() const { return _value; }
 
diff --git a/src/Magnum/Math/Vector.h b/src/Magnum/Math/Vector.h
index 374e6f492..83aefa147 100644
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@@ -226,9 +226,6 @@ template<std::size_t size, class T> class Vector {
         /** @brief Construct a vector from external representation */
         template<class U, class V = decltype(Implementation::VectorConverter<size, T, U>::from(std::declval<U>()))> constexpr explicit Vector(const U& other) noexcept: Vector(Implementation::VectorConverter<size, T, U>::from(other)) {}
 
-        /** @brief Copy constructor */
-        constexpr /*implicit*/ Vector(const Vector<size, T>&) noexcept = default;
-
         /** @brief Convert a vector to external representation */
         template<class U, class V = decltype(Implementation::VectorConverter<size, T, U>::to(std::declval<Vector<size, T>>()))> constexpr explicit operator U() const {
             return Implementation::VectorConverter<size, T, U>::to(*this);