TResultPair<S, F>

A classe TResultPair<S, F> é uma classe genérica que desempenha um papel significativo na programação funcional. Ela é projetada para representar resultados de operações que podem ter êxito (sucesso) ou falhar (failure), encapsulando dois tipos genéricos, S para sucesso e F para falha. A seguir, são explicados os recursos e a importância dessa classe:

Importância na Programação Funcional:

A classe TResultPair é uma ferramenta valiosa para a programação funcional, pois permite lidar com resultados de operações de forma expressiva e sem a necessidade de exceções. Ela promove a imutabilidade, o tratamento controlado de erros e a composição de funções.

Recursos e Utilidades:

1. class function New: TResultPair<S, F>; static;

   • Cria uma nova instância da classe TResultPair.

   • Útil para iniciar uma instância vazia.

2. procedure Dispose;

   • Libera recursos e destrói a instância.

   • Importante para a gestão de recursos e coleta de lixo.

3. function Success(const ASuccess: S): TResultPair<S, F>;

   • Define o resultado como um sucesso e atribui o valor de sucesso.

   • Útil para criar um TResultPair com êxito.

4. function Failure(const AFailure: F): TResultPair<S, F>;

   • Define o resultado como uma falha e atribui o valor de falha.

   • Útil para criar um TResultPair com falha.

5. function TryException(const ASuccessProc: TProc<S>; const AFailureProc: TProc<F>): TResultPair<S, F>;

   • Tenta executar uma operação de sucesso ou falha com tratamento de exceções.

   • Útil para encapsular operações que podem lançar exceções.

6. function Fold<R>(const AFunc: TFunc<S, F, R>): R;

   • Aplica uma função para transformar o valor de sucesso ou falha em um resultado de tipo R.

   • Útil para extrair valores de sucesso ou falha de forma controlada.

7. function When<R>(const ASuccessFunc: TFunc<S, R>; const AFailureFunc: TFunc<F, R>): R;

   • Aplica funções condicionais com base no resultado.

   • Útil para realizar diferentes ações com base no resultado.

8. function Map<R>(const ASuccessFunc: TFunc<S, R>): TResultPair<S, F>;

   • Aplica uma função de mapeamento ao valor de sucesso, retornando um novo TResultPair com o resultado do mapeamento.

   • Útil para transformar o valor de sucesso.

9. function MapFailure<R>(const AFailureFunc: TFunc<F, R>): TResultPair<S, F>;

   • Aplica uma função de mapeamento ao valor de falha, retornando um novo TResultPair com o resultado do mapeamento.

   • Útil para transformar o valor de falha.

10. function FlatMap<R>(const ASuccessFunc: TFunc<S, R>): TResultPair<S, F>;

    • Aplica uma função de mapeamento ao valor de sucesso e retorna um novo TResultPair com o resultado do mapeamento, que pode ser outro TResultPair.

    • Útil para transformações complexas de resultados.

11. function FlatMapFailure<R>(const AFailureFunc: TFunc<F, R>): TResultPair<S, F>;

    • Aplica uma função de mapeamento ao valor de falha e retorna um novo TResultPair com o resultado do mapeamento, que pode ser outro TResultPair.

    • Útil para transformações complexas de resultados.

12. function Pure(const ASuccess: S): TResultPair<S, F>;

    • Cria um TResultPair com um valor de sucesso, preservando qualquer falha existente.

13. function PureFailure(const AFailure: F): TResultPair<S, F>;

    • Cria um TResultPair com um valor de falha, preservando qualquer sucesso existente.

14. function Swap: TResultPair<F, S>;

    • Inverte os valores de sucesso e falha.

    • Útil para trocar entre êxito e falha.

15. function Recover<R>(const AFailureFunc: TFunc<F, R>): TResultPair<R, S>;

    • Aplica uma função de recuperação à falha, retornando um novo TResultPair com êxito.

    • Útil para recuperar de falhas.

16. function GetSuccessOrElse(const ASuccessFunc: TFunc<S, S>): S;

    • Obtém o valor de sucesso ou aplica uma função de fallback se for uma falha.

    • Útil para obter o valor de sucesso com tratamento de falhas.

17. function GetSuccessOrException: S;

    • Obtém o valor de sucesso ou lança uma exceção se for uma falha.

    • Útil para obter o valor de sucesso com tratamento de exceções.

18. function GetSuccessOrDefault: S; overload;

    • Obtém o valor de sucesso ou o valor padrão se for uma falha (sobrecarga sem parâmetros).

19. function GetSuccessOrDefault(const ADefault: S): S; overload;

    • Obtém o valor

de sucesso ou um valor padrão se for uma falha (sobrecarga com parâmetros).

20. function GetFailureOrElse(const AFailureFunc: TFunc<F, F>): F;

    • Obtém o valor de falha ou aplica uma função de fallback se for um sucesso.

    • Útil para obter o valor de falha com tratamento de sucesso.

21. function GetFailureOrException: F;

    • Obtém o valor de falha ou lança uma exceção se for um sucesso.

    • Útil para obter o valor de falha com tratamento de exceções.

22. function GetFailureOrDefault: F; overload;

    • Obtém o valor de falha ou o valor padrão se for um sucesso (sobrecarga sem parâmetros).

23. function GetFailureOrDefault(const ADefault: F): F; overload;

    • Obtém o valor de falha ou um valor padrão se for um sucesso (sobrecarga com parâmetros).

24. function isSuccess: boolean;

    • Verifica se é um sucesso.

25. function isFailure: boolean;

    • Verifica se é uma falha.

26. function ValueSuccess: S;

    • Obtém o valor de sucesso.

27. function ValueFailure: F;

    • Obtém o valor de falha.

28. function Exec(const AFunc: TFuncExec): TResultPair<S, F>;

    • Executa uma função com base no resultado.

    • Útil para executar operações customizadas com base no resultado.

29. function Ok(const ASuccess: S): TResultPair<S, F>;

    • Define o resultado como sucesso, preservando o valor de sucesso ou falha existente.

    • Útil para marcar explicitamente um sucesso.

30. function Fail(const AFailure: F): TResultPair<S, F>;

    • Define o resultado como falha, preservando o valor de sucesso ou falha existente.

    • Útil para marcar explicitamente uma falha.

31. function ThenOf(const AFunc: TFuncOk): TResultPair<S, F>;

    • Executa uma função de sucesso, mantendo o resultado atual.

    • Útil para executar operações de sucesso encadeadas.

32. function ExceptOf(const AFunc: TFuncFail): TResultPair<S, F>;

    • Executa uma função de falha, mantendo o resultado atual.

    • Útil para executar operações de falha encadeadas.

33. function Return: TResultPair<S, F>;

    • Retorna o próprio objeto TResultPair.

    • Útil para encadear operações de forma fluida.

Exemplo de uso 1

var
  LResultPair: TResultPair<Double, string>;
  LResult: Double;
begin
  try
    LResultPair := TResultPair<Double, string>
               .New
               .Success(FDividend div FDivisor)
               .Map<Double>(function(Value: Double): Double
                            begin
                              Result := Value * 2.5;
                            end);

    LResult := (FDividend div FDivisor) * 2.5;
    Assert.AreEqual(LResultPair.ValueSuccess, LResult, '');
  finally
    LResultPair.Dispose;
  end;

Exemplo de uso 2

var
  LTotalPrice: Double;
  LResultPair: TResultPair<Double, string>;
begin
  // Comece com Success() porque o carrinho está vazio no início
  try
    LResultPair := TResultPair<Double, string>.New
      .Success(0.0)
      .ThenOf(
        function (const ASubtotal: Double): TResultPair<Double, string>
        begin
          // Adicione um item ao carrinho
          Result := TResultPair<Double, string>.New.Success(ASubtotal + 29.99);
        end
      )
      .ThenOf(
        function (const ASubtotal: Double): TResultPair<Double, string>
        begin
          // Adicione outro item ao carrinho
          Result := TResultPair<Double, string>.New.Success(ASubtotal + 19.99);
        end
      ).Return;

    // Verifique se o resultado é sucesso e obtenha o preço total
    if LResultPair.IsSuccess then
      LTotalPrice := LResultPair.GetSuccessOrDefault(0.0)
    else
      LTotalPrice := 0.0;

    Assert.AreEqual(49.98, LTotalPrice, 0.001); // Verifica se o preço total está correto
  finally
    LResultPair.Dispose;
  end;
end;

Conclusão:

A classe TResultPair<S, F> é uma ferramenta poderosa para lidar com resultados de operações de forma controlada e expressiva. Ela desempenha um papel significativo na programação funcional, promovendo a imutabilidade, o tratamento de erros controlado e a composição de funções. Ao documentar essa classe, é importante explicar cada método e sua utilidade, ilustrando sua importância em cenários reais de desenvolvimento.