"Static method" or properties on functions gives rise to issue

[babakness]

I looked for duplicates, perhaps this is related?
#5863

Not sure...

Suppose we have some IO function that returns an object. In Javascript, Classes are more or less just functions

const IO = f => ({
  f,
  map: g => IO( (...args) => g ( f(...args) ) ) ,
  join: () => f()
})

IO.of = (val) => IO(()=>val)

The of class function raises an issue with Property 'of' does not exist on type '(f: any) => { f: any; map: (g: any) => any; join: () => any; }'.

Expected behavior is that TS understands that of is a property or "static method" of sorts on the IO function.

The error goes away by doing one of the following

const IO = (f => ({
  f,
  map: g => IO( (...args) => g ( f(...args) ) ) ,
  join: () => f()
})) as any

Or something like this

interface P {
  f: any,
  map: (f) => P,
  join: any
}
interface F { 
  (f): P; 
  of: (f) => P; 
}


const IO = (f => ({
  f,
  map: g => IO( (...args) => g ( f(...args) ) ) ,
  join: () => f()
})) as F


IO.of = (val) => IO(()=>val)

It seems that of should be inferred without this however. Also, in the later example, Intellisense doesn't seem to realize that map return a new copy of P interface but that is probably news for a different team ;-)

[RyanCavanaugh]

We do this sort of inference in JavaScript now; see #21974

For TypeScript it's a bit less obvious because we don't want every property write to be equivalent to a property declaration, so it becomes an exercise in dividing up the gray areas into "You tried to write to a non-existant property (error)" and "You intended to declare a new property via an assignment".

[yortus]

I'd be wary of implicit property declarations in TypeScript, because they would mask a common source of errors (ie typos) that TypeScript currently catches. I think its better to keep some explicit syntax difference so TS can continue to distinguish between new property declarations and plain old typos.

[yortus]

Also this seems to be covered by #15868. @RyanCavanaugh you already approved that one 😁.

[RyanCavanaugh]

We're pretty skeptical (in the classical sense) of implicit property declarations, but there are a few places where it seems safe. For example, immediately following a function declaration or function-expression-initialized const, there's basically nothing legitimate you can do with a function that involves assigning to its properties except for creating a function/object hybrid. In that "immediately following" region it's also unlikely you meant to assign to something else. So we're probably looking at some very restricted set of syntax where it's nearly 100% unambiguous what you intended to do.

[RyanCavanaugh]

Ah look at that

[typescript-bot]

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