how do i prevent non-nullable types in arguments

so we have the following convenience function:

export function asDefinedOr<T, D>(value: T | undefined, defaultValue: D): T | D {
    return value !== undefined ? value : defaultValue;
}

we would like to prevent the following from happening

declare var x : number;
asDefinedOr(x, 0); // <-- problem, unnecessary call, because x cannot be undefined

so we would like to make only T | undefined types allowed as aguments but not just T

is there a way to do it using conditional types?

This question should probably be on Stack Overflow or Gitter instead of here, if I understand the rules correctly.

But I can't stop myself because I love this sort of thing. Using conditional types:

export function asDefinedOr<T extends (undefined extends T ? any : undefined), D>(
  value: T, defaultValue: D
): (T extends undefined ? never : T) |  D {
  return value !== undefined ? value : defaultValue;
}

declare var x : number;
const xD = asDefinedOr(x, 0); // error
// Argument of type number is not assignable to parameter of type 'undefined'.

declare var y : number | undefined;
const yD = asDefinedOr(y, 0); // okay, yD is number

declare var z: string | undefined;
const zD = asDefinedOr(z, 0); // okay, zD is string | 0

i asked about the Not operator #22323 (comment)

which turned out being defined like this:

type Not<T, U> = T extends U ? never : T;

can my question be answered using it? something like:

export function asDefinedOr<T, D>(value: Not<T, NonNullable<T>>, defaultValue: D): T | D {

No, that doesn't work. What's wrong with the code I wrote above?

i don't like any there

O....kay, then maybe

type top = {} | void | null;
export function asDefinedOr<T extends (undefined extends T ? top : undefined), D>(
  value: T, defaultValue: D
): (T extends undefined ? never : T) | D {
  return value !== undefined ? value as (T extends undefined ? never : T) : defaultValue; 
}

Note that T extends any and T extends top are not very different. Control flow analysis doesn't seem to know how to deal with conditional types the way I'd like, so I had to assert that value will be T extends undefined ? never : T in the "then" branch of the ternary expression for it to type check.

Joe Calzaretta (@jcalz)

+1 for Joe Calzaretta (@jcalz), not sure I would include the void part though.

Joe Calzaretta (@jcalz)

Interesting that you can constrain a type parameter based on itself! Cool solution Joe Calzaretta (@jcalz)

Joe Calzaretta (@jcalz)

I just feel like another reason to implemented type exclusion...

Now, coming to Joe Calzaretta (@jcalz) solution... I still don't understand how that constraint after function parameters work... It seem like the solution I've been looking for over two weeks now.

I purpose to sign a decorator @Inject with different signature depending whether it is applied on static or instance side :

Static side : (cfg?: {type: SymbolConstructor | ConstructorLike})
Instance side : (cfg?: {id: string} | {type: SymbolConstructor | ConstructorLike} | {id: string, type: SymbolConstructor | ConstructorLike})

The instance side allow specifying the id. Here is how far I have gone :

declare global
{
    interface ConstructorLike<T = {}>
    {
        new(...args: any[]): T;
    }
}

export const Inject: {
    (cfg?: {type: SymbolConstructor | ConstructorLike}): <C extends ConstructorLike<T>, K extends keyof C, T>(context: C, property: K, index?: number) => void;
    (cfg?: {id: string} | {type: SymbolConstructor | ConstructorLike} | {id: string, type: SymbolConstructor | ConstructorLike}): <C extends T, K extends keyof C, T>(context: C, property: K, index?: number) => void;
} = <any>void 0; //TODO: implements the injection logic

...and the use case bellow fail even where it is not expected :

class Clazz
{
    @Inject()
    public string!: string;

    @Inject({id: 'number'})
    public number!: number;

    @Inject({type: Array})
    public array!: any[];

    @Inject({id: 'symbol', type: Symbol})
    public symbol!: Symbol;

    public method(@Inject() arg0: string, @Inject({type: Symbol}) arg1: symbol, @Inject({id: 'number'}) arg2: number, @Inject({id: 'array', type: Array}) arg3: any[])
    {
    }



    @Inject()
    public static string: string;

    @Inject({id: 'number'})
    public static number: number;

    @Inject({type: Clazz})
    public static prop: any[];

    @Inject({id: 'symbol', type: Symbol})
    public static symbol: Symbol;

    public constructor(@Inject() arg0: string, @Inject({type: Symbol}) arg1: symbol, @Inject({id: 'number'}) arg2: number, @Inject({id: 'array', type: Array}) arg3: any[])
    {
    }

    public static method(@Inject() arg0: string, @Inject({type: Symbol}) arg1: symbol, @Inject({id: 'number'}) arg2: number, @Inject({id: 'array', type: Array}) arg3: any[])
    {
    }
}

Any help is welcome. Thanks.

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.

Navigation Menu

how do i prevent non-nullable types in arguments #22375

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

how do i prevent non-nullable types in arguments #22375

Description

Activity

jcalz commented on Mar 7, 2018

zpdDG4gta8XKpMCd commented on Mar 7, 2018

jcalz commented on Mar 7, 2018

zpdDG4gta8XKpMCd commented on Mar 7, 2018

jcalz commented on Mar 7, 2018

mhegazy commented on Mar 7, 2018

jack-williams commented on Mar 7, 2018

SalathielGenese commented on Mar 8, 2018

typescript-bot commented on Mar 23, 2018

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions