Elementos rest de tuplas, tipos de curry
Use elementos rest de tuplas para capturar listas arbitrárias de argumentos e crie pequenos auxiliares de curry com inferência de tipos.
Elementos rest de tuplas, tipos de curry é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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: capturar listas de argumentos com tuplas variádicas e escrever um pequeno, mas útil, auxiliar de currificação. Isso mantém suas APIs flexíveis e preserva a segurança de tipos.
Fundamentos das tuplas variádicas
O padrão [...A, L]: primeiro vêm os argumentos iniciais (a tupla A), depois o último argumento (L). Ele é a base dos auxiliares.
type HeadTail<A extends any[], L> = [...A, L]
function callWithLast<A extends any[], L, R>(fn: (...args: [...A, L]) => R, last: L, ...head: A): R {
return fn(...head, last)
}
// Example
function join3(a: string, b: number, c: boolean) { return `${a}-${b}-${c}` }
const r = callWithLast(join3, true, "x", 42) // ok → stringAuxiliar de currificação
Uma pequena currificação: graças a [...A, L], tanto os tipos iniciais quanto o último tipo estão corretos.
function curryLast<A extends any[], L, R>(fn: (...args: [...A, L]) => R) {
return (last: L) => (...head: A) => fn(...head, last)
}
const curried = curryLast(join3)
const out = curried(true)("x", 42) // stringcurryFromFn geral
Solução geral: infira a cauda e o último argumento a partir de Parameters<F>, preservando assim a quantidade de parâmetros e seus tipos.
type Fn = (...args: any[]) => any
type Tail<T extends any[]> = T extends [...infer H, any] ? H : never
type Last<T extends any[]> = T extends [...any[], infer L] ? L : never
function curryFromFn<F extends Fn>(fn: F) {
type A = Tail<Parameters<F>>
type L = Last<Parameters<F>>
return (last: L) => (...head: A) => fn(...head, last)
}
const cur = curryFromFn(join3)
const o2 = cur(true)("x", 42) // still stringCompor com tuplas
Encadeie A → B → C com composição: os argumentos da tupla A são preservados e os tipos de saída são encadeados.
function compose<A extends any[], B, C>(g: (b: B) => C, f: (...args: A) => B) {
return (...args: A): C => g(f(...args))
}
function len(a: string, b: number) { return `${a}${b}`.length }
function isEven(n: number) { return n % 2 === 0 }
const comp = compose(isEven, len)
const ok = comp("id", 99) // booleanDicas
Dicas:
Tuplas variádicas exigem TS 4.0 ou posterior; mantenha o destino atualizado.
Oriente o compilador: às vezes, escrever os parâmetros de tipo explicitamente melhora a inferência.
O excesso de generalização adiciona complexidade ao design da interface de programação; auxiliares simples são mais eficazes.
Verificação da assinatura de currificação
Verificação rápida: qual assinatura captura quaisquer argumentos A e o último argumento L para um auxiliar de currificação?
Recapitulação
Recapitulação: modele listas de argumentos com [...A, L]; escreva pequenos auxiliares de currificação e composição; os tipos são preservados automaticamente.
Perguntas Frequentes
A aula “Elementos rest de tuplas, tipos de curry” é grátis?
Sim — o texto completo de “Elementos rest de tuplas, tipos de curry” é 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 “Elementos rest de tuplas, tipos de curry”?
Use elementos rest de tuplas para capturar listas arbitrárias de argumentos e crie pequenos auxiliares de curry com inferência de 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 1 de 3.
Quanto tempo leva a aula “Elementos rest de tuplas, tipos de curry”?
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