TTuple<K, V>

A classe TTuple<K> é uma implementação de tupla imutável em Delphi, projetada para fornecer uma estrutura eficiente e funcional para trabalhar com pares de chave-valor. A usabilidade da classe TTuple<K> se baseia em princípios comuns encontrados em outras linguagens de programação que também oferecem suporte a tuplas ou estruturas semelhantes. Aqui estão algumas informações importantes sobre a usabilidade da classe:

1. Imutabilidade: A classe TTuple<K> é imutável, o que significa que uma vez que uma instância é criada, seus valores não podem ser alterados. Isso ajuda a garantir a integridade dos dados e simplifica a lógica do programa, pois você não precisa se preocupar com alterações inesperadas nos valores da tupla.

2. Criação de Instâncias Simples: Através do método estático New, você pode criar facilmente instâncias da tupla fornecendo um array de chaves e um array de valores correspondentes. Essa abordagem é semelhante à forma como as tuplas são criadas em outras linguagens de programação.

3. Recuperação de Valores Tipados: O método Get<T> permite recuperar valores associados a uma chave específica de forma segura e tipada. Isso facilita o acesso aos dados na tupla sem a necessidade de conversões de tipo explícitas.

4. Contagem de Elementos: O método Count fornece o número de pares de chave-valor na tupla. Isso é útil para determinar o tamanho da tupla ou iterar sobre seus elementos.

5. Composição de Dados Complexos: A classe TTuple<K> permite a composição de dados complexos, onde as chaves e os valores podem ser de tipos variados, oferecendo flexibilidade na estruturação dos dados.

6. Sem Mutação Acidental: Devido à imutabilidade, você pode confiar na estabilidade dos dados na tupla. Isso evita erros comuns de mutação acidental que podem ocorrer quando se trabalha com estruturas de dados mutáveis.

7. Inspiração em Outras Linguagens: A classe TTuple<K> se inspira em conceitos semelhantes encontrados em linguagens como Python (tuplas) e C++/Rust (tuplas). Isso facilita a adaptação para desenvolvedores que estão familiarizados com essas linguagens.

8. Clareza e Legibilidade: O uso de tuplas pode melhorar a clareza e a legibilidade do código, especialmente em situações em que pares de chave-valor são utilizados para representar informações relacionadas.

No geral, a classe TTuple<K> foi projetada para simplificar o trabalho com pares de chave-valor em Delphi, seguindo os princípios de imutabilidade e usabilidade encontrados em outras linguagens de programação. Ela contribui para um código mais robusto e legível, especialmente em situações onde estruturas de dados imutáveis são preferíveis.

Exemplo de uso 1

var
  LDados: TArray<TTuple<string>>;
  LChave: string;
  LValor: TValue;
  LFor: Integer;
begin
  // Crie uma lista de dados fictícia
  SetLength(LDados, 3);
  LDados[0] := TTuple<string>.New(['Nome', 'Idade'], ['Alice', 25]);
  LDados[1] := TTuple<string>.New(['Nome', 'Idade'], ['Bob', 30]);
  LDados[2] := TTuple<string>.New(['Nome', 'Idade'], ['Charlie', 22]);

  // Processando e exibindo os dados
  for LFor := Low(LDados) to High(LDados) do
  begin
    LChave := 'Nome';
    LValor := LDados[i].Get<string>(LChave);
    WriteLn('Nome: ', LValor);

    LChave := 'Idade';
    LValor := LDados[i].Get<Integer>(LChave);
    WriteLn('Idade: ', LValor);

    WriteLn;
  end;
end;

Exemplo de uso 2

var
  LConfiguracoes: TTuple<string>;
  LChave: string;
  LValor: TValue;
begin
  // Defina as configurações iniciais
  LConfiguracoes := TTuple<string>.New(['CorFundo', 'TamanhoFonte'], [clWhite, 12]);

  // Consulte configurações com base na chave
  LChave := 'TamanhoFonte';
  LValor := LConfiguracoes.Get<Integer>(LChave);
  WriteLn('Tamanho da fonte: ', LValor);

  // Altere uma configuração
  LChave := 'CorFundo';
  LConfiguracoes := LConfiguracoes.NewValue(Chave, clBlack);
  WriteLn('Cor de fundo atualizada: ', LConfiguracoes.Get<TColor>(LChave));
end;