concepts.h

#pragma once

#include <concepts>
#include <type_traits>

namespace funcy::linalg
{
    namespace detail
    {
        template < class Matrix >
        struct NumberOfRows : std::integral_constant< int, -1 >
        {
        };

        template < class Matrix >
        struct NumberOfColumns : std::integral_constant< int, -1 >
        {
        };

        template < class >
        struct GetTransposed;
    } // namespace detail

    template < class V >
    concept ConstantSize = linalg::detail::NumberOfRows< V >::value > 0;

    template < class M >
    concept SquareMatrix = ( ( linalg::detail::NumberOfRows< M >::value ==
                               linalg::detail::NumberOfColumns< M >::value ) &&
                             ConstantSize< M > );


    template < class T >
    concept Matrix = (
                         requires( T t ) { { t[ 0 ][ 0 ] }; } ||
                         requires( T t ) { { t( 0, 0 ) }; } ) &&
                     (
                         requires( std::decay_t< T > t ) { { t *= 2.0 }; } ||
                         requires( std::decay_t< T > t ) { { t = 2.0 * t }; } ) &&
                     std::copy_constructible< T >;

    template < class T >
    concept Vector = (
                         requires( T t ) { { t[ 0 ] }; } || requires( T t ) { { t( 0 ) }; } ) &&
                     (
                         requires( std::decay_t< T > t ) { { t *= 2.0 }; } ||
                         requires( std::decay_t< T > t ) { { t = 2.0 * t }; } ) &&
                     std::copy_constructible< T >;

} // namespace funcy::linalg