.agent/rules/funcoes-anonimas-arrow.md

type	name	trigger	description	scope	updatedAt	globs	alwaysApply
rule	funcoes-anonimas-arrow	always_on	Exige uso de arrow functions (const x = () => {}) em vez de function declarations (function x() {})	global	2026-07-01	**/*.ts, **/*.tsx, **/*.js, **/*.vue	true

Contexto

Este projeto adota arrow functions como padrão obrigatório para definição de funções. A declaração clássica function x() {} é proibida sempre que uma arrow function puder substituí-la, o que cobre a esmagadora maioria dos casos.

Isso garante consistência de estilo, evita ambiguidades de this, favorece inferência de tipos em TypeScript e mantém o código visualmente uniforme em todo o ecossistema.

Regra

Sempre que possível, é obrigatório usar arrow function expression:

// ✅ CORRETO — arrow function expression
const calcular = (a: number, b: number): number => a + b

const buscarUsuario = async (id: string): Promise<Usuario> => {
  return api.get(`/usuarios/${id}`)
}

const transformar = <T>(lista: T[], fn: (item: T) => T): T[] =>
  lista.map(fn)

// ❌ PROIBIDO — function declaration
function calcular(a: number, b: number): number {
  return a + b
}

async function buscarUsuario(id: string): Promise<Usuario> {
  return api.get(`/usuarios/${id}`)
}

function transformar<T>(lista: T[], fn: (item: T) => T): T[] {
  return lista.map(fn)
}

Exceções permitidas

As únicas situações em que function é tolerada:

1. Generators — function* não tem equivalente em arrow function:

   function* gerador() { yield 1 }
   

2. Métodos de objeto/classe — dentro de um class ou object literal com método de protocolo, a sintaxe de método é aceita:

   class Servico {
     processar() { ... } // OK dentro de classe
   }
   

3. Callbacks que exigem this dinâmico — raro; apenas quando a API externa exige explicitamente (ex: certas integrações jQuery legadas).

Fora dessas três exceções, function é proibida.

Diretiva para o agente

Ao revisar ou escrever código, o agente deve:

1. Identificar toda ocorrência de function nome( fora de classes e generators;
2. Substituir pela forma const nome = (...) => { ... };
3. Ajustar a tipagem de retorno explícita quando necessário: const fn = (): Tipo => { ... };
4. Para funções genéricas, manter o generic na arrow: const fn = <T>(arg: T): T => arg;
5. Nunca silenciar um erro de tipagem ao fazer a conversão — se surgir erro, resolver com tipagem correta.

Referências

• Rule: global/rules/typescript-sem-any
• Rule: global/rules/jsdoc-padrao