Do I need to use an additional interface for repositories?

Question

C++ / C#

In Laravel, to use the Domain architecture, I saw how they use an additional implementation of the Entity Entity repository interface in the DoctrineEntityRepository.
That is, DoctrineUserRepository implements UserRepositoy, which contains all the methods that should be in the Doctrine Repository.
Why, for what and why?
Using the basic maker generator in Symphony, we have an Entity and its repository, that's all, no additional interfaces. Why?

Answer 1

You can help with the answer, and not turn on your wit, the hint is small.

#include<iostream>
#include<string>
#include<vector>
#include<iterator>
#include<memory>
#include<sstream>
#include<Windows.h>
using namespace std;

enum class spType {ALL, SP, TH};

class Policlinic
{
public:
  Policlinic();
  ~Policlinic();
  // ... 
  void addSpecialists(const string& s);
  void addTherapists(const string& s);
  void printPersonnel(spType = spType::ALL);
  // ...
  // Геттеры Сеттеры сам по шаблону
  // ...
private:
  struct Personnel;
  unique_ptr<Personnel> m_personnel;

  string desk;
  string type;

  unsigned pharmacy = 0;

  friend istream& operator>>(istream& is, vector<string>& values);
  friend ostream& operator<<(ostream& os, const vector<string>& values);
};

struct Policlinic::Personnel
{
  vector<string> specialists;
  vector<string> therapists;
};

Policlinic::Policlinic() : m_personnel(make_unique<Personnel>())
{
}

Policlinic::~Policlinic()
{
}

istream& operator>>(istream& is, vector<string>& values)
{
  copy(istream_iterator<string>{is}, {}, back_inserter(values));
  return is;
}

ostream& operator<<(ostream& os, const vector<string>& values)
{
  copy(values.begin(), values.end(), ostream_iterator<string>{os, "\n"});
  return os;
}

void Policlinic::addSpecialists(const string& s)
{
  istringstream is(s);
  is >> m_personnel->specialists;
}

void Policlinic::addTherapists(const string& s)
{
  istringstream is(s);
  is >> m_personnel->therapists;
}

void Policlinic::printPersonnel(spType stype)
{
  switch(stype)
  {
  case spType::SP:
    cout << "Специалисты:\n"
         << m_personnel->specialists;
    break;

  case spType::TH:
    cout << "Терапевты:\n" 
         << m_personnel->therapists;
    break;

  default:
    cout << "[Весь персонал]\n";
         printPersonnel(spType::SP);
         printPersonnel(spType::TH);
    break;
  }
}

int main()
{
  SetConsoleCP(1251);
  SetConsoleOutputCP(1251);
  setlocale(LC_ALL, "ru");

  Policlinic ply;

  // Для простоты
  string value;
  
  cout << "Введите врачей специалистов через пробел \n$: ";
  getline(cin, value);
  ply.addSpecialists(value);
  
  cout << "\nВведите врачей терапевтов через пробел\n$: ";
  getline(cin, value);
  ply.addTherapists(value);
 
  ply.printPersonnel(spType::ALL);

  system("pause");
}

Answer 2

Why, for what and why?

To abstract away from a specific ORM.
Because in the vast majority of cases, you will only work with doctrine and there is not much point in adding an interface.
PS
It's like oil. Entity is an entity.