user3624334's questions

Existe uma maneira de declarar uma função Typescript de forma que o tsc rejeite uma chamada a ela se passar um valor que é estaticamente conhecido como sendo de um tipo específico; caso contrário, aceite a chamada?

No meu exemplo abaixo, tenho uma função que encapsula um valor passado, mas quero que a função rejeite estaticamente a chamada se o valor passado já estiver encapsulado.

Neste ponto, o melhor que consegui fazer foi fazer com que o analisador estático esperasse que o valor retornado da função fosse 'nunca' se um valor encapsulado fosse passado.

class WrappedValue<T> {
    constructor(readonly value:T) {}
}

function wrap<T>( value:T) : WrappedValue<T> {
    return new WrappedValue(value)
}

type SingleWrapped<RR> = RR extends WrappedValue<unknown> ? never : WrappedValue<RR>;

function wrap_strict<TT>(retvalIn:TT) : SingleWrapped<TT> {
    if (retvalIn instanceof WrappedValue) {
        throw new Error('strict failure')
    } else {
        //@ts-expect-error   TODO: How do we avoid the error below:   TS2322: Type 'WrappedValue<TT>' is not assignable to type 'SingleWrapped<TT>'.
        let retval  : SingleWrapped<TT> =  wrap<TT>(retvalIn);
        return retval;
      }
}

const xx1 = wrap_strict(2)
xx1.value
const xx2 = wrap_strict(wrap(3))
// TODO: is there a way to cause tsc to complain on the line above rather than the line below?
xx2.value   // tsc complains about this line because xx2  is of type  never