Componha funções e argumentos com segurança
Componha funções preservando tuplas de argumentos e tipos de retorno; escreva auxiliares pipe/compose que continuem seguros quanto aos tipos.
Componha funções e argumentos com segurança é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 3 aulas no total.
Introdução
Objetivo: compor funções sem perder informações dos argumentos. Tuplas variádicas permitem manter a tupla completa de argumentos durante os auxiliares de composição e pipe.
- Preservar aridade e nomes
- Manter a inferência entre etapas
- Sem
any, sem casts
Composição básica
composição: a primeira função recebe todos os argumentos (...args: A), e a segunda consome sua saída; a aridade e os tipos são preservados.
function compose<A extends any[], B, C>(g: (b: B) => C, f: (...args: A) => B) {
return (...args: A): C => g(f(...args))
}
function toLen(a: string, n: number) { return `${a}${n}`.length }
function isEven(x: number) { return x % 2 === 0 }
const c1 = compose(isEven, toLen)
const ok = c1("id", 99) // booleanAuxiliar pipe
pipe implementa a mesma ideia na ordem inversa; o fluxo da inferência é mais intuitivo.
function pipe<A extends any[], B, C>(f: (...args: A) => B, g: (b: B) => C) {
return (...args: A): C => g(f(...args))
}
const p1 = pipe(toLen, isEven)
const ok2 = p1("xx", 7) // booleanComposição de 3 ou mais funções
Para 3 ou mais funções, o mesmo padrão se repete; a tupla A é preservada e os retornos intermediários são encadeados.
function compose3<A extends any[], B, C, D>(h: (c: C) => D, g: (b: B) => C, f: (...args: A) => B) {
return (...args: A): D => h(g(f(...args)))
}
function toUpper(s: string) { return s.toUpperCase() }
const c3 = compose3(toUpper, (x: number) => x.toString(), toLen)
const val = c3("a", 5) // "2" → then upper → "2"Vincular o início
bindHead: prefixe todos os argumentos e gere uma função sem argumentos; apenas para demonstração (na prática, ela pode ser tornada mais flexível com Parameters).
function bindHead<A extends any[], B>(fn: (...args: A) => B, ...head: A) {
return (...rest: []): B => fn(...head)
}
const bh = bindHead(toLen, "x", 42)
const r = bh() // numberDicas
Dicas:
Evite any nos auxiliares; ele rompe a cadeia de inferência.
Se necessário, torne o tipo de retorno explícito; isso melhora a experiência de desenvolvimento.
Para composição em várias etapas, escolha auxiliares pequenos em vez de auxiliares excessivamente genéricos.
Verificação da assinatura de composição
Verificação rápida: qual assinatura de composição preserva a tupla de argumentos de origem?
Recapitulação
Recapitulação: você escreveu auxiliares de composição e pipe preservando os argumentos com tuplas variádicas; o fluxo é estabelecido sem perder a aridade nem os tipos.
Perguntas Frequentes
A aula “Componha funções e argumentos com segurança” é grátis?
Sim — o texto completo de “Componha funções e argumentos com segurança” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 3 aulas no total.
O que vou aprender em “Componha funções e argumentos com segurança”?
Componha funções preservando tuplas de argumentos e tipos de retorno; escreva auxiliares pipe/compose que continuem seguros quanto aos tipos. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar TypeScript Academy?
Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.
Quanto tempo leva a aula “Componha funções e argumentos com segurança”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de TypeScript Academy?
Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Elementos rest de tuplas, tipos de curry
- Componha funções e argumentos com segurança
- Construtores fortemente tipados