user29889977's questions

Escrevi uma função que retorna uma função que resolve a fome no mundo, mas somente se alguém ainda estiver com fome, caso contrário, será nulo.

Se, e somente se, alguém ainda estiver com fome, a função interna é criada e inclui a variável const informando se alguém ainda está com fome.

Durante a execução desta função, sabemos logicamente que a variável foi reduzida para trueou "fileNotFound.

E a edição #56908 de @ahejlsberg admite que deveria funcionar:

Atualmente preservamos refinamentos de tipo em fechamentos para variáveis ​​​​const

Mas o TypeScript reclama.

O playground mostra os tipos:

type IsStillHungry = true | false | 'fileNotFound' | undefined

function solveWorldHungerStrategy(opts: { isAnyoneStillHungry: IsStillHungry }) {

  const condition = opts.isAnyoneStillHungry

  if (condition) {
    
    condition
    // ^? const condition: true | "fileNotFound"

    function pretendToSolveWorldHunger() {

      condition
      // ^? const condition: boolean | "fileNotFound" | undefined

    }

    return pretendToSolveWorldHunger

  }

  return null

}

Vamos imaginar que eu tenha uma função. É uma função muito boa, muito amigável. E ela recebe um argumento, vamos chamá-la de type. Mas adivinhe? Na verdade, é uma string! Deixe-me dar um exemplo:

function returnWithType(o: any, type: 'string' | 'number') {
  if (typeof o === type) return o
  throw new Error(`AHHHH!!!!!`)
}

Viu o que eu fiz? Comparei o tipo com o tipo!

Mas, ok, agora deixe-me perguntar isto... como posso especificar o tipo de retorno real da função , de modo que se eles passarem "string", o tipo de retorno seja string, e o mesmo para number , mas "number"em vez de "string"assumir que eles passaram o valor da string "number"para o segundo parâmetro neste caso???

Eu basicamente quero isso:

function returnWithType(o: any, type: 'string' | 'number'):
  asserts typeof o === as // <---- THIS
{
  // ...
}

Ou talvez isto:

function returnWithType(...):
  type extends 'string' ? string :
  type extends 'number' ? number :
  boolean
{
  // ... solves world hunger ...
}

Acabei de perceber que posso fazer isso criando o genérico T extends ...e retornando um ternário baseado em T, mas existe alguma maneira mais limpa , talvez com alguns builtins inteligentes, de derivar essas informações automaticamente???

Gostaria de criar uma classe chamável que Foo(...args)seja idêntica e new Foo(...args)ao mesmo tempo mantenha a verificação de tipo do TypeScript satisfatória.

Em tempo de execução, isso é fácil, basta encapsular a classe com um Proxy implementando apply.

O problema é que qualquer função que retorna um Proxy não pode especificar o tipo de classe e a interface da classe passada.

No TypeScript, a class Foo ...expressão cria um valor like const Foo = ... e uma interface like interface Foo ...ao mesmo tempo.

Mas não consigo adicionar a interface ao tipo de retorno da função wrapper.

const Foo = wrap(class Foo {
  x
  y
  constructor(x: number, y: number) {
    this.x = x
    this.y = y
  }
})

function wrap<T>(ctor: T): T {
  return ctor
}

const foo: Foo = new Foo(1, 2)

Esta última linha dá o erro:

'Foo' se refere a um valor, mas está sendo usado como um tipo aqui. Você quis dizer 'typeof Foo'?ts(2749)

Mas adicionar typeof é claramente a solução errada, pois significaria o próprio Foo.

Posso resolver isso retirando a classe do wrapper:

class _Foo {
  x
  y
  constructor(x: number, y: number) {
    this.x = x
    this.y = y
  }
}

const Foo = wrap(_Foo)
interface Foo extends _Foo { }

function wrap<T>(ctor: T): T {
  return ctor
}

const foo: Foo = new Foo(1, 2)

Mas isso tem três problemas:

1. Requer que eu use o nome _Fooque é simplesmente feio
2. Requer que a classe esteja no contexto do valor de retorno de wrap()
3. Requer muitas repetições da palavra Foo(cinco vezes!)

Sugestões sobre como resolver isso?