Refine array types using `filter`

[vkurchatkin]

Not sure if it's possible, but it would be nice if flow could refine array type using filter:

function getArray(): Array<?{}> { [{}, {}, null, {}, null] }

const array: Array<{}> = getArray().filter(i => Boolean(i));

Simplest patterns that are already used to refine optional types would be just enough

[avikchaudhuri]

Yeah, this feature should eventually be supported, along with the ability to annotate functions like the one you pass to filter with "effects." It's on the TODO list, but not hi-pri right now.

[vkurchatkin]

Here is my proposal:

• implement a magic type, that represents result of type check, for example Typecheck<Foo>;
• Typecheck is subtype of boolean;
• Typecheck is only allowed to be explicitly used as type of return value of a single-argument function:

function isNumber(val: mixed): Typecheck<number> {
  if (typeof val === 'number') {
    return true;
  }

  return false;
}

• if typecheck function returns true, that means that argument is of type Foo;
• typecheck function is validated, so you can only return true if val is of type Foo at this point;
• typecheck function is only allowed to call other typecheck functions

For example, Boolean can be declared as <T: {}>(v: ?T): Typecheck<T>.

Finally, filter function could be declared like this:

filter<T2>(fn: (v: T) => Typecheck<T2>): Array<T2>

[ctrlplusb]

I was just coming to post a similar issue. I am experiencing the following:

Completely kills my clean functional workflows... :'(

[ctrlplusb]

@gcanti suggested the following workaround in #1915:

const input: Array<number|string> = [1, 'a', 2, 3, 'b']
const result = ((input.filter(el => {
  return typeof el == 'number'
}): Array<any>): Array<number>)

[ctrlplusb]

Sorry for the spam, but another update on this. Using .reduce seems to play much nicer with types. Just annotate your accumulator and it's all good.

[gabro]

It seems that with more recent versions of flow this is supported using a point-free style, e.g.

declare function getArray(): Array<?{}>
const array: Array<{}> = getArray().filter(Boolean);

The snippet above type-checks on flow.

https://flowtype.org/try/#0CYUwxgNghgTiAEAzArgOzAFwJYHtXwHMQMBBGGKATwAoBKALnjIsoB4B+AbwF8A+AKHjx+YPAGcM8WC0bMqrHr3gBeQsTk1aAOkRYIGEDGoAhHDgggoqWgG4gA

[vkurchatkin]

It doesn't work for generic predicates though

[gabro]

Right, that one is still missing.