Peter's questions

Tenho a seguinte turma:

template<typename Population, typename... Operators> class GA
{
public:
    template<typename Evaluator,
             typename std::enable_if_t<
             std::is_same_v<Evaluator, Evaluator<Operators...>>>>
  void EvaluatePopulation(Evaluator& evaluator)
  {
    evaluator.Evaluate();
  }
};

Isso não compila devido a EvaluatePopulationuma declaração incorreta.

Como posso especificar que o EvaluatePopulationmétodo pode ser chamado somente com Evaluatoruma classe que foi inicializada com o mesmo Operators...nome da GAclasse?

Eu tenho as seguintes estruturas:

public struct BasicIndividualStruct
{
  public void Dispose()
  {
    path.Dispose();
  }

  public float fitness;
  public UnsafeList<float2> path;
}

public struct NativeBasicPopulation
{
  public void Dispose()
  {
    foreach(var individual in _population)
    {
      individual.Dispose();
    }
    _population.Dispose();
  }

  public NativeArray<BasicIndividualStruct> _population;
}

Estou criando assim:

    var population = new NativeArray<BasicIndividualStruct>(50, Allocator.TempJob);
    for (int i = 0; i < populationSize; i++)
    {
      var element = population[i];
      element.path = new Unity.Collections.LowLevel.Unsafe.UnsafeList<Unity.Mathematics.float2>(10, Allocator.TempJob);
      element.path.Resize(10);
      element.fitness = 0;
      population[i] = element;
    } 
    var pop = new NativeBasicPopulation()
    {
      _population = population
    };

Minha pergunta é: como descartá-lo adequadamente após o término do trabalho?

Meu _populationinterior é NativeBasicPopulationapenas uma cópia da popvariável local, portanto preciso ligar Disposeimediatamente pop?

O loop interno NativeBasicPopulation::Disposerealmente funcionará? Porque pelo que entendi, individualem determinado loop é apenas uma cópia de um elemento dentro do array.