Random Access Iterator Implementation (This is the Non-const version, I have to implement the const one too).
Could someone please review this implementation? This is made for std::vector
I'm unsure whether I respected all requirements for LegacyRandomAccessIterator; so if I'm missing something, please do let me know.
namespace random_access
{
    template&lt;typename Type&gt;
    class iterator
    {
    private:
        Type* m_iterator;


    public:
        using value_type = Type;
        using reference = value_type&amp;;
        using pointer = value_type*;
        using iterator_category = std::random_access_iterator_tag;
        using difference_type = std::ptrdiff_t;
        //using iterator_concept = std::contiguous_iterator_tag;

        constexpr iterator(Type* iter = nullptr) : m_iterator{ iter } {}

        constexpr bool operator==(const iterator&amp; other) const noexcept { return m_iterator == other.m_iterator; }
        constexpr bool operator!=(const iterator&amp; other) const noexcept { return m_iterator != other.m_iterator; }
        constexpr reference operator*() const noexcept { return *m_iterator; }
        constexpr pointer operator-&gt;() const noexcept { return m_iterator; }
        constexpr iterator&amp; operator++() noexcept { ++m_iterator; return *this; }
        constexpr iterator operator++(int) noexcept { iterator tmp(*this); ++(*this); return tmp; }
        constexpr iterator&amp; operator--() noexcept { --m_iterator; return *this; }
        constexpr iterator operator--(int) noexcept { iterator tmp(*this); --(*this); return tmp; }
        constexpr iterator&amp; operator+=(const difference_type other) noexcept { m_iterator += other; return *this; }
        constexpr iterator&amp; operator-=(const difference_type other) noexcept { m_iterator -= other; return *this; }
        constexpr iterator operator+(const difference_type other) const noexcept { return iterator(m_iterator + other); }
        constexpr iterator operator-(const difference_type other) const noexcept { return iterator(m_iterator - other); }
        constexpr iterator operator+(const iterator&amp; other) const noexcept { return iterator(*this + other.m_iterator); }
        constexpr difference_type operator-(const iterator&amp; other) const noexcept { return std::distance(m_iterator, other.m_iterator); }
        constexpr reference operator[](std::size_t index) const { return m_iterator[index]; }
        constexpr bool operator&lt;(const iterator&amp; other) const noexcept { return m_iterator &lt; other.m_iterator; }
        constexpr bool operator&gt;(const iterator&amp; other) const noexcept { return m_iterator &gt; other.m_iterator; }
        constexpr bool operator&lt;=(const iterator&amp; other) const noexcept { return m_iterator &lt;= other.m_iterator; }
        constexpr bool operator&gt;=(const iterator&amp; other) const noexcept { return m_iterator &gt;= other.m_iterator; }
    };
}

Thanks !
As pointed out by @Martin York in the comments that your class is just a wrapper for a pointer, I don't have much to say. I only have one suggestion

Better Formatting

Good formatting IMO plays a major role in how readable your code is. In this case, I find it impossible to navigate through the functions because they all look extremely cramped.
constexpr pointer operator-&gt;() const noexcept { return m_iterator; }
constexpr iterator&amp; operator++() noexcept { ++m_iterator; return *this; }

Compare that to
constexpr pointer operator-&gt;() const noexcept { 
    return m_iterator;
}

constexpr iterator&amp; operator++() noexcept { 
    ++m_iterator; 
    return *this; 
}