Type alias circularly references itself

[pelotom]

Why does this work:

type Foo = { x: Foo }

but this doesn't:

type Bar<A> = { x: A }
type Foo = Bar<Foo>
//   ^^^ Type alias 'Foo' circularly references itself

Shouldn't they be equivalent?

[KiaraGrouwstra]

See the explanation here for more info.

[RyanCavanaugh]

type Foo = Bar<Foo>

Illegal because we don't know that the definition of Bar isn't

type Bar<T> = T;

[pelotom]

Don't you have access to the definition of Bar so you could check that?

[RyanCavanaugh]

Bar might be

type Bar<T> = Foo<T>;

and now we're going infinitely deep.

Type aliases and interfaces are subtly different and there are rules about self-recursion for aliases that don't apply to interfaces. Because an alias is supposed to always be "immediately expandable" (it's as if it were an in-place expansion of its referand), there are things you can do interfaces you can't do with type aliases.

[pelotom]

Cycles can be detected and you can give up at that point, but as long as you can topologically order the type aliases by their references to one another it's fine. Haskell, PureScript, Scala etc have no problem with this.

[RyanCavanaugh]

I mean, we could, it's just that writing interface Bar<T> extends Foo<T> { } accomplishes the same thing without requiring us to rearchitect how type aliases work

[pelotom]

Sure, you can do that to emulate

type Foo = Bar<Foo>

But what about

type Foo = Bar<Foo> | Baz<Foo>

In this situation afaict the only solution is to expand the definitions of Bar and Baz into the union, substituting Foo for their type variable. Bar and Baz (and however many other alternatives) could be large complex interfaces, and must now each be maintained as 2 separate copies that must be kept in sync with one another.

[skreborn]

I'm trying to create a type that circularly references itself, but in a way that it makes sense - or at least it does to me. This is basically the same problem as @pelotom is having.

type Data = number | string | Data[] | Record<string, Data>;

If I modify it to the following, it works as intended, but this really is just more work for the user. This gets even worse when the data types are more complicated than a simple key-value pair.

type Data = number | string | { [key: number]: Data } | { [key: string]: Data };

This type allows me to create values like the following and handle them in a type safe way even when they are deeply nested.

const data: Data = {
    foo: [ 1, 'one', { two: 2 } ],
    bar: 'foobar'
};

@RyanCavanaugh Is there any other (sane) way to create type-safe nested objects?

[mhegazy]

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

[pelotom]

I think this is a reasonable feature request for reasons that are made clear in the comments, can we reopen please?