Rename `Node` to something better

[soenkehahn]

Currently the specification of a type Foo has the flow type Node<Foo>. I think Node is a bad name for two reasons:

• I have no intuition why this is called Node. (I suspect it's called Node because of some internal implementation detail, but I might be wrong.)
• flow has a built-in type of the same name (https://flow.org/en/docs/react/types/#toc-react-node). So if I'm trying to use Node from validated but forget to import it, I don't get a helpful error message that Node is not in scope, but something confusing. (At least that's what I think happens.)

Could we consider renaming that type?

(To clarify: I'm talking about renaming the type that validated exposes. I don't care about the internals that much.)

We could rename it to Spec, Specification, Schema or something else. I'd be willing to create a PR for this.

[pronebird]

Yeah the collision with React.Node is bad, and if I recall it correctly, the one cannot rename imports in Flow, i.e import type { X as Y } from Z does not work.

[Alxandr]

This would be a breaking change requiring a new version (which is fine, just pointing it out). Any idea of what it should be called? Validator?

[soenkehahn]

@Alxandr: I had proposed Spec, Specification or Schema above.

In my mind, what's currently called Node is just specifying a type. Not validating values against that specification. (That's what the validate function is doing.) In theory you could also use Nodes for something different, i.e. generating an SQL schema. That's why I'd prefer my proposed names over Validator.

But I'm just bike-shedding and not really that opinionated. I'd be happy with almost anything except Node and Validator seems fine to me.

[Alxandr]

Seems I skimmed your issue too much 😛. I think Schema is might be a good way to go. Though, AnySchema and BooleanSchema sound a bit weird 🤔. Anyways; I might get working on something like this soon :), (if I have time).

[pronebird]

Schema sounds like a set of fields. Nodes validated are like field descriptors that can be nested, hence Node remains as a good candidate in my opinion 🥇

I realized that the one can avoid weird errors by using a slightly different import statement, i.e.:

import * as V from 'validated';

// then use `V.Node`

[Alxandr]

TypeDescriptor? It's a bit verbose. And might not even be entirely correct (not sure how much of a "description" you can get out of a Node), but it sort of maybe fits? 😛

[Alxandr]

@pronebird looking at the code again, the only actual "interface" that Nodes have, is a validate function (and a chaining andThen function, which could probably actually be rewritten as a combinator). And if Validate is the only function, I think we might as well rename it to Validator.

[Edit]
Also, as an FYI; the following is perfectly valid in Flow:

// @flow

import type { Node as ReactNode } from 'react';

const n: ReactNode = 'foo';