static absl::flat_hash_map<string, std::vector<string>>* result =
      new absl::flat_hash_map<string, std::vector<string>>{
          // Unary
          {"PW",
           {"ComplexAbs", "Angle", "Conj", "Abs", "Acos", "Acosh", "Asin",
            "Atan", "Atanh", "Ceil", "Cos", "Cosh", "Sin", "Exp", "Expm1",
            "Floor", "IsFinite", "IsInf", "IsNan", "Inv", "Reciprocal", "Log",

  // CHECK:  return [[BCT]] : tensor<?x?x?x?x?xf32>
}

func.func @complex_abs(%arg0: tensor<1 x complex<f32>>) -> tensor<1xf32> {
  %0 = "tf.ComplexAbs"(%arg0) : (tensor<1 x complex<f32>>) -> tensor<1xf32>
  func.return %0: tensor<1xf32>

// CHECK-LABEL: complex_abs
// CHECK:  "tfl.complex_abs"(%arg0) : (tensor<1xcomplex<f32>>) -> tensor<1xf32>
// CHECK:  return
}

* Valida **estruturas complexas**:
    * Use modelos hierárquicos do Pydantic, `List` e `Dict` do `typing` do Python, etc.
    * Validadores permitem que esquemas de dados complexos sejam limpos e facilmente definidos, conferidos e documentados como JSON Schema.

* Valide les **structures complexes**:
    * Utilise les modèles hiérarchique de Pydantic, le `typage` Python pour les `Lists`, `Dict`, etc.
    * Et les validateurs permettent aux schémas de données complexes d'être clairement et facilement définis, validés et documentés sous forme d'un schéma JSON.

# Tipos de dados extras

Até agora, você tem usado tipos de dados comuns, tais como:

* `int`
* `float`
* `str`
* `bool`

Mas você também pode usar tipos de dados mais complexos.

E você ainda terá os mesmos recursos que viu até agora:

* Ótimo suporte do editor.
* Conversão de dados das requisições recebidas.
* Conversão de dados para os dados da resposta.
* Validação de dados.
* Anotação e documentação automáticas.

> Quelle est l'histoire de ce projet ? Il semble être sorti de nulle part et est devenu génial en quelques semaines [...].

Voici un petit bout de cette histoire.

## Alternatives

Je crée des API avec des exigences complexes depuis plusieurs années (Machine Learning, systèmes distribués, jobs asynchrones, bases de données NoSQL, etc), en dirigeant plusieurs équipes de développeurs.

> Qual é a história desse projeto? Parece que surgiu do nada e se tornou incrível em poucas semanas [...]

Aqui está um pouco dessa história.

## Alternativas

Eu tenho criado APIs com requisitos complexos por vários anos (Aprendizado de Máquina, sistemas distribuídos, tarefas assíncronas, banco de dados NoSQL etc.), liderando vários times de desenvolvedores.

Como parte disso, eu precisava investigar, testar e usar muitas alternativas.

  func.return %0 : tensor<?xf32>
}

// CHECK-LABEL:   func @complex_abs(
// CHECK-SAME:                      %[[VAL_0:.*]]: tensor<2xcomplex<f32>>) -> tensor<2xf32> {
// CHECK:           %[[VAL_1:.*]] = "tf.ComplexAbs"(%[[VAL_0]]) : (tensor<2xcomplex<f32>>) -> tensor<2xf32>
// CHECK:           return %[[VAL_1]] : tensor<2xf32>
// CHECK:         }
func.func @complex_abs(%arg0: tensor<2xcomplex<f32>>) -> tensor<2xf32> {

  func.return %0 : tensor<?xf32>
}

// -----

// CHECK-LABEL: @complex_abs
func.func @complex_abs(%arg0: tensor<2xcomplex<f32>>) -> tensor<2xf32> {
  // CHECK:  mhlo.abs %arg0 : (tensor<2xcomplex<f32>>) -> tensor<2xf32>
  %0 = "tf.ComplexAbs"(%arg0) : (tensor<2xcomplex<f32>>) -> tensor<2xf32>
  func.return %0 : tensor<2xf32>
}

// -----

* Conversão de dados
* Validação de dados
* Documentação automatica

## Tipos especiais e validação

Além dos tipos singulares normais como `str`, `int`, `float`, etc. Você também pode usar tipos singulares mais complexos que herdam de `str`.