Suggestion: The `object` primitive type

[fdecampredon]

The object primitive type

This proposal describe a new primitive type for typescript object.

Use case

JavaScript core api contains some functions that takes object as parameter :

• Object.getPrototypeOf
• Object.getOwnPropertyDescriptor
• Object.create
• ...etc

Currently there is no way in typescript to prevent passing other primitive type (string, number, etc ...) to those functions.
For example Object.create('string') is a perfectly valid typescript statement, even if it will ends up with an error.
Creating a new object primitive type would allows to model more correctly the signature of those function, and every function that share similar constraint.

Type Checking

Assignability

The object type is the equivalent of {} minus the assignability of other basic type, that means that :

• any other basic types are not assignable to object
• any non-basic type is assignable to object
• object is only assignable to {} and any

This behavior is coherant to how javascript works, the type represent every value that respect the constraint typeof value === 'object' plus undefined.

Type guard

A new type guard has to be introduced for object : typeof value === 'object'.
Optionally the compiler could also accept comparaison with the Object function cast : Object(value) === value.

[RyanCavanaugh]

It'd be useful to list some APIs other than the Object. functions which would benefit from this.

[fdecampredon]

In the javascript core api except from Object only perhaps some es6 constructs will benefit from this (WeakMap, Proxy etc).
But for example every underscore collections function would also gain better typing, framework like React use a 'setState' method that accept only object or null, ImmutableJS, Mori etc etc.

Edit: underscore collection work with any types

[RyanCavanaugh]

Discussed at suggestion review meeting. This all makes sense, but we need to justify the complexity of a new primitive type with the number of errors / richness of description it is able to provide. Basically, more examples of APIs that can't operate on primitives, especially ones that aren't "expert" APIs (e.g. Proxies)

[RyanCavanaugh]

Posting more as reference than recommendation 😉

interface String { _primitiveBrand?: string; }
interface Boolean { _primitiveBrand?: boolean; }
interface Number { _primitiveBrand?: number; }

interface ObjectOnly {  _primitiveBrand?: void; }

function fn(x: ObjectOnly) { }

// Error
fn(43);
// Error
fn('foo');
// OK
fn({});
// OK
fn(window);

[sccolbert]

+1 on this proposal. I wouldn't consider WeakMap an "expert" API, but I do consider it reason enough alone to implement this. Since the runtime makes a distinction between object types and primitive types, it only makes sense to have a facility in TypeScript to make the distinction as well.

This proposal will also solve the problem of typing "object bags" where each property is optional, but other primitive types should be disallowed.